Merge pull request #94 from Seluj78/messages

Author: Seluj78

PyMatcha.postman_collection.json

@@ -54,7 +54,7 @@
 
 for item in REQUIRED_ENV_VARS:
     if item not in os.environ:
-        raise EnvironmentError(f"{item} is not set in the server's environment or .env file. It is required")
+        raise EnvironmentError(f"{item} is not set in the server's environment or .env file. It is required.")
 
 if os.getenv("ENABLE_LOGGING") == "True":
     setup_logging()
@@ -122,7 +122,7 @@ def expired_token_callback(expired_token):
 
 logging.debug("Setting database config from environment variables")
 database_config = {
-    "host": os.getenv("DB_HOST") if not os.getenv("IS_DOCKER_COMPOSE") else "mysql",
+    "host": os.getenv("DB_HOST"),
     "port": int(os.getenv("DB_PORT")),
     "user": os.getenv("DB_USER"),
     "password": database_password,
@@ -185,7 +185,6 @@ def check_if_token_is_revoked(decrypted_token):
     return entry == "true"
 
 
-from PyMatcha.routes.api.ping_pong import ping_pong_bp
 from PyMatcha.routes.api.user import user_bp
 from PyMatcha.routes.api.auth.email import auth_email_bp
 from PyMatcha.routes.api.auth.password import auth_password_bp
@@ -197,9 +196,9 @@ def check_if_token_is_revoked(decrypted_token):
 from PyMatcha.routes.api.profile.report import profile_report_bp
 from PyMatcha.routes.api.like import like_bp
 from PyMatcha.routes.api.match import match_bp
+from PyMatcha.routes.api.messages import messages_bp
 
 logging.debug("Registering Flask blueprints")
-application.register_blueprint(ping_pong_bp)
 application.register_blueprint(user_bp)
 application.register_blueprint(auth_email_bp)
 application.register_blueprint(auth_password_bp)
@@ -211,6 +210,7 @@ def check_if_token_is_revoked(decrypted_token):
 application.register_blueprint(profile_report_bp)
 application.register_blueprint(like_bp)
 application.register_blueprint(match_bp)
+application.register_blueprint(messages_bp)
 
 if application.debug:
     logging.debug("Registering debug route")

backend/PyMatcha/__init__.py

@@ -0,0 +1,66 @@
+"""
+    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 datetime import datetime
+
+from PyMatcha.utils import create_messages_table
+from PyMatcha.utils.orm import Field
+from PyMatcha.utils.orm import Model
+
+
+class Message(Model):
+    table_name = "messages"
+
+    id = Field(int, modifiable=False)
+    from_id = Field(int)
+    to_id = Field(int)
+    timestamp = Field(datetime)
+    seen_timestamp = Field(datetime)
+    content = Field(str)
+    is_seen = Field(bool)
+    is_liked = Field(bool)
+
+    @staticmethod
+    def create(
+        from_id: int,
+        to_id: int,
+        content: str,
+        timestamp: datetime = datetime.utcnow(),
+        seen_timestamp: datetime = None,
+        is_seen: bool = False,
+        is_liked: bool = False,
+    ) -> Message:
+        new_message = Message(
+            from_id=from_id,
+            to_id=to_id,
+            content=content,
+            timestamp=timestamp,
+            seen_timestamp=seen_timestamp,
+            is_seen=is_seen,
+            is_liked=is_liked,
+        )
+        new_message.save()
+        logging.debug("Created new message")
+        return new_message
+
+    @classmethod
+    def create_table(cls):
+        create_messages_table(cls.db)

backend/PyMatcha/models/message.py

@@ -19,15 +19,16 @@
 from __future__ import annotations
 
 import datetime
-import hashlib
 import logging
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Optional
 
 import Geohash
 from PyMatcha.models.like import Like
 from PyMatcha.models.match import Match
+from PyMatcha.models.message import Message
 from PyMatcha.models.report import Report
 from PyMatcha.models.tag import Tag
 from PyMatcha.models.view import View
@@ -62,11 +63,6 @@ class User(Model):
     confirmed_on = Field(datetime.datetime, fmt="%Y-%m-%d %H:%M:%S")
     previous_reset_token = Field(str)
 
-    def check_password(self, password: str) -> bool:
-        logging.debug("Checking password again {} hashed password".format(self.id))
-        _hash, salt = self.password.split(":")
-        return _hash == hashlib.sha256(salt.encode() + password.encode()).hexdigest()
-
     @staticmethod
     def create(
         first_name: str,
@@ -94,7 +90,7 @@ def create(
             pass
         else:
             logging.error("Email {} taken".format(email))
-            raise ConflictError("Email {} taken".format(email), "Use another email")
+            raise ConflictError("Email {} taken.".format(email), "Use another email.")
 
         # Check username availability
         try:
@@ -103,21 +99,20 @@ def create(
             pass
         else:
             logging.error("Username {} taken".format(username))
-            raise ConflictError("Username {} taken".format(username), "Try another username")
+            raise ConflictError("Username {} taken.".format(username), "Try another username.")
 
         # Check correct gender
         if gender not in ["male", "female", "other"]:
             logging.error("Gender must be male, female or other, not {}".format(gender))
-            raise ConflictError("Gender must be male, female or other, not {}".format(gender), "Try again")
+            raise ConflictError("Gender must be male, female or other, not {}.".format(gender))
 
         # Check correct orientation
         if orientation not in ["heterosexual", "homosexual", "bisexual", "other"]:
             logging.error(
-                "Sexual Orientation must be heterosexual, homosexual, bisexual or other, not {}".format(orientation)
+                "Sexual Orientation must be heterosexual, homosexual, bisexual or other, not {}.".format(orientation)
             )
             raise ConflictError(
-                "Sexual Orientation must be heterosexual, homosexual, bisexual or other, not {}".format(orientation),
-                "Try again",
+                "Sexual Orientation must be heterosexual, homosexual, bisexual or other, not {}.".format(orientation)
             )
 
         # Check correct geohash
@@ -163,7 +158,7 @@ def register(email: str, username: str, password: str, first_name: str, last_nam
             pass
         else:
             logging.debug("Email {} taken".format(email))
-            raise ConflictError("Email {} taken".format(email), "Use another email")
+            raise ConflictError("Email {} taken.".format(email), "Use another email.")
 
         # Check username availability
         try:
@@ -172,7 +167,7 @@ def register(email: str, username: str, password: str, first_name: str, last_nam
             pass
         else:
             logging.error("Username {} taken".format(username))
-            raise ConflictError("Username {} taken".format(username), "Try another username")
+            raise ConflictError("Username {} taken.".format(username), "Try another username.")
 
         # Encrypt password
         password = hash_password(password)
@@ -387,6 +382,108 @@ def get_matches(self):
                 match_list.append(Match(match))
         return match_list
 
+    def send_message(self, to_id, content):
+        Message.create(from_id=self.id, to_id=to_id, content=content)
+
+    def get_messages(self) -> List[Message]:
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT 
+                messages.from_id as from_id, 
+                messages.to_id as to_id, 
+                messages.id as id, 
+                messages.timestamp as timestamp, 
+                messages.seen_timestamp as seen_timestamp, 
+                messages.content as content, 
+                messages.is_liked as is_liked, 
+                messages.is_seen as is_seen
+                FROM messages 
+                INNER JOIN users on users.id = messages.from_id or users.id = messages.to_id 
+                WHERE users.id = CAST({} AS SIGNED)
+                """.format(
+                    self.id
+                )
+            )
+            messages = c.fetchall()
+            message_list = []
+            for message in messages:
+                message_list.append(Message(message))
+        logging.debug("Getting all messages sent or received by user {}".format(self.id))
+        return message_list
+
+    def get_conversation_list(self) -> List[Message]:
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT t1.*
+                FROM messages AS t1
+                INNER JOIN
+                (
+                    SELECT
+                        LEAST(from_id, to_id) AS from_id,
+                        GREATEST(from_id, to_id) AS to_id,
+                        MAX(id) AS max_id
+                    FROM messages
+                    GROUP BY
+                        LEAST(from_id, to_id),
+                        GREATEST(from_id, to_id)
+                ) AS t2
+                    ON LEAST(t1.from_id, t1.to_id) = t2.from_id AND
+                       GREATEST(t1.from_id, t1.to_id) = t2.to_id AND
+                       t1.id = t2.max_id
+                    WHERE t1.from_id = {0} OR t1.to_id = {0}
+                """.format(
+                    self.id
+                )
+            )
+            conversations = c.fetchall()
+            conversation_list = []
+            for last_message in conversations:
+                conversation_list.append(Message(last_message))
+        return conversation_list
+
+    def get_messages_with_user(self, with_user_id) -> List[Message]:
+        with self.db.cursor() as c:
+            c.execute(
+                """
+                SELECT 
+                messages.from_id as from_id, 
+                messages.to_id as to_id, 
+                messages.id as id, 
+                messages.timestamp as timestamp, 
+                messages.seen_timestamp as seen_timestamp, 
+                messages.content as content, 
+                messages.is_liked as is_liked, 
+                messages.is_seen as is_seen
+                FROM messages 
+                WHERE from_id=CAST({0} AS SIGNED) and to_id=CAST({1} AS SIGNED)
+
+                UNION ALL
+
+                SELECT messages.from_id as from_id, 
+                messages.to_id as to_id, 
+                messages.id as id, 
+                messages.timestamp as timestamp, 
+                messages.seen_timestamp as seen_timestamp, 
+                messages.content as content, 
+                messages.is_liked as is_liked, 
+                messages.is_seen as is_seen
+                FROM messages 
+                WHERE from_id=CAST({1} AS SIGNED) and to_id=CAST({0} AS SIGNED)
+                """.format(
+                    self.id, with_user_id
+                )
+            )
+            messages = c.fetchall()
+            message_list = []
+            for message in messages:
+                message_list.append(Message(message))
+        logging.debug(
+            "Getting all messages between user {} and {} (Total: {})".format(self.id, with_user_id, len(message_list))
+        )
+        return message_list
+
 
 def get_user(uid: Any[int, str]) -> Optional[User]:
     not_found = 0
@@ -417,6 +514,6 @@ def get_user(uid: Any[int, str]) -> Optional[User]:
     # If none of those worked, throw an error
     if not_found == 3:
         logging.debug("User {} not found.".format(uid))
-        raise NotFoundError("User {} not found.".format(uid), "Try again with another uid")
+        raise NotFoundError("User {} not found.".format(uid))
     logging.debug("Found user {} from {}".format(f_user.id, uid))
     return f_user

backend/PyMatcha/models/user.py

@@ -35,10 +35,10 @@
 from PyMatcha.utils.decorators import validate_params
 from PyMatcha.utils.errors import NotFoundError
 from PyMatcha.utils.errors import UnauthorizedError
+from PyMatcha.utils.password import check_password
 from PyMatcha.utils.success import Success
 from PyMatcha.utils.success import SuccessOutput
 
-
 REQUIRED_KEYS_LOGIN = {"username": str, "password": str}
 
 auth_login_bp = Blueprint("auth_login", __name__)
@@ -55,14 +55,14 @@ def auth_login():
         u = get_user(username)
     except NotFoundError:
         current_app.logger.debug("/auth/login -> User not found")
-        raise UnauthorizedError("Incorrect username or password", "Try again")
-    if not u.check_password(password):
+        raise UnauthorizedError("Incorrect username or password.")
+    if not check_password(u.password, password):
         current_app.logger.debug("/auth/login -> Password invalid")
-        raise UnauthorizedError("Incorrect username or password", "Try again")
+        raise UnauthorizedError("Incorrect username or password.")
 
     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")
+        raise UnauthorizedError("User needs to be confirmed first.", "Try again when you have confirmed your email.")
     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)

backend/PyMatcha/routes/api/auth/login.py

@@ -82,17 +82,17 @@ def reset_password():
     else:
         if token_type != "reset":
             current_app.logger.debug("/auth/password/reset -> Wrong token type")
-            raise BadRequestError("Wrong token type", "Try again with the correct type")
+            raise BadRequestError("Wrong token type.")
         try:
             u = get_user(email)
         except NotFoundError:
             current_app.logger.debug("/auth/password/reset -> User not found")
-            raise NotFoundError("User not found", "Try again with another user.")
+            raise NotFoundError("User not found.")
         if u.previous_reset_token == data["token"]:
             current_app.logger.debug("/auth/password/reset -> Token already used")
-            raise BadRequestError("Token already used", "Please request a new one")
+            raise BadRequestError("Token already used", "Please request a new one.")
         u.password = hash_password(data["password"])
         u.previous_reset_token = data["token"]
         u.save()
         current_app.logger.debug("/auth/password/reset -> Password reset successfully")
-        return Success("Password reset successful")
+        return Success("Password reset successful.")