Merge pull request #233 from impulsonetwork/dev

Dev into Master

README.md

@@ -7,7 +7,7 @@
 [![Twitter Follow](https://img.shields.io/twitter/follow/impulsonetwork.svg?style=social&label=Follow)](https://twitter.com/impulsonetwork)
 
 
-## Atena v.0.1 
+## Atena v.0.1
 
 ### [en](https://github.com/impulsonetwork/atena/blob/master/README_EN.md)
 
@@ -59,20 +59,23 @@ CHANNELS=CCWSMJZ6U CCXCXJWBW
 ```
 
 ### Executando
+
 - Inicie o servidor utilizando o seguinte comando:
 ```sh
 > yarn start:dev
 ```
 
 ### Debug
-- Em um terminal inicie o servidor com o seguinte comando:
+
+Em um terminal inicie o servidor com o seguinte comando:
 ```
 > yarn start:dev:debug
 ```
 Rode o node inspect em outra janela de terminal
 ```
 > node-inspect localhost:9229
 ```
+
 ### Configurando o Bot do Rocket
 
 É preciso gerar um token, para isso o bot precisa da role de usuário. Logar com

config/ratings.yml

@@ -0,0 +1,5 @@
+- Bronze
+- Prata
+- Ouro
+- Platina
+- Diamante

controllers/achievement.js

@@ -1,9 +1,10 @@
 import config from "config-yml";
 import AchievementModel from "../models/achievement";
-import UserModel from "../models/user";
 import { calculateLevel } from "../utils";
 import { isPositiveReaction, isAtenaReaction } from "../utils/reactions";
 import { _throw } from "../helpers";
+import { getInteractionType } from "../utils/achievements";
+import userController from "../controllers/user";
 
 export const findAllByUser = async userId => {
   const result = await AchievementModel.find({ user: userId }).exec();
@@ -15,43 +16,17 @@ export const save = async interaction => {
   try {
     if (isValidAction(interaction)) {
       const type = getInteractionType(interaction);
-      await saveUserAchievement(interaction.user, type, interaction);
+      await saveUserAchievement(type, interaction);
 
       if (interaction.parentUser) {
-        await saveUserAchievement(
-          interaction.parentUser,
-          "received",
-          interaction
-        );
+        await saveUserAchievement("received", interaction, true);
       }
     }
   } catch (error) {
     _throw("Error saving achievement");
   }
 };
 
-const getInteractionType = interaction => {
-  let type = interaction.type;
-
-  if (isChatInteraction(interaction)) {
-    type = "sended";
-  }
-
-  return type;
-};
-
-const isChatInteraction = interaction => {
-  return (
-    interaction.type === "reaction_added" ||
-    interaction.type === "reaction_removed" ||
-    interaction.type === "thread" ||
-    interaction.type === "manual" ||
-    interaction.type === "inactivity" ||
-    (interaction.type === "message" &&
-      interaction.action === config.actions.message.type)
-  );
-};
-
 const isValidAction = interaction => {
   return (
     interaction.parentUser !== interaction.user && isValidReaction(interaction)
@@ -82,9 +57,15 @@ const findMain = (category, action, type) => {
   return achievements;
 };
 
-const saveUserAchievement = async (user, type, interaction) => {
+const saveUserAchievement = async (type, interaction, isParent = false) => {
+  const user = await userController.findByOrigin(interaction, isParent);
+
+  if (!user) {
+    _throw("Error no user found to achievement");
+  }
+
   const query = {
-    user: user,
+    user: user._id,
     kind: `${interaction.category}.${interaction.action}.${type}`
   };
 
@@ -107,11 +88,7 @@ const saveUserAchievement = async (user, type, interaction) => {
   }
 };
 
-const updateUserScore = async (userId, achievementScore) => {
-  const user = await UserModel.findOne({
-    slackId: userId
-  }).exec();
-
+const updateUserScore = async (user, achievementScore) => {
   if (user) {
     let newScore = user.score + achievementScore;
     user.level = calculateLevel(newScore);
@@ -160,38 +137,38 @@ const generateRange = doc => {
 
 const createAchievement = (interaction, type, user) => {
   const achievements = findMain(interaction.category, interaction.action, type);
-  let category = null;
+  let achievement = null;
 
   if (achievements) {
-    category = generateNewCategory(interaction, type, user);
+    achievement = generateNewAchievement(interaction, type, user);
 
     let currentRating = 0;
     for (let item in achievements) {
-      category.ratings.push(generateNewRating(achievements, item));
+      achievement.ratings.push(generateNewRating(achievements, item));
 
       for (let range in achievements[item].ranges) {
-        category.ratings[currentRating].ranges.push(
+        achievement.ratings[currentRating].ranges.push(
           generateNewRange(achievements, item, range)
         );
       }
 
       currentRating++;
     }
 
-    category = addFirstNewEarnedDate(category);
+    achievement = addFirstNewEarnedDate(achievement);
   }
 
-  return category;
+  return achievement;
 };
 
-const generateNewCategory = (interaction, type, user) => {
+const generateNewAchievement = (interaction, type, user) => {
   const category = config.categories[interaction.category];
   const action = config.actions[interaction.action];
 
   return {
     name: `${category.name} | ${action.name} ${action[type]}`,
     kind: `${category.type}.${action.type}.${type}`,
-    user: user,
+    user: user._id,
     total: 1,
     ratings: []
   };
@@ -213,12 +190,12 @@ const generateNewRange = (achievements, item, range) => {
   };
 };
 
-const addFirstNewEarnedDate = category => {
-  if (category.ratings[0].ranges[0].value === 1) {
-    category.ratings[0].ranges[0].earnedDate = Date.now();
+const addFirstNewEarnedDate = achievement => {
+  if (achievement.ratings[0].ranges[0].value === 1) {
+    achievement.ratings[0].ranges[0].earnedDate = Date.now();
   }
 
-  return category;
+  return achievement;
 };
 
 export default {

controllers/achievementTemporary.js

@@ -0,0 +1,108 @@
+import moment from "moment-timezone";
+import TemporaryAchievementModel from "../models/achievementTemporary";
+import TemporaryAchievementDataModel from "../models/achievementTemporaryData";
+import {
+  addEarnedAchievement,
+  getQueryToFindCurrent,
+  getRecord,
+  isBeforeLimitDate,
+  isBeforeEndDate,
+  resetEarnedAchievements
+} from "../utils/achievementsTemporary";
+import { convertDataToAchievement } from "../utils/achievementsTemporaryData";
+import { _throw } from "../helpers";
+import userController from "../controllers/user";
+
+export const save = async interaction => {
+  try {
+    const user = await userController.findByOrigin(interaction);
+
+    if (!user) {
+      _throw("Error on find user to saving temporary achievement");
+    }
+
+    const query = getQueryToFindCurrent(interaction);
+    let temporaryAchievementsData = await TemporaryAchievementDataModel.find(
+      query
+    ).exec();
+
+    for (let temporaryAchievementData of temporaryAchievementsData) {
+      let temporaryAchievementExistent = await TemporaryAchievementModel.findOne(
+        {
+          temporaryData: temporaryAchievementData._id,
+          user: user._id
+        }
+      ).exec();
+
+      if (
+        !temporaryAchievementExistent &&
+        isBeforeLimitDate(temporaryAchievementData)
+      ) {
+        let temporaryAchievement = convertDataToAchievement(
+          temporaryAchievementData,
+          user._id
+        );
+
+        temporaryAchievementExistent = await temporaryAchievement.save();
+      }
+
+      if (temporaryAchievementExistent) {
+        if (isBeforeEndDate(temporaryAchievementData)) {
+          let achievementToUpdate = addEarnedAchievement(
+            temporaryAchievementExistent
+          );
+
+          let temporaryAchievement = achievementToUpdate.achievement;
+          temporaryAchievement.record = getRecord(temporaryAchievement);
+          await temporaryAchievement.save();
+
+          if (achievementToUpdate.xpToIncrease) {
+            user.score += achievementToUpdate.xpToIncrease;
+            await user.save();
+          }
+        } else {
+          let temporaryAchievement = resetEarnedAchievements(
+            temporaryAchievementExistent
+          );
+          await temporaryAchievement.save();
+        }
+      }
+    }
+  } catch (error) {
+    _throw("Error saving temporary achievement");
+  }
+};
+
+export const findAllByUser = async userId => {
+  return await TemporaryAchievementModel.find({
+    user: userId
+  })
+    .populate({
+      path: "temporaryData",
+      match: { endDate: { $gte: moment(new Date()).format("YYYY-MM-DD") } }
+    })
+    .exec();
+};
+
+export const findInactivities = async () => {
+  return await getAllInactivitiesDaily();
+};
+
+const getAllInactivitiesDaily = async () => {
+  const achievements = await TemporaryAchievementModel.find({
+    lastEarnedDate: {
+      $gte: moment(new Date())
+        .subtract(1, "days")
+        .format("YYYY-MM-DD"),
+      $lte: moment(new Date()).format("YYYY-MM-DD")
+    }
+  }).exec();
+
+  return achievements;
+};
+
+export default {
+  save,
+  findInactivities,
+  findAllByUser
+};