Creating get all activities enrolled

src/core/repositories/database/repositories/ActivityRepo.ts

@@ -1,8 +1,9 @@
-import { Includeable } from "sequelize";
+import { Includeable, Op } from "sequelize";
 import { ActivityDTO } from "../dtos/ActivityDTO";
 import { User } from "../../../structure/entities/User";
 import { IActivityRepo } from "../../interfaces/IActivityRepo";
 import { Activity } from "../../../structure/entities/Activity";
+import { ActivityTypeEnum } from "../../../helpers/enums/ActivityTypeEnum";
 import { ActivityStatusEnum } from "../../../helpers/enums/ActivityStatusEnum";
 import {
     Course,
@@ -68,12 +69,57 @@ export class ActivityRepo implements IActivityRepo {
             return null;
         }
 
-        console.log(activity.toJSON());
         return this.ActivityDTO.to_entity(activity.toJSON());
     }
 
-    async get_activities_by_user_id(user_id: string, type: ActivityStatusEnum): Promise<Activity[] | null> {
-        throw new Error("Method not implemented.");
+    async get_activities_by_user_id(
+      user_id: string,
+      type: ActivityTypeEnum
+    ): Promise<Activity[] | null> {
+      const activities = await ActivityDB.findAll({
+        include: [
+          {
+            model: ActivityCourse,
+            as: 'courses',
+            include: [{ model: Course, as: "course", attributes: ['name'] }],
+            attributes: ['course_id']
+          },
+          { model: ActivityLanguage, as: 'languages', attributes: ['language'] },
+          {
+            model: ActivityPartnerInstitution,
+            as: 'partner_institutions',
+            include: [{
+              model: Institution,
+              as: 'institution',
+              include: [{
+                model: InstitutionImageDB,
+                as: 'images',
+                limit: 1,
+                order: [['id', 'ASC']],
+                attributes: ['image']
+              }],
+              attributes: ['name']
+            }],
+            attributes: ['institution_id']
+          },
+          {
+            model: ActivityStatus,
+            as: 'activity_status',
+            where: { id: { [Op.notLike]: ActivityStatusEnum.CANCELED } },
+          },
+          { model: ActivityType, as: 'activity_type', where: { id: type } },
+          { model: ActivityApplication, as: 'applications', where: { user_id: user_id } },
+        ],
+        order: [['start_date', 'ASC']],
+      });
+
+      if (!activities) {
+        return null;
+      }
+
+      return activities.map((activity) =>
+        activity.toJSON()
+      );
     }
 
     async create_activity(activity: Activity): Promise<boolean> {
@@ -285,13 +331,12 @@ export class ActivityRepo implements IActivityRepo {
         return true;
     }
 
-    async update_user_activity_status(activity_id: string, user_id: string, status: boolean): Promise<boolean> {
-        const response = await ActivityApplication.update({
-            status: status
+    async update_activity_status(activity_id: string, status: ActivityStatusEnum): Promise<boolean> {
+        const response = await ActivityDB.update({
+            status_id: status
         }, {
             where: {
-                activity_id: activity_id,
-                user_id: user_id
+                id: activity_id
             }
         });
         if (response[0] === 0) {
@@ -300,14 +345,18 @@ export class ActivityRepo implements IActivityRepo {
         return true;
     }
 
-    async update_activity_status(activity_id: string, status: ActivityStatusEnum): Promise<boolean> {
-        await ActivityDB.update({
-            status_id: status
+    async update_user_activity_status(activity_id: string, user_id: string, status: boolean): Promise<boolean> {
+        const response = await ActivityApplication.update({
+            status: status
         }, {
             where: {
-                id: activity_id
+                activity_id: activity_id,
+                user_id: user_id
             }
         });
+        if (response[0] === 0) {
+            return false;
+        }
         return true;
     }
 }

src/core/repositories/interfaces/IActivityRepo.ts

@@ -13,7 +13,7 @@ export interface IActivityRepo {
 
     get_activity(id: string, applicants?: boolean): Promise<Activity | null>
     get_users_assigned_to_activity(activity_id: string): Promise<User[]>
-    get_activities_by_user_id(user_id: string, type: ActivityStatusEnum): Promise<Activity[] | null>
+    get_activities_by_user_id(user_id: string, type: ActivityTypeEnum): Promise<Activity[] | null>
     get_all_activities_by_status(status: ActivityStatusEnum | ActivityStatusEnum[], type: ActivityTypeEnum): Promise<Activity[] | null> 
 
     assign_user_to_activity(activity_id: string, user_id: string): Promise<{ assign: boolean }>

src/core/repositories/mocks/ActivityRepoMock.ts

@@ -3,6 +3,7 @@ import { IActivityRepo } from '../interfaces/IActivityRepo';
 import { Activity } from '../../structure/entities/Activity';
 import { ActivityMock } from '../../structure/mocks/ActivityMock';
 import { ActivityStatusEnum } from "../../helpers/enums/ActivityStatusEnum";
+import { ActivityTypeEnum } from '../../helpers/enums/ActivityTypeEnum';
 
 
 export class ActivityRepoMock implements IActivityRepo {
@@ -12,8 +13,8 @@ export class ActivityRepoMock implements IActivityRepo {
         this.activity_mock = new ActivityMock();
     }
 
-    async get_activities_by_user_id(user_id: string, type: ActivityStatusEnum): Promise<Activity[] | null> {
-        throw new Error("Method not implemented.");
+    async get_activities_by_user_id(user_id: string, type: ActivityTypeEnum): Promise<Activity[] | null> {
+        return this.activity_mock.activities.filter(activity => activity.applicants.some(applicant => applicant.id === user_id && activity.type_activity === type));
     }
 
     async check_activity_by_title(title: string): Promise<boolean> {

src/modules/get_all_activities_enrolled/app/get_all_activities_enrolled_controller.ts

@@ -0,0 +1,67 @@
+import {
+  InvalidRequest,
+  MissingParameter,
+  NotfoundError,
+  UserNotAllowed,
+  UserNotAuthenticated,
+} from "../../../core/helpers/errors/ModuleError";
+import {
+  BadRequest,
+  HttpRequest,
+  HttpResponse,
+  InternalServerError,
+  OK,
+  ParameterError,
+  Unauthorized,
+  NotFound,
+  Forbidden,
+} from "../../../core/helpers/http/http_codes";
+import { GetAllActivitiesEnrolledUsecase } from "./get_all_activities_enrolled_usecase";
+
+export class GetAllActivitiesEnrolledController {
+  public usecase: GetAllActivitiesEnrolledUsecase;
+
+  constructor(usecase: GetAllActivitiesEnrolledUsecase) {
+    this.usecase = usecase;
+  }
+
+  public async execute(request: HttpRequest): Promise<HttpResponse> {
+    try {
+      if (!request) {
+        throw new InvalidRequest();
+      }
+      if (!request.headers) {
+        throw new InvalidRequest("Headers");
+      }
+      if (!request.body) {
+        throw new InvalidRequest("Body");
+      }
+
+      const queryStringParams = request.body.queryStringParameters;
+
+      const response = await this.usecase.execute(
+        request.headers,
+        queryStringParams
+      );
+
+      return new OK(response || {}, "Activities enrolled found successfully");
+    } catch (error) {
+      if (error instanceof InvalidRequest) {
+        return new BadRequest(error.message);
+      }
+      if (error instanceof UserNotAuthenticated) {
+        return new Unauthorized(error.message);
+      }
+      if( error instanceof UserNotAllowed) {
+        return new Forbidden(error.message);
+      }
+      if (error instanceof MissingParameter) {
+        return new ParameterError(error.message);
+      }
+      if (error instanceof NotfoundError) {
+        return new NotFound(error.message);
+      }
+      return new InternalServerError(error.message);
+    }
+  }
+}

src/modules/get_all_activities_enrolled/app/get_all_activities_enrolled_presenter.ts

@@ -0,0 +1,18 @@
+import { HttpRequest } from "../../../core/helpers/http/http_codes";
+import { GetAllActivitiesEnrolledController } from "./get_all_activities_enrolled_controller";
+import { GetAllActivitiesEnrolledUsecase } from "./get_all_activities_enrolled_usecase";
+import { Repository } from "../../../core/repositories/Repository";
+
+const repository = new Repository({ user_repo: true, activity_repo: true });
+
+const usecase = new GetAllActivitiesEnrolledUsecase(
+  repository.UserRepo,
+  repository.ActivityRepo
+);
+const controller = new GetAllActivitiesEnrolledController(usecase);
+
+export const handler = async (event: any, context: any) => {
+  let request = new HttpRequest(event);
+  let response = await controller.execute(request);
+  return response.to_json();
+};

src/modules/get_all_activities_enrolled/app/get_all_activities_enrolled_usecase.ts

@@ -0,0 +1,67 @@
+import { ActivityStatusEnum } from "../../../core/helpers/enums/ActivityStatusEnum";
+import { UserTypeEnum } from "../../../core/helpers/enums/UserTypeEnum";
+import { IActivityRepo } from "../../../core/repositories/interfaces/IActivityRepo";
+import { IUserRepo } from "../../../core/repositories/interfaces/IUserRepo";
+import {
+  InvalidRequest,
+  MissingParameter,
+  UserNotAllowed,
+  UserNotAuthenticated,
+} from "../../../core/helpers/errors/ModuleError";
+import { TokenAuth } from "../../../core/helpers/functions/token_auth";
+import { NotFound } from "../../../core/helpers/http/http_codes";
+
+export class GetAllActivitiesEnrolledUsecase {
+  public token_auth: TokenAuth;
+  public user_repo: IUserRepo;
+  public activity_repo: IActivityRepo;
+
+  constructor(user_repo: IUserRepo, activity_repo: IActivityRepo) {
+    this.token_auth = new TokenAuth();
+    this.user_repo = user_repo;
+    this.activity_repo = activity_repo;
+  }
+
+  async execute(
+    headers: { [key: string]: any },
+    queryStringParameters: { [key: string]: any }
+  ) {
+    if (!headers) {
+      throw new InvalidRequest("Headers");
+    }
+    if (!headers.Authorization) {
+      throw new MissingParameter("Authorization");
+    }
+
+    if (!queryStringParameters) {
+      throw new InvalidRequest("Query String Parameters");
+    }
+    if (!queryStringParameters.type_activity) {
+      throw new MissingParameter("type_activity");
+    }
+
+    const user_id = await this.token_auth
+      .decode_token(headers.Authorization)
+      .then((response) => {
+        return response;
+      })
+      .catch((error) => {
+        throw new UserNotAuthenticated("Invalid or expired token");
+      });
+
+    const user = await this.user_repo.get_user(user_id);
+    if (!user) {
+      throw new UserNotAuthenticated();
+    }
+
+    if (user.user_type !== UserTypeEnum.STUDENT) {
+      throw new UserNotAllowed("User is not a student");
+    }
+
+    const activities = await this.activity_repo.get_activities_by_user_id(
+      user_id,
+      queryStringParameters.type_activity
+    );
+    return activities ? activities : [];
+  }
+}

src/modules/update_activity/app/update_activity_usecase.ts

@@ -106,8 +106,6 @@ export class UpdateActivityUsecase {
       throw new NotfoundError("Activity not found");
     }
 
-    console.log(activity);
-
     if (body.start_date && body.end_date) {
       if (new Date(body.start_date) < new Date()) {
         throw new InvalidParameter("StartDate", "Start Date must be in the future");