Merge pull request #150 from Seluj78/tags

Author: Seluj78

PyMatcha.postman_collection.json

@@ -0,0 +1,51 @@
+"""
+    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 logging
+from typing import Dict
+
+from PyMatcha.utils import create_tags_table
+from PyMatcha.utils.orm import Field
+from PyMatcha.utils.orm import Model
+
+
+class Tag(Model):
+    table_name = "tags"
+
+    id = Field(int, modifiable=False)
+    user_id = Field(int)
+    name = Field(str)
+
+    def before_init(self, data):
+        pass
+
+    @staticmethod
+    def create(user_id: int, name="") -> Tag:
+        new_tag = Tag(user_id=user_id, name=name)
+        new_tag.save()
+        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

@@ -20,7 +20,6 @@
 
 import datetime
 import hashlib
-import json
 import logging
 from typing import Any
 from typing import Dict
@@ -31,6 +30,7 @@
 import PyMatcha.models.user_image as user_image
 from PyMatcha.errors import ConflictError
 from PyMatcha.errors import NotFoundError
+from PyMatcha.models.tag import Tag
 from PyMatcha.utils import create_user_table
 from PyMatcha.utils import hash_password
 from PyMatcha.utils.orm import Field
@@ -53,7 +53,6 @@ class User(Model):
     orientation = Field(str)
     birthdate = Field(datetime.date)
     geohash = Field(str)
-    tags = Field(dict)
     heat_score = Field(int)
     is_online = Field(bool)
     date_joined = Field(datetime.datetime, fmt="%Y-%m-%d %H:%M:%S")
@@ -86,7 +85,6 @@ def create(
         orientation: str,
         birthdate: datetime.date,
         geohash: str,
-        tags,
         heat_score: int = 0,
         is_online: bool = False,
         date_joined: datetime.datetime = datetime.datetime.utcnow(),
@@ -135,8 +133,6 @@ def create(
             logging.error("Geohash error: {}".format(e))
             raise e
 
-        # TODO: Check if all tags are set in tags
-
         # Encrypt password
         password = hash_password(password)
 
@@ -151,7 +147,6 @@ def create(
             orientation=orientation,
             birthdate=birthdate,
             geohash=geohash,
-            tags=str(json.dumps(tags)),
             heat_score=heat_score,
             is_online=is_online,
             date_joined=date_joined,
@@ -199,7 +194,6 @@ def register(email: str, username: str, password: str, first_name: str, last_nam
             orientation="bisexual",
             birthdate=None,
             geohash=None,
-            tags="",
             heat_score=0,
             is_online=False,
             date_joined=datetime.datetime.utcnow(),
@@ -220,21 +214,19 @@ def get_all_info(self) -> Dict:
             "last_name": self.last_name,
             "email": self.email,
             "username": self.username,
-            "password": self.password,
             "bio": self.bio,
             "gender": self.gender,
             "orientation": self.orientation,
             "birthdate": self.birthdate,
             "geohash": self.geohash,
-            "tags": json.loads(self.tags) if self.tags else "",  # TODO: Optimize this
+            "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,
-            "previous_reset_token": self.previous_reset_token,
         }
 
     @classmethod
@@ -250,7 +242,7 @@ def get_images(self) -> List[UserImage]:
                 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 INT)
+                WHERE users.id = CAST({} AS UNSIGNED)
                 """.format(
                     self.id
                 )
@@ -270,6 +262,25 @@ def get_base_info(self):
             "date_lastseen": self.date_lastseen,
         }
 
+    def get_tags(self):
+        logging.debug("Getting all tags for user {}".format(self.id))
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT tags.id as id, tags.user_id as user_id, tags.name as name
+                FROM users 
+                INNER JOIN tags on users.id = tags.user_id 
+                WHERE users.id = CAST({} AS UNSIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            tags = c.fetchall()
+            tags_list = []
+            for t in tags:
+                tags_list.append(Tag(t))
+        return tags_list
+
 
 def get_user(uid: Any[int, str]) -> Optional[User]:
     not_found = 0

backend/PyMatcha/models/user.py

@@ -16,23 +16,40 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
+import datetime
+import os
+
 import flask_jwt_extended as fjwt
+import Geohash
 import PyMatcha.models.user as user
 from flask import Blueprint
 from flask import request
+from ip2geotools.databases.noncommercial import DbIpCity
 from PyMatcha.errors import BadRequestError
+from PyMatcha.errors import NotFoundError
+from PyMatcha.errors import UnauthorizedError
+from PyMatcha.models.tag import Tag
 from PyMatcha.success import Success
+from PyMatcha.utils import hash_password
+from PyMatcha.utils.confirm_token import generate_confirmation_token
 from PyMatcha.utils.decorators import validate_params
+from PyMatcha.utils.mail import send_mail_text
 
 User = user.User
 get_user = user.get_user
 
 profile_bp = Blueprint("profile", __name__)
 
-REQUIRED_PARAMS_COMPLETE_PROFILE = {
-    "orientation": str,
+REQUIRED_PARAMS_COMPLETE_PROFILE = {"gender": str, "birthdate": int, "orientation": str, "bio": str, "tags": list}
+REQUIRED_PARAMS_EDIT_PROFILE = {
+    "first_name": str,
+    "last_name": str,
+    "username": str,
     "bio": str,
-    # "tags": str
+    "gender": str,
+    "orientation": str,
+    "birthdate": int,
+    "tags": list,
 }
 
 
@@ -48,12 +65,127 @@ def complete_profile():
     data = request.get_json()
     orientation = data["orientation"]
     bio = data["bio"]
+    tags = data["tags"]
+    gender = data["gender"]
+    birthdate = data["birthdate"]
 
-    if orientation not in ["heterosexual", "homosexual", "bisexual", "other"]:
-        raise BadRequestError("Genre must be heterosexual, homosexual, bisexual or other", "Try again")
+    for tag in tags:
+        Tag.create(name=tag, user_id=current_user.id)
 
     current_user.orientation = orientation
     current_user.bio = bio
     current_user.is_profile_completed = True
+    current_user.gender = gender
+    current_user.birthdate = datetime.date.fromtimestamp(int(birthdate))
     current_user.save()
     return Success("Profile completed !")
+
+
+@profile_bp.route("/profile/edit", methods=["PUT"])
+@fjwt.jwt_required
+@validate_params(REQUIRED_PARAMS_EDIT_PROFILE)
+def edit_profile():
+    current_user = fjwt.current_user
+    if not current_user.is_profile_completed:
+        raise BadRequestError("The user has not completed his profile", "Complete your profile and try again")
+    data = request.get_json()
+    first_name = data["first_name"]
+    last_name = data["last_name"]
+    username = data["username"]
+    bio = data["bio"]
+    gender = data["gender"]
+    orientation = data["orientation"]
+    birthdate = data["birthdate"]
+
+    try:
+        get_user(username)
+    except NotFoundError:
+        pass
+    else:
+        raise BadRequestError("Username taken", "Try again")
+
+    if orientation not in ["heterosexual", "homosexual", "bisexual", "other"]:
+        raise BadRequestError("Orientation must be heterosexual, homosexual, bisexual or other", "Try again")
+
+    if gender not in ["male", "female", "other"]:
+        raise BadRequestError("Gender must be male, female or other", "Try again")
+
+    birthdate = datetime.date.fromtimestamp(birthdate)
+
+    current_user.first_name = first_name
+    current_user.last_name = last_name
+    current_user.username = username
+    current_user.bio = bio
+    current_user.gender = gender
+    current_user.orientation = orientation
+    current_user.birthdate = birthdate
+    current_user.save()
+    return Success("User successfully modified !")
+
+
+@profile_bp.route("/profile/edit/email", methods=["PUT"])
+@fjwt.jwt_required
+@validate_params({"email": str})
+def edit_email():
+    data = request.get_json()
+    new_email = data["email"].lower()
+    current_user = fjwt.current_user
+    if current_user.email == new_email:
+        raise BadRequestError("The new email is the same as the old one !", "Try again")
+    current_user.email = new_email
+    current_user.is_confirmed = False
+    current_user.save()
+    token = generate_confirmation_token(email=new_email, token_type="confirm")
+    send_mail_text.delay(
+        dest=data["email"],
+        subject="Confirm your new email for PyMatcha",
+        body=os.getenv("APP_URL") + "/auth/confirm/" + token,
+    )
+    return Success("Email sent for new email")
+
+
+@profile_bp.route("/profile/edit/password", methods=["PUT"])
+@fjwt.jwt_required
+@validate_params({"old_password": str, "new_password": str})
+def edit_password():
+    data = request.get_json()
+    old_password = data["old_password"]
+    new_password = data["new_password"]
+    current_user = fjwt.current_user
+    if not current_user.check_password(old_password):
+        raise UnauthorizedError("Incorrect password", "Try again")
+    current_user.password = hash_password(new_password)
+    current_user.save()
+    # TODO: Send mail
+    send_mail_text.delay(
+        dest=current_user.email,
+        subject="Password change notification",
+        body=f"Your password was changed at {datetime.datetime.utcnow()}."
+        f" If you believe it wasn't you, please change it immediatly",
+    )
+    return Success("User password successfully updated.")
+
+
+@profile_bp.route("/profile/edit/geolocation", methods=["PUT"])
+@fjwt.jwt_required
+@validate_params({"ip": str}, {"lat": float, "lng": float})
+def edit_geolocation():
+    data = request.get_json()
+    ip = data["ip"]
+    current_user = fjwt.current_user
+    try:
+        lat = data["lat"]
+        lng = data["lng"]
+    except KeyError:
+        lat = None
+        lng = None
+
+    if lat and lng:
+        current_user.geohash = Geohash.encode(lat, lng)
+    else:
+        response = DbIpCity.get(ip, api_key="free")
+        lat = response.latitude
+        lng = response.longitude
+        current_user.geohash = Geohash.encode(lat, lng)
+    current_user.save()
+    return Success("New location sucessfully saved.")

backend/PyMatcha/routes/api/profile.py

@@ -1,7 +1,11 @@
 from PyMatcha.utils.password import hash_password
-from PyMatcha.utils.tables import create_tables, _create_user_images_table, _create_user_table
+from PyMatcha.utils.tables import _create_tags_table
+from PyMatcha.utils.tables import _create_user_images_table
+from PyMatcha.utils.tables import _create_user_table
+from PyMatcha.utils.tables import create_tables
 
 create_user_images_table = _create_user_images_table
 create_user_table = _create_user_table
+create_tags_table = _create_tags_table
 
-__all__ = ["hash_password", "create_tables", "create_user_table", "create_user_images_table"]
+__all__ = ["hash_password", "create_tables", "create_user_table", "create_user_images_table", "create_tags_table"]

backend/PyMatcha/utils/__init__.py

@@ -38,7 +38,6 @@ def _create_user_table(db):
         orientation          ENUM('heterosexual', 'homosexual', 'bisexual', 'other'),
         birthdate            DATE DEFAULT NULL,
         geohash              VARCHAR(256) DEFAULT NULL,
-        tags                 LONGTEXT,  # TODO: JSON ?
         heat_score           INT DEFAULT (0),
         date_joined          DATETIME DEFAULT NOW(),
         date_lastseen        DATETIME DEFAULT NOW(),
@@ -72,6 +71,24 @@ def _create_user_images_table(db):
         c.execute("""SET sql_notes = 1;""")
 
 
+def _create_tags_table(db):
+    with db.cursor() as c:
+        logging.info("Creating table tags.")
+        c.execute("""SET sql_notes = 0;""")
+        c.execute(
+            """
+        CREATE TABLE IF NOT EXISTS tags
+        (
+        id            INT auto_increment PRIMARY KEY,
+        user_id       INT NOT NULL,
+        name          VARCHAR(256)
+        )
+        """
+        )
+        c.execute("""SET sql_notes = 1;""")
+
+
 def create_tables(db):
     _create_user_table(db)
     _create_user_images_table(db)
+    _create_tags_table(db)