4.63.0

chore(i18n): update locales
Merge branch 'develop' into release
2026-05-10 11:09:46 -05:00 · 2018-10-02 23:12:11 +00:00 · 2018-10-02 23:11:49 +00:00 · 2018-10-02 23:07:08 +00:00 · 2018-10-02 16:59:39 -05:00 · 2018-10-02 16:38:47 -05:00
1773 changed files with 86070 additions and 60204 deletions
@@ -1,7 +1,7 @@
 [//]: # (Note: See http://habitica.wikia.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API for more info)

-[//]: # (Put Issue # or URL here, if applicable. This will automatically close the issue if your PR is merged in)
-Fixes put_issue_url_here
+[//]: # (Put Issue # here, if applicable. This will automatically close the issue if your PR is merged in)
+Fixes put_#_and_issue_numer_here

 ### Changes
 [//]: # (Describe the changes that were made in detail here. Include pictures if necessary)
@@ -39,6 +39,7 @@ dist-client
 test/client/unit/coverage
 test/client/e2e/reports
 test/client-old/spec/mocks/translations.js
+yarn.lock

 # Elastic Beanstalk Files
 .elasticbeanstalk/*
@@ -17,3 +17,4 @@ CHANGELOG.md
 newrelic_agent.log
 *.swp
 *.swx
+website/raw_sprites/**
@@ -20,8 +20,9 @@ env:
    - DISABLE_REQUEST_LOGGING=true
  matrix:
    - TEST="lint"
-    - TEST="test:api-v3:unit" REQUIRES_SERVER=true COVERAGE=true
+    - TEST="test:api:unit" REQUIRES_SERVER=true COVERAGE=true
    - TEST="test:api-v3:integration" REQUIRES_SERVER=true COVERAGE=true
+    - TEST="test:api-v4:integration" REQUIRES_SERVER=true COVERAGE=true
    - TEST="test:sanity"
    - TEST="test:content" COVERAGE=true
    - TEST="test:common" COVERAGE=true
@@ -1,18 +1,29 @@
-FROM node:8
-
-# Install global packages
-RUN npm install -g gulp-cli mocha
-
-# Clone Habitica repo and install dependencies
-RUN mkdir -p /usr/src/habitrpg
-WORKDIR /usr/src/habitrpg
-RUN git clone https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
-RUN cp config.json.example config.json
-RUN npm install
-
-# Create Build dir
-RUN mkdir -p ./website/build
-
-# Start Habitica
-EXPOSE 3000
-CMD ["npm", "start"]
+FROM node:8
+
+ENV ADMIN_EMAIL admin@habitica.com
+ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
+ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
+ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
+ENV BASE_URL https://habitica.com
+ENV FACEBOOK_KEY 128307497299777
+ENV GA_ID UA-33510635-1
+ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
+ENV NODE_ENV production
+ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
+
+# Install global packages
+RUN npm install -g gulp-cli mocha
+
+# Clone Habitica repo and install dependencies
+RUN mkdir -p /usr/src/habitrpg
+WORKDIR /usr/src/habitrpg
+RUN git clone --branch release https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN npm install
+RUN gulp build:prod --force
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["node", "./website/transpiled-babel/index.js"]
@@ -0,0 +1,18 @@
+FROM node:8
+
+# Install global packages
+RUN npm install -g gulp-cli mocha
+
+# Clone Habitica repo and install dependencies
+RUN mkdir -p /usr/src/habitrpg
+WORKDIR /usr/src/habitrpg
+RUN git clone https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN cp config.json.example config.json
+RUN npm install
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["npm", "start"]
@@ -1,29 +0,0 @@
-FROM node:8
-
-ENV ADMIN_EMAIL admin@habitica.com
-ENV AMAZON_PAYMENTS_CLIENT_ID amzn1.application-oa2-client.68ed9e6904ef438fbc1bf86bf494056e
-ENV AMAZON_PAYMENTS_SELLER_ID AMQ3SB4SG5E91
-ENV AMPLITUDE_KEY e8d4c24b3d6ef3ee73eeba715023dd43
-ENV BASE_URL https://habitica.com
-ENV FACEBOOK_KEY 128307497299777
-ENV GA_ID UA-33510635-1
-ENV GOOGLE_CLIENT_ID 1035232791481-32vtplgnjnd1aufv3mcu1lthf31795fq.apps.googleusercontent.com
-ENV NODE_ENV production
-ENV STRIPE_PUB_KEY pk_85fQ0yMECHNfHTSsZoxZXlPSwSNfA
-
-# Install global packages
-RUN npm install -g gulp-cli mocha
-
-# Clone Habitica repo and install dependencies
-RUN mkdir -p /usr/src/habitrpg
-WORKDIR /usr/src/habitrpg
-RUN git clone --branch v4.37.2 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
-RUN npm install
-RUN gulp build:prod --force
-
-# Create Build dir
-RUN mkdir -p ./website/build
-
-# Start Habitica
-EXPOSE 3000
-CMD ["node", "./website/transpiled-babel/index.js"]
@@ -10,4 +10,3 @@ We need more programmers! Your assistance will be greatly appreciated.
 For an introduction to the technologies used and how the software is organized, refer to [Guidance for Blacksmiths](http://habitica.wikia.com/wiki/Guidance_for_Blacksmiths).

 To set up a local install of Habitica for development and testing on various platforms, see [Setting up Habitica Locally](http://habitica.wikia.com/wiki/Setting_up_Habitica_Locally).
-
@@ -17,7 +17,7 @@
    "NODE_DB_URI":"mongodb://localhost/habitrpg",
    "TEST_DB_URI":"mongodb://localhost/habitrpg_test",
    "NODE_ENV":"development",
-    "ENABLE_CONSOLE_LOGS_IN_TEST": false,
+    "ENABLE_CONSOLE_LOGS_IN_TEST": "false",
    "CRON_SAFE_MODE":"false",
    "CRON_SEMI_SAFE_MODE":"false",
    "MAINTENANCE_MODE": "false",
@@ -78,6 +78,9 @@
    "PUSH_CONFIGS": {
        "GCM_SERVER_API_KEY": "",
        "APN_ENABLED": "false",
+        "APN_KEY_ID": "xxxxxxxxxx",
+        "APN_KEY": "xxxxxxxxxx",
+        "APN_TEAM_ID": "aaabbbcccd",
        "FCM_SERVER_API_KEY": ""
    },
    "SITE_HTTP_AUTH": {
@@ -113,5 +116,5 @@
      "CLOUDKARAFKA_PASSWORD": "",
      "CLOUDKARAFKA_TOPIC_PREFIX": ""
    },
-    "STACK_IMPACT_KEY": "aaaabbbbccccddddeeeeffffgggg111100002222"
+    "MIGRATION_CONNECT_STRING": "mongodb://localhost:27017/habitrpg?auto_reconnect=true"
 }
@@ -0,0 +1,100 @@
+import max from 'lodash/max';
+import mean from 'lodash/mean';
+import monk from 'monk';
+import round from 'lodash/round';
+import sum from 'lodash/sum';
+
+/*
+ * Output data on subscribers' task histories, formatted for CSV.
+ * User ID,Count of Dailies,Count of Habits,Total History Size,Max History Size,Mean History Size,Median History Size
+ */
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+
+let dbUsers = monk(connectionString).get('users', { castIds: false });
+let dbTasks = monk(connectionString).get('tasks', { castIds: false });
+
+function usersReport () {
+  let allHistoryLengths = [];
+
+  console.info('User ID,Count of Dailies,Count of Habits,Total History Size,Max History Size,Mean History Size,Median History Size');
+
+  dbUsers.find(
+    {
+      $and:
+        [
+          {'purchased.plan.planId': {$ne:null}},
+          {'purchased.plan.planId': {$ne:''}},
+        ],
+      $or:
+        [
+          {'purchased.plan.dateTerminated': null},
+          {'purchased.plan.dateTerminated': ''},
+          {'purchased.plan.dateTerminated': {$gt:new Date()}},
+        ],
+    },
+    {
+      fields: {_id: 1},
+    }
+  ).each((user, {close, pause, resume}) => {
+    let historyLengths = [];
+    let habitCount = 0;
+    let dailyCount = 0;
+
+    pause();
+    return dbTasks.find(
+      {
+        userId: user._id,
+        $or:
+          [
+            {type: 'habit'},
+            {type: 'daily'},
+          ],
+      },
+      {
+        fields: {
+          type: 1,
+          history: 1,
+        },
+      }
+    ).each((task) => {
+      if (task.type === 'habit') {
+        habitCount++;
+      }
+      if (task.type === 'daily') {
+        dailyCount++;
+      }
+      if (task.history.length > 0) {
+        allHistoryLengths.push(task.history.length);
+        historyLengths.push(task.history.length);
+      }
+    }).then(() => {
+      const totalHistory = sum(historyLengths);
+      const maxHistory = historyLengths.length > 0 ? max(historyLengths) : 0;
+      const meanHistory = historyLengths.length > 0 ? round(mean(historyLengths)) : 0;
+      const medianHistory = historyLengths.length > 0 ? median(historyLengths) : 0;
+      console.info(`${user._id},${dailyCount},${habitCount},${totalHistory},${maxHistory},${meanHistory},${medianHistory}`);
+      resume();
+    });
+  }).then(() => {
+    console.info(`Total Subscriber History Entries: ${sum(allHistoryLengths)}`);
+    console.info(`Largest History Size: ${max(allHistoryLengths)}`);
+    console.info(`Mean History Size: ${round(mean(allHistoryLengths))}`);
+    console.info(`Median History Size: ${median(allHistoryLengths)}`);
+    return process.exit(0);
+  });
+}
+
+function median(values) { // https://gist.github.com/caseyjustus/1166258
+  values.sort( function(a,b) {return a - b;} );
+
+  var half = Math.floor(values.length/2);
+
+  if (values.length % 2) {
+    return values[half];
+  }
+  else {
+    return (values[half-1] + values[half]) / 2.0;
+  }
+}
+
+module.exports = usersReport;
@@ -2,9 +2,13 @@ version: "3"
 services:

  client:
+    environment:
+      - NODE_ENV=development
    volumes:
      - '.:/usr/src/habitrpg'

  server:
+    environment:
+      - NODE_ENV=development
    volumes:
      - '.:/usr/src/habitrpg'
@@ -25,7 +25,7 @@ services:
      - mongo

  mongo:
-    image: mongo
+    image: mongo:3.4
    ports:
      - "27017:27017"
    networks:
@@ -165,9 +165,9 @@ gulp.task('test:content:safe', gulp.series('test:prepare:build', (cb) => {
  pipe(runner);
 }));

-gulp.task('test:api-v3:unit', (done) => {
+gulp.task('test:api:unit', (done) => {
  let runner = exec(
-    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v3-unit --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v3/unit --recursive --require ./test/helpers/start-server'),
+    testBin('node_modules/.bin/istanbul cover --dir coverage/api-unit node_modules/mocha/bin/_mocha -- test/api/unit --recursive --require ./test/helpers/start-server'),
    (err) => {
      if (err) {
        process.exit(1);
@@ -179,8 +179,8 @@ gulp.task('test:api-v3:unit', (done) => {
  pipe(runner);
 });

-gulp.task('test:api-v3:unit:watch', () => {
-  return gulp.watch(['website/server/libs/*', 'test/api/v3/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api-v3:unit', done => done()));
+gulp.task('test:api:unit:watch', () => {
+  return gulp.watch(['website/server/libs/*', 'test/api/v3/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api:unit', done => done()));
 });

 gulp.task('test:api-v3:integration', (done) => {
@@ -215,17 +215,43 @@ gulp.task('test:api-v3:integration:separate-server', (done) => {
  pipe(runner);
 });

+gulp.task('test:api-v4:integration', (done) => {
+  let runner = exec(
+    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v4-integration --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v4 --recursive --require ./test/helpers/start-server'),
+    {maxBuffer: 500 * 1024},
+    (err) => {
+      if (err) {
+        process.exit(1);
+      }
+      done();
+    }
+  );
+
+  pipe(runner);
+});
+
+gulp.task('test:api-v4:integration:separate-server', (done) => {
+  let runner = exec(
+    testBin('mocha test/api/v4 --recursive --require ./test/helpers/start-server', 'LOAD_SERVER=0'),
+    {maxBuffer: 500 * 1024},
+    (err) => done(err)
+  );
+
+  pipe(runner);
+});
+
 gulp.task('test', gulp.series(
  'test:sanity',
  'test:content',
  'test:common',
-  'test:api-v3:unit',
+  'test:api:unit',
  'test:api-v3:integration',
+  'test:api-v4:integration',
  done => done()
 ));

 gulp.task('test:api-v3', gulp.series(
-  'test:api-v3:unit',
+  'test:api:unit',
  'test:api-v3:integration',
  done => done()
-));
+));
@@ -0,0 +1,123 @@
+const migrationName = '20180811_inboxOutsideUser.js';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Move inbox messages from the user model to their own collection
+ */
+
+const monk = require('monk');
+const nconf = require('nconf');
+
+const Inbox = require('../website/server/models/message').inboxModel;
+const connectionString = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+const dbInboxes = monk(connectionString).get('inboxes', { castIds: false });
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 1000,
+    fields: ['_id', 'inbox'],
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+let msgCount = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users and their tasks found and modified.');
+    displayData();
+    return;
+  }
+
+  let usersPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(usersPromises)
+    .then(() => {
+      return processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (msgCount % progressCount === 0) console.warn(`${msgCount  } messages processed`);
+  if (user._id === authorUuid) console.warn(`${authorName  } being processed`);
+
+  const oldInboxMessages = user.inbox.messages || {};
+  const oldInboxMessagesIds = Object.keys(oldInboxMessages);
+
+  msgCount += oldInboxMessagesIds.length;
+
+  const newInboxMessages = oldInboxMessagesIds.map(msgId => {
+    const msg = oldInboxMessages[msgId];
+    if (!msg || (!msg.id && !msg._id)) { // eslint-disable-line no-extra-parens
+      console.log('missing message or message _id and id', msg);
+      throw new Error('error!');
+    }
+
+    if (msg.id && !msg._id) msg._id = msg.id;
+    if (msg._id && !msg.id) msg.id = msg._id;
+
+    const newMsg = new Inbox(msg);
+    newMsg.ownerId = user._id;
+    return newMsg.toJSON();
+  });
+
+  return dbInboxes.insert(newInboxMessages)
+    .then(() => {
+      return dbUsers.update({_id: user._id}, {
+        $set: {
+          migration: migrationName,
+          'inbox.messages': {},
+        },
+      });
+    })
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  console.warn(`\n${  msgCount  } messages processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -0,0 +1,52 @@
+// @migrationName = 'MigrateGroupChat';
+// @authorName = 'TheHollidayInn'; // in case script author needs to know when their ...
+// @authorUuid = ''; // ... own data is done
+
+
+/*
+ * This migration moves chat off of groups and into their own model
+ */
+
+import { model as Group } from '../../website/server/models/group';
+import { model as Chat } from '../../website/server/models/chat';
+
+async function moveGroupChatToModel (skip = 0) {
+  const groups = await Group.find({})
+    .limit(50)
+    .skip(skip)
+    .sort({ _id: -1 })
+    .exec();
+
+  if (groups.length === 0) {
+    console.log('End of groups');
+    process.exit();
+  }
+
+  const promises = groups.map(group => {
+    const chatpromises = group.chat.map(message => {
+      const newChat = new Chat();
+      Object.assign(newChat, message);
+      newChat._id = message.id;
+      newChat.groupId = group._id;
+
+      return newChat.save();
+    });
+
+    group.chat = [];
+    chatpromises.push(group.save());
+
+    return chatpromises;
+  });
+
+
+  const reducedPromises = promises.reduce((acc, curr) => {
+    acc = acc.concat(curr);
+    return acc;
+  }, []);
+
+  console.log(reducedPromises);
+  await Promise.all(reducedPromises);
+  moveGroupChatToModel(skip + 50);
+}
+
+module.exports = moveGroupChatToModel;
@@ -0,0 +1,107 @@
+import monk from 'monk';
+import nconf from 'nconf';
+import stripePayments from '../../website/server/libs/payments/stripe';
+
+/*
+ * Ensure that group plan billing is accurate by doing the following:
+ * 1. Correct the memberCount in all paid groups whose counts are wrong
+ * 2. Where the above uses Stripe, update their subscription counts in Stripe
+ *
+ * Provides output on what groups were fixed, which can be piped to CSV.
+ */
+
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+
+let dbGroups = monk(CONNECTION_STRING).get('groups', { castIds: false });
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+async function fixGroupPlanMembers () {
+  console.info('Group ID, Customer ID, Plan ID, Quantity, Recorded Member Count, Actual Member Count');
+  let groupPlanCount = 0;
+  let fixedGroupCount = 0;
+
+  dbGroups.find(
+    {
+      $and:
+        [
+          {'purchased.plan.planId': {$ne: null}},
+          {'purchased.plan.planId': {$ne: ''}},
+          {'purchased.plan.customerId': {$ne: 'cus_9f0DV4g7WHRzpM'}}, // Demo groups
+          {'purchased.plan.customerId': {$ne: 'cus_9maalqDOFTrvqx'}},
+        ],
+      $or:
+        [
+          {'purchased.plan.dateTerminated': null},
+          {'purchased.plan.dateTerminated': ''},
+        ],
+    },
+    {
+      fields: {
+        memberCount: 1,
+        'purchased.plan': 1,
+      },
+    }
+  ).each(async (group, {close, pause, resume}) => { // eslint-disable-line no-unused-vars
+    pause();
+    groupPlanCount++;
+
+    const canonicalMemberCount = await dbUsers.count(
+      {
+        $or:
+          [
+            {'party._id': group._id},
+            {guilds: group._id},
+          ],
+      }
+    );
+    const incorrectMemberCount = group.memberCount !== canonicalMemberCount;
+
+    const isMonthlyPlan = group.purchased.plan.planId === 'group_monthly';
+    const quantityMismatch = group.purchased.plan.quantity !== group.memberCount + 2;
+    const incorrectQuantity = isMonthlyPlan && quantityMismatch;
+
+    if (!incorrectMemberCount && !incorrectQuantity) {
+      resume();
+      return;
+    }
+
+    console.info(`${group._id}, ${group.purchased.plan.customerId}, ${group.purchased.plan.planId}, ${group.purchased.plan.quantity}, ${group.memberCount}, ${canonicalMemberCount}`);
+
+    const groupUpdate = await dbGroups.update(
+      { _id: group._id },
+      {
+        $set: {
+          memberCount: canonicalMemberCount,
+        },
+      }
+    );
+
+    if (!groupUpdate) return;
+
+    fixedGroupCount++;
+    if (group.purchased.plan.paymentMethod === 'Stripe') {
+      await stripePayments.chargeForAdditionalGroupMember(group);
+      await dbGroups.update(
+        {_id: group._id},
+        {$set: {'purchased.plan.quantity': canonicalMemberCount + 2}}
+      );
+    }
+
+    if (incorrectQuantity) {
+      await dbGroups.update(
+        {_id: group._id},
+        {$set: {'purchased.plan.quantity': canonicalMemberCount + 2}}
+      );
+    }
+
+    resume();
+  }).then(() => {
+    console.info(`Fixed ${fixedGroupCount} out of ${groupPlanCount} active Group Plans`);
+    return process.exit(0);
+  }).catch((err) => {
+    console.log(err);
+    return process.exit(1);
+  });
+}
+
+module.exports = fixGroupPlanMembers;
@@ -17,5 +17,5 @@ function setUpServer () {
 setUpServer();

 // Replace this with your migration
-const processUsers = require('./20180125_clean_new_notifications.js');
+const processUsers = require('./users/takeThis.js');
 processUsers();
@@ -0,0 +1,138 @@
+// const migrationName = 'habits-one-history-entry-per-day';
+// const authorName = 'paglias'; // in case script author needs to know when their ...
+// const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Iterates over all habits and condense multiple history entries for the same day into a single entry
+ */
+
+const monk = require('monk');
+const _ = require('lodash');
+const moment = require('moment');
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const dbTasks = monk(connectionString).get('tasks', { castIds: false });
+
+function processChallengeHabits (lastId) {
+  let query = {
+    'challenge.id': {$exists: true},
+    userId: {$exists: false},
+    type: 'habit',
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbTasks.find(query, {
+    sort: {_id: 1},
+    limit: 500,
+  })
+    .then(updateChallengeHabits)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateChallengeHabits (habits) {
+  if (!habits || habits.length === 0) {
+    console.warn('All appropriate challenge habits found and modified.');
+    displayData();
+    return;
+  }
+
+  let habitsPromises = habits.map(updateChallengeHabit);
+  let lastHabit = habits[habits.length - 1];
+
+  return Promise.all(habitsPromises)
+    .then(() => {
+      return processChallengeHabits(lastHabit._id);
+    });
+}
+
+function updateChallengeHabit (habit) {
+  count++;
+
+  if (habit && habit.history && habit.history.length > 0) {
+    // First remove missing entries
+    habit.history = habit.history.filter(entry => Boolean(entry));
+
+    habit.history = _.chain(habit.history)
+      // processes all entries to identify an up or down score
+      .forEach((entry, index) => {
+        if (index === 0) { // first entry doesn't have a previous one
+          // first value < 0 identifies a negative score as the first action
+          entry.scoreDirection = entry.value >= 0 ? 'up' : 'down';
+        } else {
+          // could be missing if the previous entry was null and thus excluded
+          const previousEntry = habit.history[index - 1];
+          const previousValue = previousEntry.value;
+
+          entry.scoreDirection = entry.value > previousValue ? 'up' : 'down';
+        }
+      })
+      .groupBy(entry => { // group entries by aggregateBy
+        return moment(entry.date).format('YYYYMMDD');
+      })
+      .toPairs() // [key, entry]
+      .sortBy(([key]) => key) // sort by date
+      .map(keyEntryPair => {
+        let entries = keyEntryPair[1]; // 1 is entry, 0 is key
+        let scoredUp = 0;
+        let scoredDown = 0;
+
+        entries.forEach(entry => {
+          if (entry.scoreDirection === 'up') {
+            scoredUp += 1;
+          } else {
+            scoredDown += 1;
+          }
+
+          // delete the unnecessary scoreDirection and scoreNotes prop
+          delete entry.scoreDirection;
+          delete entry.scoreNotes;
+        });
+
+        return {
+          date: Number(entries[entries.length - 1].date), // keep last value
+          value: entries[entries.length - 1].value, // keep last value,
+          scoredUp,
+          scoredDown,
+        };
+      })
+      .value();
+
+    return dbTasks.update({_id: habit._id}, {
+      $set: {history: habit.history},
+    });
+  }
+
+  if (count % progressCount === 0) console.warn(`${count  } habits processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } tasks processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processChallengeHabits;
@@ -0,0 +1,163 @@
+const migrationName = 'habits-one-history-entry-per-day';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Iterates over all habits and condense multiple history entries for the same day into a single entry
+ */
+
+const monk = require('monk');
+const _ = require('lodash');
+const moment = require('moment');
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const dbTasks = monk(connectionString).get('tasks', { castIds: false });
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 50, // just 50 users per time since we have to process all their habits as well
+    fields: ['_id', 'preferences.timezoneOffset', 'preferences.dayStart'],
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users and their tasks found and modified.');
+    displayData();
+    return;
+  }
+
+  let usersPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(usersPromises)
+    .then(() => {
+      return processUsers(lastUser._id);
+    });
+}
+
+function updateHabit (habit, timezoneOffset, dayStart) {
+  if (habit && habit.history && habit.history.length > 0) {
+    // First remove missing entries
+    habit.history = habit.history.filter(entry => Boolean(entry));
+
+    habit.history = _.chain(habit.history)
+      // processes all entries to identify an up or down score
+      .forEach((entry, index) => {
+        if (index === 0) { // first entry doesn't have a previous one
+          // first value < 0 identifies a negative score as the first action
+          entry.scoreDirection = entry.value >= 0 ? 'up' : 'down';
+        } else {
+          // could be missing if the previous entry was null and thus excluded
+          const previousEntry = habit.history[index - 1];
+          const previousValue = previousEntry.value;
+
+          entry.scoreDirection = entry.value > previousValue ? 'up' : 'down';
+        }
+      })
+      .groupBy(entry => { // group entries by aggregateBy
+        const entryDate = moment(entry.date).zone(timezoneOffset || 0);
+        if (entryDate.hour() < dayStart) entryDate.subtract(1, 'day');
+        return entryDate.format('YYYYMMDD');
+      })
+      .toPairs() // [key, entry]
+      .sortBy(([key]) => key) // sort by date
+      .map(keyEntryPair => {
+        let entries = keyEntryPair[1]; // 1 is entry, 0 is key
+        let scoredUp = 0;
+        let scoredDown = 0;
+
+        entries.forEach(entry => {
+          if (entry.scoreDirection === 'up') {
+            scoredUp += 1;
+          } else {
+            scoredDown += 1;
+          }
+
+          // delete the unnecessary scoreDirection and scoreNotes prop
+          delete entry.scoreDirection;
+          delete entry.scoreNotes;
+        });
+
+        return {
+          date: Number(entries[entries.length - 1].date), // keep last value
+          value: entries[entries.length - 1].value, // keep last value,
+          scoredUp,
+          scoredDown,
+        };
+      })
+      .value();
+
+    return dbTasks.update({_id: habit._id}, {
+      $set: {history: habit.history},
+    });
+  }
+}
+
+function updateUser (user) {
+  count++;
+
+  const timezoneOffset = user.preferences.timezoneOffset;
+  const dayStart = user.preferences.dayStart;
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } being processed`);
+
+  return dbTasks.find({
+    type: 'habit',
+    userId: user._id,
+  })
+    .then(habits => {
+      return Promise.all(habits.map(habit => updateHabit(habit, timezoneOffset, dayStart)));
+    })
+    .then(() => {
+      return dbUsers.update({_id: user._id}, {
+        $set: {migration: migrationName},
+      });
+    })
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+function displayData () {
+  console.warn(`\n${  count  } tasks processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -7,7 +7,7 @@ let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
 */

 let monk = require('monk');
-let connectionString = 'mongodb://sabrecat:z8e8jyRA8CTofMQ@ds013393-a0.mlab.com:13393/habitica?auto_reconnect=true';
+let connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true';
 let dbTasks = monk(connectionString).get('tasks', { castIds: false });

 function processTasks (lastId) {
@@ -0,0 +1,99 @@
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Generate usernames for users who lack them
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+import { generateUsername } from '../../website/server/libs/auth/utils';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    'auth.local.username': {$exists: false},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-04-01')}, // Initial coverage for users active within last 6 months
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'auth',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  if (!user.auth.local.username) {
+    const newName = generateUsername();
+    dbUsers.update(
+      {_id: user._id},
+      {$set:
+        {
+          'auth.local.username': newName,
+          'auth.local.lowerCaseUsername': newName,
+        },
+      }
+    );
+  }
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -1,15 +1,17 @@
-const migrationName = 'mystery-items-201802.js'; // Update per month
+import monk from 'monk';
+import nconf from 'nconf';
+
+const migrationName = 'mystery-items-201808.js'; // Update per month
 const authorName = 'Sabe'; // in case script author needs to know when their ...
 const authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done

 /*
 * Award this month's mystery items to subscribers
 */
-const MYSTERY_ITEMS = ['back_mystery_201803', 'head_mystery_201803'];
-const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+const MYSTERY_ITEMS = ['armor_mystery_201809', 'head_mystery_201809'];
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');

-let monk = require('monk');
-let dbUsers = monk(connectionString).get('users', { castIds: false });
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
 let UserNotification = require('../../website/server/models/userNotification').model;

 function processUsers (lastId) {
@@ -0,0 +1,123 @@
+let migrationName = '20180731_naming-day.js'; // Update when running in future years
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Award Naming Day ladder items to participants in this month's Naming Day festivities
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'items.gear.owned',
+      'items.mounts',
+      'items.pets',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  let set = {};
+  let push;
+
+  const inc = {
+    'items.food.Cake_Base': 1,
+    'items.food.Cake_CottonCandyBlue': 1,
+    'items.food.Cake_CottonCandyPink': 1,
+    'items.food.Cake_Desert': 1,
+    'items.food.Cake_Golden': 1,
+    'items.food.Cake_Red': 1,
+    'items.food.Cake_Shade': 1,
+    'items.food.Cake_Skeleton': 1,
+    'items.food.Cake_White': 1,
+    'items.food.Cake_Zombie': 1,
+    'achievements.habiticaDays': 1,
+  };
+
+  if (user && user.items && user.items.gear && user.items.gear.owned && typeof user.items.gear.owned.head_special_namingDay2017 !== 'undefined') {
+    set = {migration: migrationName, 'items.gear.owned.body_special_namingDay2018': false};
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.body_special_namingDay2018', _id: monk.id()}};
+  } else if (user && user.items && user.items.pets && typeof user.items.pets['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = {migration: migrationName, 'items.gear.owned.head_special_namingDay2017': false};
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.head_special_namingDay2017', _id: monk.id()}};
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = {migration: migrationName, 'items.pets.Gryphon-RoyalPurple': 5};
+  } else {
+    set = {migration: migrationName, 'items.mounts.Gryphon-RoyalPurple': true};
+  }
+
+  if (push) {
+    dbUsers.update({_id: user._id}, {$set: set, $push: push, $inc: inc});
+  } else {
+    dbUsers.update({_id: user._id}, {$set: set, $inc: inc});
+  }
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -0,0 +1,109 @@
+const migrationName = 'remove-social-users-extra-data.js';
+const authorName = 'paglias'; // in case script author needs to know when their ...
+const authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; // ... own data is done
+
+/*
+ * Remove not needed data from social profiles
+ */
+const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+
+const monk = require('monk');
+const dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+    $or: [
+      { 'auth.facebook.id': { $exists: true } },
+      { 'auth.google.id': { $exists: true } },
+    ],
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  const isFacebook = user.auth.facebook && user.auth.facebook.id;
+  const isGoogle = user.auth.google && user.auth.google.id;
+
+  const update = { $set: {} };
+
+  if (isFacebook) {
+    update.$set['auth.facebook'] = {
+      id: user.auth.facebook.id,
+      emails: user.auth.facebook.emails,
+    };
+  }
+
+  if (isGoogle) {
+    update.$set['auth.google'] = {
+      id: user.auth.google.id,
+      emails: user.auth.google.emails,
+    };
+  }
+
+  dbUsers.update({
+    _id: user._id,
+  }, update);
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -0,0 +1,99 @@
+let migrationName = '20180724_summer-splash-orcas.js'; // Update per month
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Award ladder items to participants in this year's Summer Splash festivities
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-07-01')}, // rerun without date restriction after initial run
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      'items.mounts',
+    ], // specify fields we are interested in to limit retrieved data (empty if we're not reading data):
+  })
+    .then(updateUsers)
+    .catch((err) => {
+      console.log(err);
+      return exiting(1, `ERROR! ${  err}`);
+    });
+}
+
+let progressCount = 1000;
+let count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  let userPromises = users.map(updateUser);
+  let lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  let set = {};
+
+  if (user && user.items && user.items.pets && typeof user.items.pets['Orca-Base'] !== 'undefined') {
+    set = {migration: migrationName};
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Orca-Base'] !== 'undefined') {
+    set = {migration: migrationName, 'items.pets.Orca-Base': 5};
+  } else {
+    set = {migration: migrationName, 'items.mounts.Orca-Base': true};
+  }
+
+  dbUsers.update({_id: user._id}, {$set: set});
+
+  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
+  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+}
+
+function displayData () {
+  console.warn(`\n${  count  } users processed\n`);
+  return exiting(0);
+}
+
+function exiting (code, msg) {
+  code = code || 0; // 0 = success
+  if (code && !msg) {
+    msg = 'ERROR!';
+  }
+  if (msg) {
+    if (code) {
+      console.error(msg);
+    } else      {
+      console.log(msg);
+    }
+  }
+  process.exit(code);
+}
+
+module.exports = processUsers;
@@ -1,4 +1,4 @@
-let migrationName = '20180102_takeThis.js'; // Update per month
+let migrationName = '20180904_takeThis.js'; // Update per month
 let authorName = 'Sabe'; // in case script author needs to know when their ...
 let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done

@@ -6,15 +6,16 @@ let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
 * Award Take This ladder items to participants in this month's challenge
 */

-let monk = require('monk');
-let connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-let dbUsers = monk(connectionString).get('users', { castIds: false });
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING'); // FOR TEST DATABASE
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });

 function processUsers (lastId) {
  // specify a query to limit the affected users (empty for all users):
  let query = {
    migration: {$ne: migrationName},
-    challenges: {$in: ['5f70ce5b-2d82-4114-8e44-ca65615aae62']}, // Update per month
+    challenges: {$in: ['1044ec0c-4a85-48c5-9f36-d51c0c62c7d3']}, // Update per month
  };

  if (lastId) {
@@ -1,48 +1,49 @@
 {
  "name": "habitica",
  "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.38.0",
+  "version": "4.63.0",
  "main": "./website/server/index.js",
  "dependencies": {
    "@slack/client": "^3.8.1",
    "accepts": "^1.3.5",
-    "amazon-payments": "^0.2.6",
+    "amazon-payments": "^0.2.7",
    "amplitude": "^3.5.0",
    "apidoc": "^0.17.5",
-    "autoprefixer": "^8.2.0",
-    "aws-sdk": "^2.224.1",
+    "apn": "^2.2.0",
+    "autoprefixer": "^8.5.0",
+    "aws-sdk": "^2.239.1",
    "axios": "^0.18.0",
-    "axios-progress-bar": "^1.1.8",
-    "babel-core": "^6.0.0",
-    "babel-eslint": "^8.2.2",
+    "axios-progress-bar": "^1.2.0",
+    "babel-core": "^6.26.3",
+    "babel-eslint": "^8.2.3",
    "babel-loader": "^7.1.4",
    "babel-plugin-syntax-async-functions": "^6.13.0",
    "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.0",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
    "babel-plugin-transform-object-rest-spread": "^6.16.0",
    "babel-plugin-transform-regenerator": "^6.16.1",
    "babel-polyfill": "^6.6.1",
    "babel-preset-es2015": "^6.6.0",
    "babel-register": "^6.6.0",
    "babel-runtime": "^6.11.6",
-    "bcrypt": "^1.0.2",
-    "body-parser": "^1.15.0",
-    "bootstrap": "^4.1.0",
-    "bootstrap-vue": "^2.0.0-rc.6",
+    "bcrypt": "^3.0.1",
+    "body-parser": "^1.18.3",
+    "bootstrap": "^4.1.1",
+    "bootstrap-vue": "^2.0.0-rc.9",
    "compression": "^1.7.2",
    "cookie-session": "^1.2.0",
    "coupon-code": "^0.4.5",
-    "cross-env": "^5.1.4",
+    "cross-env": "^5.1.5",
    "css-loader": "^0.28.11",
-    "csv-stringify": "^2.1.0",
+    "csv-stringify": "^3.0.0",
    "cwait": "^1.1.1",
    "domain-middleware": "~0.1.0",
    "express": "^4.16.3",
-    "express-basic-auth": "^1.1.4",
-    "express-validator": "^5.1.2",
+    "express-basic-auth": "^1.1.5",
+    "express-validator": "^5.2.0",
    "extract-text-webpack-plugin": "^3.0.2",
    "glob": "^7.1.2",
-    "got": "^8.3.0",
+    "got": "^9.0.0",
    "gulp": "^4.0.0",
    "gulp-babel": "^7.0.1",
    "gulp-imagemin": "^4.1.0",
@@ -52,23 +53,22 @@
    "hellojs": "^1.15.1",
    "html-webpack-plugin": "^3.2.0",
    "image-size": "^0.6.2",
-    "in-app-purchase": "^1.9.0",
-    "intro.js": "^2.6.0",
+    "in-app-purchase": "^1.9.4",
+    "intro.js": "^2.9.3",
    "jquery": ">=3.0.0",
    "js2xmlparser": "^3.0.0",
-    "lodash": "^4.17.4",
-    "memwatch-next": "^0.3.0",
+    "lodash": "^4.17.10",
    "merge-stream": "^1.0.0",
    "method-override": "^2.3.5",
-    "moment": "^2.22.0",
+    "moment": "^2.22.1",
    "moment-recur": "^1.0.7",
-    "mongoose": "^5.0.14",
+    "mongoose": "^5.1.3",
    "morgan": "^1.7.0",
    "nconf": "^0.10.0",
    "node-gcm": "^0.14.4",
-    "node-sass": "^4.8.3",
+    "node-sass": "^4.9.0",
    "nodemailer": "^4.6.4",
-    "ora": "^2.0.0",
+    "ora": "^2.1.0",
    "pageres": "^4.1.1",
    "passport": "^0.4.0",
    "passport-facebook": "^2.0.0",
@@ -79,23 +79,25 @@
    "postcss-easy-import": "^3.0.0",
    "ps-tree": "^1.0.0",
    "pug": "^2.0.3",
-    "push-notify": "git://github.com/habitrpg/push-notify.git#6bc2b5fdb1bdc9649b9ec1964d79ca50187fc8a9",
    "pusher": "^1.3.0",
    "rimraf": "^2.4.3",
    "sass-loader": "^7.0.0",
-    "shelljs": "^0.8.1",
-    "stackimpact": "^1.3.0",
-    "stripe": "^5.8.0",
-    "superagent": "^3.4.3",
+    "shelljs": "^0.8.2",
+    "short-uuid": "^3.0.0",
+    "smartbanner.js": "^1.9.1",
+    "stripe": "^5.9.0",
+    "superagent": "^3.8.3",
    "svg-inline-loader": "^0.8.0",
    "svg-url-loader": "^2.3.2",
    "svgo": "^1.0.5",
    "svgo-loader": "^2.1.0",
    "universal-analytics": "^0.4.16",
+    "update": "^0.7.4",
+    "upgrade": "^1.1.0",
    "url-loader": "^1.0.0",
    "useragent": "^2.1.9",
    "uuid": "^3.0.1",
-    "validator": "^9.4.1",
+    "validator": "^10.5.0",
    "vinyl-buffer": "^1.0.1",
    "vue": "^2.5.16",
    "vue-loader": "^14.2.2",
@@ -105,9 +107,9 @@
    "vue-template-compiler": "^2.5.16",
    "vuedraggable": "^2.15.0",
    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#5d237615463a84a23dd6f3f77c6ab577d68593ec",
-    "webpack": "^3.11.0",
+    "webpack": "^3.12.0",
    "webpack-merge": "^4.0.0",
-    "winston": "^2.4.1",
+    "winston": "^2.4.2",
    "winston-loggly-bulk": "^2.0.2",
    "xml2js": "^0.4.4"
  },
@@ -121,9 +123,11 @@
    "test": "npm run lint && gulp test && gulp apidoc",
    "test:build": "gulp test:prepare:build",
    "test:api-v3": "gulp test:api-v3",
-    "test:api-v3:unit": "gulp test:api-v3:unit",
+    "test:api:unit": "gulp test:api:unit",
    "test:api-v3:integration": "gulp test:api-v3:integration",
    "test:api-v3:integration:separate-server": "NODE_ENV=test gulp test:api-v3:integration:separate-server",
+    "test:api-v4:integration": "gulp test:api-v4:integration",
+    "test:api-v4:integration:separate-server": "NODE_ENV=test gulp test:api-v4:integration:separate-server",
    "test:sanity": "istanbul cover --dir coverage/sanity --report lcovonly node_modules/mocha/bin/_mocha -- test/sanity --recursive",
    "test:common": "istanbul cover --dir coverage/common --report lcovonly node_modules/mocha/bin/_mocha -- test/common --recursive",
    "test:content": "istanbul cover --dir coverage/content --report lcovonly node_modules/mocha/bin/_mocha -- test/content --recursive",
@@ -141,15 +145,15 @@
    "apidoc": "gulp apidoc"
  },
  "devDependencies": {
-    "@vue/test-utils": "^1.0.0-beta.13",
+    "@vue/test-utils": "^1.0.0-beta.16",
    "babel-plugin-istanbul": "^4.1.6",
    "babel-plugin-syntax-object-rest-spread": "^6.13.0",
    "chai": "^4.1.2",
    "chai-as-promised": "^7.1.1",
-    "chalk": "^2.3.2",
-    "chromedriver": "^2.37.0",
+    "chalk": "^2.4.1",
+    "chromedriver": "^2.38.3",
    "connect-history-api-fallback": "^1.1.0",
-    "coveralls": "^3.0.0",
+    "coveralls": "^3.0.1",
    "cross-spawn": "^6.0.5",
    "eslint": "^4.19.1",
    "eslint-config-habitrpg": "^4.0.0",
@@ -161,33 +165,34 @@
    "expect.js": "^0.3.1",
    "http-proxy-middleware": "^0.18.0",
    "istanbul": "^1.1.0-alpha.1",
-    "karma": "^2.0.0",
+    "karma": "^3.0.0",
    "karma-babel-preprocessor": "^7.0.0",
    "karma-chai-plugins": "^0.9.0",
    "karma-chrome-launcher": "^2.2.0",
-    "karma-coverage": "^1.1.1",
+    "karma-coverage": "^1.1.2",
    "karma-mocha": "^1.3.0",
    "karma-mocha-reporter": "^2.2.5",
-    "karma-sinon-chai": "^1.3.4",
+    "karma-sinon-chai": "^2.0.0",
    "karma-sinon-stub-promise": "^1.0.0",
    "karma-sourcemap-loader": "^0.3.7",
    "karma-spec-reporter": "0.0.32",
    "karma-webpack": "^3.0.0",
-    "lcov-result-merger": "^2.0.0",
-    "mocha": "^5.0.5",
-    "monk": "^6.0.5",
-    "nightwatch": "^0.9.20",
-    "puppeteer": "^1.2.0",
+    "lcov-result-merger": "^3.0.0",
+    "mocha": "^5.1.1",
+    "monk": "^6.0.6",
+    "nightwatch": "^0.9.21",
+    "puppeteer": "^1.4.0",
    "require-again": "^2.0.0",
-    "selenium-server": "^3.11.0",
+    "selenium-server": "^3.12.0",
    "sinon": "^4.5.0",
    "sinon-chai": "^3.0.0",
    "sinon-stub-promise": "^4.0.0",
-    "webpack-bundle-analyzer": "^2.11.1",
+    "webpack-bundle-analyzer": "^2.12.0",
    "webpack-dev-middleware": "^2.0.5",
-    "webpack-hot-middleware": "^2.22.0"
+    "webpack-hot-middleware": "^2.22.2"
  },
  "optionalDependencies": {
+    "memwatch-next": "^0.3.0",
    "node-rdkafka": "^2.3.0"
  }
 }
@@ -1,5 +1,5 @@
 /* eslint-disable camelcase */
-import analyticsService from '../../../../../website/server/libs/analyticsService';
+import analyticsService from '../../../../website/server/libs/analyticsService';
 import Amplitude from 'amplitude';
 import { Visitor } from 'universal-analytics';

@@ -1,19 +1,19 @@
-import apiMessages from '../../../../../website/server/libs/apiMessages';
+import apiError from '../../../../website/server/libs/apiError';

 describe('API Messages', () => {
  const message = 'Only public guilds support pagination.';
  it('returns an API message', () => {
-    expect(apiMessages('guildsOnlyPaginate')).to.equal(message);
+    expect(apiError('guildsOnlyPaginate')).to.equal(message);
  });

  it('throws if the API message does not exist', () => {
-    expect(() => apiMessages('iDoNotExist')).to.throw;
+    expect(() => apiError('iDoNotExist')).to.throw;
  });

  it('clones the passed variables', () => {
    let vars = {a: 1};
    sandbox.stub(_, 'clone').returns({});
-    apiMessages('guildsOnlyPaginate', vars);
+    apiError('guildsOnlyPaginate', vars);
    expect(_.clone).to.have.been.calledOnce;
    expect(_.clone).to.have.been.calledWith(vars);
  });
@@ -22,7 +22,7 @@ describe('API Messages', () => {
    let vars = {a: 1};
    let stub = sinon.stub().returns('string');
    sandbox.stub(_, 'template').returns(stub);
-    apiMessages('guildsOnlyPaginate', vars);
+    apiError('guildsOnlyPaginate', vars);
    expect(_.template).to.have.been.calledOnce;
    expect(_.template).to.have.been.calledWith(message);
    expect(stub).to.have.been.calledOnce;
@@ -1,4 +1,4 @@
-import baseModel from '../../../../../website/server/libs/baseModel';
+import baseModel from '../../../../website/server/libs/baseModel';
 import mongoose from 'mongoose';

 describe('Base model plugin', () => {
@@ -1,7 +1,7 @@
 import mongoose from 'mongoose';
 import {
  removeFromArray,
-} from '../../../../../website/server/libs/collectionManipulators';
+} from '../../../../website/server/libs/collectionManipulators';

 describe('Collection Manipulators', () => {
  describe('removeFromArray', () => {
@@ -2,17 +2,18 @@
 import moment from 'moment';
 import nconf from 'nconf';
 import requireAgain from 'require-again';
-import { recoverCron, cron } from '../../../../../website/server/libs/cron';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import common from '../../../../../website/common';
-import analytics from '../../../../../website/server/libs/analyticsService';
+import { recoverCron, cron } from '../../../../website/server/libs/cron';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import common from '../../../../website/common';
+import analytics from '../../../../website/server/libs/analyticsService';

 // const scoreTask = common.ops.scoreTask;

-let pathToCronLib = '../../../../../website/server/libs/cron';
+let pathToCronLib = '../../../../website/server/libs/cron';

 describe('cron', () => {
+  let clock = null;
  let user;
  let tasksByType = {habits: [], dailys: [], todos: [], rewards: []};
  let daysMissed = 0;
@@ -34,6 +35,8 @@ describe('cron', () => {
  });

  afterEach(() => {
+    if (clock !== null)
+      clock.restore();
    analytics.track.restore();
  });

@@ -62,6 +65,12 @@ describe('cron', () => {
    expect(analytics.track.callCount).to.equal(1);
  });

+  it('calls analytics when user is sleeping', () => {
+    user.preferences.sleep = true;
+    cron({user, tasksByType, daysMissed, analytics});
+    expect(analytics.track.callCount).to.equal(1);
+  });
+
  describe('end of the month perks', () => {
    beforeEach(() => {
      user.purchased.plan.customerId = 'subscribedId';
@@ -82,14 +91,12 @@ describe('cron', () => {
    });

    it('does not reset plan.gemsBought within the month', () => {
-      let clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').toDate());
+      clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').toDate());
      user.purchased.plan.dateUpdated = moment().startOf('month').toDate();

      user.purchased.plan.gemsBought = 10;
      cron({user, tasksByType, daysMissed, analytics});
      expect(user.purchased.plan.gemsBought).to.equal(10);
-
-      clock.restore();
    });

    it('resets plan.dateUpdated on a new month', () => {
@@ -156,7 +163,6 @@ describe('cron', () => {
    });

    describe('for a 1-month recurring subscription', () => {
-      let clock;
      // create a user that will be used for all of these tests without a reset before each
      let user1 = new User({
        auth: {
@@ -187,7 +193,6 @@ describe('cron', () => {
        expect(user1.purchased.plan.consecutive.offset).to.equal(0);
        expect(user1.purchased.plan.consecutive.trinkets).to.equal(0);
        expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(0);
-        clock.restore();
      });

      it('does not increment consecutive benefits after the second month', () => {
@@ -199,7 +204,6 @@ describe('cron', () => {
        expect(user1.purchased.plan.consecutive.offset).to.equal(0);
        expect(user1.purchased.plan.consecutive.trinkets).to.equal(0);
        expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(0);
-        clock.restore();
      });

      it('increments consecutive benefits after the third month', () => {
@@ -211,7 +215,6 @@ describe('cron', () => {
        expect(user1.purchased.plan.consecutive.offset).to.equal(0);
        expect(user1.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits after the fourth month', () => {
@@ -223,7 +226,6 @@ describe('cron', () => {
        expect(user1.purchased.plan.consecutive.offset).to.equal(0);
        expect(user1.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -233,12 +235,10 @@ describe('cron', () => {
        expect(user1.purchased.plan.consecutive.offset).to.equal(0);
        expect(user1.purchased.plan.consecutive.trinkets).to.equal(3);
        expect(user1.purchased.plan.consecutive.gemCapExtra).to.equal(15);
-        clock.restore();
      });
    });

    describe('for a 3-month recurring subscription', () => {
-      let clock;
      let user3 = new User({
        auth: {
          local: {
@@ -266,7 +266,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(2);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the middle of the period that they already have benefits for', () => {
@@ -276,7 +275,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(1);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -286,7 +284,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(0);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -296,7 +293,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(2);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the second month of the second period that they already have benefits for', () => {
@@ -306,7 +302,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(1);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the final month of the second period that they already have benefits for', () => {
@@ -316,7 +311,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(0);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(2);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -326,7 +320,6 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(2);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(3);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(15);
-        clock.restore();
      });

      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -336,12 +329,10 @@ describe('cron', () => {
        expect(user3.purchased.plan.consecutive.offset).to.equal(2);
        expect(user3.purchased.plan.consecutive.trinkets).to.equal(4);
        expect(user3.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
      });
    });

    describe('for a 6-month recurring subscription', () => {
-      let clock;
      let user6 = new User({
        auth: {
          local: {
@@ -369,7 +360,6 @@ describe('cron', () => {
        expect(user6.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6.purchased.plan.consecutive.trinkets).to.equal(2);
        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -379,7 +369,6 @@ describe('cron', () => {
        expect(user6.purchased.plan.consecutive.offset).to.equal(0);
        expect(user6.purchased.plan.consecutive.trinkets).to.equal(2);
        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -389,7 +378,6 @@ describe('cron', () => {
        expect(user6.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6.purchased.plan.consecutive.trinkets).to.equal(4);
        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -399,7 +387,6 @@ describe('cron', () => {
        expect(user6.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6.purchased.plan.consecutive.trinkets).to.equal(6);
        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -409,13 +396,10 @@ describe('cron', () => {
        expect(user6.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6.purchased.plan.consecutive.trinkets).to.equal(8);
        expect(user6.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });
    });

    describe('for a 12-month recurring subscription', () => {
-      let clock;
-
      let user12 = new User({
        auth: {
          local: {
@@ -443,7 +427,6 @@ describe('cron', () => {
        expect(user12.purchased.plan.consecutive.offset).to.equal(11);
        expect(user12.purchased.plan.consecutive.trinkets).to.equal(4);
        expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
@@ -453,7 +436,6 @@ describe('cron', () => {
        expect(user12.purchased.plan.consecutive.offset).to.equal(0);
        expect(user12.purchased.plan.consecutive.trinkets).to.equal(4);
        expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(20);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the second paid period has started', () => {
@@ -463,7 +445,6 @@ describe('cron', () => {
        expect(user12.purchased.plan.consecutive.offset).to.equal(11);
        expect(user12.purchased.plan.consecutive.trinkets).to.equal(8);
        expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('increments consecutive benefits the month after the third paid period has started', () => {
@@ -473,7 +454,6 @@ describe('cron', () => {
        expect(user12.purchased.plan.consecutive.offset).to.equal(11);
        expect(user12.purchased.plan.consecutive.trinkets).to.equal(12);
        expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
@@ -483,12 +463,10 @@ describe('cron', () => {
        expect(user12.purchased.plan.consecutive.offset).to.equal(11);
        expect(user12.purchased.plan.consecutive.trinkets).to.equal(16);
        expect(user12.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });
    });

    describe('for a 3-month gift subscription (non-recurring)', () => {
-      let clock;
      let user3g = new User({
        auth: {
          local: {
@@ -503,7 +481,7 @@ describe('cron', () => {
      // user3g has a 3-month gift subscription starting today
      user3g.purchased.plan.customerId = 'Gift';
      user3g.purchased.plan.dateUpdated = moment().toDate();
-      user3g.purchased.plan.dateTerminated = moment().add(3, 'months').toDate();
+      user3g.purchased.plan.dateTerminated = moment().startOf('month').add(3, 'months').add(15, 'days').toDate();
      user3g.purchased.plan.planId = null;
      user3g.purchased.plan.consecutive.count = 0;
      user3g.purchased.plan.consecutive.offset = 3;
@@ -517,7 +495,6 @@ describe('cron', () => {
        expect(user3g.purchased.plan.consecutive.offset).to.equal(2);
        expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the second month of the gift subscription', () => {
@@ -527,7 +504,6 @@ describe('cron', () => {
        expect(user3g.purchased.plan.consecutive.offset).to.equal(1);
        expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the third month of the gift subscription', () => {
@@ -537,7 +513,6 @@ describe('cron', () => {
        expect(user3g.purchased.plan.consecutive.offset).to.equal(0);
        expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the month after the gift subscription has ended', () => {
@@ -547,12 +522,10 @@ describe('cron', () => {
        expect(user3g.purchased.plan.consecutive.offset).to.equal(0);
        expect(user3g.purchased.plan.consecutive.trinkets).to.equal(1);
        expect(user3g.purchased.plan.consecutive.gemCapExtra).to.equal(0); // erased
-        clock.restore();
      });
    });

    describe('for a 6-month recurring subscription where the user has incorrect consecutive month data from prior bugs', () => {
-      let clock;
      let user6x = new User({
        auth: {
          local: {
@@ -580,7 +553,6 @@ describe('cron', () => {
        expect(user6x.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
        expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the second month after the fix goes live', () => {
@@ -590,7 +562,6 @@ describe('cron', () => {
        expect(user6x.purchased.plan.consecutive.offset).to.equal(4);
        expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
        expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('does not increment consecutive benefits in the third month after the fix goes live', () => {
@@ -600,7 +571,6 @@ describe('cron', () => {
        expect(user6x.purchased.plan.consecutive.offset).to.equal(3);
        expect(user6x.purchased.plan.consecutive.trinkets).to.equal(5);
        expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });

      it('increments consecutive benefits in the seventh month after the fix goes live', () => {
@@ -610,7 +580,6 @@ describe('cron', () => {
        expect(user6x.purchased.plan.consecutive.offset).to.equal(5);
        expect(user6x.purchased.plan.consecutive.trinkets).to.equal(7);
        expect(user6x.purchased.plan.consecutive.gemCapExtra).to.equal(25);
-        clock.restore();
      });
    });
  });
@@ -627,14 +596,12 @@ describe('cron', () => {
    });

    it('does not reset plan.gemsBought within the month', () => {
-      let clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').unix());
+      clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').unix());
      user.purchased.plan.dateUpdated = moment().startOf('month').toDate();

      user.purchased.plan.gemsBought = 10;
      cron({user, tasksByType, daysMissed, analytics});
      expect(user.purchased.plan.gemsBought).to.equal(10);
-
-      clock.restore();
    });

    it('does not reset plan.dateUpdated on a new month', () => {
@@ -694,76 +661,6 @@ describe('cron', () => {
    });
  });

-  describe('user is sleeping', () => {
-    beforeEach(() => {
-      user.preferences.sleep = true;
-    });
-
-    it('calls analytics', () => {
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(analytics.track.callCount).to.equal(1);
-    });
-
-    it('clears user buffs', () => {
-      user.stats.buffs = {
-        str: 1,
-        int: 1,
-        per: 1,
-        con: 1,
-        stealth: 1,
-        streaks: true,
-      };
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(user.stats.buffs.str).to.equal(0);
-      expect(user.stats.buffs.int).to.equal(0);
-      expect(user.stats.buffs.per).to.equal(0);
-      expect(user.stats.buffs.con).to.equal(0);
-      expect(user.stats.buffs.stealth).to.equal(0);
-      expect(user.stats.buffs.streaks).to.be.false;
-    });
-
-    it('resets all dailies without damaging user', () => {
-      let daily = {
-        text: 'test daily',
-        type: 'daily',
-        frequency: 'daily',
-        everyX: 5,
-        startDate: new Date(),
-      };
-
-      let task = new Tasks.daily(Tasks.Task.sanitize(daily)); // eslint-disable-line new-cap
-      tasksByType.dailys.push(task);
-      tasksByType.dailys[0].completed = true;
-
-      let healthBefore = user.stats.hp;
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(tasksByType.dailys[0].completed).to.be.false;
-      expect(user.stats.hp).to.equal(healthBefore);
-    });
-
-    it('sets isDue for daily', () => {
-      let daily = {
-        text: 'test daily',
-        type: 'daily',
-        frequency: 'daily',
-        everyX: 5,
-        startDate: new Date(),
-      };
-
-      let task = new Tasks.daily(Tasks.Task.sanitize(daily)); // eslint-disable-line new-cap
-      tasksByType.dailys.push(task);
-      tasksByType.dailys[0].completed = true;
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(tasksByType.dailys[0].isDue).to.be.exist;
-    });
-  });
-
  describe('todos', () => {
    beforeEach(() => {
      let todo = {
@@ -885,6 +782,15 @@ describe('cron', () => {
      expect(tasksByType.dailys[0].isDue).to.be.false;
    });

+    it('computes isDue when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].frequency = 'daily';
+      tasksByType.dailys[0].everyX = 5;
+      tasksByType.dailys[0].startDate = moment().toDate();
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].isDue).to.exist;
+    });
+
    it('computes nextDue', () => {
      tasksByType.dailys[0].frequency = 'daily';
      tasksByType.dailys[0].everyX = 5;
@@ -904,6 +810,13 @@ describe('cron', () => {
      expect(tasksByType.dailys[0].completed).to.be.false;
    });

+    it('should set tasks completed to false when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].completed = true;
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].completed).to.be.false;
+    });
+
    it('should reset task checklist for completed dailys', () => {
      tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
      tasksByType.dailys[0].completed = true;
@@ -911,6 +824,14 @@ describe('cron', () => {
      expect(tasksByType.dailys[0].checklist[0].completed).to.be.false;
    });

+    it('should reset task checklist for completed dailys when user is sleeping', () => {
+      user.preferences.sleep = true;
+      tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
+      tasksByType.dailys[0].completed = true;
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].checklist[0].completed).to.be.false;
+    });
+
    it('should reset task checklist for dailys with scheduled misses', () => {
      daysMissed = 10;
      tasksByType.dailys[0].checklist.push({title: 'test', completed: false});
@@ -923,12 +844,19 @@ describe('cron', () => {
      daysMissed = 1;
      let hpBefore = user.stats.hp;
      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
-
      cron({user, tasksByType, daysMissed, analytics});
-
      expect(user.stats.hp).to.be.lessThan(hpBefore);
    });

+    it('should not do damage for missing a daily when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      let hpBefore = user.stats.hp;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(user.stats.hp).to.equal(hpBefore);
+    });
+
    it('should not do damage for missing a daily when CRON_SAFE_MODE is set', () => {
      sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
      let cronOverride = requireAgain(pathToCronLib).cron;
@@ -969,7 +897,7 @@ describe('cron', () => {
      expect(hpDifferenceOfPartiallyIncompleteDaily).to.be.lessThan(hpDifferenceOfFullyIncompleteDaily);
    });

-    it('should decrement quest progress down for missing a daily', () => {
+    it('should decrement quest.progress.down for missing a daily', () => {
      daysMissed = 1;
      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});

@@ -978,6 +906,16 @@ describe('cron', () => {
      expect(progress.down).to.equal(-1);
    });

+    it('should not decrement quest.progress.down for missing a daily when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let progress = cron({user, tasksByType, daysMissed, analytics});
+
+      expect(progress.down).to.equal(0);
+    });
+
    it('should do damage for only yesterday\'s dailies', () => {
      daysMissed = 3;
      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
@@ -1040,15 +978,11 @@ describe('cron', () => {

    describe('counters', () => {
      let notStartOfWeekOrMonth = new Date(2016, 9, 28).getTime(); // a Friday
-      let clock;

      beforeEach(() => {
        // Replace system clocks so we can get predictable results
        clock = sinon.useFakeTimers(notStartOfWeekOrMonth);
      });
-      afterEach(() => {
-        return clock.restore();
-      });

      it('should reset a daily habit counter each day', () => {
        tasksByType.habits[0].counterUp = 1;
@@ -1060,7 +994,7 @@ describe('cron', () => {
        expect(tasksByType.habits[0].counterDown).to.equal(0);
      });

-      it('should reset habit counters even if user is resting in the Inn', () => {
+      it('should reset habit counters even if user is sleeping', () => {
        user.preferences.sleep = true;
        tasksByType.habits[0].counterUp = 1;
        tasksByType.habits[0].counterDown = 1;
@@ -1321,7 +1255,23 @@ describe('cron', () => {
      expect(user.achievements.perfect).to.equal(0);
    });

-    it('increments user buffs if all (at least 1) due dailies were completed', () => {
+    it('gives perfect day buff if all (at least 1) due dailies were completed', () => {
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = true;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let previousBuffs = user.stats.buffs.toObject();
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.be.greaterThan(previousBuffs.str);
+      expect(user.stats.buffs.int).to.be.greaterThan(previousBuffs.int);
+      expect(user.stats.buffs.per).to.be.greaterThan(previousBuffs.per);
+      expect(user.stats.buffs.con).to.be.greaterThan(previousBuffs.con);
+    });
+
+    it('gives perfect day buff if all (at least 1) due dailies were completed when user is sleeping', () => {
+      user.preferences.sleep = true;
      daysMissed = 1;
      tasksByType.dailys[0].completed = true;
      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
@@ -1360,6 +1310,31 @@ describe('cron', () => {
      expect(user.stats.buffs.streaks).to.be.false;
    });

+    it('clears buffs if user does not have a perfect day (no due dailys) when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = true;
+      tasksByType.dailys[0].startDate = moment(new Date()).add({days: 1});
+
+      user.stats.buffs = {
+        str: 1,
+        int: 1,
+        per: 1,
+        con: 1,
+        stealth: 0,
+        streaks: true,
+      };
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.equal(0);
+      expect(user.stats.buffs.int).to.equal(0);
+      expect(user.stats.buffs.per).to.equal(0);
+      expect(user.stats.buffs.con).to.equal(0);
+      expect(user.stats.buffs.stealth).to.equal(0);
+      expect(user.stats.buffs.streaks).to.be.false;
+    });
+
    it('clears buffs if user does not have a perfect day (at least one due daily not completed)', () => {
      daysMissed = 1;
      tasksByType.dailys[0].completed = false;
@@ -1384,7 +1359,50 @@ describe('cron', () => {
      expect(user.stats.buffs.streaks).to.be.false;
    });

-    it('still grants a perfect day when CRON_SAFE_MODE is set', () => {
+    it('clears buffs if user does not have a perfect day (at least one due daily not completed) when user is sleeping', () => {
+      user.preferences.sleep = true;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = false;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      user.stats.buffs = {
+        str: 1,
+        int: 1,
+        per: 1,
+        con: 1,
+        stealth: 0,
+        streaks: true,
+      };
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.equal(0);
+      expect(user.stats.buffs.int).to.equal(0);
+      expect(user.stats.buffs.per).to.equal(0);
+      expect(user.stats.buffs.con).to.equal(0);
+      expect(user.stats.buffs.stealth).to.equal(0);
+      expect(user.stats.buffs.streaks).to.be.false;
+    });
+
+    it('always grants a perfect day buff when CRON_SAFE_MODE is set', () => {
+      sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
+      let cronOverride = requireAgain(pathToCronLib).cron;
+      daysMissed = 1;
+      tasksByType.dailys[0].completed = false;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let previousBuffs = user.stats.buffs.toObject();
+
+      cronOverride({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.buffs.str).to.be.greaterThan(previousBuffs.str);
+      expect(user.stats.buffs.int).to.be.greaterThan(previousBuffs.int);
+      expect(user.stats.buffs.per).to.be.greaterThan(previousBuffs.per);
+      expect(user.stats.buffs.con).to.be.greaterThan(previousBuffs.con);
+    });
+
+    it('always grants a perfect day buff when CRON_SAFE_MODE is set when user is sleeping', () => {
+      user.preferences.sleep = true;
      sandbox.stub(nconf, 'get').withArgs('CRON_SAFE_MODE').returns('true');
      let cronOverride = requireAgain(pathToCronLib).cron;
      daysMissed = 1;
@@ -1416,6 +1434,20 @@ describe('cron', () => {
      common.statsComputed.restore();
    });

+    it('should not add mp to user when user is sleeping', () => {
+      const statsComputedRes = common.statsComputed(user);
+      const stubbedStatsComputed = sinon.stub(common, 'statsComputed');
+
+      user.preferences.sleep = true;
+      let mpBefore = user.stats.mp;
+      tasksByType.dailys[0].completed = true;
+      stubbedStatsComputed.returns(Object.assign(statsComputedRes, {maxMP: 100}));
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(user.stats.mp).to.equal(mpBefore);
+
+      common.statsComputed.restore();
+    });
+
    it('set user\'s mp to statsComputed.maxMP when user.stats.mp is greater', () => {
      const statsComputedRes = common.statsComputed(user);
      const stubbedStatsComputed = sinon.stub(common, 'statsComputed');
@@ -1557,27 +1589,6 @@ describe('cron', () => {
        flagCount: 0,
      };
    });
-
-    xit('does not clear pms under 200', () => {
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.inbox.messages[lastMessageId]).to.exist;
-    });
-
-    xit('clears pms over 200', () => {
-      let messageId = common.uuid();
-      user.inbox.messages[messageId] = {
-        id: messageId,
-        text: `test ${messageId}`,
-        timestamp: Number(new Date()),
-        likes: {},
-        flags: {},
-        flagCount: 0,
-      };
-
-      cron({user, tasksByType, daysMissed, analytics});
-
-      expect(user.inbox.messages[messageId]).to.not.exist;
-    });
  });

  describe('login incentives', () => {
@@ -1611,7 +1622,7 @@ describe('cron', () => {
      expect(user.loginIncentives).to.eql(1);
    });

-    it('increments loginIncentives by 1 even if user has Dailies paused', () => {
+    it('increments loginIncentives by 1 even if user is sleeping', () => {
      user.preferences.sleep = true;
      cron({user, tasksByType, daysMissed, analytics});
      expect(user.loginIncentives).to.eql(1);
@@ -3,9 +3,9 @@ import got from 'got';
 import nconf from 'nconf';
 import nodemailer from 'nodemailer';
 import requireAgain from 'require-again';
-import logger from '../../../../../website/server/libs/logger';
-import { TAVERN_ID } from '../../../../../website/server/models/group';
-import { defer } from '../../../../helpers/api-unit.helper';
+import logger from '../../../../website/server/libs/logger';
+import { TAVERN_ID } from '../../../../website/server/models/group';
+import { defer } from '../../../helpers/api-unit.helper';

 function getUser () {
  return {
@@ -19,7 +19,6 @@ function getUser () {
        emails: [{
          value: 'email@facebook',
        }],
-        displayName: 'fb display name',
      },
    },
    profile: {
@@ -34,7 +33,7 @@ function getUser () {
 }

 describe('emails', () => {
-  let pathToEmailLib = '../../../../../website/server/libs/email';
+  let pathToEmailLib = '../../../../website/server/libs/email';

  describe('sendEmail', () => {
    let sendMailSpy;
@@ -100,7 +99,7 @@ describe('emails', () => {

      let data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);

-      expect(data).to.have.property('name', user.auth.facebook.displayName);
+      expect(data).to.have.property('name', user.profile.name);
      expect(data).to.have.property('email', user.auth.facebook.emails[0].value);
      expect(data).to.have.property('_id', user._id);
      expect(data).to.have.property('canSend', true);
@@ -110,13 +109,12 @@ describe('emails', () => {
      let attachEmail = requireAgain(pathToEmailLib);
      let getUserInfo = attachEmail.getUserInfo;
      let user = getUser();
-      delete user.profile.name;
      delete user.auth.local.email;
      delete user.auth.facebook;

      let data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);

-      expect(data).to.have.property('name', user.auth.local.username);
+      expect(data).to.have.property('name', user.profile.name);
      expect(data).not.to.have.property('email');
      expect(data).to.have.property('_id', user._id);
      expect(data).to.have.property('canSend', true);
@@ -1,7 +1,7 @@
 import {
  encrypt,
  decrypt,
-} from '../../../../../website/server/libs/encryption';
+} from '../../../../website/server/libs/encryption';

 describe('encryption', () => {
  it('can encrypt and decrypt', () => {
@@ -5,7 +5,7 @@ import {
  BadRequest,
  InternalServerError,
  NotFound,
-} from '../../../../../website/server/libs/errors';
+} from '../../../../website/server/libs/errors';

 describe('Custom Errors', () => {
  describe('CustomError', () => {
@@ -2,7 +2,7 @@ import {
  translations,
  localePath,
  langCodes,
-} from '../../../../../website/server/libs/i18n';
+} from '../../../../website/server/libs/i18n';
 import fs from 'fs';
 import path from 'path';

@@ -1,8 +1,8 @@
 import winston from 'winston';
-import logger from '../../../../../website/server/libs/logger';
+import logger from '../../../../website/server/libs/logger';
 import {
  NotFound,
-} from '../../../../../website/server/libs//errors';
+} from '../../../../website/server/libs//errors';

 describe('logger', () => {
  let logSpy;
@@ -2,11 +2,11 @@

 import {
  encrypt,
-} from '../../../../../website/server/libs/encryption';
+} from '../../../../website/server/libs/encryption';
 import moment from 'moment';
 import {
  generateUser,
-} from '../../../../helpers/api-integration/v3';
+} from '../../../helpers/api-integration/v3';
 import {
  sha1Encrypt as sha1EncryptPassword,
  sha1MakeSalt,
@@ -15,7 +15,7 @@ import {
  compare,
  convertToBcrypt,
  validatePasswordResetCodeAndFindUser,
-} from '../../../../../website/server/libs/password';
+} from '../../../../website/server/libs/password';

 describe('Password Utilities', () => {
  describe('compare', () => {
@@ -107,6 +107,25 @@ describe('Password Utilities', () => {
      }
    });

+    it('defaults to SHA1 encryption if salt is provided', async () => {
+      let textPassword = 'mySecretPassword';
+      let salt = sha1MakeSalt();
+      let hashedPassword = sha1EncryptPassword(textPassword, salt);
+
+      let user = {
+        auth: {
+          local: {
+            hashed_password: hashedPassword,
+            salt,
+            passwordHashMethod: '',
+          },
+        },
+      };
+
+      let isValidPassword = await compare(user, textPassword);
+      expect(isValidPassword).to.eql(true);
+    });
+
    it('throws an error if an invalid hashing method is used', async () => {
      try {
        await compare({
@@ -2,11 +2,11 @@ import moment from 'moment';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
 import { createNonLeaderGroupMember } from '../paymentHelpers';

 const i18n = common.i18n;
@@ -1,7 +1,7 @@
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+import { model as User } from '../../../../../../website/server/models/user';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -2,12 +2,12 @@ import cc from 'coupon-code';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -2,11 +2,11 @@ import uuid from 'uuid';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import payments from '../../../../../../website/server/libs/payments/payments';

 describe('#upgradeGroupPlan', () => {
  let spy, data, user, group, uuidString;
@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import iapModule from '../../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../../website/server/libs/payments/payments';
-import applePayments from '../../../../../../website/server/libs/payments/apple';
-import iap from '../../../../../../website/server/libs/inAppPurchases';
-import {model as User} from '../../../../../../website/server/models/user';
-import common from '../../../../../../website/common';
+import iapModule from '../../../../../website/server/libs/inAppPurchases';
+import payments from '../../../../../website/server/libs/payments/payments';
+import applePayments from '../../../../../website/server/libs/payments/apple';
+import iap from '../../../../../website/server/libs/inAppPurchases';
+import {model as User} from '../../../../../website/server/models/user';
+import common from '../../../../../website/common';
 import moment from 'moment';

 const i18n = common.i18n;
@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import iapModule from '../../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../../website/server/libs/payments/payments';
-import googlePayments from '../../../../../../website/server/libs/payments/google';
-import iap from '../../../../../../website/server/libs/inAppPurchases';
-import {model as User} from '../../../../../../website/server/models/user';
-import common from '../../../../../../website/common';
+import iapModule from '../../../../../website/server/libs/inAppPurchases';
+import payments from '../../../../../website/server/libs/payments/payments';
+import googlePayments from '../../../../../website/server/libs/payments/google';
+import iap from '../../../../../website/server/libs/inAppPurchases';
+import {model as User} from '../../../../../website/server/models/user';
+import common from '../../../../../website/common';
 import moment from 'moment';

 const i18n = common.i18n;
@@ -1,13 +1,13 @@
 import moment from 'moment';

-import * as sender from '../../../../../../../website/server/libs/email';
-import * as api from '../../../../../../../website/server/libs/payments/payments';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
+import * as sender from '../../../../../../website/server/libs/email';
+import * as api from '../../../../../../website/server/libs/payments/payments';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import i18n from '../../../../../../../website/common/script/i18n';
+} from '../../../../../helpers/api-unit.helper.js';
+import i18n from '../../../../../../website/common/script/i18n';

 describe('Canceling a subscription for group', () => {
  let plan, group, user, data;
@@ -2,16 +2,16 @@ import moment from 'moment';
 import stripeModule from 'stripe';
 import nconf from 'nconf';

-import * as sender from '../../../../../../../website/server/libs/email';
-import * as api from '../../../../../../../website/server/libs/payments/payments';
-import amzLib from '../../../../../../../website/server/libs/payments/amazon';
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
+import * as sender from '../../../../../../website/server/libs/email';
+import * as api from '../../../../../../website/server/libs/payments/payments';
+import amzLib from '../../../../../../website/server/libs/payments/amazon';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
+} from '../../../../../helpers/api-unit.helper.js';

 describe('Purchasing a group plan for group', () => {
  const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_GOOGLE = 'Google_subscription';
@@ -443,8 +443,7 @@ describe('Purchasing a group plan for group', () => {

    await api.createSubscription(data);

-    let updatedUser = await User.findById(recipient._id).exec();
-
+    const updatedUser = await User.findById(recipient._id).exec();
    expect(updatedUser.purchased.plan.extraMonths).to.within(2, 3);
  });

@@ -1,4 +1,4 @@
-import { model as User } from '../../../../../../website/server/models/user';
+import { model as User } from '../../../../../website/server/models/user';

 export async function createNonLeaderGroupMember (group) {
  let nonLeader = new User();
@@ -1,14 +1,14 @@
 import moment from 'moment';

-import * as sender from '../../../../../../website/server/libs/email';
-import * as api from '../../../../../../website/server/libs/payments/payments';
-import analytics from '../../../../../../website/server/libs/analyticsService';
-import notifications from '../../../../../../website/server/libs/pushNotifications';
-import { model as User } from '../../../../../../website/server/models/user';
-import { translate as t } from '../../../../../helpers/api-v3-integration.helper';
+import * as sender from '../../../../../website/server/libs/email';
+import * as api from '../../../../../website/server/libs/payments/payments';
+import analytics from '../../../../../website/server/libs/analyticsService';
+import notifications from '../../../../../website/server/libs/pushNotifications';
+import { model as User } from '../../../../../website/server/models/user';
+import { translate as t } from '../../../../helpers/api-integration/v3';
 import {
  generateGroup,
-} from '../../../../../helpers/api-unit.helper.js';
+} from '../../../../helpers/api-unit.helper.js';

 describe('payments/index', () => {
  let user, group, data, plan;
@@ -210,7 +210,7 @@ describe('payments/index', () => {
        let msg = '\`Hello recipient, sender has sent you 3 months of subscription!\`';

        expect(user.sendMessage).to.be.calledOnce;
-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
      });

      it('sends an email about the gift', async () => {
@@ -629,7 +629,16 @@ describe('payments/index', () => {
        await api.buyGems(data);
        let msg = '\`Hello recipient, sender has sent you 4 gems!\`';

-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
+      });
+
+      it('sends a message from purchaser to recipient wtih custom message', async () => {
+        data.gift.message = 'giftmessage';
+
+        await api.buyGems(data);
+
+        const msg = `\`Hello recipient, sender has sent you 4 gems!\` ${data.gift.message}`;
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: msg, senderMsg: msg, save: false });
      });

      it('sends a push notification if user did not gift to self', async () => {
@@ -658,7 +667,7 @@ describe('payments/index', () => {
          return `\`${messageContent}\``;
        });

-        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: recipientsMessageContent, senderMsg: sendersMessageContent });
+        expect(user.sendMessage).to.be.calledWith(recipient, { receiverMsg: recipientsMessageContent, senderMsg: sendersMessageContent, save: false });
      });
    });
  });
@@ -1,7 +1,7 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import { model as User } from '../../../../../../../website/server/models/user';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import { model as User } from '../../../../../../website/server/models/user';

 describe('checkout success', () => {
  const subKey = 'basic_3mo';
@@ -1,9 +1,9 @@
 /* eslint-disable camelcase */
 import nconf from 'nconf';

-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';

 const BASE_URL = nconf.get('BASE_URL');
 const i18n = common.i18n;
@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';

 describe('ipn', () => {
  const subKey = 'basic_3mo';
@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';
 import { createNonLeaderGroupMember } from '../paymentHelpers';

 const i18n = common.i18n;
@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import payments from '../../../../../../website/server/libs/payments/payments';
 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import common from '../../../../../../website/common';

 describe('subscribeSuccess', () => {
  const subKey = 'basic_3mo';
@@ -2,9 +2,9 @@
 import moment from 'moment';
 import cc from 'coupon-code';

-import paypalPayments from '../../../../../../../website/server/libs/payments/paypal';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import common from '../../../../../../../website/common';
+import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -2,11 +2,11 @@ import stripeModule from 'stripe';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -3,12 +3,12 @@ import cc from 'coupon-code';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Coupon } from '../../../../../../../website/server/models/coupon';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Coupon } from '../../../../../../website/server/models/coupon';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -1,9 +1,9 @@
 import stripeModule from 'stripe';

-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -37,6 +37,22 @@ describe('checkout', () => {
    payments.createSubscription.restore();
  });

+  it('should error if there is no token', async () => {
+    await expect(stripePayments.checkout({
+      user,
+      gift,
+      groupId,
+      email,
+      headers,
+      coupon,
+    }, stripe))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Missing req.body.id',
+        name: 'BadRequest',
+      });
+  });
+
  it('should error if gem amount is too low', async () => {
    let receivingUser = new User();
    receivingUser.save();
@@ -64,7 +80,6 @@ describe('checkout', () => {
      });
  });

-
  it('should error if user cannot get gems', async () => {
    gift = undefined;
    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
@@ -2,10 +2,10 @@ import stripeModule from 'stripe';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import common from '../../../../../../../website/common';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import common from '../../../../../../website/common';

 const i18n = common.i18n;

@@ -2,12 +2,12 @@ import stripeModule from 'stripe';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
-import common from '../../../../../../../website/common';
-import logger from '../../../../../../../website/server/libs/logger';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';
+import common from '../../../../../../website/common';
+import logger from '../../../../../../website/server/libs/logger';
 import { v4 as uuid } from 'uuid';
 import moment from 'moment';

@@ -2,11 +2,11 @@ import stripeModule from 'stripe';

 import {
  generateGroup,
-} from '../../../../../../helpers/api-unit.helper.js';
-import { model as User } from '../../../../../../../website/server/models/user';
-import { model as Group } from '../../../../../../../website/server/models/group';
-import stripePayments from '../../../../../../../website/server/libs/payments/stripe';
-import payments from '../../../../../../../website/server/libs/payments/payments';
+} from '../../../../../helpers/api-unit.helper.js';
+import { model as User } from '../../../../../../website/server/models/user';
+import { model as Group } from '../../../../../../website/server/models/group';
+import stripePayments from '../../../../../../website/server/libs/payments/stripe';
+import payments from '../../../../../../website/server/libs/payments/payments';

 describe('Stripe - Upgrade Group Plan', () => {
  const stripe = stripeModule('test');
@@ -1,7 +1,7 @@
-import { preenHistory } from '../../../../../website/server/libs/preening';
+import { preenHistory } from '../../../../website/server/libs/preening';
 import moment from 'moment';
 import sinon from 'sinon'; // eslint-disable-line no-shadow
-import { generateHistory } from '../../../../helpers/api-unit.helper.js';
+import { generateHistory } from '../../../helpers/api-unit.helper.js';

 describe('preenHistory', () => {
  let clock;
@@ -1,13 +1,13 @@
-import { model as User } from '../../../../../website/server/models/user';
+import { model as User } from '../../../../website/server/models/user';
 import requireAgain from 'require-again';
-import pushNotify from 'push-notify';
+import apn from 'apn/mock';
 import nconf from 'nconf';
 import gcmLib from 'node-gcm'; // works with FCM notifications too

 describe('pushNotifications', () => {
  let user;
  let sendPushNotification;
-  let pathToPushNotifications = '../../../../../website/server/libs/pushNotifications';
+  let pathToPushNotifications = '../../../../website/server/libs/pushNotifications';
  let fcmSendSpy;
  let apnSendSpy;

@@ -24,7 +24,7 @@ describe('pushNotifications', () => {

    sandbox.stub(gcmLib.Sender.prototype, 'send').callsFake(fcmSendSpy);

-    sandbox.stub(pushNotify, 'apn').returns({
+    sandbox.stub(apn.Provider.prototype, 'send').returns({
      on: () => null,
      send: apnSendSpy,
    });
@@ -104,10 +104,7 @@ describe('pushNotifications', () => {
      },
    };

-    sendPushNotification(user, details);
-    expect(apnSendSpy).to.have.been.calledOnce;
-    expect(apnSendSpy).to.have.been.calledWithMatch({
-      token: '123',
+    const expectedNotification = new apn.Notification({
      alert: message,
      sound: 'default',
      category: 'fun',
@@ -117,6 +114,10 @@ describe('pushNotifications', () => {
        b: true,
      },
    });
+
+    sendPushNotification(user, details);
+    expect(apnSendSpy).to.have.been.calledOnce;
+    expect(apnSendSpy).to.have.been.calledWithMatch(expectedNotification, '123');
    expect(fcmSendSpy).to.not.have.been.called;
  });
 });
@@ -1,4 +1,4 @@
-import setupNconf from '../../../../../website/server/libs/setupNconf';
+import setupNconf from '../../../../website/server/libs/setupNconf';

 import path from 'path';
 import nconf from 'nconf';
@@ -1,10 +1,11 @@
 /* eslint-disable camelcase */
 import { IncomingWebhook } from '@slack/client';
 import requireAgain from 'require-again';
-import slack from '../../../../../website/server/libs/slack';
-import logger from '../../../../../website/server/libs/logger';
-import { TAVERN_ID } from '../../../../../website/server/models/group';
+import slack from '../../../../website/server/libs/slack';
+import logger from '../../../../website/server/libs/logger';
+import { TAVERN_ID } from '../../../../website/server/models/group';
 import nconf from 'nconf';
+import moment from 'moment';

 describe('slack', () => {
  describe('sendFlagNotification', () => {
@@ -45,17 +46,19 @@ describe('slack', () => {
    it('sends a slack webhook', () => {
      slack.sendFlagNotification(data);

+      const timestamp = `${moment(data.message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
      expect(IncomingWebhook.prototype.send).to.be.calledOnce;
      expect(IncomingWebhook.prototype.send).to.be.calledWith({
        text: 'flagger (flagger-id; language: flagger-lang) flagged a message',
        attachments: [{
          fallback: 'Flag Message',
          color: 'danger',
-          author_name: 'Author - author@example.com - author-id',
+          author_name: `Author - author@example.com - author-id\n${timestamp}`,
          title: 'Flag in Some group - (private guild)',
          title_link: undefined,
          text: 'some text',
-          footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
+          footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message.>/),
          mrkdwn_in: [
            'text',
          ],
@@ -97,9 +100,11 @@ describe('slack', () => {

      slack.sendFlagNotification(data);

+      const timestamp = `${moment(data.message.timestamp).utc().format('YYYY-MM-DD HH:mm')} UTC`;
+
      expect(IncomingWebhook.prototype.send).to.be.calledWithMatch({
        attachments: [sandbox.match({
-          author_name: 'System Message',
+          author_name: `System Message\n${timestamp}`,
        })],
      });
    });
@@ -107,7 +112,7 @@ describe('slack', () => {
    it('noops if no flagging url is provided', () => {
      sandbox.stub(nconf, 'get').withArgs('SLACK:FLAGGING_URL').returns('');
      sandbox.stub(logger, 'error');
-      let reRequiredSlack = requireAgain('../../../../../website/server/libs/slack');
+      let reRequiredSlack = requireAgain('../../../../website/server/libs/slack');

      expect(logger.error).to.be.calledOnce;

@@ -3,13 +3,13 @@ import {
  getTasks,
  syncableAttrs,
  moveTask,
-} from '../../../../../website/server/libs/taskManager';
-import i18n from '../../../../../website/common/script/i18n';
+} from '../../../../website/server/libs/taskManager';
+import i18n from '../../../../website/common/script/i18n';
 import {
  generateUser,
  generateGroup,
  generateChallenge,
-} from '../../../../helpers/api-unit.helper.js';
+} from '../../../helpers/api-unit.helper.js';

 describe('taskManager', () => {
  let user, group, challenge;
@@ -178,4 +178,12 @@ describe('taskManager', () => {

    expect(order).to.eql(['task-id-2', 'task-id-1']);
  });
+
+  it('moves tasks to a specified position out of length', async () => {
+    let order = ['task-id-1'];
+
+    moveTask(order, 'task-id-2', 2);
+
+    expect(order).to.eql(['task-id-1', 'task-id-2']);
+  });
 });
@@ -4,11 +4,19 @@ import {
  taskScoredWebhook,
  groupChatReceivedWebhook,
  taskActivityWebhook,
-} from '../../../../../website/server/libs/webhook';
-import { defer } from '../../../../helpers/api-unit.helper';
+  questActivityWebhook,
+  userActivityWebhook,
+} from '../../../../website/server/libs/webhook';
+import {
+  model as User,
+} from '../../../../website/server/models/user';
+import {
+  generateUser,
+} from '../../../helpers/api-unit.helper.js';
+import { defer } from '../../../helpers/api-unit.helper';

 describe('webhooks', () => {
-  let webhooks;
+  let webhooks, user;

  beforeEach(() => {
    sandbox.stub(got, 'post').returns(defer().promise);
@@ -23,6 +31,26 @@ describe('webhooks', () => {
        updated: true,
        deleted: true,
        scored: true,
+        checklistScored: true,
+      },
+    }, {
+      id: 'questActivity',
+      url: 'http://quest-activity.com',
+      enabled: true,
+      type: 'questActivity',
+      options: {
+        questStarted: true,
+        questFinised: true,
+      },
+    }, {
+      id: 'userActivity',
+      url: 'http://user-activity.com',
+      enabled: true,
+      type: 'userActivity',
+      options: {
+        petHatched: true,
+        mountRaised: true,
+        leveledUp: true,
      },
    }, {
      id: 'groupChatReceived',
@@ -33,6 +61,9 @@ describe('webhooks', () => {
        groupId: 'group-id',
      },
    }];
+
+    user = generateUser();
+    user.webhooks = webhooks;
  });

  afterEach(() => {
@@ -57,7 +88,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(WebhookSender.defaultTransformData).to.be.calledOnce;
      expect(got.post).to.be.calledOnce;
@@ -67,6 +99,30 @@ describe('webhooks', () => {
      });
    });

+    it('adds default data (user and webhookType) to the body', () => {
+      let sendWebhook = new WebhookSender({
+        type: 'custom',
+      });
+      sandbox.spy(sendWebhook, 'attachDefaultData');
+
+      let body = { foo: 'bar' };
+
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);
+
+      expect(sendWebhook.attachDefaultData).to.be.calledOnce;
+      expect(got.post).to.be.calledOnce;
+      expect(got.post).to.be.calledWithMatch('http://custom-url.com', {
+        json: true,
+      });
+
+      expect(body).to.eql({
+        foo: 'bar',
+        user: {_id: user._id},
+        webhookType: 'custom',
+      });
+    });
+
    it('can pass in a data transformation function', () => {
      sandbox.spy(WebhookSender, 'defaultTransformData');
      let sendWebhook = new WebhookSender({
@@ -80,7 +136,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(WebhookSender.defaultTransformData).to.not.be.called;
      expect(got.post).to.be.calledOnce;
@@ -93,7 +150,7 @@ describe('webhooks', () => {
      });
    });

-    it('provieds a default filter function', () => {
+    it('provides a default filter function', () => {
      sandbox.spy(WebhookSender, 'defaultWebhookFilter');
      let sendWebhook = new WebhookSender({
        type: 'custom',
@@ -101,7 +158,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(WebhookSender.defaultWebhookFilter).to.be.calledOnce;
    });
@@ -117,7 +175,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(WebhookSender.defaultWebhookFilter).to.not.be.called;
      expect(got.post).to.not.be.called;
@@ -134,10 +193,11 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([
+      user.webhooks = [
        { id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom', options: { foo: 'bar' }},
        { id: 'other-custom-webhook', url: 'http://other-custom-url.com', enabled: true, type: 'custom', options: { foo: 'foo' }},
-      ], body);
+      ];
+      sendWebhook.send(user, body);

      expect(got.post).to.be.calledOnce;
      expect(got.post).to.be.calledWithMatch('http://custom-url.com');
@@ -150,7 +210,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'http://custom-url.com', enabled: false, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'http://custom-url.com', enabled: false, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(got.post).to.not.be.called;
    });
@@ -162,7 +223,8 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([{id: 'custom-webhook', url: 'httxp://custom-url!!', enabled: true, type: 'custom'}], body);
+      user.webhooks = [{id: 'custom-webhook', url: 'httxp://custom-url!!!', enabled: true, type: 'custom'}];
+      sendWebhook.send(user, body);

      expect(got.post).to.not.be.called;
    });
@@ -174,10 +236,30 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([
+      user.webhooks = [
        { id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'},
        { id: 'other-webhook', url: 'http://other-url.com', enabled: true, type: 'other'},
-      ], body);
+      ];
+      sendWebhook.send(user, body);
+
+      expect(got.post).to.be.calledOnce;
+      expect(got.post).to.be.calledWithMatch('http://custom-url.com', {
+        body,
+        json: true,
+      });
+    });
+
+    it('sends every type of activity to global webhooks', () => {
+      let sendWebhook = new WebhookSender({
+        type: 'custom',
+      });
+
+      let body = { foo: 'bar' };
+
+      user.webhooks = [
+        { id: 'global-webhook', url: 'http://custom-url.com', enabled: true, type: 'globalActivity'},
+      ];
+      sendWebhook.send(user, body);

      expect(got.post).to.be.calledOnce;
      expect(got.post).to.be.calledWithMatch('http://custom-url.com', {
@@ -193,10 +275,11 @@ describe('webhooks', () => {

      let body = { foo: 'bar' };

-      sendWebhook.send([
+      user.webhooks = [
        { id: 'custom-webhook', url: 'http://custom-url.com', enabled: true, type: 'custom'},
        { id: 'other-custom-webhook', url: 'http://other-url.com', enabled: true, type: 'custom'},
-      ], body);
+      ];
+      sendWebhook.send(user, body);

      expect(got.post).to.be.calledTwice;
      expect(got.post).to.be.calledWithMatch('http://custom-url.com', {
@@ -216,7 +299,6 @@ describe('webhooks', () => {
    beforeEach(() => {
      data = {
        user: {
-          _id: 'user-id',
          _tmp: {foo: 'bar'},
          stats: {
            lvl: 5,
@@ -227,17 +309,6 @@ describe('webhooks', () => {
              return this;
            },
          },
-          addComputedStatsToJSONObj () {
-            let mockStats = Object.assign({
-              maxHealth: 50,
-              maxMP: 103,
-              toNextLevel: 40,
-            }, this.stats);
-
-            delete mockStats.toJSON;
-
-            return mockStats;
-          },
        },
        task: {
          text: 'text',
@@ -245,18 +316,66 @@ describe('webhooks', () => {
        direction: 'up',
        delta: 176,
      };
+
+      let mockStats = Object.assign({
+        maxHealth: 50,
+        maxMP: 103,
+        toNextLevel: 40,
+      }, data.user.stats);
+      delete mockStats.toJSON;
+
+      sandbox.stub(User, 'addComputedStatsToJSONObj').returns(mockStats);
    });

    it('sends task and stats data', () => {
-      taskScoredWebhook.send(webhooks, data);
+      taskScoredWebhook.send(user, data);

      expect(got.post).to.be.calledOnce;
      expect(got.post).to.be.calledWithMatch(webhooks[0].url, {
        json: true,
        body: {
          type: 'scored',
+          webhookType: 'taskActivity',
          user: {
-            _id: 'user-id',
+            _id: user._id,
+            _tmp: {foo: 'bar'},
+            stats: {
+              lvl: 5,
+              int: 10,
+              str: 5,
+              exp: 423,
+              toNextLevel: 40,
+              maxHealth: 50,
+              maxMP: 103,
+            },
+          },
+          task: {
+            text: 'text',
+          },
+          direction: 'up',
+          delta: 176,
+        },
+      });
+    });
+
+    it('sends task and stats data to globalActivity webhookd', () => {
+      user.webhooks = [{
+        id: 'globalActivity',
+        url: 'http://global-activity.com',
+        enabled: true,
+        type: 'globalActivity',
+      }];
+
+      taskScoredWebhook.send(user, data);
+
+      expect(got.post).to.be.calledOnce;
+      expect(got.post).to.be.calledWithMatch('http://global-activity.com', {
+        json: true,
+        body: {
+          type: 'scored',
+          webhookType: 'taskActivity',
+          user: {
+            _id: user._id,
            _tmp: {foo: 'bar'},
            stats: {
              lvl: 5,
@@ -280,7 +399,7 @@ describe('webhooks', () => {
    it('does not send task scored data if scored option is not true', () => {
      webhooks[0].options.scored = false;

-      taskScoredWebhook.send(webhooks, data);
+      taskScoredWebhook.send(user, data);

      expect(got.post).to.not.be.called;
    });
@@ -301,13 +420,17 @@ describe('webhooks', () => {
      it(`sends ${type} tasks`, () => {
        data.type = type;

-        taskActivityWebhook.send(webhooks, data);
+        taskActivityWebhook.send(user, data);

        expect(got.post).to.be.calledOnce;
        expect(got.post).to.be.calledWithMatch(webhooks[0].url, {
          json: true,
          body: {
            type,
+            webhookType: 'taskActivity',
+            user: {
+              _id: user._id,
+            },
            task: data.task,
          },
        });
@@ -317,7 +440,142 @@ describe('webhooks', () => {
        data.type = type;
        webhooks[0].options[type] = false;

-        taskActivityWebhook.send(webhooks, data);
+        taskActivityWebhook.send(user, data);
+
+        expect(got.post).to.not.be.called;
+      });
+    });
+
+    describe('checklistScored', () => {
+      beforeEach(() => {
+        data = {
+          task: {
+            text: 'text',
+          },
+          item: {
+            text: 'item-text',
+          },
+        };
+      });
+
+      it('sends \'checklistScored\' tasks', () => {
+        data.type = 'checklistScored';
+
+        taskActivityWebhook.send(user, data);
+
+        expect(got.post).to.be.calledOnce;
+        expect(got.post).to.be.calledWithMatch(webhooks[0].url, {
+          json: true,
+          body: {
+            webhookType: 'taskActivity',
+            user: {
+              _id: user._id,
+            },
+            type: data.type,
+            task: data.task,
+            item: data.item,
+          },
+        });
+      });
+
+      it('does not send task \'checklistScored\' data if \'checklistScored\' option is not true', () => {
+        data.type = 'checklistScored';
+        webhooks[0].options.checklistScored = false;
+
+        taskActivityWebhook.send(user, data);
+
+        expect(got.post).to.not.be.called;
+      });
+    });
+  });
+
+  describe('userActivityWebhook', () => {
+    let data;
+
+    beforeEach(() => {
+      data = {
+        something: true,
+      };
+    });
+
+    ['petHatched', 'mountRaised', 'leveledUp'].forEach((type) => {
+      it(`sends ${type} webhooks`, () => {
+        data.type = type;
+
+        userActivityWebhook.send(user, data);
+
+        expect(got.post).to.be.calledOnce;
+        expect(got.post).to.be.calledWithMatch(webhooks[2].url, {
+          json: true,
+          body: {
+            type,
+            webhookType: 'userActivity',
+            user: {
+              _id: user._id,
+            },
+            something: true,
+          },
+        });
+      });
+
+      it(`does not send webhook ${type} data if ${type} option is not true`, () => {
+        data.type = type;
+        webhooks[2].options[type] = false;
+
+        userActivityWebhook.send(user, data);
+
+        expect(got.post).to.not.be.called;
+      });
+    });
+  });
+
+  describe('questActivityWebhook', () => {
+    let data;
+
+    beforeEach(() => {
+      data = {
+        group: {
+          id: 'group-id',
+          name: 'some group',
+          otherData: 'foo',
+        },
+        quest: {
+          key: 'some-key',
+        },
+      };
+    });
+
+    ['questStarted', 'questFinised'].forEach((type) => {
+      it(`sends ${type} webhooks`, () => {
+        data.type = type;
+
+        questActivityWebhook.send(user, data);
+
+        expect(got.post).to.be.calledOnce;
+        expect(got.post).to.be.calledWithMatch(webhooks[1].url, {
+          json: true,
+          body: {
+            type,
+            webhookType: 'questActivity',
+            user: {
+              _id: user._id,
+            },
+            group: {
+              id: 'group-id',
+              name: 'some group',
+            },
+            quest: {
+              key: 'some-key',
+            },
+          },
+        });
+      });
+
+      it(`does not send webhook ${type} data if ${type} option is not true`, () => {
+        data.type = type;
+        webhooks[1].options[type] = false;
+
+        userActivityWebhook.send(user, data);

        expect(got.post).to.not.be.called;
      });
@@ -338,12 +596,16 @@ describe('webhooks', () => {
        },
      };

-      groupChatReceivedWebhook.send(webhooks, data);
+      groupChatReceivedWebhook.send(user, data);

      expect(got.post).to.be.calledOnce;
      expect(got.post).to.be.calledWithMatch(webhooks[webhooks.length - 1].url, {
        json: true,
        body: {
+          webhookType: 'groupChatReceived',
+          user: {
+            _id: user._id,
+          },
          group: {
            id: 'group-id',
            name: 'some group',
@@ -369,7 +631,7 @@ describe('webhooks', () => {
        },
      };

-      groupChatReceivedWebhook.send(webhooks, data);
+      groupChatReceivedWebhook.send(user, data);

      expect(got.post).to.not.be.called;
    });
@@ -3,14 +3,14 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
-import analyticsService from '../../../../../website/server/libs/analyticsService';
+} from '../../../helpers/api-unit.helper';
+import analyticsService from '../../../../website/server/libs/analyticsService';
 import nconf from 'nconf';
 import requireAgain from 'require-again';

 describe('analytics middleware', () => {
  let res, req, next;
-  let pathToAnalyticsMiddleware = '../../../../../website/server/middlewares/analytics';
+  let pathToAnalyticsMiddleware = '../../../../website/server/middlewares/analytics';

  beforeEach(() => {
    res = generateRes();
@@ -1,8 +1,8 @@
 import {
  generateRes,
  generateReq,
-} from '../../../../helpers/api-unit.helper';
-import { authWithHeaders as authWithHeadersFactory } from '../../../../../website/server/middlewares/auth';
+} from '../../../helpers/api-unit.helper';
+import { authWithHeaders as authWithHeadersFactory } from '../../../../website/server/middlewares/auth';

 describe('auth middleware', () => {
  let res, req, user;
@@ -15,7 +15,7 @@ describe('auth middleware', () => {

  describe('auth with headers', () => {
    it('allows to specify a list of user field that we do not want to load', (done) => {
-      const authWithHeaders = authWithHeadersFactory(false, {
+      const authWithHeaders = authWithHeadersFactory({
        userFieldsToExclude: ['items', 'flags', 'auth.timestamps'],
      });

@@ -3,8 +3,8 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
-import cors from '../../../../../website/server/middlewares/cors';
+} from '../../../helpers/api-unit.helper';
+import cors from '../../../../website/server/middlewares/cors';

 describe('cors middleware', () => {
  let res, req, next;
@@ -3,14 +3,14 @@ import {
  generateReq,
  generateTodo,
  generateDaily,
-} from '../../../../helpers/api-unit.helper';
-import cronMiddleware from '../../../../../website/server/middlewares/cron';
+} from '../../../helpers/api-unit.helper';
+import cronMiddleware from '../../../../website/server/middlewares/cron';
 import moment from 'moment';
-import { model as User } from '../../../../../website/server/models/user';
-import { model as Group } from '../../../../../website/server/models/group';
-import * as Tasks from '../../../../../website/server/models/task';
-import analyticsService from '../../../../../website/server/libs/analyticsService';
-import * as cronLib from '../../../../../website/server/libs/cron';
+import { model as User } from '../../../../website/server/models/user';
+import { model as Group } from '../../../../website/server/models/group';
+import * as Tasks from '../../../../website/server/models/task';
+import analyticsService from '../../../../website/server/libs/analyticsService';
+import * as cronLib from '../../../../website/server/libs/cron';
 import { v4 as generateUUID } from 'uuid';

 const CRON_TIMEOUT_WAIT = new Date(60 * 60 * 1000).getTime();
@@ -166,8 +166,11 @@ describe('cron middleware', () => {
    await new Promise((resolve, reject) => {
      cronMiddleware(req, res, (err) => {
        if (err) return reject(err);
-        expect(user.stats.hp).to.be.lessThan(hpBefore);
-        resolve();
+        User.findOne({_id: user._id}, function (secondErr, updatedUser) {
+          if (secondErr) return reject(secondErr);
+          expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
+          resolve();
+        });
      });
    });
  });
@@ -176,7 +179,7 @@ describe('cron middleware', () => {
    user.lastCron = moment(new Date()).subtract({days: 2});
    let todo = generateTodo(user);
    let todoValueBefore = todo.value;
-    await user.save();
+    await Promise.all([todo.save(), user.save()]);

    await new Promise((resolve, reject) => {
      cronMiddleware(req, res, (err) => {
@@ -217,8 +220,11 @@ describe('cron middleware', () => {
    await new Promise((resolve, reject) => {
      cronMiddleware(req, res, (err) => {
        if (err) return reject(err);
-        expect(user.stats.hp).to.be.lessThan(hpBefore);
-        resolve();
+        User.findOne({_id: user._id}, function (secondErr, updatedUser) {
+          if (secondErr) return reject(secondErr);
+          expect(updatedUser.stats.hp).to.be.lessThan(hpBefore);
+          resolve();
+        });
      });
    });
  });
@@ -3,11 +3,11 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
-import i18n from '../../../../../website/common/script/i18n';
-import { ensureAdmin, ensureSudo } from '../../../../../website/server/middlewares/ensureAccessRight';
-import { NotAuthorized } from '../../../../../website/server/libs/errors';
-import apiMessages from '../../../../../website/server/libs/apiMessages';
+} from '../../../helpers/api-unit.helper';
+import i18n from '../../../../website/common/script/i18n';
+import { ensureAdmin, ensureSudo } from '../../../../website/server/middlewares/ensureAccessRight';
+import { NotAuthorized } from '../../../../website/server/libs/errors';
+import apiError from '../../../../website/server/libs/apiError';

 describe('ensure access middlewares', () => {
  let res, req, next;
@@ -46,7 +46,7 @@ describe('ensure access middlewares', () => {
      ensureSudo(req, res, next);

      const calledWith = next.getCall(0).args;
-      expect(calledWith[0].message).to.equal(apiMessages('noSudoAccess'));
+      expect(calledWith[0].message).to.equal(apiError('noSudoAccess'));
      expect(calledWith[0] instanceof NotAuthorized).to.equal(true);
    });

@@ -3,9 +3,9 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
-import ensureDevelpmentMode from '../../../../../website/server/middlewares/ensureDevelpmentMode';
-import { NotFound } from '../../../../../website/server/libs/errors';
+} from '../../../helpers/api-unit.helper';
+import ensureDevelpmentMode from '../../../../website/server/middlewares/ensureDevelpmentMode';
+import { NotFound } from '../../../../website/server/libs/errors';
 import nconf from 'nconf';

 describe('developmentMode middleware', () => {
@@ -2,17 +2,17 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';

-import errorHandler from '../../../../../website/server/middlewares/errorHandler';
-import responseMiddleware from '../../../../../website/server/middlewares/response';
+import errorHandler from '../../../../website/server/middlewares/errorHandler';
+import responseMiddleware from '../../../../website/server/middlewares/response';
 import {
  getUserLanguage,
  attachTranslateFunction,
-} from '../../../../../website/server/middlewares/language';
+} from '../../../../website/server/middlewares/language';

-import { BadRequest } from '../../../../../website/server/libs/errors';
-import logger from '../../../../../website/server/libs/logger';
+import { BadRequest } from '../../../../website/server/libs/errors';
+import logger from '../../../../website/server/libs/logger';

 describe('errorHandler', () => {
  let res, req, next;
@@ -2,13 +2,13 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import {
  getUserLanguage,
  attachTranslateFunction,
-} from '../../../../../website/server/middlewares/language';
-import common from '../../../../../website/common';
-import { model as User } from '../../../../../website/server/models/user';
+} from '../../../../website/server/middlewares/language';
+import common from '../../../../website/common';
+import { model as User } from '../../../../website/server/models/user';

 const i18n = common.i18n;

@@ -2,13 +2,13 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import nconf from 'nconf';
 import requireAgain from 'require-again';

 describe('maintenance mode middleware', () => {
  let res, req, next;
-  let pathToMaintenanceModeMiddleware = '../../../../../website/server/middlewares/maintenanceMode';
+  let pathToMaintenanceModeMiddleware = '../../../../website/server/middlewares/maintenanceMode';

  beforeEach(() => {
    res = generateRes();
@@ -2,13 +2,13 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
+} from '../../../helpers/api-unit.helper';
 import nconf from 'nconf';
 import requireAgain from 'require-again';

 describe('redirects middleware', () => {
  let res, req, next;
-  let pathToRedirectsMiddleware = '../../../../../website/server/middlewares/redirects';
+  let pathToRedirectsMiddleware = '../../../../website/server/middlewares/redirects';

  beforeEach(() => {
    res = generateRes();
@@ -2,9 +2,9 @@ import {
  generateRes,
  generateReq,
  generateNext,
-} from '../../../../helpers/api-unit.helper';
-import responseMiddleware from '../../../../../website/server/middlewares/response';
-import packageInfo from '../../../../../package.json';
+} from '../../../helpers/api-unit.helper';
+import responseMiddleware from '../../../../website/server/middlewares/response';
+import packageInfo from '../../../../package.json';

 describe('response middleware', () => {
  let res, req, next;
@@ -1,8 +1,8 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import common from '../../../../../website/common/';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import common from '../../../../website/common/';
 import { each, find } from 'lodash';

 describe('Challenge Model', () => {
@@ -1,26 +1,30 @@
 import moment from 'moment';
 import { v4 as generateUUID } from 'uuid';
 import validator from 'validator';
-import { sleep } from '../../../../helpers/api-unit.helper';
+import { sleep } from '../../../helpers/api-unit.helper';
 import {
  SPAM_MESSAGE_LIMIT,
  SPAM_MIN_EXEMPT_CONTRIB_LEVEL,
  SPAM_WINDOW_LENGTH,
  INVITES_LIMIT,
  model as Group,
-} from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import { quests as questScrolls } from '../../../../../website/common/script/content';
-import { groupChatReceivedWebhook } from '../../../../../website/server/libs/webhook';
-import * as email from '../../../../../website/server/libs/email';
-import { TAVERN_ID } from '../../../../../website/common/script/';
-import shared from '../../../../../website/common';
+} from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import { quests as questScrolls } from '../../../../website/common/script/content';
+import {
+  groupChatReceivedWebhook,
+  questActivityWebhook,
+} from '../../../../website/server/libs/webhook';
+import * as email from '../../../../website/server/libs/email';
+import { TAVERN_ID } from '../../../../website/common/script/';
+import shared from '../../../../website/common';

 describe('Group Model', () => {
-  let party, questLeader, participatingMember, nonParticipatingMember, undecidedMember;
+  let party, questLeader, participatingMember, sleepingParticipatingMember, nonParticipatingMember, undecidedMember;

  beforeEach(async () => {
    sandbox.stub(email, 'sendTxn');
+    sandbox.stub(questActivityWebhook, 'send');

    party = new Group({
      name: 'test party',
@@ -44,6 +48,11 @@ describe('Group Model', () => {
      party: { _id: party._id },
      profile: { name: 'Participating Member' },
    });
+    sleepingParticipatingMember = new User({
+      party: { _id: party._id },
+      profile: { name: 'Sleeping Participating Member' },
+      preferences: { sleep: true },
+    });
    nonParticipatingMember = new User({
      party: { _id: party._id },
      profile: { name: 'Non-Participating Member' },
@@ -57,6 +66,7 @@ describe('Group Model', () => {
      party.save(),
      questLeader.save(),
      participatingMember.save(),
+      sleepingParticipatingMember.save(),
      nonParticipatingMember.save(),
      undecidedMember.save(),
    ]);
@@ -76,6 +86,7 @@ describe('Group Model', () => {
        party.quest.members = {
          [questLeader._id]: true,
          [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
          [nonParticipatingMember._id]: false,
          [undecidedMember._id]: null,
        };
@@ -171,6 +182,34 @@ describe('Group Model', () => {
          expect(party._processBossQuest).to.not.be.called;
          expect(Group.prototype._processCollectionQuest).to.be.calledOnce;
        });
+
+        it('does not call _processBossQuest when user is resting in the inn', async () => {
+          party.quest.key = 'whale';
+
+          await party.startQuest(questLeader);
+          await party.save();
+
+          await Group.processQuestProgress(sleepingParticipatingMember, progress);
+
+          party = await Group.findOne({_id: party._id});
+
+          expect(party._processBossQuest).to.not.be.called;
+          expect(party._processCollectionQuest).to.not.be.called;
+        });
+
+        it('does not call _processCollectionQuest when user is resting in the inn', async () => {
+          party.quest.key = 'evilsanta2';
+
+          await party.startQuest(questLeader);
+          await party.save();
+
+          await Group.processQuestProgress(sleepingParticipatingMember, progress);
+
+          party = await Group.findOne({_id: party._id});
+
+          expect(party._processBossQuest).to.not.be.called;
+          expect(party._processCollectionQuest).to.not.be.called;
+        });
      });

      context('Boss Quests', () => {
@@ -182,7 +221,7 @@ describe('Group Model', () => {
          await party.startQuest(questLeader);
          await party.save();

-          sendChatStub = sandbox.stub(Group.prototype, 'sendChat');
+          sendChatStub = sandbox.spy(Group.prototype, 'sendChat');
        });

        afterEach(() => sendChatStub.restore());
@@ -212,17 +251,20 @@ describe('Group Model', () => {
          let [
            updatedLeader,
            updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
            updatedNonParticipatingMember,
            updatedUndecidedMember,
          ] = await Promise.all([
            User.findById(questLeader._id),
            User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
            User.findById(nonParticipatingMember._id),
            User.findById(undecidedMember._id),
          ]);

          expect(updatedLeader.stats.hp).to.eql(42.5);
          expect(updatedParticipatingMember.stats.hp).to.eql(42.5);
+          expect(updatedSleepingParticipatingMember.stats.hp).to.eql(42.5);
          expect(updatedNonParticipatingMember.stats.hp).to.eql(50);
          expect(updatedUndecidedMember.stats.hp).to.eql(50);
        });
@@ -232,6 +274,7 @@ describe('Group Model', () => {
          party.quest.members = {
            [questLeader._id]: true,
            [participatingMember._id]: true,
+            [sleepingParticipatingMember._id]: true,
            [nonParticipatingMember._id]: false,
            [undecidedMember._id]: null,
          };
@@ -244,17 +287,20 @@ describe('Group Model', () => {
          let [
            updatedLeader,
            updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
            updatedNonParticipatingMember,
            updatedUndecidedMember,
          ] = await Promise.all([
            User.findById(questLeader._id),
            User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
            User.findById(nonParticipatingMember._id),
            User.findById(undecidedMember._id),
          ]);

          expect(updatedLeader.stats.hp).to.eql(42.5);
          expect(updatedParticipatingMember.stats.hp).to.eql(42.5);
+          expect(updatedSleepingParticipatingMember.stats.hp).to.eql(42.5);
          expect(updatedNonParticipatingMember.stats.hp).to.eql(50);
          expect(updatedUndecidedMember.stats.hp).to.eql(50);
        });
@@ -378,7 +424,7 @@ describe('Group Model', () => {
          await party.startQuest(questLeader);
          await party.save();

-          sendChatStub = sandbox.stub(Group.prototype, 'sendChat');
+          sendChatStub = sandbox.spy(Group.prototype, 'sendChat');
        });

        afterEach(() => sendChatStub.restore());
@@ -493,9 +539,11 @@ describe('Group Model', () => {
          let [
            updatedLeader,
            updatedParticipatingMember,
+            updatedSleepingParticipatingMember,
          ] = await Promise.all([
            User.findById(questLeader._id),
            User.findById(participatingMember._id),
+            User.findById(sleepingParticipatingMember._id),
          ]);

          expect(updatedLeader.achievements.quests[party.quest.key]).to.eql(1);
@@ -504,6 +552,9 @@ describe('Group Model', () => {
          expect(updatedParticipatingMember.achievements.quests[party.quest.key]).to.eql(1);
          expect(updatedParticipatingMember.stats.exp).to.be.greaterThan(0);
          expect(updatedParticipatingMember.stats.gp).to.be.greaterThan(0);
+          expect(updatedSleepingParticipatingMember.achievements.quests[party.quest.key]).to.eql(1);
+          expect(updatedSleepingParticipatingMember.stats.exp).to.be.greaterThan(0);
+          expect(updatedSleepingParticipatingMember.stats.gp).to.be.greaterThan(0);
        });
      });
    });
@@ -643,6 +694,7 @@ describe('Group Model', () => {
      it('returns an array of members whose quest status set to true', () => {
        party.quest.members = {
          [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
          [questLeader._id]: true,
          [nonParticipatingMember._id]: false,
          [undecidedMember._id]: null,
@@ -650,6 +702,7 @@ describe('Group Model', () => {

        expect(party.getParticipatingQuestMembers()).to.eql([
          participatingMember._id,
+          sleepingParticipatingMember._id,
          questLeader._id,
        ]);
      });
@@ -752,11 +805,12 @@ describe('Group Model', () => {
      it('removes user from group quest', async () => {
        party.quest.members = {
          [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
          [questLeader._id]: true,
          [nonParticipatingMember._id]: false,
          [undecidedMember._id]: null,
        };
-        party.memberCount = 4;
+        party.memberCount = 5;
        await party.save();

        await party.leave(participatingMember);
@@ -764,6 +818,7 @@ describe('Group Model', () => {
        party = await Group.findOne({_id: party._id});
        expect(party.quest.members).to.eql({
          [questLeader._id]: true,
+          [sleepingParticipatingMember._id]: true,
          [nonParticipatingMember._id]: false,
          [undecidedMember._id]: null,
        });
@@ -771,6 +826,7 @@ describe('Group Model', () => {

      it('deletes a private party when the last member leaves', async () => {
        await party.leave(participatingMember);
+        await party.leave(sleepingParticipatingMember);
        await party.leave(questLeader);
        await party.leave(nonParticipatingMember);
        await party.leave(undecidedMember);
@@ -842,6 +898,7 @@ describe('Group Model', () => {
        party.privacy = 'public';

        await party.leave(participatingMember);
+        await party.leave(sleepingParticipatingMember);
        await party.leave(questLeader);
        await party.leave(nonParticipatingMember);
        await party.leave(undecidedMember);
@@ -918,21 +975,8 @@ describe('Group Model', () => {
        sandbox.spy(User, 'update');
      });

-      it('puts message at top of chat array', () => {
-        let oldMessage = {
-          text: 'a message',
-        };
-        party.chat.push(oldMessage, oldMessage, oldMessage);
-
-        party.sendChat('a new message', {_id: 'user-id', profile: { name: 'user name' }});
-
-        expect(party.chat).to.have.a.lengthOf(4);
-        expect(party.chat[0].text).to.eql('a new message');
-        expect(party.chat[0].uuid).to.eql('user-id');
-      });
-
      it('formats message', () => {
-        party.sendChat('a new message', {
+        const chatMessage = party.sendChat('a new message', {
          _id: 'user-id',
          profile: { name: 'user name' },
          contributor: {
@@ -947,11 +991,11 @@ describe('Group Model', () => {
          },
        });

-        let chat = party.chat[0];
+        const chat = chatMessage;

        expect(chat.text).to.eql('a new message');
        expect(validator.isUUID(chat.id)).to.eql(true);
-        expect(chat.timestamp).to.be.a('number');
+        expect(chat.timestamp).to.be.a('date');
        expect(chat.likes).to.eql({});
        expect(chat.flags).to.eql({});
        expect(chat.flagCount).to.eql(0);
@@ -962,13 +1006,11 @@ describe('Group Model', () => {
      });

      it('formats message as system if no user is passed in', () => {
-        party.sendChat('a system message');
-
-        let chat = party.chat[0];
+        const chat = party.sendChat('a system message');

        expect(chat.text).to.eql('a system message');
        expect(validator.isUUID(chat.id)).to.eql(true);
-        expect(chat.timestamp).to.be.a('number');
+        expect(chat.timestamp).to.be.a('date');
        expect(chat.likes).to.eql({});
        expect(chat.flags).to.eql({});
        expect(chat.flagCount).to.eql(0);
@@ -978,32 +1020,6 @@ describe('Group Model', () => {
        expect(chat.user).to.not.exist;
      });

-      it('cuts down chat to 200 messages', () => {
-        for (let i = 0; i < 220; i++) {
-          party.chat.push({ text: 'a message' });
-        }
-
-        expect(party.chat).to.have.a.lengthOf(220);
-
-        party.sendChat('message');
-
-        expect(party.chat).to.have.a.lengthOf(200);
-      });
-
-      it('cuts down chat to 400 messages when group is subcribed', () => {
-        party.purchased.plan.customerId = 'test-customer-id';
-
-        for (let i = 0; i < 420; i++) {
-          party.chat.push({ text: 'a message' });
-        }
-
-        expect(party.chat).to.have.a.lengthOf(420);
-
-        party.sendChat('message');
-
-        expect(party.chat).to.have.a.lengthOf(400);
-      });
-
      it('updates users about new messages in party', () => {
        party.sendChat('message');

@@ -1085,6 +1101,7 @@ describe('Group Model', () => {
          party.quest.members = {
            [questLeader._id]: true,
            [participatingMember._id]: true,
+            [sleepingParticipatingMember._id]: true,
            [nonParticipatingMember._id]: false,
            [undecidedMember._id]: null,
          };
@@ -1141,6 +1158,7 @@ describe('Group Model', () => {
          let expectedQuestMembers = {};
          expectedQuestMembers[questLeader._id] = true;
          expectedQuestMembers[participatingMember._id] = true;
+          expectedQuestMembers[sleepingParticipatingMember._id] = true;

          expect(party.quest.members).to.eql(expectedQuestMembers);
        });
@@ -1159,12 +1177,18 @@ describe('Group Model', () => {

          questLeader = await User.findById(questLeader._id);
          participatingMember = await User.findById(participatingMember._id);
+          sleepingParticipatingMember = await User.findById(sleepingParticipatingMember._id);

          expect(participatingMember.party.quest.key).to.eql('whale');
          expect(participatingMember.party.quest.progress.down).to.eql(0);
          expect(participatingMember.party.quest.progress.collectedItems).to.eql(0);
          expect(participatingMember.party.quest.completed).to.eql(null);

+          expect(sleepingParticipatingMember.party.quest.key).to.eql('whale');
+          expect(sleepingParticipatingMember.party.quest.progress.down).to.eql(0);
+          expect(sleepingParticipatingMember.party.quest.progress.collectedItems).to.eql(0);
+          expect(sleepingParticipatingMember.party.quest.completed).to.eql(null);
+
          expect(questLeader.party.quest.key).to.eql('whale');
          expect(questLeader.party.quest.progress.down).to.eql(0);
          expect(questLeader.party.quest.progress.collectedItems).to.eql(0);
@@ -1183,9 +1207,11 @@ describe('Group Model', () => {

        it('sends email to participating members that quest has started', async () => {
          participatingMember.preferences.emailNotifications.questStarted = true;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = true;
          questLeader.preferences.emailNotifications.questStarted = true;
          await Promise.all([
            participatingMember.save(),
+            sleepingParticipatingMember.save(),
            questLeader.save(),
          ]);

@@ -1198,17 +1224,70 @@ describe('Group Model', () => {
          let memberIds = _.map(email.sendTxn.args[0][0], '_id');
          let typeOfEmail = email.sendTxn.args[0][1];

-          expect(memberIds).to.have.a.lengthOf(2);
+          expect(memberIds).to.have.a.lengthOf(3);
          expect(memberIds).to.include(participatingMember._id);
+          expect(memberIds).to.include(sleepingParticipatingMember._id);
          expect(memberIds).to.include(questLeader._id);
          expect(typeOfEmail).to.eql('quest-started');
        });

+        it('sends webhook to participating members that quest has started', async () => {
+          // should receive webhook
+          participatingMember.webhooks = [{
+            type: 'questActivity',
+            url: 'http://someurl.com',
+            options: {
+              questStarted: true,
+            },
+          }];
+          sleepingParticipatingMember.webhooks = [{
+            type: 'questActivity',
+            url: 'http://someurl.com',
+            options: {
+              questStarted: true,
+            },
+          }];
+          questLeader.webhooks = [{
+            type: 'questActivity',
+            url: 'http://someurl.com',
+            options: {
+              questStarted: true,
+            },
+          }];
+
+          await Promise.all([participatingMember.save(), sleepingParticipatingMember.save(), questLeader.save()]);
+
+          await party.startQuest(nonParticipatingMember);
+
+          await sleep(0.5);
+
+          expect(questActivityWebhook.send).to.be.calledThrice; // for 3 participating members
+
+          let args = questActivityWebhook.send.args[0];
+          let webhooks = args[0].webhooks;
+          let webhookOwner = args[0]._id;
+          let options = args[1];
+
+          expect(webhooks).to.have.a.lengthOf(1);
+          if (webhookOwner === questLeader._id) {
+            expect(webhooks[0].id).to.eql(questLeader.webhooks[0].id);
+          } else if (webhookOwner === sleepingParticipatingMember._id) {
+            expect(webhooks[0].id).to.eql(sleepingParticipatingMember.webhooks[0].id);
+          } else {
+            expect(webhooks[0].id).to.eql(participatingMember.webhooks[0].id);
+          }
+          expect(webhooks[0].type).to.eql('questActivity');
+          expect(options.group).to.eql(party);
+          expect(options.quest.key).to.eql('whale');
+        });
+
        it('sends email only to members who have not opted out', async () => {
          participatingMember.preferences.emailNotifications.questStarted = false;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = false;
          questLeader.preferences.emailNotifications.questStarted = true;
          await Promise.all([
            participatingMember.save(),
+            sleepingParticipatingMember.save(),
            questLeader.save(),
          ]);

@@ -1222,14 +1301,17 @@ describe('Group Model', () => {

          expect(memberIds).to.have.a.lengthOf(1);
          expect(memberIds).to.not.include(participatingMember._id);
+          expect(memberIds).to.not.include(sleepingParticipatingMember._id);
          expect(memberIds).to.include(questLeader._id);
        });

        it('does not send email to initiating member', async () => {
          participatingMember.preferences.emailNotifications.questStarted = true;
+          sleepingParticipatingMember.preferences.emailNotifications.questStarted = true;
          questLeader.preferences.emailNotifications.questStarted = true;
          await Promise.all([
            participatingMember.save(),
+            sleepingParticipatingMember.save(),
            questLeader.save(),
          ]);

@@ -1241,8 +1323,9 @@ describe('Group Model', () => {

          let memberIds = _.map(email.sendTxn.args[0][0], '_id');

-          expect(memberIds).to.have.a.lengthOf(1);
+          expect(memberIds).to.have.a.lengthOf(2);
          expect(memberIds).to.not.include(participatingMember._id);
+          expect(memberIds).to.include(sleepingParticipatingMember._id);
          expect(memberIds).to.include(questLeader._id);
        });

@@ -1251,7 +1334,7 @@ describe('Group Model', () => {

          await party.startQuest(nonParticipatingMember);

-          let members = [questLeader._id, participatingMember._id];
+          let members = [questLeader._id, participatingMember._id, sleepingParticipatingMember._id];

          expect(User.update).to.be.calledWith(
            { _id: { $in: members } },
@@ -1316,6 +1399,7 @@ describe('Group Model', () => {
        party.quest.members = {
          [questLeader._id]: true,
          [participatingMember._id]: true,
+          [sleepingParticipatingMember._id]: true,
          [nonParticipatingMember._id]: false,
          [undecidedMember._id]: null,
        };
@@ -1338,7 +1422,7 @@ describe('Group Model', () => {

          await party.finishQuest(quest);

-          expect(User.update).to.be.calledTwice;
+          expect(User.update).to.be.calledThrice;
        });

        it('stops retrying when a successful update has occurred', async () => {
@@ -1348,7 +1432,7 @@ describe('Group Model', () => {

          await party.finishQuest(quest);

-          expect(User.update).to.be.calledThrice;
+          expect(User.update.callCount).to.equal(4);
        });

        it('retries failed updates at most five times per user', async () => {
@@ -1356,7 +1440,7 @@ describe('Group Model', () => {

          await expect(party.finishQuest(quest)).to.eventually.be.rejected;

-          expect(User.update.callCount).to.eql(10);
+          expect(User.update.callCount).to.eql(15); // for 3 users
        });
      });

@@ -1366,17 +1450,19 @@ describe('Group Model', () => {
        let [
          updatedLeader,
          updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
        ] = await Promise.all([
          User.findById(questLeader._id),
          User.findById(participatingMember._id),
+          User.findById(sleepingParticipatingMember._id),
        ]);

        expect(updatedLeader.achievements.quests[quest.key]).to.eql(1);
        expect(updatedParticipatingMember.achievements.quests[quest.key]).to.eql(1);
+        expect(updatedSleepingParticipatingMember.achievements.quests[quest.key]).to.eql(1);
      });

-      // Disable test, it fails on TravisCI, but only there
-      xit('gives out super awesome Masterclasser achievement to the deserving', async () => {
+      it('gives out super awesome Masterclasser achievement to the deserving', async () => {
        quest = questScrolls.lostMasterclasser4;
        party.quest.key = quest.key;

@@ -1403,17 +1489,19 @@ describe('Group Model', () => {
        let [
          updatedLeader,
          updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
        ] = await Promise.all([
          User.findById(questLeader._id).exec(),
          User.findById(participatingMember._id).exec(),
+          User.findById(sleepingParticipatingMember._id).exec(),
        ]);

        expect(updatedLeader.achievements.lostMasterclasser).to.eql(true);
        expect(updatedParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
+        expect(updatedSleepingParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
      });

-      // Disable test, it fails on TravisCI, but only there
-      xit('gives out super awesome Masterclasser achievement when quests done out of order', async () => {
+      it('gives out super awesome Masterclasser achievement when quests done out of order', async () => {
        quest = questScrolls.lostMasterclasser1;
        party.quest.key = quest.key;

@@ -1440,13 +1528,16 @@ describe('Group Model', () => {
        let [
          updatedLeader,
          updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
        ] = await Promise.all([
          User.findById(questLeader._id).exec(),
          User.findById(participatingMember._id).exec(),
+          User.findById(sleepingParticipatingMember._id).exec(),
        ]);

        expect(updatedLeader.achievements.lostMasterclasser).to.eql(true);
        expect(updatedParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
+        expect(updatedSleepingParticipatingMember.achievements.lostMasterclasser).to.not.eql(true);
      });

      it('gives xp and gold', async () => {
@@ -1455,15 +1546,19 @@ describe('Group Model', () => {
        let [
          updatedLeader,
          updatedParticipatingMember,
+          updatedSleepingParticipatingMember,
        ] = await Promise.all([
          User.findById(questLeader._id),
          User.findById(participatingMember._id),
+          User.findById(sleepingParticipatingMember._id),
        ]);

        expect(updatedLeader.stats.exp).to.eql(quest.drop.exp);
        expect(updatedLeader.stats.gp).to.eql(quest.drop.gp);
        expect(updatedParticipatingMember.stats.exp).to.eql(quest.drop.exp);
        expect(updatedParticipatingMember.stats.gp).to.eql(quest.drop.gp);
+        expect(updatedSleepingParticipatingMember.stats.exp).to.eql(quest.drop.exp);
+        expect(updatedSleepingParticipatingMember.stats.gp).to.eql(quest.drop.gp);
      });

      context('drops', () => {
@@ -1563,13 +1658,16 @@ describe('Group Model', () => {
          sandbox.spy(User, 'update');
          await party.finishQuest(quest);

-          expect(User.update).to.be.calledTwice;
+          expect(User.update).to.be.calledThrice;
          expect(User.update).to.be.calledWithMatch({
            _id: questLeader._id,
          });
          expect(User.update).to.be.calledWithMatch({
            _id: participatingMember._id,
          });
+          expect(User.update).to.be.calledWithMatch({
+            _id: sleepingParticipatingMember._id,
+          });
        });

        it('sets user quest object to a clean state', async () => {
@@ -1585,6 +1683,42 @@ describe('Group Model', () => {
        });
      });

+      it('sends webhook to participating members that quest has finished', async () => {
+        // should receive webhook
+        participatingMember.webhooks = [{
+          type: 'questActivity',
+          url: 'http://someurl.com',
+          options: {
+            questFinished: true,
+          },
+        }];
+        questLeader.webhooks = [{
+          type: 'questActivity',
+          url: 'http://someurl.com',
+          options: {
+            questStarted: true, // will not receive the webhook
+          },
+        }];
+
+        await Promise.all([participatingMember.save(), sleepingParticipatingMember.save(), questLeader.save()]);
+
+        await party.finishQuest(quest);
+
+        await sleep(0.5);
+
+        expect(questActivityWebhook.send).to.be.calledOnce;
+
+        let args = questActivityWebhook.send.args[0];
+        let webhooks = args[0].webhooks;
+        let options = args[1];
+
+        expect(webhooks).to.have.a.lengthOf(1);
+        expect(webhooks[0].id).to.eql(participatingMember.webhooks[0].id);
+        expect(webhooks[0].type).to.eql('questActivity');
+        expect(options.group).to.eql(party);
+        expect(options.quest.key).to.eql(quest.key);
+      });
+
      context('World quests in Tavern', () => {
        let tavernQuest;

@@ -1700,7 +1834,7 @@ describe('Group Model', () => {
        expect(groupChatReceivedWebhook.send).to.be.calledOnce;

        let args = groupChatReceivedWebhook.send.args[0];
-        let webhooks = args[0];
+        let webhooks = args[0].webhooks;
        let options = args[1];

        expect(webhooks).to.have.a.lengthOf(1);
@@ -1764,9 +1898,9 @@ describe('Group Model', () => {
        expect(groupChatReceivedWebhook.send).to.be.calledThrice;

        let args = groupChatReceivedWebhook.send.args;
-        expect(args.find(arg => arg[0][0].id === memberWithWebhook.webhooks[0].id)).to.be.exist;
-        expect(args.find(arg => arg[0][0].id === memberWithWebhook2.webhooks[0].id)).to.be.exist;
-        expect(args.find(arg => arg[0][0].id === memberWithWebhook3.webhooks[0].id)).to.be.exist;
+        expect(args.find(arg => arg[0].webhooks[0].id === memberWithWebhook.webhooks[0].id)).to.be.exist;
+        expect(args.find(arg => arg[0].webhooks[0].id === memberWithWebhook2.webhooks[0].id)).to.be.exist;
+        expect(args.find(arg => arg[0].webhooks[0].id === memberWithWebhook3.webhooks[0].id)).to.be.exist;
      });
    });

@@ -1,7 +1,7 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
 import { each, find, findIndex } from 'lodash';

 describe('Group Task Methods', () => {
@@ -1,10 +1,10 @@
-import { model as Challenge } from '../../../../../website/server/models/challenge';
-import { model as Group } from '../../../../../website/server/models/group';
-import { model as User } from '../../../../../website/server/models/user';
-import * as Tasks from '../../../../../website/server/models/task';
-import { InternalServerError } from '../../../../../website/server/libs/errors';
+import { model as Challenge } from '../../../../website/server/models/challenge';
+import { model as Group } from '../../../../website/server/models/group';
+import { model as User } from '../../../../website/server/models/user';
+import * as Tasks from '../../../../website/server/models/task';
+import { InternalServerError } from '../../../../website/server/libs/errors';
 import { each } from 'lodash';
-import { generateHistory } from '../../../../helpers/api-unit.helper.js';
+import { generateHistory } from '../../../helpers/api-unit.helper.js';

 describe('Task Model', () => {
  let guild, leader, challenge, task;
@@ -1,7 +1,7 @@
 import moment from 'moment';
-import { model as User } from '../../../../../website/server/models/user';
-import { model as Group } from '../../../../../website/server/models/group';
-import common from '../../../../../website/common';
+import { model as User } from '../../../../website/server/models/user';
+import { model as Group } from '../../../../website/server/models/group';
+import common from '../../../../website/common';

 describe('User Model', () => {
  it('keeps user._tmp when calling .toJSON', () => {
@@ -42,13 +42,48 @@ describe('User Model', () => {
    expect(userToJSON.stats.maxHealth).to.not.exist;
    expect(userToJSON.stats.toNextLevel).to.not.exist;

-    user.addComputedStatsToJSONObj(userToJSON.stats);
+    User.addComputedStatsToJSONObj(userToJSON.stats, userToJSON);

    expect(userToJSON.stats.maxMP).to.exist;
    expect(userToJSON.stats.maxHealth).to.equal(common.maxHealth);
    expect(userToJSON.stats.toNextLevel).to.equal(common.tnl(user.stats.lvl));
  });

+  it('can transform user object without mongoose helpers', async () => {
+    let user = new User();
+    await user.save();
+    let userToJSON = await User.findById(user._id).lean().exec();
+
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+    expect(userToJSON.id).to.not.exist;
+
+    User.transformJSONUser(userToJSON);
+
+    expect(userToJSON.id).to.equal(userToJSON._id);
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+  });
+
+  it('can transform user object without mongoose helpers (including computed stats)', async () => {
+    let user = new User();
+    await user.save();
+    let userToJSON = await User.findById(user._id).lean().exec();
+
+    expect(userToJSON.stats.maxMP).to.not.exist;
+    expect(userToJSON.stats.maxHealth).to.not.exist;
+    expect(userToJSON.stats.toNextLevel).to.not.exist;
+
+    User.transformJSONUser(userToJSON, true);
+
+    expect(userToJSON.id).to.equal(userToJSON._id);
+    expect(userToJSON.stats.maxMP).to.exist;
+    expect(userToJSON.stats.maxHealth).to.equal(common.maxHealth);
+    expect(userToJSON.stats.toNextLevel).to.equal(common.tnl(user.stats.lvl));
+  });
+
  context('notifications', () => {
    it('can add notifications without data', () => {
      let user = new User();
@@ -1,4 +1,4 @@
-import { model as UserNotification } from '../../../../../website/server/models/userNotification';
+import { model as UserNotification } from '../../../../website/server/models/userNotification';

 describe('UserNotification Model', () => {
  context('convertNotificationsToSafeJson', () => {
@@ -0,0 +1,323 @@
+import { model as Webhook } from '../../../../website/server/models/webhook';
+import { BadRequest } from '../../../../website/server/libs/errors';
+import { v4 as generateUUID } from 'uuid';
+import apiError from '../../../../website/server/libs/apiError';
+
+describe('Webhook Model', () => {
+  context('Instance Methods', () => {
+    describe('#formatOptions', () => {
+      let res;
+
+      beforeEach(() => {
+        res = {
+          t: sandbox.spy(),
+        };
+      });
+      context('type is taskActivity', () => {
+        let config;
+
+        beforeEach(() => {
+          config = {
+            type: 'taskActivity',
+            url: 'https//exmaple.com/endpoint',
+            options: {
+              created: true,
+              updated: true,
+              deleted: true,
+              scored: true,
+              checklistScored: true,
+            },
+          };
+        });
+
+        it('it provides default values for options', () => {
+          delete config.options;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            checklistScored: false,
+            created: false,
+            updated: false,
+            deleted: false,
+            scored: true,
+          });
+        });
+
+        it('provides missing task options', () => {
+          delete config.options.created;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            checklistScored: true,
+            created: false,
+            updated: true,
+            deleted: true,
+            scored: true,
+          });
+        });
+
+        it('discards additional options', () => {
+          config.options.foo = 'another option';
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options.foo).to.not.exist;
+          expect(wh.options).to.eql({
+            checklistScored: true,
+            created: true,
+            updated: true,
+            deleted: true,
+            scored: true,
+          });
+        });
+
+        ['created', 'updated', 'deleted', 'scored', 'checklistScored'].forEach((option) => {
+          it(`validates that ${option} is a boolean`, (done) => {
+            config.options[option] = 'not a boolean';
+
+            try {
+              let wh = new Webhook(config);
+
+              wh.formatOptions(res);
+            } catch (err) {
+              expect(err).to.be.an.instanceOf(BadRequest);
+              expect(res.t).to.be.calledOnce;
+              expect(res.t).to.be.calledWith('webhookBooleanOption', { option });
+              done();
+            }
+          });
+        });
+      });
+
+      context('type is userActivity', () => {
+        let config;
+
+        beforeEach(() => {
+          config = {
+            type: 'userActivity',
+            url: 'https//exmaple.com/endpoint',
+            options: {
+              petHatched: true,
+              mountRaised: true,
+              leveledUp: true,
+            },
+          };
+        });
+
+        it('it provides default values for options', () => {
+          delete config.options;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            petHatched: false,
+            mountRaised: false,
+            leveledUp: false,
+          });
+        });
+
+        it('provides missing user options', () => {
+          delete config.options.petHatched;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            petHatched: false,
+            mountRaised: true,
+            leveledUp: true,
+          });
+        });
+
+        it('discards additional options', () => {
+          config.options.foo = 'another option';
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options.foo).to.not.exist;
+          expect(wh.options).to.eql({
+            petHatched: true,
+            mountRaised: true,
+            leveledUp: true,
+          });
+        });
+
+        ['petHatched', 'petHatched', 'leveledUp'].forEach((option) => {
+          it(`validates that ${option} is a boolean`, (done) => {
+            config.options[option] = 'not a boolean';
+
+            try {
+              let wh = new Webhook(config);
+
+              wh.formatOptions(res);
+            } catch (err) {
+              expect(err).to.be.an.instanceOf(BadRequest);
+              expect(res.t).to.be.calledOnce;
+              expect(res.t).to.be.calledWith('webhookBooleanOption', { option });
+              done();
+            }
+          });
+        });
+      });
+
+      context('type is questActivity', () => {
+        let config;
+
+        beforeEach(() => {
+          config = {
+            type: 'questActivity',
+            url: 'https//exmaple.com/endpoint',
+            options: {
+              questStarted: true,
+              questFinished: true,
+            },
+          };
+        });
+
+        it('it provides default values for options', () => {
+          delete config.options;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            questStarted: false,
+            questFinished: false,
+          });
+        });
+
+        it('provides missing user options', () => {
+          delete config.options.questStarted;
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql({
+            questStarted: false,
+            questFinished: true,
+          });
+        });
+
+        it('discards additional options', () => {
+          config.options.foo = 'another option';
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options.foo).to.not.exist;
+          expect(wh.options).to.eql({
+            questStarted: true,
+            questFinished: true,
+          });
+        });
+
+        ['questStarted', 'questFinished'].forEach((option) => {
+          it(`validates that ${option} is a boolean`, (done) => {
+            config.options[option] = 'not a boolean';
+
+            try {
+              let wh = new Webhook(config);
+
+              wh.formatOptions(res);
+            } catch (err) {
+              expect(err).to.be.an.instanceOf(BadRequest);
+              expect(res.t).to.be.calledOnce;
+              expect(res.t).to.be.calledWith('webhookBooleanOption', { option });
+              done();
+            }
+          });
+        });
+      });
+
+      context('type is groupChatReceived', () => {
+        let config;
+
+        beforeEach(() => {
+          config = {
+            type: 'groupChatReceived',
+            url: 'https//exmaple.com/endpoint',
+            options: {
+              groupId: generateUUID(),
+            },
+          };
+        });
+
+        it('creates options', () => {
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options).to.eql(config.options);
+        });
+
+        it('discards additional objects', () => {
+          config.options.foo = 'another thing';
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options.foo).to.not.exist;
+          expect(wh.options).to.eql({
+            groupId: config.options.groupId,
+          });
+        });
+
+        it('requires groupId option to be a uuid', (done) => {
+          config.options.groupId = 'not a uuid';
+
+          try {
+            let wh = new Webhook(config);
+
+            wh.formatOptions(res);
+          } catch (err) {
+            expect(err).to.be.an.instanceOf(BadRequest);
+
+            expect(err.message).to.eql(apiError('groupIdRequired'));
+            done();
+          }
+        });
+      });
+
+
+      context('type is globalActivity', () => {
+        let config;
+
+        beforeEach(() => {
+          config = {
+            type: 'globalActivity',
+            url: 'https//exmaple.com/endpoint',
+            options: { },
+          };
+        });
+
+        it('discards additional objects', () => {
+          config.options.foo = 'another thing';
+
+          let wh = new Webhook(config);
+
+          wh.formatOptions(res);
+
+          expect(wh.options.foo).to.not.exist;
+          expect(wh.options).to.eql({});
+        });
+      });
+    });
+  });
+});
@@ -5,7 +5,7 @@ import {
  sleep,
  checkExistence,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('DELETE /challenges/:challengeId', () => {
@@ -41,6 +41,7 @@ describe('DELETE /challenges/:challengeId', () => {
      group = populatedGroup.group;

      challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);

      await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
        {type: 'habit', text: taskText},
@@ -3,7 +3,7 @@ import {
  createAndPopulateGroup,
  generateChallenge,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('GET /challenges/:challengeId', () => {
@@ -33,9 +33,11 @@ describe('GET /challenges/:challengeId', () => {
      group = populatedGroup.group;

      challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
    });

    it('should return challenge data', async () => {
+      await challenge.sync();
      let chal = await user.get(`/challenges/${challenge._id}`);
      expect(chal.memberCount).to.equal(challenge.memberCount);
      expect(chal.name).to.equal(challenge.name);
@@ -61,44 +63,48 @@ describe('GET /challenges/:challengeId', () => {

  context('private guild', () => {
    let groupLeader;
+    let challengeLeader;
    let group;
    let challenge;
    let members;
-    let user;
+    let nonMember;
+    let otherMember;

    beforeEach(async () => {
-      user = await generateUser();
+      nonMember = await generateUser();

      let populatedGroup = await createAndPopulateGroup({
        groupDetails: {type: 'guild', privacy: 'private'},
-        members: 1,
+        members: 2,
      });

      groupLeader = populatedGroup.groupLeader;
      group = populatedGroup.group;
      members = populatedGroup.members;

-      challenge = await generateChallenge(groupLeader, group);
-      await members[0].post(`/challenges/${challenge._id}/join`);
+      challengeLeader = members[0];
+      otherMember = members[1];
+
+      challenge = await generateChallenge(challengeLeader, group);
    });

-    it('fails if user doesn\'t have access to the challenge', async () => {
-      await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
+    it('fails if user isn\'t in the guild and isn\'t challenge leader', async () => {
+      await expect(nonMember.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
        code: 404,
        error: 'NotFound',
        message: t('challengeNotFound'),
      });
    });

-    it('should return challenge data', async () => {
-      let chal = await members[0].get(`/challenges/${challenge._id}`);
+    it('returns challenge data for any user in the guild', async () => {
+      let chal = await otherMember.get(`/challenges/${challenge._id}`);
      expect(chal.name).to.equal(challenge.name);
      expect(chal._id).to.equal(challenge._id);

      expect(chal.leader).to.eql({
-        _id: groupLeader._id,
-        id: groupLeader._id,
-        profile: {name: groupLeader.profile.name},
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
      });
      expect(chal.group).to.eql({
        _id: group._id,
@@ -111,52 +117,72 @@ describe('GET /challenges/:challengeId', () => {
        leader: groupLeader.id,
      });
    });
+
+    it('returns challenge data if challenge leader isn\'t in the guild or challenge', async () => {
+      await challengeLeader.post(`/groups/${group._id}/leave`);
+      await challengeLeader.sync();
+      expect(challengeLeader.guilds).to.be.empty; // check that leaving worked
+
+      let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
+      expect(chal.name).to.equal(challenge.name);
+      expect(chal._id).to.equal(challenge._id);
+
+      expect(chal.leader).to.eql({
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
+      });
+    });
  });

  context('party', () => {
    let groupLeader;
+    let challengeLeader;
    let group;
    let challenge;
    let members;
-    let user;
+    let nonMember;
+    let otherMember;

    beforeEach(async () => {
-      user = await generateUser();
+      nonMember = await generateUser();

      let populatedGroup = await createAndPopulateGroup({
-        groupDetails: {type: 'party'},
-        members: 1,
+        groupDetails: {type: 'party', privacy: 'private'},
+        members: 2,
      });

      groupLeader = populatedGroup.groupLeader;
      group = populatedGroup.group;
      members = populatedGroup.members;

-      challenge = await generateChallenge(groupLeader, group);
-      await members[0].post(`/challenges/${challenge._id}/join`);
+      challengeLeader = members[0];
+      otherMember = members[1];
+
+      challenge = await generateChallenge(challengeLeader, group);
    });

-    it('fails if user doesn\'t have access to the challenge', async () => {
-      await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
+    it('fails if user isn\'t in the party and isn\'t challenge leader', async () => {
+      await expect(nonMember.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
        code: 404,
        error: 'NotFound',
        message: t('challengeNotFound'),
      });
    });

-    it('should return challenge data', async () => {
-      let chal = await members[0].get(`/challenges/${challenge._id}`);
+    it('returns challenge data for any user in the party', async () => {
+      let chal = await otherMember.get(`/challenges/${challenge._id}`);
      expect(chal.name).to.equal(challenge.name);
      expect(chal._id).to.equal(challenge._id);

      expect(chal.leader).to.eql({
-        _id: groupLeader._id,
-        id: groupLeader.id,
-        profile: {name: groupLeader.profile.name},
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
      });
      expect(chal.group).to.eql({
        _id: group._id,
-        id: group.id,
+        id: group._id,
        categories: [],
        name: group.name,
        summary: group.name,
@@ -165,5 +191,21 @@ describe('GET /challenges/:challengeId', () => {
        leader: groupLeader.id,
      });
    });
+
+    it('returns challenge data if challenge leader isn\'t in the party or challenge', async () => {
+      await challengeLeader.post('/groups/party/leave');
+      await challengeLeader.sync();
+      expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
+
+      let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
+      expect(chal.name).to.equal(challenge.name);
+      expect(chal._id).to.equal(challenge._id);
+
+      expect(chal.leader).to.eql({
+        _id: challengeLeader._id,
+        id: challengeLeader._id,
+        profile: {name: challengeLeader.profile.name},
+      });
+    });
  });
 });
@@ -4,7 +4,7 @@ import {
  generateChallenge,
  translate as t,
  sleep,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('GET /challenges/:challengeId/export/csv', () => {
@@ -24,6 +24,7 @@ describe('GET /challenges/:challengeId/export/csv', () => {
    members = populatedGroup.members;

    challenge = await generateChallenge(groupLeader, group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
    await members[0].post(`/challenges/${challenge._id}/join`);
    await members[1].post(`/challenges/${challenge._id}/join`);
    await members[2].post(`/challenges/${challenge._id}/join`);
@@ -60,9 +61,9 @@ describe('GET /challenges/:challengeId/export/csv', () => {
  });

  it('should return a valid CSV file with export data', async () => {
-    let res = await members[0].get(`/challenges/${challenge._id}/export/csv`);
-    let sortedMembers = _.sortBy([members[0], members[1], members[2], groupLeader], '_id');
-    let splitRes = res.split('\n');
+    const res = await members[0].get(`/challenges/${challenge._id}/export/csv`);
+    const sortedMembers = _.sortBy([members[0], members[1], members[2], groupLeader], '_id');
+    const splitRes = res.split('\n');

    expect(splitRes[0]).to.equal('UUID,name,Task,Value,Notes,Streak,Task,Value,Notes,Streak');
    expect(splitRes[1]).to.equal(`${sortedMembers[0]._id},${sortedMembers[0].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
@@ -71,4 +72,16 @@ describe('GET /challenges/:challengeId/export/csv', () => {
    expect(splitRes[4]).to.equal(`${sortedMembers[3]._id},${sortedMembers[3].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
    expect(splitRes[5]).to.equal('');
  });
+
+  it('should successfully return when it contains erroneous residue user data', async () => {
+    await members[0].update({challenges: []});
+    const res = await members[1].get(`/challenges/${challenge._id}/export/csv`);
+    const sortedMembers = _.sortBy([members[1], members[2], groupLeader], '_id');
+    const splitRes = res.split('\n');
+    expect(splitRes[0]).to.equal('UUID,name,Task,Value,Notes,Streak,Task,Value,Notes,Streak');
+    expect(splitRes[1]).to.equal(`${sortedMembers[0]._id},${sortedMembers[0].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
+    expect(splitRes[2]).to.equal(`${sortedMembers[1]._id},${sortedMembers[1].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
+    expect(splitRes[3]).to.equal(`${sortedMembers[2]._id},${sortedMembers[2].profile.name},habit:Task 1,0,,0,todo:Task 2,0,,0`);
+    expect(splitRes[4]).to.equal('');
+  });
 });
@@ -1,16 +1,17 @@
 import {
  generateUser,
  generateGroup,
+  createAndPopulateGroup,
  generateChallenge,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('GET /challenges/:challengeId/members', () => {
  let user;

  beforeEach(async () => {
-    user = await generateUser();
+    user = await generateUser({ balance: 1 });
  });

  it('validates optional req.query.lastId to be an UUID', async () => {
@@ -21,7 +22,7 @@ describe('GET /challenges/:challengeId/members', () => {
    });
  });

-  it('fails if challenge doesn\'t exists', async () => {
+  it('fails if challenge doesn\'t exist', async () => {
    await expect(user.get(`/challenges/${generateUUID()}/members`)).to.eventually.be.rejected.and.eql({
      code: 404,
      error: 'NotFound',
@@ -29,8 +30,8 @@ describe('GET /challenges/:challengeId/members', () => {
    });
  });

-  it('fails if user doesn\'t have access to the challenge', async () => {
-    let group = await generateGroup(user);
+  it('fails if user isn\'t in the private group and isn\'t challenge leader', async () => {
+    let group = await generateGroup(user, {type: 'party', privacy: 'private'});
    let challenge = await generateChallenge(user, group);
    let anotherUser = await generateUser();

@@ -41,10 +42,32 @@ describe('GET /challenges/:challengeId/members', () => {
    });
  });

+  it('works if user isn\'t in the private group but is challenge leader', async () => {
+    let populatedGroup = await createAndPopulateGroup({
+      groupDetails: {type: 'party', privacy: 'private'},
+      members: 1,
+    });
+    let groupLeader = populatedGroup.groupLeader;
+    let challengeLeader = populatedGroup.members[0];
+    let challenge = await generateChallenge(challengeLeader, populatedGroup.group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
+    await challengeLeader.post('/groups/party/leave');
+    await challengeLeader.sync();
+    expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
+
+    let res = await challengeLeader.get(`/challenges/${challenge._id}/members`);
+    expect(res[0]).to.eql({
+      _id: groupLeader._id,
+      id: groupLeader._id,
+      profile: {name: groupLeader.profile.name},
+    });
+  });
+
  it('works with challenges belonging to public guild', async () => {
    let leader = await generateUser({balance: 4});
    let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
    let challenge = await generateChallenge(leader, group);
+    await leader.post(`/challenges/${challenge._id}/join`);
    let res = await user.get(`/challenges/${challenge._id}/members`);
    expect(res[0]).to.eql({
      _id: leader._id,
@@ -59,6 +82,7 @@ describe('GET /challenges/:challengeId/members', () => {
    let anotherUser = await generateUser({balance: 3});
    let group = await generateGroup(anotherUser, {type: 'guild', privacy: 'public', name: generateUUID()});
    let challenge = await generateChallenge(anotherUser, group);
+    await anotherUser.post(`/challenges/${challenge._id}/join`);
    let res = await user.get(`/challenges/${challenge._id}/members`);
    expect(res[0]).to.eql({
      _id: anotherUser._id,
@@ -72,6 +96,7 @@ describe('GET /challenges/:challengeId/members', () => {
  it('returns only first 30 members if req.query.includeAllMembers is not true', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);

    let usersToGenerate = [];
    for (let i = 0; i < 31; i++) {
@@ -90,6 +115,7 @@ describe('GET /challenges/:challengeId/members', () => {
  it('returns only first 30 members if req.query.includeAllMembers is not defined', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);

    let usersToGenerate = [];
    for (let i = 0; i < 31; i++) {
@@ -108,6 +134,7 @@ describe('GET /challenges/:challengeId/members', () => {
  it('returns all members if req.query.includeAllMembers is true', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);

    let usersToGenerate = [];
    for (let i = 0; i < 31; i++) {
@@ -123,9 +150,11 @@ describe('GET /challenges/:challengeId/members', () => {
    });
  });

-  it('supports using req.query.lastId to get more members', async () => {
+  it('supports using req.query.lastId to get more members', async function () {
+    this.timeout(30000); // @TODO: times out after 8 seconds
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);

    let usersToGenerate = [];
    for (let i = 0; i < 57; i++) {
@@ -146,6 +175,7 @@ describe('GET /challenges/:challengeId/members', () => {
  it('supports using req.query.search to get search members', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);

    let usersToGenerate = [];
    for (let i = 0; i < 3; i++) {
@@ -3,7 +3,7 @@ import {
  generateChallenge,
  generateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('GET /challenges/:challengeId/members/:memberId', () => {
@@ -50,6 +50,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
  it('fails if user doesn\'t have access to the challenge', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
    let anotherUser = await generateUser();
    let member = await generateUser();
    await expect(anotherUser.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
@@ -62,6 +63,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
  it('fails if member is not part of the challenge', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
    let member = await generateUser();
    await expect(user.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
      code: 404,
@@ -74,6 +76,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
    let groupLeader = await generateUser({balance: 4});
    let group = await generateGroup(groupLeader, {type: 'guild', privacy: 'public', name: generateUUID()});
    let challenge = await generateChallenge(groupLeader, group);
+    await groupLeader.post(`/challenges/${challenge._id}/join`);
    let taskText = 'Test Text';
    await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: taskText}]);

@@ -86,6 +89,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
  it('returns the member tasks for the challenges', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
    await user.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: 'Test Text'}]);

    let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
@@ -98,6 +102,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
  it('returns the tasks without the tags and checklist', async () => {
    let group = await generateGroup(user, {type: 'party', name: generateUUID()});
    let challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
    let taskText = 'Test Text';
    await user.post(`/tasks/challenge/${challenge._id}`, [{
      type: 'todo',
@@ -3,7 +3,7 @@ import {
  generateChallenge,
  createAndPopulateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { TAVERN_ID } from '../../../../../website/common/script/constants';

 describe('GET challenges/groups/:groupId', () => {
@@ -25,7 +25,9 @@ describe('GET challenges/groups/:groupId', () => {
      nonMember = await generateUser();

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should return group challenges for non member with populated leader', async () => {
@@ -73,6 +75,7 @@ describe('GET challenges/groups/:groupId', () => {
      expect(foundChallengeIndex).to.eql(0);

      let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);

      challenges = await user.get(`/challenges/groups/${publicGuild._id}`);

@@ -99,7 +102,9 @@ describe('GET challenges/groups/:groupId', () => {
      nonMember = await generateUser();

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should prevent non-member from seeing challenges', async () => {
@@ -156,9 +161,12 @@ describe('GET challenges/groups/:groupId', () => {
          slug: 'habitica_official',
        }],
      });
+      await user.post(`/challenges/${officialChallenge._id}/join`);

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should return official challenges first', async () => {
@@ -178,6 +186,7 @@ describe('GET challenges/groups/:groupId', () => {
      expect(foundChallengeIndex).to.eql(1);

      let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);

      challenges = await user.get(`/challenges/groups/${publicGuild._id}`);

@@ -203,7 +212,9 @@ describe('GET challenges/groups/:groupId', () => {
      nonMember = await generateUser();

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should prevent non-member from seeing challenges', async () => {
@@ -263,7 +274,9 @@ describe('GET challenges/groups/:groupId', () => {
      tavern = await user.get(`/groups/${TAVERN_ID}`);

      challenge = await generateChallenge(user, tavern, {prize: 1});
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, tavern, {prize: 1});
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should return tavern challenges with populated leader', async () => {
@@ -2,7 +2,7 @@ import {
  generateUser,
  generateChallenge,
  createAndPopulateGroup,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';

 describe('GET challenges/user', () => {
  context('no official challenges', () => {
@@ -24,7 +24,9 @@ describe('GET challenges/user', () => {
      nonMember = await generateUser();

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should return challenges user has joined', async () => {
@@ -146,6 +148,7 @@ describe('GET challenges/user', () => {
      expect(foundChallengeIndex).to.eql(0);

      let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);

      challenges = await user.get('/challenges/user');

@@ -164,6 +167,7 @@ describe('GET challenges/user', () => {
      });

      let privateChallenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${privateChallenge._id}/join`);

      let challenges = await nonMember.get('/challenges/user');

@@ -198,9 +202,12 @@ describe('GET challenges/user', () => {
          slug: 'habitica_official',
        }],
      });
+      await user.post(`/challenges/${officialChallenge._id}/join`);

      challenge = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge._id}/join`);
      challenge2 = await generateChallenge(user, group);
+      await user.post(`/challenges/${challenge2._id}/join`);
    });

    it('should return official challenges first', async () => {
@@ -220,6 +227,7 @@ describe('GET challenges/user', () => {
      expect(foundChallengeIndex).to.eql(1);

      let newChallenge = await generateChallenge(user, publicGuild);
+      await user.post(`/challenges/${newChallenge._id}/join`);

      challenges = await user.get('/challenges/user');

@@ -252,12 +260,14 @@ describe('GET challenges/user', () => {
      await user.update({balance: 20});

      for (let i = 0; i < 11; i += 1) {
-        await generateChallenge(user, group); // eslint-disable-line
+        let challenge = await generateChallenge(user, group); // eslint-disable-line
+        await user.post(`/challenges/${challenge._id}/join`); // eslint-disable-line
      }
    });

    it('returns public guilds filtered by category', async () => {
      const categoryChallenge = await generateChallenge(user, guild, {categories});
+      await user.post(`/challenges/${categoryChallenge._id}/join`);
      const challenges = await user.get(`/challenges/user?categories=${categories[0].slug}`);

      expect(challenges[0]._id).to.eql(categoryChallenge._id);
@@ -2,7 +2,7 @@ import {
  generateUser,
  createAndPopulateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('POST /challenges', () => {
@@ -94,16 +94,6 @@ describe('POST /challenges', () => {
      });
    });

-    it('returns an error when non-leader member creates a challenge in leaderOnly group', async () => {
-      await expect(groupMember.post('/challenges', {
-        group: group._id,
-      })).to.eventually.be.rejected.and.eql({
-        code: 401,
-        error: 'NotAuthorized',
-        message: t('onlyGroupLeaderChal'),
-      });
-    });
-
    it('allows non-leader member to create a challenge', async () => {
      let populatedGroup = await createAndPopulateGroup({
        members: 1,
@@ -242,7 +232,6 @@ describe('POST /challenges', () => {
    it('returns an error when challenge validation fails; doesn\'s save user or group', async () => {
      let oldChallengeCount = group.challengeCount;
      let oldUserBalance = groupLeader.balance;
-      let oldUserChallenges = groupLeader.challenges;
      let oldGroupBalance = group.balance;

      await expect(groupLeader.post('/challenges', {
@@ -260,7 +249,6 @@ describe('POST /challenges', () => {
      expect(group.challengeCount).to.eql(oldChallengeCount);
      expect(group.balance).to.eql(oldGroupBalance);
      expect(groupLeader.balance).to.eql(oldUserBalance);
-      expect(groupLeader.challenges).to.eql(oldUserChallenges);
    });

    it('sets all properites of the challenge as passed', async () => {
@@ -291,28 +279,29 @@ describe('POST /challenges', () => {
        name: group.name,
        type: group.type,
      });
-      expect(challenge.memberCount).to.eql(1);
+      expect(challenge.memberCount).to.eql(0);
      expect(challenge.prize).to.eql(prize);
    });

-    it('adds challenge to creator\'s challenges', async () => {
-      let challenge = await groupLeader.post('/challenges', {
+    it('does not add challenge to creator\'s challenges', async () => {
+      await groupLeader.post('/challenges', {
        group: group._id,
        name: 'Test Challenge',
        shortName: 'TC Label',
      });

-      await expect(groupLeader.sync()).to.eventually.have.property('challenges').to.include(challenge._id);
+      await groupLeader.sync();
+      expect(groupLeader.challenges.length).to.equal(0);
    });

-    it('awards achievement if this is creator\'s first challenge', async () => {
+    it('does not award joinedChallenge achievement for creating a challenge', async () => {
      await groupLeader.post('/challenges', {
        group: group._id,
        name: 'Test Challenge',
        shortName: 'TC Label',
      });
      groupLeader = await groupLeader.sync();
-      expect(groupLeader.achievements.joinedChallenge).to.be.true;
+      expect(groupLeader.achievements.joinedChallenge).to.not.be.true;
    });

    it('sets summary to challenges name when not supplied', async () => {
@@ -3,7 +3,7 @@ import {
  generateChallenge,
  createAndPopulateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('POST /challenges/:challengeId/join', () => {
@@ -43,9 +43,10 @@ describe('POST /challenges/:challengeId/join', () => {
      authorizedUser = populatedGroup.members[0];

      challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);
    });

-    it('returns an error when user doesn\'t have permissions to access the challenge', async () => {
+    it('returns an error when user isn\'t in the private group and isn\'t challenge leader', async () => {
      let unauthorizedUser = await generateUser();

      await expect(unauthorizedUser.post(`/challenges/${challenge._id}/join`)).to.eventually.be.rejected.and.eql({
@@ -55,6 +56,16 @@ describe('POST /challenges/:challengeId/join', () => {
      });
    });

+    it('succeeds when user isn\'t in the private group but is challenge leader', async () => {
+      await groupLeader.post(`/challenges/${challenge._id}/leave`);
+      await groupLeader.post(`/groups/${group._id}/leave`);
+      await groupLeader.sync();
+      expect(groupLeader.guilds).to.be.empty; // check that leaving worked
+
+      let res = await groupLeader.post(`/challenges/${challenge._id}/join`);
+      expect(res.name).to.equal(challenge.name);
+    });
+
    it('returns challenge data', async () => {
      let res = await authorizedUser.post(`/challenges/${challenge._id}/join`);

@@ -91,6 +102,7 @@ describe('POST /challenges/:challengeId/join', () => {
    });

    it('increases memberCount of challenge', async () => {
+      await challenge.sync();
      let oldMemberCount = challenge.memberCount;

      await authorizedUser.post(`/challenges/${challenge._id}/join`);
@@ -3,7 +3,7 @@ import {
  generateChallenge,
  createAndPopulateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('POST /challenges/:challengeId/leave', () => {
@@ -48,6 +48,7 @@ describe('POST /challenges/:challengeId/leave', () => {
      notInGroupLeavingUser = populatedGroup.members[2];

      challenge = await generateChallenge(groupLeader, group);
+      await groupLeader.post(`/challenges/${challenge._id}/join`);

      taskText = 'A challenge task text';

@@ -5,7 +5,7 @@ import {
  sleep,
  checkExistence,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('POST /challenges/:challengeId/winner/:winnerId', () => {
@@ -58,6 +58,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
      challenge = await generateChallenge(groupLeader, group, {
        prize: 1,
      });
+      await groupLeader.post(`/challenges/${challenge._id}/join`);

      await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
        {type: 'habit', text: taskText},
@@ -1,7 +1,7 @@
 import {
  generateUser,
  generateGroup,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';

 describe('POST /challenges/:challengeId/clone', () => {
  it('clones a challenge', async () => {
@@ -3,7 +3,7 @@ import {
  generateChallenge,
  createAndPopulateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';

 describe('PUT /challenges/:challengeId', () => {
  let privateGuild, user, nonMember, challenge, member;
@@ -25,6 +25,7 @@ describe('PUT /challenges/:challengeId', () => {
    member = members[0];

    challenge = await generateChallenge(user, group);
+    await user.post(`/challenges/${challenge._id}/join`);
    await member.post(`/challenges/${challenge._id}/join`);
  });

@@ -2,7 +2,7 @@ import {
  createAndPopulateGroup,
  generateUser,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';
 import { v4 as generateUUID } from 'uuid';

 describe('DELETE /groups/:groupId/chat/:chatId', () => {
@@ -53,16 +53,26 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {

    it('allows creator to delete a their message', async () => {
      await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
-      let messages = await user.get(`/groups/${groupWithChat._id}/chat/`);
-      expect(messages).is.an('array');
-      expect(messages).to.not.include(nextMessage);
+
+      const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
+      const messageFromUser = returnedMessages.find(returnedMessage => {
+        return returnedMessage.id === nextMessage.id;
+      });
+
+      expect(returnedMessages).is.an('array');
+      expect(messageFromUser).to.not.exist;
    });

    it('allows admin to delete another user\'s message', async () => {
      await admin.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
-      let messages = await user.get(`/groups/${groupWithChat._id}/chat/`);
-      expect(messages).is.an('array');
-      expect(messages).to.not.include(nextMessage);
+
+      const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
+      const messageFromUser = returnedMessages.find(returnedMessage => {
+        return returnedMessage.id === nextMessage.id;
+      });
+
+      expect(returnedMessages).is.an('array');
+      expect(messageFromUser).to.not.exist;
    });

    it('returns empty when previous message parameter is passed and the last message was deleted', async () => {
@@ -71,9 +81,9 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
    });

    it('returns the update chat when previous message parameter is passed and the chat is updated', async () => {
-      let deleteResult = await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}?previousMsg=${message.id}`);
+      const updatedChat = await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}?previousMsg=${message.id}`);

-      expect(deleteResult[0].id).to.eql(message.id);
+      expect(updatedChat[0].id).to.eql(message.id);
    });
  });
 });
@@ -2,7 +2,7 @@ import {
  generateUser,
  generateGroup,
  translate as t,
-} from '../../../../helpers/api-v3-integration.helper';
+} from '../../../../helpers/api-integration/v3';

 describe('GET /groups/:groupId/chat', () => {
  let user;
@@ -23,16 +23,17 @@ describe('GET /groups/:groupId/chat', () => {
        privacy: 'public',
      }, {
        chat: [
-          {text: 'Hello', flags: {}},
-          {text: 'Welcome to the Guild', flags: {}},
+          {text: 'Hello', flags: {}, id: 1},
+          {text: 'Welcome to the Guild', flags: {}, id: 2},
        ],
      });
    });

    it('returns Guild chat', async () => {
-      let chat = await user.get(`/groups/${group._id}/chat`);
+      const chat = await user.get(`/groups/${group._id}/chat`);

-      expect(chat).to.eql(group.chat);
+      expect(chat[0].id).to.eql(group.chat[0].id);
+      expect(chat[1].id).to.eql(group.chat[1].id);
    });
  });

--- a/Show More
+++ b/Show More