Merge pull request #151 from Seluj78/view_profile

Author: Seluj78

PyMatcha.postman_collection.json

@@ -0,0 +1,60 @@
+"""
+    PyMatcha - A Python Dating Website
+    Copyright (C) 2018-2019 jlasne/gmorer
+    <jlasne@student.42.fr> - <gmorer@student.42.fr>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import datetime
+import logging
+
+from PyMatcha.utils import create_reports_table
+from PyMatcha.utils.orm import Field
+from PyMatcha.utils.orm import Model
+
+
+class Report(Model):
+    table_name = "reports"
+
+    id = Field(int, modifiable=False)
+    reporter_id = Field(int)
+    reported_id = Field(int)
+    dt_reported = Field(datetime.datetime)
+    details = Field(str)
+    reason = Field(str)
+    status = Field(str)
+
+    def before_init(self, data):
+        pass
+
+    @staticmethod
+    def create(
+        reported_id: int,
+        reporter_id: int,
+        reason: str,
+        details: str = None,
+        dt_reported: datetime.datetime = datetime.datetime.utcnow(),
+    ) -> Report:
+        new_report = Report(
+            reported_id=reported_id, reporter_id=reporter_id, reason=reason, details=details, dt_reported=dt_reported
+        )
+        new_report.save()
+        logging.debug("Creating new report")
+        return new_report
+
+    @classmethod
+    def create_table(cls):
+        create_reports_table(cls.db)

backend/PyMatcha/models/report.py

@@ -19,7 +19,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict
 
 from PyMatcha.utils import create_tags_table
 from PyMatcha.utils.orm import Field
@@ -43,9 +42,6 @@ def create(user_id: int, name="") -> Tag:
         logging.debug("Creating new tag")
         return new_tag
 
-    def get_all_info(self) -> Dict:
-        return {"id": self.id, "user_id": self.user_id, "name": self.name}
-
     @classmethod
     def create_table(cls):
         create_tags_table(cls.db)

backend/PyMatcha/models/tag.py

@@ -30,7 +30,9 @@
 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.orm import Field
@@ -207,27 +209,13 @@ def register(email: str, username: str, password: str, first_name: str, last_nam
         logging.debug("New user {} created".format(new_user.email))
         return new_user
 
-    def get_all_info(self) -> Dict:
-        return {
-            "id": self.id,
-            "first_name": self.first_name,
-            "last_name": self.last_name,
-            "email": self.email,
-            "username": self.username,
-            "bio": self.bio,
-            "gender": self.gender,
-            "orientation": self.orientation,
-            "birthdate": self.birthdate,
-            "geohash": self.geohash,
-            "tags": [t.name for t in self.get_tags()],
-            "heat_score": self.heat_score,
-            "is_online": self.is_online,
-            "date_joined": self.date_joined,
-            "date_lastseen": self.date_lastseen,
-            "is_profile_completed": self.is_profile_completed,
-            "is_confirmed": self.is_confirmed,
-            "confirmed_on": self.confirmed_on,
-        }
+    def to_dict(self) -> Dict:
+        returned_dict = super().to_dict()
+        returned_dict["tags"] = [t.to_dict() for t in self.get_tags()]
+        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()]
+        return returned_dict
 
     @classmethod
     def create_table(cls):
@@ -253,7 +241,7 @@ def get_images(self) -> List[UserImage]:
                 image_list.append(UserImage(image))
         return image_list
 
-    def get_base_info(self):
+    def get_jwt_info(self):
         return {
             "id": self.id,
             "email": self.email,
@@ -281,6 +269,68 @@ def get_tags(self):
                 tags_list.append(Tag(t))
         return tags_list
 
+    def get_views(self):
+        logging.debug("Getting all views for user profile {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT views.id as id, views.profile_id as profile_id, 
+                views.viewer_id as viewer_id, views.dt_seen as dt_seen
+                FROM users 
+                INNER JOIN views on users.id = views.profile_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            views = c.fetchall()
+            views_list = []
+            for v in views:
+                views_list.append(View(v))
+        return views_list
+
+    def get_reports_received(self):
+        logging.debug("Getting all reports received for user {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT reports.id as id, reports.reported_id as reported_id, 
+                reports.reporter_id as reporter_id, reports.dt_reported as dt_reported,
+                reports.details as details, reports.reason as reason, reports.status as status
+                FROM users 
+                INNER JOIN reports on users.id = reports.reported_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            reports = c.fetchall()
+            reports_list = []
+            for r in reports:
+                reports_list.append(Report(r))
+        return reports_list
+
+    def get_reports_sent(self):
+        logging.debug("Getting all reports sent for user {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT reports.id as id, reports.reported_id as reported_id, 
+                reports.reporter_id as reporter_id, reports.dt_reported as dt_reported,
+                reports.details as details, reports.reason as reason, reports.status as status
+                FROM users 
+                INNER JOIN reports on users.id = reports.reporter_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            reports = c.fetchall()
+            reports_list = []
+            for r in reports:
+                reports_list.append(Report(r))
+        return reports_list
+
 
 def get_user(uid: Any[int, str]) -> Optional[User]:
     not_found = 0

backend/PyMatcha/models/user.py

@@ -16,15 +16,14 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
-
 from __future__ import annotations
 
 import logging
 from datetime import datetime
-from typing import Dict
 
 from PyMatcha.utils import create_user_images_table
-from PyMatcha.utils.orm import Model, Field
+from PyMatcha.utils.orm import Field
+from PyMatcha.utils.orm import Model
 
 
 class UserImage(Model):
@@ -48,15 +47,6 @@ def create(
         logging.debug("Creating new user image")
         return new_image
 
-    def get_all_info(self) -> Dict:
-        return {
-            "id": self.id,
-            "user_id": self.user_id,
-            "description": self.description,
-            "timestamp": self.timestamp,
-            "is_primary": self.is_primary,
-        }
-
     @classmethod
     def create_table(cls):
         create_user_images_table(cls.db)

backend/PyMatcha/models/user_image.py

@@ -0,0 +1,49 @@
+"""
+    PyMatcha - A Python Dating Website
+    Copyright (C) 2018-2019 jlasne/gmorer
+    <jlasne@student.42.fr> - <gmorer@student.42.fr>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import datetime
+import logging
+
+from PyMatcha.utils import create_views_table
+from PyMatcha.utils.orm import Field
+from PyMatcha.utils.orm import Model
+
+
+class View(Model):
+    table_name = "views"
+
+    id = Field(int, modifiable=False)
+    profile_id = Field(int)
+    viewer_id = Field(int)
+    dt_seen = Field(datetime.datetime)
+
+    def before_init(self, data):
+        pass
+
+    @staticmethod
+    def create(profile_id: int, viewer_id: int, dt_seen: datetime.datetime = datetime.datetime.utcnow()) -> View:
+        new_view = View(profile_id=profile_id, viewer_id=viewer_id, dt_seen=dt_seen)
+        new_view.save()
+        logging.debug("Creating new view")
+        return new_view
+
+    @classmethod
+    def create_table(cls):
+        create_views_table(cls.db)

backend/PyMatcha/models/view.py

@@ -192,8 +192,8 @@ 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_base_info(), fresh=True)
-    refresh_token = fjwt.create_refresh_token(identity=u.get_base_info())
+    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)
 

backend/PyMatcha/routes/api/auth.py

@@ -1,14 +1,19 @@
 import datetime
 
+import flask_jwt_extended as fjwt
 import PyMatcha.models.user as user
 from flask import Blueprint
 from flask import current_app
 from flask import jsonify
+from flask import request
 from PyMatcha import redis
 from PyMatcha.errors import NotFoundError
+from PyMatcha.models.report import Report
+from PyMatcha.models.view import View
 from PyMatcha.success import Success
 from PyMatcha.success import SuccessDeleted
 from PyMatcha.utils.decorators import debug_token_required
+from PyMatcha.utils.decorators import validate_params
 
 debug_bp = Blueprint("debug", __name__)
 
@@ -52,8 +57,26 @@ def delete_user(uid):
         return SuccessDeleted("User {} Deleted".format(uid))
 
 
+@debug_bp.route("/debug/views/<int:amount>", methods=["POST"])
+@debug_token_required
+@fjwt.jwt_required
+def create_views(amount):
+    current_user = fjwt.current_user
+    for i in range(amount):
+        View.create(profile_id=current_user.id, viewer_id=i)
+    return Success(f"Added {amount} views to user {current_user.id}")
+
+
+@debug_bp.route("/debug/views", methods=["DELETE"])
+@debug_token_required
+def delete_views():
+    View.drop_table()
+    View.create_table()
+    return "", 204
+
+
 @debug_bp.route("/debug/redis")
-# @debug_token_required
+@debug_token_required
 def debug_show_redis():
     ret = {"users": {}, "jtis": {}}
     for key in redis.scan_iter("user:*"):
@@ -63,3 +86,45 @@ def debug_show_redis():
         value = redis.get(str(key))
         ret["jtis"][key] = value
     return jsonify(ret), 200
+
+
+@debug_bp.route("/debug/reports", methods=["DELETE"])
+@debug_token_required
+def delete_reports():
+    Report.drop_table()
+    Report.create_table()
+    return "", 204
+
+
+@debug_bp.route("/debug/reports", methods=["GET"])
+@debug_token_required
+def debug_get_all_reports():
+    report_list = []
+    for r in Report.select_all():
+        report_list.append(r.to_dict())
+    return jsonify(report_list)
+
+
+@debug_bp.route("/debug/reports/<uid>", methods=["GET"])
+@debug_token_required
+def debug_get_user_reports(uid):
+    u = get_user(uid)
+    reports_received = [r.to_dict() for r in u.get_reports_received()]
+    reports_sent = [r.to_dict() for r in u.get_reports_sent()]
+    return jsonify({"reports_received": reports_received, "reports_sent": reports_sent}), 200
+
+
+DEBUG_CREATE_FAKE_REPORT = {"reporter_id": int, "reported_id": int, "reason": str, "details": str}
+
+
+@debug_bp.route("/debug/reports", methods=["POST"])
+@debug_token_required
+@validate_params(DEBUG_CREATE_FAKE_REPORT)
+def debug_create_report():
+    data = request.get_json()
+    reporter_id = data["reporter_id"]
+    reported_id = data["reported_id"]
+    reason = data["reason"]
+    details = data["details"]
+    Report.create(reported_id=reported_id, reporter_id=reporter_id, reason=reason, details=details)
+    return "", 204