Added reports + to_dict method

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,6 +30,7 @@
 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
@@ -208,27 +209,10 @@ 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()]
+        return returned_dict
 
     @classmethod
     def create_table(cls):
@@ -254,7 +238,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,
@@ -302,6 +286,48 @@ def get_views(self):
                 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

@@ -20,7 +20,6 @@
 
 import datetime
 import logging
-from typing import Dict
 
 from PyMatcha.utils import create_views_table
 from PyMatcha.utils.orm import Field
@@ -45,9 +44,6 @@ def create(profile_id: int, viewer_id: int, dt_seen: datetime.datetime = datetim
         logging.debug("Creating new view")
         return new_view
 
-    def get_all_info(self) -> Dict:
-        return {"id": self.id, "profile_id": self.profile_id, "viewer_id": self.viewer_id, "dt_seen": self.dt_seen}
-
     @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

@@ -7,6 +7,7 @@
 from flask import jsonify
 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
@@ -83,3 +84,29 @@ 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")
+@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>")
+@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

backend/PyMatcha/routes/api/debug.py

@@ -28,6 +28,7 @@
 from PyMatcha.errors import BadRequestError
 from PyMatcha.errors import NotFoundError
 from PyMatcha.errors import UnauthorizedError
+from PyMatcha.models.report import Report
 from PyMatcha.models.tag import Tag
 from PyMatcha.models.view import View
 from PyMatcha.success import Success
@@ -198,7 +199,7 @@ def edit_geolocation():
 def get_profile_views():
     current_user = fjwt.current_user
     profile_views = current_user.get_views()
-    profile_views = [v.get_all_info() for v in profile_views]
+    profile_views = [v.to_dict() for v in profile_views]
     return SuccessOutput("views", profile_views)
 
 
@@ -214,4 +215,30 @@ def view_profile(uid):
     if current_user.id != u.id:
         View.create(profile_id=u.id, viewer_id=current_user.id)
 
-    return SuccessOutput("profile", u.get_all_info())
+    return SuccessOutput("profile", u.to_dict())
+
+
+@profile_bp.route("/profile/report/<uid>", methods=["POST"])
+@validate_params({"reason": str}, {"details": str})
+@fjwt.jwt_required
+def report_profile(uid):
+    current_user = fjwt.current_user
+    data = request.get_json()
+    reason = data["reason"]
+
+    if reason not in ["harassment", "bot", "spam", "inappropriate content"]:
+        raise BadRequestError("Reason must be 'harassment', 'bot', 'spam' or 'inappropriate content'", "Try again")
+
+    try:
+        details = data["details"]
+    except KeyError:
+        details = None
+    try:
+        u = get_user(uid)
+    except NotFoundError:
+        raise NotFoundError(f"User {uid} not found", "try again")
+    if current_user.id == u.id:
+        raise BadRequestError("Cannot report yourself", "Try again")
+    Report.create(reporter_id=current_user.id, reported_id=u.id, reason=reason, details=details)
+
+    return Success(f"Report created on user {u.id} {u.get_reports_sent()} {u.get_reports_received()}")

backend/PyMatcha/routes/api/profile.py

@@ -36,7 +36,7 @@ def get_all_users():
     current_app.logger.info("/users/ -> Call")
     user_list = []
     for u in User.select_all():
-        user_list.append(u.get_all_info())
+        user_list.append(u.to_dict())
     current_app.logger.info("/users/ -> Returning all users list")
     return jsonify(user_list)
 
@@ -51,7 +51,7 @@ def get_one_user(uid):
         raise NotFoundError("User {} not found".format(uid), "Check given uid and try again")
     else:
         current_app.logger.info("/users/{} -> Returning info on user {}".format(uid, uid))
-        return jsonify(u.get_all_info())
+        return jsonify(u.to_dict())
 
 
 @user_bp.route("/users/online", methods=["GET"])