Deploying to prod

iac/lib/iac_stack.ts

@@ -19,8 +19,7 @@ export class IacStack extends cdk.Stack {
         allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
         allowHeaders: ["*"],
       }
-    }
-    );
+    });
 
     const bucket = new Bucket(this, "Coil_Bucket", {
       bucketName: "coil-bucket",

iac/lib/lambda_stack.ts

@@ -6,24 +6,28 @@ export class LambdaStack extends Construct {
     private get_user: lambda_js.NodejsFunction;
     private auth_user: lambda_js.NodejsFunction;
     private create_moderator: lambda_js.NodejsFunction;
-
+    private get_all_moderators: lambda_js.NodejsFunction;
+    private delete_moderator: lambda_js.NodejsFunction;
+
     private get_institution: lambda_js.NodejsFunction;
     private create_institution: lambda_js.NodejsFunction;
     private update_institution: lambda_js.NodejsFunction;
     private get_all_institutions: lambda_js.NodejsFunction;
     private get_institution_requirements: lambda_js.NodejsFunction;
 
-    private assign_user: lambda_js.NodejsFunction; 
+    private assign_user: lambda_js.NodejsFunction;
     private get_activity: lambda_js.NodejsFunction;
     private create_activity: lambda_js.NodejsFunction;
     private update_activity: lambda_js.NodejsFunction;
     private get_all_activities: lambda_js.NodejsFunction;
     private update_users_activity: lambda_js.NodejsFunction;
     private update_activity_event: lambda_js.NodejsFunction;
     private get_activity_requirements: lambda_js.NodejsFunction;
+    private get_catalog: lambda_js.NodejsFunction;
     private get_all_activities_enrolled: lambda_js.NodejsFunction;
 
     public functions_need_s3_access: lambda.Function[] = [];
+    public function_need_event_bridge_access: lambda.Function[] = [];
     public functions_need_event_bridge_access: lambda.Function[] = [];
 
     private create_lambda(
@@ -57,9 +61,9 @@ export class LambdaStack extends Construct {
 
         restapi_resource.addResource(function_name.replace(/_/g, "-"), {
             defaultCorsPreflightOptions: {
-            allowOrigins: origins,
-            allowMethods: [method],
-            allowHeaders: ["*"],
+                allowOrigins: origins,
+                allowMethods: [method],
+                allowHeaders: ["*"],
             }
         }).addMethod(method, new apigw.LambdaIntegration(function_lambda));
 
@@ -104,6 +108,14 @@ export class LambdaStack extends Construct {
             origins
         );
 
+        this.delete_moderator = this.create_lambda(
+            "delete_moderator",
+            environment_variables,
+            "GET",
+            restapi_resource,
+            origins
+        );
+
         this.create_activity = this.create_lambda(
             "create_activity",
             environment_variables,
@@ -222,6 +234,22 @@ export class LambdaStack extends Construct {
             origins
         )
 
+        this.get_catalog = this.create_lambda(
+            "get_catalog",
+            environment_variables,
+            "GET",
+            restapi_resource,
+            origins
+        )
+
+        this.get_all_moderators = this.create_lambda(
+            "get_all_moderators",
+            environment_variables,
+            "GET",
+            restapi_resource,
+            origins
+        )
+
         this.functions_need_s3_access = [
             this.create_institution,
             this.update_institution,
@@ -230,6 +258,25 @@ export class LambdaStack extends Construct {
         this.functions_need_event_bridge_access = [
             this.create_activity,
             this.update_activity,
+            this.update_activity_event,
         ]
+
+        this.functions_need_event_bridge_access.forEach((function_lambda) => {
+            function_lambda.addToRolePolicy(
+                new iam.PolicyStatement({
+                    actions: [
+                        "events:PutRule",
+                        "events:PutTargets",
+                        "events:RemoveTargets",
+                        "events:DeleteRule",
+                    ],
+                    resources: ["*"],
+                }))
+            function_lambda.addPermission("EventBridgePermission", {
+                principal: new iam.ServicePrincipal("events.amazonaws.com"),
+                sourceArn: "arn:aws:events:us-east-1:123456789012:rule/*",
+                action: "lambda:InvokeFunction",
+            });
+        });
     }
 }

populate_database.ts

@@ -269,6 +269,39 @@ async function createOrUpdateUser(user: UserEntity): Promise<void> {
     }
 }
 
+async function createOrUpdateStatusActivity(status: ActivityStatusEnum) {
+    try {
+        let existing = await ActivityStatus.findOne({ where: { id: status } });
+        let name: string;
+        switch (status) {
+            case ActivityStatusEnum.ACTIVE:
+                name = "Apply Now";
+                break;
+            case ActivityStatusEnum.CANCELED:
+                name = "Canceled";
+                break;
+            case ActivityStatusEnum.ENDED:
+                name = "Ended";
+                break;
+            case ActivityStatusEnum.ON_HOLD:
+                name = "Under Analysis";
+                break;
+            case ActivityStatusEnum.TO_START:
+                name = "Coming Soon";
+                break;
+        }
+        if (!existing) {
+            await ActivityStatus.create({ name: name });
+            console.log(`Activity status ${status} created`);
+        } else {
+            await ActivityStatus.update({ name: name }, { where: { id: status } });
+            console.log(`Activity status ${status} updated`);
+        }
+    } catch (error) {
+        console.error(`Error creating or updating activity status ${status}:`, error);
+    }
+}
+
 (async () => {
     try {
         await handleDatabaseCreation();
@@ -278,12 +311,17 @@ async function createOrUpdateUser(user: UserEntity): Promise<void> {
         await handleLanguagesCreation();
 
         await handleCountriesCreation();
-        
+
         await handleCriteriasCreation();
 
-        await createOrUpdateSocialMedia();
+        await createOrUpdateSocialMedia();  
+
+        await createOrUpdateStatusActivity(ActivityStatusEnum.ACTIVE);
+        await createOrUpdateStatusActivity(ActivityStatusEnum.CANCELED);
+        await createOrUpdateStatusActivity(ActivityStatusEnum.ENDED);
+        await createOrUpdateStatusActivity(ActivityStatusEnum.ON_HOLD);
+        await createOrUpdateStatusActivity(ActivityStatusEnum.TO_START);
 
-        await createOrUpdateEnumItems(ActivityStatus, activityStatuses, ActivityStatusEnum);
         await createOrUpdateEnumItems(ActivityType, activityTypes, ActivityTypeEnum);
         await createOrUpdateEnumItems(UserType, userTypes, UserTypeEnum);
 

src/core/helpers/functions/event_bridge.ts

@@ -5,16 +5,12 @@ dotenv.config();
 
 
 export class EventBridgeManager {
-    private event: EventBridge;
     private lambda: Lambda;
-    private aws_region: string;
-    private aws_account_id: string;
+    private event: EventBridge;
 
     constructor() {
-        this.event = new EventBridge();
         this.lambda = new Lambda();
-        this.aws_region = process.env.AWS_REGION as string;
-        this.aws_account_id = process.env.AWS_ACCOUNT_ID as string;
+        this.event = new EventBridge();
     }
 
     private async get_rule(rule_name: string): Promise<any | undefined> {
@@ -40,20 +36,11 @@ export class EventBridgeManager {
         }).promise();
         const lambda_arn = lambda_response.Configuration?.FunctionArn as string;
 
-        // Add permission
-        await this.lambda.addPermission({
-            Action: "lambda:InvokeFunction",
-            FunctionName: lambda_function,
-            Principal: "events.amazonaws.com",
-            StatementId: rule_name,
-            SourceArn: "arn:aws:events:" + this.aws_region + ":" + this.aws_account_id + ":rule/" + rule_name,
-        }).promise();
-
         // Create CloudWatch Events rule
         await this.event.putRule({
             Name: rule_name,
             ScheduleExpression: "cron(" + date.getMinutes() + " " + date.getHours() + " " + date.getDate() + " " + (date.getMonth() + 1) + " ? " + date.getFullYear() + ")",
-            State: "ENABLED",
+            State: "ENABLED"
         }).promise();
 
         // Add target to the rule
@@ -72,27 +59,34 @@ export class EventBridgeManager {
                 },
             ],
         }).promise();
+
+        // Add permission to Lambda function
+        await this.lambda.addPermission({
+            FunctionName: lambda_function,
+            StatementId: rule_name,
+            Action: "lambda:InvokeFunction",
+            Principal: "events.amazonaws.com",
+            SourceArn: "arn:aws:events:" + process.env.AWS_REGION + ":" + process.env.AWS_ACCOUNT_ID + ":rule/" + rule_name,
+        }).promise();
+
+        return true;
     }
 
     public async delete_trigger(rule_name: string, lambda_function: string): Promise<boolean> {
         const has_rule = await this.get_rule(rule_name);
         lambda_function = lambda_function + "_Coil";
-    
+
         if (has_rule) {
-            await this.lambda.removePermission({
-                FunctionName: lambda_function,
-                StatementId: rule_name,
-            }).promise();
-
+
             await this.event.removeTargets({
                 Rule: rule_name,
                 Ids: [rule_name],
             }).promise();
-    
+
             await this.event.deleteRule({
                 Name: rule_name,
             }).promise();
-    
+
             return true;
         } else {
             return true;

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

@@ -25,6 +25,7 @@ import {
     Country,
     SocialMedia
 } from "../models/Models";
+import { a } from "vitest/dist/suite-IbNSsUWN";
 
 
 export class ActivityRepo implements IActivityRepo {
@@ -158,8 +159,6 @@ export class ActivityRepo implements IActivityRepo {
             return null;
         }
 
-        console.log(activities.map((activity) => activity.toJSON()));
-
         return activities.map((activity) => this.ActivityDTO.to_entity(activity.toJSON()));
     }
 
@@ -354,7 +353,7 @@ export class ActivityRepo implements IActivityRepo {
                 id: activity.id
             }
         });
-        
+
         await ActivityPartnerInstitution.destroy({
             where: {
                 activity_id: activity.id
@@ -438,19 +437,96 @@ export class ActivityRepo implements IActivityRepo {
     }
 
     async update_users_activity_status(activity_id: string, users: { user_id: string, status: boolean }[]): Promise<boolean> {
-        for (let user of users) {
-            const response = await ActivityApplication.update({
-                status: user.status
+        let response = true;
+
+        users.forEach(async user => {
+            const response_user = await ActivityApplication.update({
+                status: !user.status
             }, {
                 where: {
                     activity_id: activity_id,
                     user_id: user.user_id
                 }
             });
-            if (response[0] === 0) {
-                return false;
+            if (response_user[0] === 0) {
+                response = false;
             }
-        }
-        return true;
+        });
+
+        return response;
+    }
+
+    async get_all_activities_catalog(): Promise<{ title: string; logo: string; type_activity: ActivityTypeEnum; }[]> {
+        const response_project = await ActivityDB.findAll({
+            include: [{
+                model: ActivityPartnerInstitution, as: 'partner_institutions',
+                include: [{
+                    model: Institution,
+                    as: 'institution',
+                    include: [{
+                        model: InstitutionImageDB, as: 'images',
+                        limit: 1,
+                        order: [['id', 'ASC']]
+                    }]
+                }]
+            }],
+            where: {
+                status_id: {
+                    [Op.or]: [ActivityStatusEnum.ACTIVE, ActivityStatusEnum.TO_START]
+                },
+                type_id: ActivityTypeEnum.PROJECT
+            },
+            order: [
+                ['start_date', 'ASC']
+            ],
+            limit: 5
+        });
+
+        const response_mobility = await ActivityDB.findAll({
+            include: [{
+                model: ActivityPartnerInstitution, as: 'partner_institutions',
+                include: [{
+                    model: Institution,
+                    as: 'institution',
+                    include: [{
+                        model: InstitutionImageDB, as: 'images',
+                        limit: 1,
+                        order: [['id', 'ASC']]
+                    }]
+                }]
+            }],
+            where: {
+                status_id: {
+                    [Op.or]: [ActivityStatusEnum.ACTIVE, ActivityStatusEnum.TO_START]
+                },
+                type_id: ActivityTypeEnum.ACADEMIC_MOBILITY
+            },
+            order: [
+                ['start_date', 'ASC']
+            ],
+            limit: 5
+        });
+
+        let activities = response_project.concat(response_mobility);
+
+        let activities_json: {
+            title: string;
+            partner_institutions: {
+                institution: {
+                    images: { image: string }[];
+                };
+            }[];
+            type_id: ActivityTypeEnum;
+        }[] = activities.map(activity => activity.toJSON());
+
+        activities_json = activities_json.map(activity => (
+            activity = activity.partner_institutions.length > 0 ? activity : { ...activity, partner_institutions: [{ institution: { images: [{ image: "" }] } }] }
+        ));
+
+        return activities_json.map(activity => ({
+            title: activity.title,
+            logo: activity.partner_institutions[0].institution.images[0].image,
+            type_activity: activity.type_id
+        }));
     }
 }