Mia Ajuda V3.0.0 (Corgi)

.eslintrc.json

@@ -12,7 +12,7 @@
         "SharedArrayBuffer": "readonly"
     },
     "parserOptions": {
-        "ecmaVersion": 2018
+        "ecmaVersion": 2020
     },
     "rules": {
         "indent": [

src/config/database.js

@@ -1,15 +1,20 @@
 const mongoose = require('mongoose');
 const CategorySeed = require('../utils/seed/CategorySeed');
 const UserSeed = require('../utils/seed/UserSeed');
-const HelpSeed = require('../utils/seed/HelpSeed');
+const HelpSeed = require('../utils/seed/HelpOfferCampaignSeed');
 const NotificationSeed = require('../utils/seed/NotificationSeed');
+const BadgeSeed = require('../utils/seed/BadgeTemplateSeed');
+const TimelineEventTemplateSeed = require('../utils/seed/TimelineEventTemplateSeed');
 
 const databaseURL = process.env.DATABASE_URL || 'mongodb://mongo:27017/miaAjudaDB';
 const envType = process.env.NODE_ENV || 'development';
 
 const databaseConnect = async () => {
   try {
-    await mongoose.connect(databaseURL, { useNewUrlParser: true, useUnifiedTopology: true });
+    await mongoose.connect(databaseURL, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
     console.log('Banco de dados conectado!');
     mongoose.set('useFindAndModify', false);
 
@@ -19,6 +24,8 @@ const databaseConnect = async () => {
       await UserSeed();
       await HelpSeed();
       await NotificationSeed();
+      await BadgeSeed();
+      await TimelineEventTemplateSeed();
     }
   } catch (err) {
     console.log('Não foi possível inicicializar corretamente a base de dados!');

src/controllers/ActivityController.js

@@ -0,0 +1,32 @@
+const ActivityService = require('../services/ActivityService');
+
+class ActivityController {
+  constructor() {
+    this.ActivityService = new ActivityService();
+  }
+
+  async fetchActivityList(req, res) {
+    const { id } = req.query;
+    const { isUserEntity } = global;
+    const coords = req.query.coords.split(',').map((coord) => Number(coord));
+    const categoryArray = req.query.categoryId?.split(',');
+    const activitiesArray = req.query.activityId?.split(',') || ['getAll'];
+    const getOtherUsers = req.query.getOtherUsers === 'true';
+
+    try {
+      const activityList = await this.ActivityService.fetchActivityList(
+        coords,
+        id,
+        isUserEntity,
+        categoryArray,
+        activitiesArray,
+        getOtherUsers,
+      );
+      return res.json(activityList);
+    } catch (error) {
+      return res.status(400).json({ error: error.message });
+    }
+  }
+}
+
+module.exports = ActivityController;

src/controllers/BadgeController.js

@@ -0,0 +1,75 @@
+const BadgeService = require('../services/BadgeService');
+const saveError = require('../utils/ErrorHistory');
+const parseBadgeByCategory = require('../utils/parseBadgeByCategory');
+
+class BadgeController {
+  constructor() {
+    this.BadgeService = new BadgeService();
+  }
+
+  async updateOrCreateBadge(req, res, next) {
+    const { userId, category } = req.body;
+
+    try {
+      let result = await this.BadgeService.createOrUpdateBadge(
+        userId,
+        category,
+      );
+      if (
+        result.badge.template.nextBadge
+        && result.badge.currentValue >= result.badge.template.nextBadge.neededValue
+      ) {
+        result = await this.BadgeService.updateBadgeReference(result.badge);
+      }
+      res.status(201).json(result);
+      next();
+    } catch (err) {
+      await saveError(err);
+      res.status(400).json({ error: err.message });
+      next();
+    }
+  }
+
+  async getBadgeHistory(req, res, next) {
+    const userId = req.query.userId || null;
+    try {
+      const userBadges = await this.BadgeService.getBadgeList(userId);
+      const allBadges = await this.BadgeService.getAllBadges();
+      const parsedUserBadges = parseBadgeByCategory(userBadges);
+      res.status(200).json({ userBadges: parsedUserBadges, allBadges });
+      next();
+    } catch (err) {
+      await saveError(err);
+      res.status(400).json({ error: err.message });
+      next();
+    }
+  }
+
+  async getBadgeList(req, res, next) {
+    const userId = req.query.userId || null;
+    try {
+      const result = await this.BadgeService.getBadgeList(userId);
+      res.status(200).json(result);
+      next();
+    } catch (err) {
+      await saveError(err);
+      res.status(400).json({ error: err.message });
+      next();
+    }
+  }
+
+  async markBadgeAsViewed(req, res, next) {
+    const { badgeId } = req.params;
+    try {
+      await this.BadgeService.markBadgeAsViewed(badgeId);
+      res.status(200).json({ message: 'Badge visualized' });
+      next();
+    } catch (err) {
+      await saveError(err);
+      res.status(400).json({ error: err.message });
+      next();
+    }
+  }
+}
+
+module.exports = BadgeController;

src/controllers/EntityController.js

@@ -32,6 +32,7 @@ class EntityController {
       notificationToken: req.body.notificationToken,
       deviceId: req.body.deviceId,
       address: req.body.address,
+      biography: req.body.biography,
     };
     try {
       const result = await this.entityService.editEntityById(data);
@@ -122,7 +123,9 @@ class EntityController {
     }
 
     try {
-      const result = await this.entityService.checkEntityExistence(entityIdentifier);
+      const result = await this.entityService.checkEntityExistence(
+        entityIdentifier,
+      );
       res.status(200).json(result);
       next();
     } catch (err) {

src/controllers/FeedbackController.js

@@ -0,0 +1,43 @@
+const FeedbackService = require('../services/FeedbackService');
+const TimelineEventService = require('../services/TimelineEventService');
+const saveError = require('../utils/ErrorHistory');
+const timelineEnum = require('../utils/enums/timelineEnum');
+
+class FeedbackController {
+  constructor() {
+    this.FeedbackService = new FeedbackService();
+    this.TimelineEventService = new TimelineEventService();
+  }
+
+  async create(req, res) {
+    try {
+      const { message, sender, receiver } = req.body;
+      const feedback = {
+        sender,
+        receiver,
+        message,
+      };
+      const newFeedback = await this.FeedbackService.create(feedback);
+      await this.TimelineEventService.create({ user: sender, template: timelineEnum.feedback });
+      res.status(200).json(newFeedback);
+    } catch (error) {
+      saveError(error);
+      res.status(500).json({ error: 'Erro ao criar feedback' });
+    }
+  }
+
+  async listByReceiver(req, res) {
+    try {
+      const { receiver } = req.params;
+      const feedbacks = await this.FeedbackService.listByReceiver(
+        receiver,
+      );
+      res.status(200).json(feedbacks);
+    } catch (error) {
+      saveError(error);
+      res.status(500).json({ error: 'Erro ao listar feedbacks' });
+    }
+  }
+}
+
+module.exports = FeedbackController;

src/controllers/HelpController.js

@@ -1,20 +1,23 @@
 const HelpService = require('../services/HelpService');
 const UserService = require('../services/UserService');
+const TimelineEventService = require('../services/TimelineEventService');
 const saveError = require('../utils/ErrorHistory');
+const timelineEnum = require('../utils/enums/timelineEnum');
 
 class HelpController {
   constructor() {
     this.HelpService = new HelpService();
     this.UserService = new UserService();
+    this.TimelineEventService = new TimelineEventService();
   }
 
   async createHelp(req, res, next) {
     const data = {
       ...req.body,
     };
-
     try {
       await this.HelpService.createHelp(data);
+      await this.TimelineEventService.create({ user: data.ownerId, template: timelineEnum.createRequest });
       res.status(201).send();
       next();
     } catch (err) {
@@ -119,6 +122,7 @@ class HelpController {
 
     try {
       await this.HelpService.ownerConfirmation(data);
+      await this.TimelineEventService.create({ user: data.ownerId, template: timelineEnum.finishRequest });
       res.status(204).send();
       next();
     } catch (err) {
@@ -147,6 +151,7 @@ class HelpController {
 
     try {
       await this.HelpService.addPossibleHelpers(id, idHelper);
+      await this.TimelineEventService.create({ user: idHelper, template: timelineEnum.offerHelp });
       res.status(204).send();
       next();
     } catch (err) {

src/controllers/HelpOfferController.js

@@ -1,16 +1,20 @@
 const HelpOfferService = require('../services/HelpOfferService');
+const TimelineEventService = require('../services/TimelineEventService');
 const saveError = require('../utils/ErrorHistory');
+const timelineEnum = require('../utils/enums/timelineEnum');
 
 class OfferedHelpController {
   constructor() {
     this.HelpOfferService = new HelpOfferService();
+    this.TimelineEventService = new TimelineEventService();
   }
 
   async createHelpOffer(req, res) {
     try {
       const newHelpOffer = await this.HelpOfferService.createNewHelpOffer(
         req.body,
       );
+      await this.TimelineEventService.create({ user: req.body.ownerId, template: timelineEnum.offer });
       return res.json(newHelpOffer);
     } catch (error) {
       return res.status(400).json({ error: error.message });
@@ -35,8 +39,9 @@ class OfferedHelpController {
     const { userId } = req.query;
     const getOtherUsers = req.query.getOtherUsers === 'true';
     const { isUserEntity } = global;
+    const coords = req.query.coords?.split(',')?.map((coord) => Number(coord)) || '';
     try {
-      const helpOffers = await this.HelpOfferService.listHelpsOffers(userId, isUserEntity, null, getOtherUsers);
+      const helpOffers = await this.HelpOfferService.listHelpsOffers(userId, isUserEntity, null, getOtherUsers, coords);
       return res.json(helpOffers);
     } catch (error) {
       return res.status(400).json({ error: error.message });