feat: comment_react

.github/workflows/config.yml

@@ -3,12 +3,16 @@ on:
     push:
         paths:
             - '**.js'
+        # branches:
+        #     - develop
         branches:
-            - develop
+            - contest/gdsc-hackathon-2024
     pull_request:
         types: [opened, synchronize]
+        # branches:
+        #     - develop
         branches:
-            - develop
+            - contest/gdsc-hackathon-2024
 jobs:
     build:
         runs-on: self-hosted

backend/.lintstagedrc.json

@@ -1,3 +1,3 @@
 {
-  "*.js": ["npm run lint", "git add ."]
+    "*.js": ["npm run lint"]
 }

backend/package.json

@@ -54,6 +54,7 @@
         "@babel/runtime": "^7.14.0",
         "@commitlint/cli": "^17.5.0",
         "@commitlint/config-conventional": "^17.4.4",
+        "@faker-js/faker": "^8.4.1",
         "babel-eslint": "^10.1.0",
         "babel-plugin-module-resolver": "^4.1.0",
         "babel-plugin-transform-runtime": "^6.23.0",

backend/src/core/api/comment/comment.controller.js

@@ -0,0 +1,43 @@
+import { ValidHttpResponse } from 'packages/handler/response/validHttp.response';
+import { DEFAULT_PAGE, DEFAULT_PAGE_SIZE } from 'core/common/constants';
+import { MessageDto } from 'core/common/dto';
+import {
+    AddCommentDto,
+    COMMENT_PARENT_TYPE,
+    CommentService,
+} from 'core/modules/comment';
+
+class Controller {
+    constructor() {
+        this.commentService = CommentService;
+    }
+
+    createComment = async req => {
+        const { parentType, parentId, content } = AddCommentDto(req.body);
+        await this.commentService.createComment(
+            parentId,
+            parentType,
+            content,
+            req.user.payload.id,
+        );
+        return ValidHttpResponse.toOkResponse(MessageDto('Comment created'));
+    };
+
+    getCommentPaginationByParentIdAndType = async req => {
+        const parentId = req.params.id;
+        const page = req.query.page || DEFAULT_PAGE;
+        const size = req.query.size || DEFAULT_PAGE_SIZE;
+        const parentType = req.query.keyword || 'POST';
+        const data =
+            await this.commentService.getCommentPaginationByParentIdAndType(
+                parentId,
+                COMMENT_PARENT_TYPE[parentType],
+                page,
+                size,
+            );
+
+        return ValidHttpResponse.toOkResponse(data);
+    };
+}
+
+export const CommentController = new Controller();

backend/src/core/api/comment/comment.resolver.js

@@ -0,0 +1,29 @@
+import { Module } from 'packages/handler/Module';
+import { RecordId, page, size, keyword } from 'core/common/swagger';
+import { CommentController } from './comment.controller';
+
+export const CommentResolver = Module.builder()
+    .addPrefix({
+        prefixPath: '/comments',
+        tag: 'comments',
+        module: 'CommentModule',
+    })
+    .register([
+        {
+            route: '',
+            method: 'post',
+            controller: CommentController.createComment,
+            body: 'AddCommentDto',
+            model: { $ref: 'MessageDto' },
+            preAuthorization: true,
+        },
+        {
+            route: '/:id/nested',
+            method: 'get',
+            params: [page, size, keyword, RecordId],
+            controller: CommentController.getCommentPaginationByParentIdAndType,
+            model: { $ref: 'PaginationCommentDto' },
+            description:
+                'Get list nested comments of a post or comment (Keyword POST or COMMENT)',
+        },
+    ]);

backend/src/core/api/emergency/emergency.controller.js

@@ -0,0 +1,16 @@
+import { EmergencyService } from 'core/modules/emergency/servicce/emergency.service';
+import { ValidHttpResponse } from '../../../packages/handler/response/validHttp.response';
+
+class Controller {
+    constructor() {
+        this.service = EmergencyService;
+    }
+
+    getAllEmergency = async () => {
+        const data = await this.service.getAllEmergency();
+        return ValidHttpResponse.toOkResponse(data);
+    };
+
+}
+
+export const EmergencyController = new Controller();

backend/src/core/api/emergency/emergency.resolver.js

@@ -0,0 +1,18 @@
+import { Module } from 'packages/handler/Module';
+import { EmergencyController } from './emergency.controller';
+
+export const EmergencyResolver = Module.builder()
+    .addPrefix({
+        prefixPath: '/emergency',
+        tag: 'emergency',
+        module: 'emergency',
+    })
+    .register([
+        {
+            route: '/getAllEmergency',
+            method: 'get',
+            controller: EmergencyController.getAllEmergency,
+            preAuthorization: true,
+        },
+
+    ]);

backend/src/core/api/emergency/index.js

@@ -0,0 +1 @@
+export * from './emergency.resolver';

backend/src/core/api/helpSignal/helpSignal.controller.js

@@ -7,12 +7,46 @@ class Controller {
         this.service = HelpSignalService;
     }
 
+    acceptSupport = async req => {
+        const { helpSignalId } = req.params;
+        const userId = req.user.payload.id;
+        const data = await this.service.acceptSupport(helpSignalId, userId);
+        return ValidHttpResponse.toOkResponse(data);
+    };
+
+    cancelSupportByRescuer = async req => {
+        const { helpSignalId } = req.params;
+        const rescuerId = req.user.payload.id;
+        const data = await this.service.cancelSupport(helpSignalId, rescuerId);
+        return ValidHttpResponse.toOkResponse(data);
+    }
+
+    cancelSupportByUser = async req => {
+        const { helpSignalId, rescuerId } = req.params;
+        const userId = req.user.payload.id;
+        const data = await this.service.cancelSupport(helpSignalId, rescuerId, userId);
+        return ValidHttpResponse.toOkResponse(data);
+    }
+
+    getRescuersByHelpSignalId = async req => {
+        const { helpSignalId } = req.params;
+        const data = await this.service.getRescuersByHelpSignalId(helpSignalId);
+        return ValidHttpResponse.toOkResponse(data);
+    };
+
     createHelpSignal = async req => {
-        const signal = { ...req.body, statusId: 0, userId: req.user.payload.id };
+        const signal = { ...req.body, userId: req.user.payload.id };
         const data = await this.service.createHelpSignal(createHelpSignalDto(signal), req);
         return ValidHttpResponse.toCreatedResponse(data);
     }
 
+    sendNotificationToUsers = async req => {
+        const {helpSignalId} = req.params;
+        const userId = req.user.payload.id;
+        const data = await this.service.sendNotificationToUsers(helpSignalId, userId);
+        return ValidHttpResponse.toOkResponse(data);
+    }
+
     findHelpSignalById = async req => {
         const data = await this.service.findHelpSignalById(req.params.helpSignalId);
         return ValidHttpResponse.toOkResponse(data);
@@ -43,6 +77,20 @@ class Controller {
         return ValidHttpResponse.toOkResponse(message);
     }
 
+    verifyDone = async req => {
+        const { helpSignalId } = req.params;
+        const userId = req.user.payload.id;
+        const data = await this.service.verifyDoneOrCancel(userId, helpSignalId, true);
+        return ValidHttpResponse.toOkResponse(data);
+    }
+
+    verifyCancel = async req => {
+        const { helpSignalId } = req.params;
+        const userId = req.user.payload.id;
+        const data = await this.service.verifyDoneOrCancel(userId, helpSignalId, false);
+        return ValidHttpResponse.toOkResponse(data);
+    }
+
 }
 
 export const HelpSignalController = new Controller();

backend/src/core/api/helpSignal/helpSignal.resolver.js

@@ -2,6 +2,7 @@ import { Module } from 'packages/handler/Module';
 import { createHelpSignalInterceptor } from 'core/modules/helpSignal/interceptor';
 import { helpSignalId, userId, emergencyId, uploadMediaSwagger } from 'core/common/swagger';
 import { MediaInterceptor } from 'core/modules/document';
+import { rescuerId } from 'core/common/swagger/rescuer-id';
 import { HelpSignalController } from './helpSignal.controller';
 
 export const HelpSignalResolver = Module.builder()
@@ -21,6 +22,13 @@ export const HelpSignalResolver = Module.builder()
             controller: HelpSignalController.createHelpSignal,
             preAuthorization: true,
         },
+        {
+            route: '/sendNoitf/:helpSignalId',
+            method: 'get',
+            params: [helpSignalId],
+            controller: HelpSignalController.sendNotificationToUsers,
+            preAuthorization: true,
+        },
         {
             route: '/getAllHelpSignals',
             method: 'get',
@@ -64,5 +72,47 @@ export const HelpSignalResolver = Module.builder()
             params: [helpSignalId],
             controller: HelpSignalController.deleteHelpSignal,
             preAuthorization: true,
-        }
+        },
+        {
+            route: '/:helpSignalId/acceptSupport',
+            method: 'post',
+            params: [helpSignalId],
+            controller: HelpSignalController.acceptSupport,
+            preAuthorization: true,
+        },
+        {
+            route: '/:helpSignalId/cancelSupportByRescuer',
+            method: 'post',
+            params: [helpSignalId],
+            controller: HelpSignalController.cancelSupportByRescuer,
+            preAuthorization: true,
+        },
+        {
+            route: '/:helpSignalId/cancelSupportByUser/:rescuerId',
+            method: 'post',
+            params: [helpSignalId, rescuerId],
+            controller: HelpSignalController.cancelSupportByUser,
+            preAuthorization: true,
+        },
+        {
+            route: '/:helpSignalId/rescuerInHelpSignal',
+            method: 'get',
+            params: [helpSignalId],
+            controller: HelpSignalController.getRescuersByHelpSignalId,
+            preAuthorization: true,
+        },
+        {
+            route: '/:helpSignalId/verifyDone',
+            method: 'patch',
+            params: [helpSignalId],
+            controller: HelpSignalController.verifyDone,
+            preAuthorization: true,
+        },
+        {
+            route: '/:helpSignalId/verifyCancel',
+            method: 'patch',
+            params: [helpSignalId],
+            controller: HelpSignalController.verifyCancel,
+            preAuthorization: true,
+        },
     ]);

backend/src/core/api/index.js

@@ -4,13 +4,18 @@ import { ApiDocument } from 'core/config/swagger.config';
 import { HelpSignalResolver } from 'core/api/helpSignal';
 import { HandlerResolver } from '../../packages/handler/HandlerResolver';
 import { AuthResolver } from './auth/auth.resolver';
+import { EmergencyResolver } from './emergency';
+import { CommentResolver } from './comment/comment.resolver';
+import { UserReactResolver } from './user-react/user-react.resolver';
 
-export const ModuleResolver = HandlerResolver
-    .builder()
+export const ModuleResolver = HandlerResolver.builder()
     .addSwaggerBuilder(ApiDocument)
     .addModule([
         AuthResolver,
         UserResolver,
         MediaResolver,
-        HelpSignalResolver
+        HelpSignalResolver,
+        EmergencyResolver,
+        CommentResolver,
+        UserReactResolver,
     ]);

backend/src/core/api/user-react/user-react.controller.js

@@ -0,0 +1,38 @@
+import { ValidHttpResponse } from 'packages/handler/response/validHttp.response';
+import { MessageDto } from 'core/common/dto';
+import { UserReactService } from 'core/modules/user-react/service/user-react.service';
+import {
+    AddUserReactDto,
+    DeleteUserReactDto,
+} from 'core/modules/user-react/dto';
+
+class Controller {
+    constructor() {
+        this.userReactService = UserReactService;
+    }
+
+    createUserReact = async req => {
+        const { reactableId, reactableType, reactType } = AddUserReactDto(
+            req.body,
+        );
+        await this.userReactService.createUserReact(
+            req.user.payload.id,
+            reactableId,
+            reactableType,
+            reactType,
+        );
+        return ValidHttpResponse.toOkResponse(MessageDto('UserReact created'));
+    };
+
+    deleteUserReact = async req => {
+        const { reactableType, reactableId } = DeleteUserReactDto(req.body);
+        await this.userReactService.deleteUserReact(
+            req.user.payload.id,
+            reactableId,
+            reactableType,
+        );
+        return ValidHttpResponse.toOkResponse(MessageDto('UserReact deleted'));
+    };
+}
+
+export const UserReactController = new Controller();