Merge pull request #198 from cuappdev/friends

Added friends storing

Author: JoshD94

.gitignore

@@ -16,4 +16,5 @@ build/
 Archive
 scripts
 *.sqlite3
-service-account-key.json
+service-account-key.json
+docker-compose.yml

app_factory.py

@@ -1,7 +1,7 @@
 import logging
 from datetime import timedelta, timezone
 from flask_jwt_extended import JWTManager
-from src.utils.constants import SERVICE_ACCOUNT_PATH
+from src.utils.constants import SERVICE_ACCOUNT_PATH, JWT_SECRET_KEY
 from datetime import datetime
 from flask import Flask, render_template
 from graphene import Schema
@@ -71,6 +71,7 @@ def create_app(run_migrations=False):
     schema = Schema(query=Query, mutation=Mutation)
     swagger = Swagger(app)
 
+    app.config['JWT_SECRET_KEY'] = JWT_SECRET_KEY
     app.config["JWT_ACCESS_TOKEN_EXPIRES"] = timedelta(hours=1)
     app.config["JWT_REFRESH_TOKEN_EXPIRES"] = timedelta(days=30)
 

migrations/versions/01234abcdef1_add_friends_table.py

@@ -0,0 +1,37 @@
+"""Add friends table
+
+Revision ID: 01234abcdef1
+Revises: previous_revision_id_here
+Create Date: 2025-03-29 00:45:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from datetime import datetime
+
+
+# revision identifiers, used by Alembic.
+revision = '01234abcdef1'
+down_revision = 'add99ce06ff5'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Create friends table
+    op.create_table('friends',
+                    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+                    sa.Column('user_id', sa.Integer(), nullable=False),
+                    sa.Column('friend_id', sa.Integer(), nullable=False),
+                    sa.Column('created_at', sa.DateTime(), nullable=True, default=datetime.utcnow),
+                    sa.Column('is_accepted', sa.Boolean(), nullable=True, default=False),
+                    sa.Column('accepted_at', sa.DateTime(), nullable=True),
+                    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+                    sa.ForeignKeyConstraint(['friend_id'], ['users.id'], ondelete='CASCADE'),
+                    sa.PrimaryKeyConstraint('id')
+                    )
+
+
+def downgrade():
+    # Drop friends table
+    op.drop_table('friends')

migrations/versions/add_friends_table_migration.py

@@ -0,0 +1,36 @@
+"""Add friends table
+
+Revision ID: add_friends_table
+Revises: 3c406131c004
+Create Date: 2025-03-29 00:55:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from datetime import datetime
+
+
+# revision identifiers, used by Alembic.
+revision = 'add_friends_table'
+down_revision = '3c406131c004'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Create friends table
+    op.create_table('friends',
+                    sa.Column('user_id', sa.Integer(), nullable=False),
+                    sa.Column('friend_id', sa.Integer(), nullable=False),
+                    sa.Column('created_at', sa.DateTime(), nullable=True, server_default=sa.text('CURRENT_TIMESTAMP')),
+                    sa.Column('is_accepted', sa.Boolean(), nullable=True, server_default=sa.text('false')),
+                    sa.Column('accepted_at', sa.DateTime(), nullable=True),
+                    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+                    sa.ForeignKeyConstraint(['friend_id'], ['users.id'], ondelete='CASCADE'),
+                    sa.PrimaryKeyConstraint('user_id', 'friend_id')
+                    )
+
+
+def downgrade():
+    # Drop friends table
+    op.drop_table('friends')

schema.graphql

@@ -136,6 +136,21 @@ enum FacilityType {
   COURT
 }
 
+type Friendship {
+  id: ID!
+  userId: Int!
+  friendId: Int!
+  createdAt: DateTime
+  isAccepted: Boolean
+  acceptedAt: DateTime
+  user: User
+  friend: User
+}
+
+type GetPendingFriendRequests {
+  pendingRequests: [Friendship]
+}
+
 type Giveaway {
   id: ID!
   name: String!
@@ -214,6 +229,10 @@ type Mutation {
   createCapacityReminder(capacityPercent: Int!, daysOfWeek: [String]!, fcmToken: String!, gyms: [String]!): CapacityReminder
   editCapacityReminder(capacityPercent: Int!, daysOfWeek: [String]!, gyms: [String]!, reminderId: Int!): CapacityReminder
   deleteCapacityReminder(reminderId: Int!): CapacityReminder
+  addFriend(friendId: Int!, userId: Int!): Friendship
+  acceptFriendRequest(friendshipId: Int!): Friendship
+  removeFriend(friendId: Int!, userId: Int!): RemoveFriend
+  getPendingFriendRequests(userId: Int!): GetPendingFriendRequests
 }
 
 type OpenHours {
@@ -245,6 +264,7 @@ enum PriceType {
 type Query {
   getAllGyms: [Gym]
   getUserByNetId(netId: String): [User]
+  getUsersFriends(id: Int): [User]
   getUsersByGiveawayId(id: Int): [User]
   getWeeklyWorkoutDays(id: Int): [String]
   getWorkoutsById(id: Int): [Workout]
@@ -253,12 +273,17 @@ type Query {
   getWorkoutGoals(id: Int!): [String]
   getUserStreak(id: Int!): JSONString
   getHourlyAverageCapacitiesByFacilityId(facilityId: Int): [HourlyAverageCapacity]
+  getUserFriends(userId: Int!): [User]
 }
 
 type RefreshAccessToken {
   newAccessToken: String
 }
 
+type RemoveFriend {
+  success: Boolean
+}
+
 type Report {
   id: ID!
   createdAt: DateTime!
@@ -286,6 +311,10 @@ type User {
   workoutGoal: [DayOfWeekGraphQLEnum]
   encodedImage: String
   giveaways: [Giveaway]
+  friendRequestsSent: [Friendship]
+  friendRequestsReceived: [Friendship]
+  friendships: [Friendship]
+  friends: [User]
 }
 
 type Workout {

src/models/friends.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column, Integer, ForeignKey, DateTime, Boolean, UniqueConstraint
+from sqlalchemy.orm import relationship
+from src.database import Base
+from datetime import datetime
+
+class Friendship(Base):
+    """
+    A friendship relationship between two users.
+
+    Attributes:
+        - `id`                 The ID of the friendship.
+        - `user_id`            The ID of the user who initiated the friendship.
+        - `friend_id`          The ID of the user who received the friendship request.
+        - `created_at`         When the friendship was created.
+        - `is_accepted`        Whether the friendship has been accepted.
+        - `accepted_at`        When the friendship was accepted.
+    """
+
+    __tablename__ = "friends"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    friend_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    __table_args__ = (UniqueConstraint('user_id', 'friend_id', name='unique_friendship'),)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    is_accepted = Column(Boolean, default=False)
+    accepted_at = Column(DateTime, nullable=True)
+
+    user = relationship("User", foreign_keys=[user_id], back_populates="friend_requests_sent")
+    friend = relationship("User", foreign_keys=[friend_id], back_populates="friend_requests_received")
+
+    def accept(self):
+        """Accept a friendship request."""
+        self.is_accepted = True
+        self.accepted_at = datetime.utcnow()

src/models/user.py

@@ -1,7 +1,8 @@
-from sqlalchemy import Column, Integer, String, ARRAY, Enum
-from sqlalchemy.orm import backref, relationship
+from sqlalchemy import Column, Integer, String, ARRAY, Enum, ForeignKey
+from sqlalchemy.orm import relationship
 from src.database import Base
 from src.models.enums import DayOfWeekEnum
+from src.models.friends import Friendship
 
 class User(Base):
     """
@@ -30,4 +31,48 @@ class User(Base):
     active_streak = Column(Integer, nullable=True)
     max_streak = Column(Integer, nullable=True)
     workout_goal = Column(ARRAY(Enum(DayOfWeekEnum)), nullable=True)
-    encoded_image = Column(String, nullable=True)
+    encoded_image = Column(String, nullable=True)
+
+    friend_requests_sent = relationship("Friendship",
+                                        foreign_keys="Friendship.user_id",
+                                        back_populates="user")
+
+    friend_requests_received = relationship("Friendship",
+                                            foreign_keys="Friendship.friend_id",
+                                            back_populates="friend")
+
+    def add_friend(self, friend):
+        # Check if friendship already exists
+        existing = Friendship.query.filter(
+            (Friendship.user_id == self.id) &
+            (Friendship.friend_id == friend.id)
+        ).first()
+
+        if not existing:
+            new_friendship = Friendship(user_id=self.id, friend_id=friend.id)
+            # Add to database session here or return for external handling
+            return new_friendship
+
+    def remove_friend(self, friend):
+        friendship = Friendship.query.filter(
+            (Friendship.user_id == self.id) &
+            (Friendship.friend_id == friend.id)
+        ).first()
+
+        if friendship:
+            # Delete from database session here or return for external handling
+            return friendship
+
+    def get_friends(self):
+        # Get users this user has added as friends
+        direct_friends_query = Friendship.query.filter_by(user_id=self.id)
+        direct_friends = [friendship.friend for friendship in direct_friends_query]
+
+        # Get users who have added this user as a friend
+        reverse_friends_query = Friendship.query.filter_by(friend_id=self.id)
+        reverse_friends = [friendship.user for friendship in reverse_friends_query]
+
+        # Combine both lists and remove duplicates
+        all_friends = list(set(direct_friends + reverse_friends))
+
+        return all_friends