Add social features [1st part]

.github/workflows/.tests-python.yml

@@ -13,6 +13,7 @@ env:
   EMAIL_URL: "smtp://none:[email protected]:1025"
   FLASK_APP: fittrackee/__main__.py
   SENDER_EMAIL: [email protected]
+  UI_URL: https://0.0.0.0:5000
 
 jobs:
   python:

Makefile

@@ -252,6 +252,11 @@ test-e2e-client:
 	E2E_ARGS=client $(PYTEST) e2e --driver firefox $(PYTEST_ARGS)
 
 test-python:
+	# for tests parallelization: 4 workers max.
+	# make test-python PYTEST_ARGS="-p no:warnings -n auto --maxprocesses=4"
+	$(PYTEST) fittrackee $(PYTEST_ARGS)
+
+test-python-cov:
 	# for tests parallelization: 4 workers max.
 	# make test-python PYTEST_ARGS="-p no:warnings -n auto --maxprocesses=4"
 	$(PYTEST) fittrackee --cov-config .coveragerc --cov=fittrackee --cov-report term-missing $(PYTEST_ARGS)

fittrackee/__init__.py

@@ -20,6 +20,7 @@
 from flask_migrate import Migrate
 from flask_sqlalchemy import SQLAlchemy
 from sqlalchemy.exc import ProgrammingError
+from sqlalchemy.ext.declarative import DeclarativeMeta
 from werkzeug.middleware.proxy_fix import ProxyFix
 
 from fittrackee.emails.email import EmailService
@@ -41,6 +42,7 @@
 db = SQLAlchemy(
     engine_options={"future": True}, session_options={"future": True}
 )
+BaseModel: DeclarativeMeta = db.Model
 bcrypt = Bcrypt()
 migrate = Migrate()
 email_service = EmailService()
@@ -128,26 +130,36 @@ def create_app(init_email: bool = True) -> Flask:
                 pass
 
     from .application.app_config import config_blueprint  # noqa
+    from .comments.comments import comments_blueprint  # noqa
     from .equipments.equipment_types import equipment_types_blueprint
     from .equipments.equipments import equipments_blueprint
     from .oauth2.routes import oauth2_blueprint  # noqa
+    from .reports.reports import reports_blueprint  # noqa
     from .users.auth import auth_blueprint  # noqa
+    from .users.follow_requests import follow_requests_blueprint  # noqa
+    from .users.notifications import notifications_blueprint  # noqa
     from .users.users import users_blueprint  # noqa
     from .workouts.records import records_blueprint  # noqa
     from .workouts.sports import sports_blueprint  # noqa
     from .workouts.stats import stats_blueprint  # noqa
+    from .workouts.timeline import timeline_blueprint  # noqa
     from .workouts.workouts import workouts_blueprint  # noqa
 
     app.register_blueprint(auth_blueprint, url_prefix='/api')
     app.register_blueprint(equipment_types_blueprint, url_prefix='/api')
     app.register_blueprint(equipments_blueprint, url_prefix='/api')
     app.register_blueprint(oauth2_blueprint, url_prefix='/api')
+    app.register_blueprint(comments_blueprint, url_prefix='/api')
     app.register_blueprint(config_blueprint, url_prefix='/api')
     app.register_blueprint(records_blueprint, url_prefix='/api')
     app.register_blueprint(sports_blueprint, url_prefix='/api')
     app.register_blueprint(stats_blueprint, url_prefix='/api')
     app.register_blueprint(users_blueprint, url_prefix='/api')
     app.register_blueprint(workouts_blueprint, url_prefix='/api')
+    app.register_blueprint(follow_requests_blueprint, url_prefix='/api')
+    app.register_blueprint(timeline_blueprint, url_prefix='/api')
+    app.register_blueprint(notifications_blueprint, url_prefix='/api')
+    app.register_blueprint(reports_blueprint, url_prefix='/api')
 
     if app.debug:
         logging.getLogger('sqlalchemy').setLevel(logging.WARNING)

fittrackee/application/models.py

@@ -4,16 +4,13 @@
 from flask import current_app
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.event import listens_for
-from sqlalchemy.ext.declarative import DeclarativeMeta
 from sqlalchemy.orm.mapper import Mapper
 from sqlalchemy.orm.session import Session
 from sqlalchemy.sql import text
 
-from fittrackee import VERSION, db
+from fittrackee import BaseModel, db
 from fittrackee.users.models import User
 
-BaseModel: DeclarativeMeta = db.Model
-
 
 class AppConfig(BaseModel):
     __tablename__ = 'app_config'
@@ -55,10 +52,10 @@ def serialize(self) -> Dict:
             'privacy_policy': self.privacy_policy,
             'privacy_policy_date': self.privacy_policy_date,
             'stats_workouts_limit': self.stats_workouts_limit,
-            'version': VERSION,
+            'version': current_app.config['VERSION'],
             'weather_provider': (
                 weather_provider
-                if weather_provider in ['darksky', 'visualcrossing']
+                if weather_provider in ['visualcrossing']
                 else None
             ),
         }

fittrackee/comments/comments.py

@@ -0,0 +1,248 @@
+from datetime import datetime
+from typing import Dict, Optional, Tuple, Union
+
+from flask import Blueprint, request
+from sqlalchemy import exc
+
+from fittrackee import db
+from fittrackee.oauth2.server import require_auth
+from fittrackee.privacy_levels import PrivacyLevel, can_view
+from fittrackee.reports.models import ReportActionAppeal
+from fittrackee.responses import (
+    ForbiddenErrorResponse,
+    HttpResponse,
+    InvalidPayloadErrorResponse,
+    handle_error_and_return_response,
+)
+from fittrackee.users.models import User
+from fittrackee.utils import clean_input, decode_short_id
+from fittrackee.workouts.decorators import check_workout
+from fittrackee.workouts.models import Workout
+
+from .decorators import check_workout_comment
+from .models import Comment, CommentLike, get_comments
+
+comments_blueprint = Blueprint('comments', __name__)
+
+
+@comments_blueprint.route(
+    "/workouts/<string:workout_short_id>/comments", methods=["POST"]
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout(only_owner=False, as_data=False)
+def add_workout_comment(
+    auth_user: User, workout: Workout, workout_short_id: str
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    comment_data = request.get_json()
+    if (
+        not comment_data
+        or not comment_data.get('text')
+        or not comment_data.get('text_visibility')
+    ):
+        return InvalidPayloadErrorResponse()
+    try:
+        reply_to = comment_data.get('reply_to')
+        comment = None
+        if reply_to:
+            comment = Comment.query.filter(
+                Comment.uuid == decode_short_id(reply_to),
+                Comment.user_id.not_in(auth_user.get_blocked_by_user_ids()),
+            ).first()
+            if (
+                not comment
+                or comment.suspended_at
+                or not can_view(comment, "text_visibility", auth_user)
+            ):
+                return InvalidPayloadErrorResponse("'reply_to' is invalid")
+
+        new_comment = Comment(
+            user_id=auth_user.id,
+            workout_id=workout.id,
+            text=clean_input(comment_data['text']),
+            text_visibility=PrivacyLevel(comment_data['text_visibility']),
+            reply_to=comment.id if comment else None,
+        )
+        db.session.add(new_comment)
+        db.session.flush()
+        new_comment.create_mentions()
+        db.session.commit()
+
+        return (
+            {
+                'status': 'created',
+                'comment': new_comment.serialize(auth_user),
+            },
+            201,
+        )
+    except (exc.IntegrityError, ValueError) as e:
+        return handle_error_and_return_response(
+            error=e,
+            message='Error during comment save.',
+            status='fail',
+            db=db,
+        )
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>", methods=["GET"]
+)
+@require_auth(scopes=["workouts:read"], optional_auth_user=True)
+@check_workout_comment(only_owner=False)
+def get_workout_comment(
+    auth_user: Optional[User], comment: Comment
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    return (
+        {
+            'status': 'success',
+            'comment': comment.serialize(auth_user, get_parent_comment=True),
+        },
+        200,
+    )
+
+
+@comments_blueprint.route(
+    "/workouts/<string:workout_short_id>/comments", methods=["GET"]
+)
+@require_auth(scopes=['workouts:read'], optional_auth_user=True)
+@check_workout(only_owner=False, as_data=False)
+def get_workout_comments(
+    auth_user: Optional[User], workout: Workout, workout_short_id: str
+) -> Union[Dict, HttpResponse]:
+    try:
+        comments = get_comments(
+            workout_id=workout.id,
+            user=auth_user,
+        )
+        return {
+            'status': 'success',
+            'data': {
+                'comments': [
+                    comment.serialize(auth_user) for comment in comments
+                ]
+            },
+        }
+    except Exception as e:
+        return handle_error_and_return_response(e)
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>", methods=["DELETE"]
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout_comment()
+def delete_workout_comment(
+    auth_user: User, comment: Comment
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    try:
+        db.session.delete(comment)
+        db.session.commit()
+        return {'status': 'no content'}, 204
+    except (
+        exc.IntegrityError,
+        exc.OperationalError,
+        ValueError,
+        OSError,
+    ) as e:
+        return handle_error_and_return_response(e, db=db)
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>", methods=["PATCH"]
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout_comment()
+def update_workout_comment(
+    auth_user: User, comment: Comment
+) -> Union[Dict, HttpResponse]:
+    comment_data = request.get_json()
+    if not comment_data or not comment_data.get('text'):
+        return InvalidPayloadErrorResponse()
+
+    try:
+        comment.text = clean_input(comment_data['text'])
+        comment.modification_date = datetime.utcnow()
+        comment.update_mentions()
+        db.session.commit()
+        return {
+            'status': 'success',
+            'comment': comment.serialize(auth_user),
+        }
+
+    except (exc.IntegrityError, exc.OperationalError, ValueError) as e:
+        return handle_error_and_return_response(e)
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>/like", methods=["POST"]
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout_comment(only_owner=False)
+def like_comment(
+    auth_user: User, comment: Comment
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    if comment.suspended_at:
+        return ForbiddenErrorResponse()
+    try:
+        like = CommentLike(user_id=auth_user.id, comment_id=comment.id)
+        db.session.add(like)
+        db.session.commit()
+    except exc.IntegrityError:
+        db.session.rollback()
+    return {
+        'status': 'success',
+        'comment': comment.serialize(auth_user),
+    }, 200
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>/like/undo",
+    methods=["POST"],
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout_comment(only_owner=False)
+def undo_comment_like(
+    auth_user: User, comment: Comment
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    like = CommentLike.query.filter_by(
+        user_id=auth_user.id, comment_id=comment.id
+    ).first()
+    if like:
+        db.session.delete(like)
+        db.session.commit()
+    return {
+        'status': 'success',
+        'comment': comment.serialize(auth_user),
+    }, 200
+
+
+@comments_blueprint.route(
+    "/comments/<string:comment_short_id>/suspension/appeal",
+    methods=["POST"],
+)
+@require_auth(scopes=["workouts:write"])
+@check_workout_comment(only_owner=True)
+def appeal_comment_suspension(
+    auth_user: User, comment: Comment
+) -> Union[Tuple[Dict, int], HttpResponse]:
+    if not comment.suspended_at:
+        return InvalidPayloadErrorResponse("workout comment is not suspended")
+    suspension_action = comment.suspension_action
+    if not suspension_action:
+        return InvalidPayloadErrorResponse("workout comment has no suspension")
+
+    text = request.get_json().get("text")
+    if not text:
+        return InvalidPayloadErrorResponse("no text provided")
+
+    try:
+        appeal = ReportActionAppeal(
+            action_id=suspension_action.id, user_id=auth_user.id, text=text
+        )
+        db.session.add(appeal)
+        db.session.commit()
+        return {"status": "success"}, 201
+
+    except exc.IntegrityError:
+        return InvalidPayloadErrorResponse("you can appeal only once")
+    except (exc.OperationalError, ValueError) as e:
+        return handle_error_and_return_response(e, db=db)

fittrackee/comments/decorators.py

@@ -0,0 +1,36 @@
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+from fittrackee.responses import ForbiddenErrorResponse, NotFoundErrorResponse
+
+from .exceptions import CommentForbiddenException
+from .utils import get_comment
+
+if TYPE_CHECKING:
+    from fittrackee.users.models import User
+
+
+def check_workout_comment(only_owner: bool = True) -> Callable:
+    def decorator_check_workout_comment(f: Callable) -> Callable:
+        @wraps(f)
+        def wrapper_check_workout_comment(
+            *args: Any, **kwargs: Any
+        ) -> Callable:
+            auth_user: Optional['User'] = args[0]
+            comment_short_id: str = kwargs["comment_short_id"]
+
+            try:
+                comment = get_comment(comment_short_id, auth_user)
+            except CommentForbiddenException:
+                return NotFoundErrorResponse(
+                    f"workout comment not found (id: {comment_short_id})"
+                )
+            if only_owner and (
+                not auth_user or auth_user.id != comment.user.id
+            ):
+                return ForbiddenErrorResponse()
+            return f(auth_user, comment)
+
+        return wrapper_check_workout_comment
+
+    return decorator_check_workout_comment

fittrackee/comments/exceptions.py

@@ -0,0 +1,6 @@
+from fittrackee.exceptions import GenericException
+
+
+class CommentForbiddenException(GenericException):
+    def __init__(self) -> None:
+        super().__init__('error', 'you do not have permissions')