feat: subscriptions

src/modules/groups/dtos/ICreateGroupDTO.ts

@@ -1,6 +1,8 @@
 interface ICreateGroupDTO {
   name: string;
+  description: string;
   super_adm_id: string;
+  subscription_id: string;
 }
 
 export default ICreateGroupDTO;

src/modules/groups/dtos/IUpdateGroupDTO.ts

@@ -1,5 +1,6 @@
 interface IUpdateGroupDTO {
   name: string;
+  description: string;
 }
 
 export default IUpdateGroupDTO;

src/modules/groups/infra/http/controller/GroupsController.ts

@@ -11,14 +11,19 @@ export default class GroupController {
   public async create(req: Request, res: Response): Promise<Response> {
     const {
       name,
-      super_adm_id,
+      description,
+      subscription_id,
     } = req.body;
 
+    const { id } = req.token;
+
     const createGroup = container.resolve(CreateGroupService);
 
     const group = await createGroup.execute({
       name,
-      super_adm_id,
+      subscription_id,
+      description,
+      super_adm_id: id,
     });
 
     return res.status(201).json(group);
@@ -49,6 +54,7 @@ export default class GroupController {
 
     const {
       name,
+      description,
     } = req.body;
 
     const updateGroup = container.resolve(UpdateGroupService);

src/modules/groups/infra/http/routes/groups.routes.ts

@@ -1,15 +1,15 @@
 import { Router } from 'express';
-
+import ensureAuthenticated from '@shared/infra/http/middlewares/EnsureAuthenticated';
 import GroupsController from '../controller/GroupsController';
 
 const groupsRoutes = Router();
 
 const groupsController = new GroupsController();
 
-groupsRoutes.post('/register', groupsController.create);
-groupsRoutes.get('/read', groupsController.readAll);
-groupsRoutes.get('/read/:id', groupsController.readById);
-groupsRoutes.patch('/update/:id', groupsController.update);
-groupsRoutes.delete('/delete/:id', groupsController.delete);
+groupsRoutes.post('/register', ensureAuthenticated, groupsController.create);
+groupsRoutes.get('/read', ensureAuthenticated, groupsController.readAll);
+groupsRoutes.get('/read/:id', ensureAuthenticated, groupsController.readById);
+groupsRoutes.patch('/update/:id', ensureAuthenticated, groupsController.update);
+groupsRoutes.delete('/delete/:id', ensureAuthenticated, groupsController.delete);
 
 export default groupsRoutes;

src/modules/groups/infra/prisma/entities/groups.prisma

@@ -1,6 +1,7 @@
 model Groups {
   id              String   @id @default(uuid())
   name            String   
+  description     String
   created_at      DateTime @default(now())
   updated_at      DateTime @default(now())  
 }

src/modules/groups/infra/prisma/repositories/GroupsRepository.ts

@@ -14,7 +14,14 @@ export default class GroupsRepository implements IGroupsRepository {
 
   public async create(data: ICreateGroupDTO & { include: { invited_users: { select: { email: true; name: true; }; }; }; }): Promise<Groups> {
     const group = await this.ormRepository.create({
-      data,
+      data: {
+        name: data.name,
+        super_adm_id: data.super_adm_id,
+        subscription: {
+          connect: { id: data.subscription_id }
+        },
+        description: data.description,
+      },
       include: {
         invited_users: {
           select: {

src/modules/groups/repositories/IGroupsRepository.ts

@@ -4,8 +4,6 @@ import ICreateGroupDTO from '../dtos/ICreateGroupDTO';
 import IUpdateGroupDTO from '../dtos/IUpdateGroupDTO';
 
 interface IGroupsRepository {
-  // findByEmailWithRelations(email: string): Promise<Groups | null>;
-  // findByEmailPhoneOrCpf(email: string, phone: string, cpf: string): Promise<Groups | null>;
   create(data: ICreateGroupDTO): Promise<Groups>;
   findAll(): Promise<Groups[]>;
   findById(id: string): Promise<Groups | null>;

src/modules/groups/services/CreateGroupService.ts

@@ -3,10 +3,14 @@ import { Groups } from '@prisma/client';
 import AppError from '@shared/errors/AppError';
 import IUsersRepository from '@modules/users/repositories/IUsersRepository';
 import IGroupsRepository from '../repositories/IGroupsRepository';
+import ISubscriptionsRepository from '@modules/subscriptions/repositories/ISubscriptionsRepository';
+import IInvitesRepository from '@modules/invites/repositories/IInvitesRepository';
 
 interface IRequest {
   name: string;
+  description: string;
   super_adm_id: string;
+  subscription_id: string;
 }
 
 @injectable()
@@ -17,19 +21,37 @@ export default class CreateGroupService {
 
     @inject('UsersRepository')
     private usersRepository: IUsersRepository,
+
+    @inject('SubscriptionsRepository')
+    private subscriptionsRepository: ISubscriptionsRepository,
+
+    @inject('InvitesRepository')
+    private invitesRepository: IInvitesRepository,
   ) { }
 
   public async execute({
-    name, super_adm_id,
+    name, description, super_adm_id, subscription_id
   }: IRequest): Promise<Groups> {
     const userAlreadyExists = await this.usersRepository.findById(super_adm_id);
     if (!userAlreadyExists) throw new AppError('User with this super_adm_id does not exist');
 
-    const group = this.groupsRepository.create({
+    const subscriptionAlreadyExists = await this.subscriptionsRepository.findById(subscription_id);
+    if (!subscriptionAlreadyExists) throw new AppError('Subscription with this id does not exist');
+
+    const groupAlreadyExists = await this.subscriptionsRepository.groupIsVinculated(subscription_id);
+    if (groupAlreadyExists) throw new AppError('This subscription is already vinculated to a group');
+
+    const group = await this.groupsRepository.create({
       name,
+      description,
       super_adm_id,
+      subscription_id,
     });
 
-    return group;
+    const updatedGroup = await this.invitesRepository.defaultAdm(group.id, super_adm_id);
+
+    const subscription = await this.subscriptionsRepository.vinculateGroup(subscription_id, group.id);
+
+    return updatedGroup;
   }
 }

src/modules/invites/infra/http/controller/InvitesController.ts

@@ -5,6 +5,8 @@ import CreateInviteService from '@modules/invites/services/CreateInviteService';
 import ReadInvitesByGroupIdService from '@modules/invites/services/ReadInvitesByGroupIdService';
 import DeleteInviteService from '@modules/invites/services/DeleteInviteService';
 import AcceptInviteService from '@modules/invites/services/AcceptInviteService';
+import RejectInviteService from '@modules/invites/services/RejectInviteService';
+import TurnIntoAdmService from '@modules/invites/services/TurnIntoAdmService';
 
 export default class InvitesController {
   public async create(req: Request, res: Response): Promise<Response> {
@@ -13,9 +15,12 @@ export default class InvitesController {
       email,
     } = req.body;
 
+    const { id } = req.token;
+
     const createInvite = container.resolve(CreateInviteService);
 
     const group = await createInvite.execute({
+      id,
       group_id,
       email,
     });
@@ -25,10 +30,12 @@ export default class InvitesController {
 
   public async readAllInvitesByGroup(req: Request, res: Response): Promise<Response> {
     const { group_id } = req.params;
+    const { id } = req.token;
 
     const readUser = container.resolve(ReadInvitesByGroupIdService);
 
     const user = await readUser.execute({
+      id,
       group_id,
     });
 
@@ -38,10 +45,12 @@ export default class InvitesController {
   public async delete(req: Request, res: Response): Promise<Response> {
     const { group_id } = req.params;
     const { email } = req.body;
+    const { id } = req.token;
 
     const deleteUser = container.resolve(DeleteInviteService);
 
     const user = await deleteUser.execute({
+      id,
       group_id,
       email,
     });
@@ -50,16 +59,46 @@ export default class InvitesController {
   }
 
   public async accept(req: Request, res: Response): Promise<Response> {
-    const { user_id } = req.params;
+    const { id } = req.token;
     const { group_id } = req.body;
 
     const acceptInvite = container.resolve(AcceptInviteService);
 
     const group = await acceptInvite.execute({
-      user_id,
+      user_id: id,
+      group_id,
+    });
+
+    return res.status(201).json(group);
+  }
+
+  public async reject(req: Request, res: Response): Promise<Response> {
+    const { id } = req.token;
+    const { group_id } = req.body;
+
+    const rejectInvite = container.resolve(RejectInviteService);
+
+    const group = await rejectInvite.execute({
+      user_id: id,
       group_id,
     });
 
     return res.status(201).json(group);
   }
+
+  public async turnIntoAdm(req: Request, res: Response): Promise<Response> {
+    const { group_id } = req.body;
+    const { user_id } = req.params;
+    const { id } = req.token;
+
+    const turnIntoAdm = container.resolve(TurnIntoAdmService);
+
+    const group = await turnIntoAdm.execute({
+      id,
+      group_id,
+      user_id,
+    });
+
+    return res.status(201).json(group);
+  }
 }

src/modules/invites/infra/http/routes/invites.routes.ts

@@ -1,14 +1,16 @@
 import { Router } from 'express';
-
+import ensureAuthenticated from '@shared/infra/http/middlewares/EnsureAuthenticated';
 import InvitesController from '../controller/InvitesController';
 
 const invitesRoutes = Router();
 
 const invitesController = new InvitesController();
 
-invitesRoutes.post('/register', invitesController.create);
-invitesRoutes.get('/read/:group_id', invitesController.readAllInvitesByGroup);
-invitesRoutes.delete('/delete/:group_id', invitesController.delete);
-invitesRoutes.post('/accept/:user_id', invitesController.accept);
+invitesRoutes.post('/register', ensureAuthenticated, invitesController.create);
+invitesRoutes.get('/read/:group_id', ensureAuthenticated, invitesController.readAllInvitesByGroup);
+invitesRoutes.delete('/delete/:group_id', ensureAuthenticated, invitesController.delete);
+invitesRoutes.post('/accept', ensureAuthenticated, invitesController.accept);
+invitesRoutes.post('/reject', ensureAuthenticated, invitesController.reject);
+invitesRoutes.post('/registerAdm/:user_id', ensureAuthenticated, invitesController.turnIntoAdm);
 
 export default invitesRoutes;

src/modules/invites/infra/prisma/repositories/InvitesRepository.ts

@@ -255,4 +255,89 @@ export default class InvitesRepository implements IInvitesRepository {
       },
     });
   }
+
+  async isAlreadyUser(group_id: string, user_id: string): Promise<Groups | null> {
+    return await prisma.groups.findUnique({
+      where: {
+        id: group_id,
+        users: {
+          some: { id: user_id },
+        }, 
+      },
+    });
+  }
+
+  async isAlreadyAdm(group_id: string, id: string): Promise<Groups | null> {
+    return await prisma.groups.findUnique({
+      where: {
+        id: group_id,
+        adms: {
+          some: { id },
+        }, 
+      },
+    });
+  }
+
+  async turnIntoAdm(group_id: string, user_id: string): Promise<Groups> {
+    return await prisma.groups.update({
+      where: {
+        id: group_id,
+      },
+      data: {
+        users: {
+          disconnect: {
+            id: user_id,
+          },
+        },
+        adms: {
+          connect: {
+            id: user_id,
+          },
+        },
+      },
+      include: {
+        users: {
+          select: {
+            email: true,
+            name: true,
+          },
+        },
+        adms: {
+          select: {
+            email: true,
+            name: true,
+          },
+        },
+      },
+    });
+  }
+
+  async defaultAdm(group_id: string, user_id: string): Promise<Groups> {
+    return await prisma.groups.update({
+      where: {
+        id: group_id,
+      },
+      data: {
+        adms: {
+          connect: {
+            id: user_id,
+          },
+        },
+      },
+      include: {
+        users: {
+          select: {
+            email: true,
+            name: true,
+          },
+        },
+        adms: {
+          select: {
+            email: true,
+            name: true,
+          },
+        },
+      },
+    });
+  }
 }

src/modules/invites/repositories/IInvitesRepository.ts

@@ -10,6 +10,10 @@ interface IInvitesRepository {
   delete(group_id: string, email: string): Promise<Groups>;
   updateInvites(email: string): Promise<Groups[]>;
   acceptInvite(group_id: string, user_id: string): Promise<Groups>;
+  isAlreadyUser(group_id: string, user_id: string): Promise<Groups | null>;
+  isAlreadyAdm(group_id: string, id: string): Promise<Groups | null>;
+  turnIntoAdm(group_id: string, user_id: string): Promise<Groups>;
+  defaultAdm(group_id: string, user_id: string): Promise<Groups>;
 }
 
 export default IInvitesRepository;