Merge pull request #152 from Seluj78/like-profile

Author: Seluj78

PyMatcha.postman_collection.json

@@ -98,7 +98,7 @@
 
 @jwt.expired_token_loader
 def expired_token_callback(expired_token):
-    logging.error("Token {} expired".format(expired_token))
+    logging.warning("Token {} expired".format(expired_token))
     resp = {
         "code": 401,
         "error": {
@@ -156,14 +156,13 @@ def expired_token_callback(expired_token):
     decode_responses=True,
 )
 
-import PyMatcha.models.user as user_module
+from PyMatcha.models.user import get_user
 
-get_user = user_module.get_user
 
 logging.debug("Configuring JWT user callback loader")
 
 
-from PyMatcha.errors import NotFoundError
+from PyMatcha.utils.errors import NotFoundError
 
 
 @jwt.user_loader_callback_loader
@@ -190,12 +189,14 @@ def check_if_token_is_revoked(decrypted_token):
 from PyMatcha.routes.api.user import user_bp
 from PyMatcha.routes.api.auth import auth_bp
 from PyMatcha.routes.api.profile import profile_bp
+from PyMatcha.routes.api.like import like_bp
 
 logging.debug("Registering Flask blueprints")
 application.register_blueprint(ping_pong_bp)
 application.register_blueprint(user_bp)
 application.register_blueprint(auth_bp)
 application.register_blueprint(profile_bp)
+application.register_blueprint(like_bp)
 
 if application.debug:
     logging.debug("Registering debug route")

backend/PyMatcha/__init__.py

@@ -18,35 +18,38 @@
 """
 from __future__ import annotations
 
+import datetime
 import logging
-from datetime import datetime
 
-from PyMatcha.utils import create_user_images_table
+from PyMatcha.utils import create_likes_table
 from PyMatcha.utils.orm import Field
 from PyMatcha.utils.orm import Model
 
 
-class UserImage(Model):
-    table_name = "user_images"
+class Like(Model):
+    table_name = "likes"
 
     id = Field(int, modifiable=False)
-    user_id = Field(int)
-    description = Field(str)
-    timestamp = Field(str)
-    is_primary = Field(bool)
+    liker_id = Field(int)
+    liked_id = Field(int)
+    dt_liked = Field(datetime.datetime, fmt="%Y-%m-%d %H:%M:%S")
+    is_superlike = Field(bool)
 
     def before_init(self, data):
         pass
 
     @staticmethod
     def create(
-        user_id: int, description="", timestamp=datetime.timestamp(datetime.utcnow()), is_primary=False
-    ) -> UserImage:
-        new_image = UserImage(user_id=user_id, description=description, timestamp=str(timestamp), is_primary=is_primary)
-        new_image.save()
-        logging.debug("Creating new user image")
-        return new_image
+        liker_id: int,
+        liked_id: int,
+        is_superlike: str = False,
+        dt_liked: datetime.datetime = datetime.datetime.utcnow(),
+    ) -> Like:
+        new_like = Like(liker_id=liker_id, liked_id=liked_id, is_superlike=is_superlike, dt_liked=dt_liked)
+        new_like.save()
+        logging.debug("Creating new like")
+        return new_like
 
     @classmethod
     def create_table(cls):
-        create_user_images_table(cls.db)
+        create_likes_table(cls.db)

backend/PyMatcha/models/user_image.py backend/PyMatcha/models/like.pybackend/PyMatcha/models/user_image.py renamed to backend/PyMatcha/models/like.py

@@ -32,7 +32,7 @@ class Report(Model):
     id = Field(int, modifiable=False)
     reporter_id = Field(int)
     reported_id = Field(int)
-    dt_reported = Field(datetime.datetime)
+    dt_reported = Field(datetime.datetime, fmt="%Y-%m-%d %H:%M:%S")
     details = Field(str)
     reason = Field(str)
     status = Field(str)

backend/PyMatcha/models/report.py

@@ -23,23 +23,19 @@
 import logging
 from typing import Any
 from typing import Dict
-from typing import List
 from typing import Optional
 
 import Geohash
-import PyMatcha.models.user_image as user_image
-from PyMatcha.errors import ConflictError
-from PyMatcha.errors import NotFoundError
 from PyMatcha.models.report import Report
 from PyMatcha.models.tag import Tag
 from PyMatcha.models.view import View
 from PyMatcha.utils import create_user_table
 from PyMatcha.utils import hash_password
+from PyMatcha.utils.errors import ConflictError
+from PyMatcha.utils.errors import NotFoundError
 from PyMatcha.utils.orm import Field
 from PyMatcha.utils.orm import Model
 
-UserImage = user_image.UserImage
-
 
 class User(Model):
     table_name = "users"
@@ -170,7 +166,7 @@ def register(email: str, username: str, password: str, first_name: str, last_nam
         except ValueError:
             pass
         else:
-            logging.error("Email {} taken".format(email))
+            logging.warning("Email {} taken".format(email))
             raise ConflictError("Email {} taken".format(email), "Use another email")
 
         # Check username availability
@@ -215,32 +211,17 @@ def to_dict(self) -> Dict:
         returned_dict["reports"] = {"sent": [], "received": []}
         returned_dict["reports"]["sent"] = [r.to_dict() for r in self.get_reports_sent()]
         returned_dict["reports"]["received"] = [r.to_dict() for r in self.get_reports_received()]
+        returned_dict["likes"] = {"sent": [], "received": []}
+        returned_dict["likes"]["sent"] = [l.to_dict() for l in self.get_likes_sent()]
+        returned_dict["likes"]["received"] = [l.to_dict() for l in self.get_likes_received()]
+        returned_dict.pop("password")
+        returned_dict.pop("previous_reset_token")
         return returned_dict
 
     @classmethod
     def create_table(cls):
         create_user_table(cls.db)
 
-    def get_images(self) -> List[UserImage]:
-        logging.debug("Getting all images for user {}".format(self.id))
-        with self.db.cursor() as c:
-            c.execute(
-                """
-                SELECT user_images.id as id, user_images.user_id as user_id, user_images.description as description, 
-                user_images.timestamp as timestamp, user_images.is_primary as is_primary
-                FROM users 
-                INNER JOIN user_images on users.id = user_images.user_id 
-                WHERE users.id = CAST({} AS UNSIGNED)
-                """.format(
-                    self.id
-                )
-            )
-            images = c.fetchall()
-            image_list = []
-            for image in images:
-                image_list.append(UserImage(image))
-        return image_list
-
     def get_jwt_info(self):
         return {
             "id": self.id,
@@ -331,6 +312,65 @@ def get_reports_sent(self):
                 reports_list.append(Report(r))
         return reports_list
 
+    def get_likes_received(self):
+        logging.debug("Getting all likes received for user {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT likes.id as id, likes.liked_id as liked_id, 
+                likes.liker_id as liker_id, likes.dt_liked as dt_liked,
+                likes.is_superlike as is_superlike
+                FROM users 
+                INNER JOIN likes on users.id = likes.liked_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            likes = c.fetchall()
+            like_list = []
+            for l in likes:
+                like_list.append(Report(l))
+        return like_list
+
+    def get_likes_sent(self):
+        logging.debug("Getting all likes sent for user {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT likes.id as id, likes.liked_id as liked_id, 
+                likes.liker_id as liker_id, likes.dt_liked as dt_liked,
+                likes.is_superlike as is_superlike
+                FROM users 
+                INNER JOIN likes on users.id = likes.liker_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            likes = c.fetchall()
+            like_list = []
+            for l in likes:
+                like_list.append(Report(l))
+        return like_list
+
+    def already_likes(self, liked_id: int) -> bool:
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT EXISTS(
+                  SELECT * FROM likes WHERE
+                    liker_id = CAST({} AS UNSIGNED) and 
+                    liked_id = CAST({} AS UNSIGNED)
+                )
+                """.format(
+                    self.id, liked_id
+                )
+            )
+            result = c.fetchone()
+            value = next(iter(result.values()))
+            return bool(value)
+
 
 def get_user(uid: Any[int, str]) -> Optional[User]:
     not_found = 0
@@ -360,7 +400,7 @@ def get_user(uid: Any[int, str]) -> Optional[User]:
         f_user = user
     # If none of those worked, throw an error
     if not_found == 3:
-        logging.error("User {} not found.".format(uid))
+        logging.warning("User {} not found.".format(uid))
         raise NotFoundError("User {} not found.".format(uid), "Try again with another uid")
     logging.debug("Found user {} from {}".format(f_user.id, uid))
     return f_user

backend/PyMatcha/models/user.py

@@ -19,32 +19,37 @@
 import datetime
 import os
 
-import flask_jwt_extended as fjwt
-import PyMatcha.models.user as user
 from flask import Blueprint
 from flask import current_app
 from flask import redirect
 from flask import request
+from flask_jwt_extended import create_access_token
+from flask_jwt_extended import create_refresh_token
+from flask_jwt_extended import get_jti
+from flask_jwt_extended import get_jwt_identity
+from flask_jwt_extended import get_raw_jwt
+from flask_jwt_extended import jwt_refresh_token_required
+from flask_jwt_extended import jwt_required
 from itsdangerous import BadSignature
 from itsdangerous import SignatureExpired
 from PyMatcha import ACCESS_TOKEN_EXPIRES
 from PyMatcha import redis
 from PyMatcha import REFRESH_TOKEN_EXPIRES
-from PyMatcha.errors import BadRequestError
-from PyMatcha.errors import ConflictError
-from PyMatcha.errors import NotFoundError
-from PyMatcha.errors import UnauthorizedError
-from PyMatcha.success import Success
-from PyMatcha.success import SuccessOutput
-from PyMatcha.success import SuccessOutputMessage
+from PyMatcha.models.user import get_user
+from PyMatcha.models.user import User
 from PyMatcha.utils import hash_password
 from PyMatcha.utils.confirm_token import confirm_token
 from PyMatcha.utils.confirm_token import generate_confirmation_token
 from PyMatcha.utils.decorators import validate_params
+from PyMatcha.utils.errors import BadRequestError
+from PyMatcha.utils.errors import ConflictError
+from PyMatcha.utils.errors import NotFoundError
+from PyMatcha.utils.errors import UnauthorizedError
 from PyMatcha.utils.mail import send_mail_text
+from PyMatcha.utils.success import Success
+from PyMatcha.utils.success import SuccessOutput
+from PyMatcha.utils.success import SuccessOutputMessage
 
-User = user.User
-get_user = user.get_user
 
 REQUIRED_KEYS_USER_CREATION = {"username": str, "email": str, "password": str, "first_name": str, "last_name": str}
 REQUIRED_KEYS_PASSWORD_FORGOT = {"email": str}
@@ -71,7 +76,7 @@ def api_create_user():
             last_name=data["last_name"],
         )
     except ConflictError as e:
-        current_app.logger.error("Conflict error on user register: {}".format(e))
+        current_app.logger.warning("Conflict error on user register: {}".format(e))
         raise e
     else:
         token = generate_confirmation_token(email=data["email"], token_type="confirm")
@@ -192,10 +197,10 @@ def auth_login():
     if not u.is_confirmed:
         current_app.logger.debug("/auth/login -> User is trying to login unconfirmed")
         raise UnauthorizedError("User needs to be confirmed first.", "Try again when you have confirmed your email")
-    access_token = fjwt.create_access_token(identity=u.get_jwt_info(), fresh=True)
-    refresh_token = fjwt.create_refresh_token(identity=u.get_jwt_info())
-    access_jti = fjwt.get_jti(access_token)
-    refresh_jti = fjwt.get_jti(refresh_token)
+    access_token = create_access_token(identity=u.get_jwt_info(), fresh=True)
+    refresh_token = create_refresh_token(identity=u.get_jwt_info())
+    access_jti = get_jti(access_token)
+    refresh_jti = get_jti(refresh_token)
 
     redis.set("jti:" + access_jti, "false", ACCESS_TOKEN_EXPIRES * 1.2)
     redis.set("jti:" + refresh_jti, "false", REFRESH_TOKEN_EXPIRES * 1.2)
@@ -207,27 +212,27 @@ def auth_login():
 
 
 @auth_bp.route("/auth/refresh", methods=["POST"])
-@fjwt.jwt_refresh_token_required
+@jwt_refresh_token_required
 def refresh():
-    current_user = fjwt.get_jwt_identity()
-    access_token = fjwt.create_access_token(identity=current_user)
-    access_jti = fjwt.get_jti(encoded_token=access_token)
+    current_user = get_jwt_identity()
+    access_token = create_access_token(identity=current_user)
+    access_jti = get_jti(encoded_token=access_token)
     redis.set("jti:" + access_jti, "false", ACCESS_TOKEN_EXPIRES * 1.2)
     return SuccessOutput("access_token", access_token)
 
 
 @auth_bp.route("/auth/access_revoke", methods=["DELETE"])
-@fjwt.jwt_required
+@jwt_required
 def logout():
-    jti = fjwt.get_raw_jwt()["jti"]
+    jti = get_raw_jwt()["jti"]
     redis.set("jti:" + jti, "true", ACCESS_TOKEN_EXPIRES * 1.2)
     return Success("Access token revoked")
 
 
 @auth_bp.route("/auth/refresh_revoke", methods=["DELETE"])
-@fjwt.jwt_refresh_token_required
+@jwt_refresh_token_required
 def logout2():
-    jti = fjwt.get_raw_jwt()["jti"]
+    jti = get_raw_jwt()["jti"]
     redis.set("jti:" + jti, "true", REFRESH_TOKEN_EXPIRES * 1.2)
     return Success("Refresh token revoked")