Initial commit

2026-03-26 22:46:03 +01:00
commit 18e0e04700
80 changed files with 13114 additions and 0 deletions
@@ -0,0 +1,102 @@
+const Bet = require('../../models/bet.model');
+const { NotFoundError, DatabaseError } = require('../../shared/errors');
+const config = require('../../config');
+
+class BetsRepository {
+  async findAll(filter = {}, options = {}) {
+    try {
+      const { sort = { startDate: -1 }, limit, skip } = options;
+      let query = Bet.find(filter);
+
+      if (sort) query = query.sort(sort);
+      if (limit) query = query.limit(limit);
+      if (skip) query = query.skip(skip);
+
+      return await query.exec();
+    } catch (error) {
+      throw new DatabaseError('Failed to fetch bets', error);
+    }
+  }
+
+  async findById(id) {
+    try {
+      const bet = await Bet.findById(id);
+      if (!bet) {
+        throw new NotFoundError('Bet not found');
+      }
+      return bet;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      if (error.name === 'CastError') {
+        throw new NotFoundError('Bet not found');
+      }
+      throw new DatabaseError(`Failed to fetch bet with id ${id}`, error);
+    }
+  }
+
+  async findByUser(userId) {
+    try {
+      return await Bet.find({ 'participants.user': userId }).sort({ startDate: -1 });
+    } catch (error) {
+      throw new DatabaseError(`Failed to fetch bets for user ${userId}`, error);
+    }
+  }
+
+  async findByGroup(groupId) {
+    try {
+      return await Bet.find({ groupId }).sort({ startDate: -1 });
+    } catch (error) {
+      throw new DatabaseError(`Failed to fetch bets for group ${groupId}`, error);
+    }
+  }
+
+  async findPublicBetsExcludingUser(userId) {
+    try {
+      return await Bet.find({
+        isPublic: true,
+        'participants.user': { $ne: userId },
+      }).sort({ startDate: -1 });
+    } catch (error) {
+      throw new DatabaseError('Failed to fetch public bets', error);
+    }
+  }
+
+  async create(betData) {
+    try {
+      const bet = new Bet({
+        ...betData,
+        startDate: new Date(),
+        status: config.BET_STATUS.ACTIVE,
+      });
+      return await bet.save();
+    } catch (error) {
+      throw new DatabaseError('Failed to create bet', error);
+    }
+  }
+
+  async update(id, updateData) {
+    try {
+      const bet = await this.findById(id);
+      Object.assign(bet, updateData);
+      return await bet.save();
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to update bet with id ${id}`, error);
+    }
+  }
+
+  async delete(id) {
+    try {
+      const result = await Bet.findByIdAndDelete(id);
+      if (!result) {
+        throw new NotFoundError('Bet not found');
+      }
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to delete bet with id ${id}`, error);
+    }
+  }
+}
+
+module.exports = BetsRepository;
@@ -0,0 +1,99 @@
+const { NotFoundError, DatabaseError } = require('../../shared/errors');
+const { Op } = require('sequelize');
+
+class FriendRequestsRepository {
+  constructor({ sequelize }) {
+    this.sequelize = sequelize;
+    this.FriendRequest = sequelize.models.FriendRequest;
+    this.User = sequelize.models.User;
+  }
+
+  async findById(id) {
+    try {
+      const request = await this.FriendRequest.findByPk(id, {
+        include: [
+          { model: this.User, as: 'fromUser' },
+          { model: this.User, as: 'toUser' },
+        ],
+      });
+      if (!request) {
+        throw new NotFoundError('Friend request not found');
+      }
+      return request;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to fetch friend request with id ${id}`, error);
+    }
+  }
+
+  async findPendingByUserId(userId) {
+    try {
+      return await this.FriendRequest.findAll({
+        where: {
+          toUserId: userId,
+          status: 'PENDING',
+        },
+        include: [
+          { model: this.User, as: 'fromUser' },
+          { model: this.User, as: 'toUser' },
+        ],
+      });
+    } catch (error) {
+      throw new DatabaseError(
+        `Failed to fetch pending requests for user ${userId}`,
+        error
+      );
+    }
+  }
+
+  async findExisting(fromUserId, toUserId) {
+    try {
+      return await this.FriendRequest.findOne({
+        where: {
+          [Op.or]: [
+            { fromUserId, toUserId },
+            { fromUserId: toUserId, toUserId: fromUserId },
+          ],
+          status: 'PENDING',
+        },
+      });
+    } catch (error) {
+      throw new DatabaseError('Failed to check existing friend request', error);
+    }
+  }
+
+  async create(fromUserId, toUserId) {
+    try {
+      return await this.FriendRequest.create({
+        fromUserId,
+        toUserId,
+        status: 'PENDING',
+      });
+    } catch (error) {
+      throw new DatabaseError('Failed to create friend request', error);
+    }
+  }
+
+  async updateStatus(id, status) {
+    try {
+      const request = await this.findById(id);
+      return await request.update({ status });
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError('Failed to update friend request status', error);
+    }
+  }
+
+  async delete(id) {
+    try {
+      const request = await this.findById(id);
+      await request.destroy();
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError('Failed to delete friend request', error);
+    }
+  }
+}
+
+module.exports = FriendRequestsRepository;
@@ -0,0 +1,78 @@
+const { NotFoundError, DatabaseError } = require('../../shared/errors');
+const { Op } = require('sequelize');
+
+class FriendshipsRepository {
+  constructor({ sequelize }) {
+    this.sequelize = sequelize;
+    this.Friendship = sequelize.models.Friendship;
+    this.User = sequelize.models.User;
+  }
+
+  async findByUserId(userId) {
+    try {
+      const friendships = await this.Friendship.findAll({
+        where: {
+          [Op.or]: [{ user1Id: userId }, { user2Id: userId }],
+        },
+        include: [
+          { model: this.User, as: 'user1' },
+          { model: this.User, as: 'user2' },
+        ],
+      });
+
+      return friendships.map((friendship) => {
+        const friend =
+          friendship.user1.id === userId ? friendship.user2 : friendship.user1;
+        return friend;
+      });
+    } catch (error) {
+      throw new DatabaseError(`Failed to fetch friendships for user ${userId}`, error);
+    }
+  }
+
+  async exists(user1Id, user2Id) {
+    try {
+      const minId = Math.min(user1Id, user2Id);
+      const maxId = Math.max(user1Id, user2Id);
+
+      const friendship = await this.Friendship.findOne({
+        where: { user1Id: minId, user2Id: maxId },
+      });
+
+      return !!friendship;
+    } catch (error) {
+      throw new DatabaseError('Failed to check friendship existence', error);
+    }
+  }
+
+  async create(user1Id, user2Id) {
+    try {
+      const minId = Math.min(user1Id, user2Id);
+      const maxId = Math.max(user1Id, user2Id);
+
+      return await this.Friendship.create({
+        user1Id: minId,
+        user2Id: maxId,
+      });
+    } catch (error) {
+      throw new DatabaseError('Failed to create friendship', error);
+    }
+  }
+
+  async delete(user1Id, user2Id) {
+    try {
+      const minId = Math.min(user1Id, user2Id);
+      const maxId = Math.max(user1Id, user2Id);
+
+      const result = await this.Friendship.destroy({
+        where: { user1Id: minId, user2Id: maxId },
+      });
+
+      return result > 0;
+    } catch (error) {
+      throw new DatabaseError('Failed to delete friendship', error);
+    }
+  }
+}
+
+module.exports = FriendshipsRepository;
@@ -0,0 +1,93 @@
+const { NotFoundError, DatabaseError } = require('../../shared/errors');
+
+class GroupsRepository {
+  constructor({ sequelize }) {
+    this.sequelize = sequelize;
+    this.Group = sequelize.models.Group;
+    this.User = sequelize.models.User;
+  }
+
+  async findAll(options = {}) {
+    try {
+      return await this.Group.findAll(options);
+    } catch (error) {
+      throw new DatabaseError('Failed to fetch groups', error);
+    }
+  }
+
+  async findById(id, includeMembers = false) {
+    try {
+      const options = {};
+      if (includeMembers) {
+        options.include = [
+          {
+            model: this.User,
+            as: 'members',
+            through: { attributes: [] },
+          },
+        ];
+      }
+      const group = await this.Group.findByPk(id, options);
+      if (!group) {
+        throw new NotFoundError('Group not found');
+      }
+      return group;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to fetch group with id ${id}`, error);
+    }
+  }
+
+  async create(groupData) {
+    try {
+      return await this.Group.create(groupData);
+    } catch (error) {
+      throw new DatabaseError('Failed to create group', error);
+    }
+  }
+
+  async addMembers(groupId, userIds) {
+    try {
+      const group = await this.findById(groupId);
+      await group.addMembers(userIds);
+      return this.findById(groupId, true);
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError('Failed to add members to group', error);
+    }
+  }
+
+  async removeMember(groupId, userId) {
+    try {
+      const group = await this.findById(groupId);
+      await group.removeMember(userId);
+      return this.findById(groupId, true);
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError('Failed to remove member from group', error);
+    }
+  }
+
+  async update(id, updateData) {
+    try {
+      const group = await this.findById(id);
+      return await group.update(updateData);
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to update group with id ${id}`, error);
+    }
+  }
+
+  async delete(id) {
+    try {
+      const group = await this.findById(id);
+      await group.destroy();
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to delete group with id ${id}`, error);
+    }
+  }
+}
+
+module.exports = GroupsRepository;
@@ -0,0 +1,68 @@
+const { NotFoundError, DatabaseError } = require('../../shared/errors');
+
+class UsersRepository {
+  constructor({ sequelize }) {
+    this.sequelize = sequelize;
+    this.User = sequelize.models.User;
+  }
+
+  async findAll(options = {}) {
+    try {
+      return await this.User.findAll(options);
+    } catch (error) {
+      throw new DatabaseError('Failed to fetch users', error);
+    }
+  }
+
+  async findById(id, options = {}) {
+    try {
+      const user = await this.User.findByPk(id, options);
+      if (!user) {
+        throw new NotFoundError('User not found');
+      }
+      return user;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to fetch user with id ${id}`, error);
+    }
+  }
+
+  async findOne(where, options = {}) {
+    try {
+      return await this.User.findOne({ where, ...options });
+    } catch (error) {
+      throw new DatabaseError('Failed to find user', error);
+    }
+  }
+
+  async create(userData) {
+    try {
+      return await this.User.create(userData);
+    } catch (error) {
+      throw new DatabaseError('Failed to create user', error);
+    }
+  }
+
+  async update(id, updateData) {
+    try {
+      const user = await this.findById(id);
+      return await user.update(updateData);
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to update user with id ${id}`, error);
+    }
+  }
+
+  async delete(id) {
+    try {
+      const user = await this.findById(id);
+      await user.destroy();
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) throw error;
+      throw new DatabaseError(`Failed to delete user with id ${id}`, error);
+    }
+  }
+}
+
+module.exports = UsersRepository;