4.106.2

fix(mobile): set default streak achievement to 0
4.106.1
2025-10-26 10:42:52 +01:00 · 2019-08-12 16:03:21 -05:00 · 2019-08-12 16:02:23 -05:00 · 2019-08-08 15:47:44 -05:00 · 2019-08-08 15:47:33 -05:00 · 2019-08-06 16:59:08 -05:00
3343 changed files with 139828 additions and 87870 deletions
--- a/.babelrc
+++ b/.babelrc
@@ -1,10 +1,6 @@
 {
-  "presets": ["es2015"],
  "plugins": [
-    "transform-object-rest-spread",
-    ["transform-async-to-module-method", {
-      "module": "bluebird",
-      "method": "coroutine"
-    }]
+    "transform-es2015-modules-commonjs",
+    "syntax-object-rest-spread",
  ]
 }
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -4,7 +4,7 @@

 # Pull Request

-[Please see these instructions for adding a pull request](http://habitica.wikia.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API)
+[Please see these instructions for adding a pull request](http://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API)

 # Requesting a feature

@@ -12,4 +12,9 @@ Habitica uses [Trello](https://trello.com/b/EpoYEYod/habitica) to track feature

 # Contributing Code

-See [Contributing to Habitica](http://habitica.wikia.com/wiki/Contributing_to_Habitica#Coders_.28Web_.26_Mobile.29)
+See [Contributing to Habitica](http://habitica.fandom.com/wiki/Contributing_to_Habitica#Coders_.28Web_.26_Mobile.29)
+
+## Issue Triage [![Open Source Helpers](https://www.codetriage.com/habitrpg/habitica/badges/users.svg)](https://www.codetriage.com/habitrpg/habitica)
+
+You can triage issues which may include reproducing bug reports or asking for vital information, such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to [subscribe to habitrpg on CodeTriage](https://www.codetriage.com/habitrpg/habitica).
+
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -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)
+[//]: # (Note: See http://habitica.fandom.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)
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,8 @@ dist-client
 test/client/unit/coverage
 test/client/e2e/reports
 test/client-old/spec/mocks/translations.js
+yarn.lock
+.gitattributes

 # Elastic Beanstalk Files
 .elasticbeanstalk/*
--- a/.nodemonignore
+++ b/.nodemonignore
@@ -4,6 +4,7 @@ node_modules/**
 .bower-registry/**
 website/client-old/**
 website/client/**
+website/client/store/**
 website/views/**
 website/build/**
 dist/**
@@ -16,3 +17,4 @@ CHANGELOG.md
 newrelic_agent.log
 *.swp
 *.swx
+website/raw_sprites/**
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-6
+10
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: node_js
 node_js:
-  - '6'
+  - '10'
 services:
  - mongodb
 cache:
@@ -8,8 +8,6 @@ cache:
    - 'node_modules'
 addons:
  chrome: stable
-before_install:
-  - npm install -g npm@5
 before_script:
  - npm run test:build
  - cp config.json.example config.json
@@ -22,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
--- a/51
+++ b/51
@@ -1,21 +1,30 @@
-FROM node:boron
-
-# Upgrade NPM to v5 (Yarn is needed because of this bug https://github.com/npm/npm/issues/16807)
-# The used solution is suggested here https://github.com/npm/npm/issues/16807#issuecomment-313591975
-RUN yarn global add npm@5
-# 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:10
+
+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 LOGGLY_CLIENT_TOKEN ab5663bf-241f-4d14-8783-7d80db77089a
+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"]
--- a/5
+++ b/5
@@ -0,0 +1,5 @@
+FROM node:10
+WORKDIR /code
+COPY package*.json /code/
+RUN npm install
+RUN npm install -g gulp-cli mocha
--- a/32
+++ b/32
@@ -1,32 +0,0 @@
-FROM node:boron
-
-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
-
-# Upgrade NPM to v5 (Yarn is needed because of this bug https://github.com/npm/npm/issues/16807)
-# The used solution is suggested here https://github.com/npm/npm/issues/16807#issuecomment-313591975
-RUN yarn global add npm@5
-# 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.29.8 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"]
--- a/README.md
+++ b/README.md
@@ -7,7 +7,6 @@ Habitica [![Build Status](https://travis-ci.org/HabitRPG/habitica.svg?branch=dev

 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).
+For an introduction to the technologies used and how the software is organized, refer to [Guidance for Blacksmiths](http://habitica.fandom.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.fandom.com/wiki/Setting_up_Habitica_Locally).
--- a/VAGRANT.md
+++ b/VAGRANT.md
@@ -8,4 +8,4 @@ minimal dependencies on the developer's local platform. It can be used
 on a variety of systems including Windows, Mac OS X, and Linux.

 Instructions for using the Habitica Vagrant environment are in
-[Setting up Habitica Locally](http://habitica.wikia.com/wiki/Setting_up_Habitica_Locally).
+[Setting up Habitica Locally](http://habitica.fandom.com/wiki/Setting_up_Habitica_Locally).
--- a/config.json.example
+++ b/config.json.example
@@ -1,117 +1,77 @@
 {
-    "PORT":3000,
-    "ENABLE_CONSOLE_LOGS_IN_PROD":"false",
-    "IP":"0.0.0.0",
-    "WEB_CONCURRENCY":1,
-    "BASE_URL":"http://localhost:3000",
-    "FACEBOOK_KEY":"123456789012345",
-    "FACEBOOK_SECRET":"aaaabbbbccccddddeeeeffff00001111",
-    "GOOGLE_CLIENT_ID":"123456789012345",
-    "GOOGLE_CLIENT_SECRET":"aaaabbbbccccddddeeeeffff00001111",
-    "PLAY_API": {
-      "CLIENT_ID": "aaaabbbbccccddddeeeeffff00001111",
-      "CLIENT_SECRET": "aaaabbbbccccddddeeeeffff00001111",
-      "ACCESS_TOKEN":"aaaabbbbccccddddeeeeffff00001111",
-      "REFRESH_TOKEN":"aaaabbbbccccddddeeeeffff00001111"
-    },
-    "NODE_DB_URI":"mongodb://localhost/habitrpg",
-    "TEST_DB_URI":"mongodb://localhost/habitrpg_test",
-    "NODE_ENV":"development",
-    "ENABLE_CONSOLE_LOGS_IN_TEST": false,
-    "CRON_SAFE_MODE":"false",
-    "CRON_SEMI_SAFE_MODE":"false",
-    "MAINTENANCE_MODE": "false",
-    "SESSION_SECRET":"YOUR SECRET HERE",
-    "SESSION_SECRET_KEY": "1234567891234567891234567891234567891234567891234567891234567891",
-    "SESSION_SECRET_IV": "12345678912345678912345678912345",
-    "ADMIN_EMAIL": "you@example.com",
-    "SMTP_USER":"user@example.com",
-    "SMTP_PASS":"password",
-    "SMTP_SERVICE":"Gmail",
-    "SMTP_HOST":"example.com",
-    "SMTP_PORT": 587,
-    "SMTP_TLS": true,
-    "STRIPE_API_KEY":"aaaabbbbccccddddeeeeffff00001111",
-    "STRIPE_PUB_KEY":"22223333444455556666777788889999",
-    "NEW_RELIC_LICENSE_KEY":"NEW_RELIC_LICENSE_KEY",
-    "NEW_RELIC_NO_CONFIG_FILE":"true",
-    "NEW_RELIC_APPLICATION_ID":"NEW_RELIC_APPLICATION_ID",
-    "NEW_RELIC_API_KEY":"NEW_RELIC_API_KEY",
-    "GA_ID": "GA_ID",
-    "AMPLITUDE_KEY": "AMPLITUDE_KEY",
-    "AMAZON_PAYMENTS": {
-        "SELLER_ID": "SELLER_ID",
-        "CLIENT_ID": "CLIENT_ID",
-        "MWS_KEY": "",
-        "MWS_SECRET": ""
-    },
-    "FLAG_REPORT_EMAIL": "email@mod.com,email2@mod.com",
-    "EMAIL_SERVER": {
-        "url": "http://example.com",
-        "authUser": "user",
-        "authPassword": "password"
-    },
-    "S3":{
-        "bucket":"bucket",
-        "accessKeyId":"accessKeyId",
-        "secretAccessKey":"secretAccessKey"
-    },
-    "SLACK_URL": "https://hooks.slack.com/services/some-url",
-    "TRANSIFEX_SLACK_CHANNEL": "transifex",
-    "PAYPAL":{
-        "billing_plans": {
-            "basic_earned":"basic_earned",
-            "basic_3mo":"basic_3mo",
-            "basic_6mo":"basic_6mo",
-            "google_6mo":"google_6mo",
-            "basic_12mo":"basic_12mo"
-        },
-        "mode":"sandbox",
-        "client_id":"client_id",
-        "client_secret":"client_secret",
-        "experience_profile_id": ""
-    },
-    "IAP_GOOGLE_KEYDIR": "/path/to/google/public/key/dir/",
-    "LOGGLY_TOKEN": "token",
-    "LOGGLY_CLIENT_TOKEN": "token",
-    "LOGGLY_ACCOUNT": "account",
-    "PUSH_CONFIGS": {
-        "GCM_SERVER_API_KEY": "",
-        "APN_ENABLED": "false",
-        "FCM_SERVER_API_KEY": ""
-    },
-    "SITE_HTTP_AUTH": {
-        "ENABLED": "false",
-        "USERNAME": "admin",
-        "PASSWORD": "password"
-    },
-    "PUSHER": {
-        "ENABLED": "false",
-        "APP_ID": "appId",
-        "KEY": "key",
-        "SECRET": "secret"
-    },
-    "SLACK": {
-        "FLAGGING_URL": "https://hooks.slack.com/services/id/id/id",
-        "FLAGGING_FOOTER_LINK": "https://habitrpg.github.io/flag-o-rama/",
-        "SUBSCRIPTIONS_URL": "https://hooks.slack.com/services/id/id/id"
-    },
-    "ITUNES_SHARED_SECRET": "aaaabbbbccccddddeeeeffff00001111",
-    "EMAILS" : {
-        "COMMUNITY_MANAGER_EMAIL" : "leslie@habitica.com",
-        "TECH_ASSISTANCE_EMAIL" : "admin@habitica.com",
-        "PRESS_ENQUIRY_EMAIL" : "leslie@habitica.com"
-    },
-    "LOGGLY" : {
-        "TOKEN" : "example-token",
-        "SUBDOMAIN" : "exmaple-subdomain"
-    },
-    "KAFKA": {
-      "GROUP_ID": "",
-      "CLOUDKARAFKA_BROKERS": "",
-      "CLOUDKARAFKA_USERNAME": "",
-      "CLOUDKARAFKA_PASSWORD": "",
-      "CLOUDKARAFKA_TOPIC_PREFIX": ""
-    },
-    "STACK_IMPACT_KEY": "aaaabbbbccccddddeeeeffffgggg111100002222"
+  "ADMIN_EMAIL": "you@example.com",
+  "AMAZON_PAYMENTS_CLIENT_ID": "CLIENT_ID",
+  "AMAZON_PAYMENTS_MODE": "sandbox",
+  "AMAZON_PAYMENTS_MWS_KEY": "MWS_KEY",
+  "AMAZON_PAYMENTS_MWS_SECRET": "MWS_SECRET",
+  "AMAZON_PAYMENTS_SELLER_ID": "SELLER_ID",
+  "AMPLITUDE_KEY": "AMPLITUDE_KEY",
+  "AMPLITUDE_SECRET": "AMPLITUDE_SECRET",
+  "BASE_URL": "http://localhost:3000",
+  "CRON_SAFE_MODE": "false",
+  "CRON_SEMI_SAFE_MODE": "false",
+  "DISABLE_REQUEST_LOGGING": "true",
+  "EMAILS_COMMUNITY_MANAGER_EMAIL": "admin@habitica.com",
+  "EMAILS_PRESS_ENQUIRY_EMAIL": "admin@habitica.com",
+  "EMAILS_TECH_ASSISTANCE_EMAIL": "admin@habitica.com",
+  "EMAIL_SERVER_AUTH_PASSWORD": "password",
+  "EMAIL_SERVER_AUTH_USER": "user",
+  "EMAIL_SERVER_URL": "http://example.com",
+  "ENABLE_CONSOLE_LOGS_IN_PROD": "false",
+  "ENABLE_CONSOLE_LOGS_IN_TEST": "false",
+  "FACEBOOK_KEY": "123456789012345",
+  "FACEBOOK_SECRET": "aaaabbbbccccddddeeeeffff00001111",
+  "FLAG_REPORT_EMAIL": "email@example.com, email2@example.com",
+  "GA_ID": "GA_ID",
+  "GOOGLE_CLIENT_ID": "123456789012345",
+  "GOOGLE_CLIENT_SECRET": "aaaabbbbccccddddeeeeffff00001111",
+  "IAP_GOOGLE_KEYDIR": "/path/to/google/public/key/dir/",
+  "IGNORE_REDIRECT": "true",
+  "ITUNES_SHARED_SECRET": "aaaabbbbccccddddeeeeffff00001111",
+  "LOGGLY_CLIENT_TOKEN": "token",
+  "LOGGLY_SUBDOMAIN": "example-subdomain",
+  "LOGGLY_TOKEN": "example-token",
+  "MAINTENANCE_MODE": "false",
+  "NODE_DB_URI": "mongodb://localhost/habitrpg",
+  "NODE_ENV": "development",
+  "PATH": "bin:node_modules/.bin:/usr/local/bin:/usr/bin:/bin",
+  "PAYPAL_BILLING_PLANS_basic_12mo": "basic_12mo",
+  "PAYPAL_BILLING_PLANS_basic_3mo": "basic_3mo",
+  "PAYPAL_BILLING_PLANS_basic_6mo": "basic_6mo",
+  "PAYPAL_BILLING_PLANS_basic_earned": "basic_earned",
+  "PAYPAL_BILLING_PLANS_google_6mo": "google_6mo",
+  "PAYPAL_CLIENT_ID": "client_id",
+  "PAYPAL_CLIENT_SECRET": "client_secret",
+  "PAYPAL_EXPERIENCE_PROFILE_ID": "xp_profile_id",
+  "PAYPAL_MODE": "sandbox",
+  "PLAY_API_ACCESS_TOKEN": "aaaabbbbccccddddeeeeffff00001111",
+  "PLAY_API_CLIENT_ID": "aaaabbbbccccddddeeeeffff00001111",
+  "PLAY_API_CLIENT_SECRET": "aaaabbbbccccddddeeeeffff00001111",
+  "PLAY_API_REFRESH_TOKEN": "aaaabbbbccccddddeeeeffff00001111",
+  "PORT": 3000,
+  "PUSH_CONFIGS_APN_ENABLED": "false",
+  "PUSH_CONFIGS_APN_KEY": "xxxxxxxxxx",
+  "PUSH_CONFIGS_APN_KEY_ID": "xxxxxxxxxx",
+  "PUSH_CONFIGS_APN_TEAM_ID": "aaabbbcccd",
+  "PUSH_CONFIGS_FCM_SERVER_API_KEY": "aaabbbcccd",
+  "S3_ACCESS_KEY_ID": "accessKeyId",
+  "S3_BUCKET": "bucket",
+  "S3_SECRET_ACCESS_KEY": "secretAccessKey",
+  "SESSION_SECRET": "YOUR SECRET HERE",
+  "SESSION_SECRET_IV": "12345678912345678912345678912345",
+  "SESSION_SECRET_KEY": "1234567891234567891234567891234567891234567891234567891234567891",
+  "SITE_HTTP_AUTH_ENABLED": "false",
+  "SITE_HTTP_AUTH_PASSWORDS": "password,wordpass,passkey",
+  "SITE_HTTP_AUTH_USERNAMES": "admin,tester,contributor",
+  "SLACK_FLAGGING_FOOTER_LINK": "https://habitrpg.github.io/flag-o-rama/",
+  "SLACK_FLAGGING_URL": "https://hooks.slack.com/services/id/id/id",
+  "SLACK_SUBSCRIPTIONS_URL": "https://hooks.slack.com/services/id/id/id",
+  "SLACK_URL": "https://hooks.slack.com/services/some-url",
+  "STRIPE_API_KEY": "aaaabbbbccccddddeeeeffff00001111",
+  "STRIPE_PUB_KEY": "22223333444455556666777788889999",
+  "TEST_DB_URI": "mongodb://localhost/habitrpg_test",
+  "TRANSIFEX_SLACK_CHANNEL": "transifex",
+  "WEB_CONCURRENCY": 1,
+  "SKIP_SSL_CHECK_KEY": "key",
+  "ENABLE_STACKDRIVER_TRACING": "false"
 }
--- a/database_reports/20180607_subscriber_histories.js
+++ b/database_reports/20180607_subscriber_histories.js
@@ -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;
--- a/database_reports/20181001_backtoschool_challenge.js
+++ b/database_reports/20181001_backtoschool_challenge.js
@@ -0,0 +1,48 @@
+import monk from 'monk';
+import nconf from 'nconf';
+
+/*
+ * Output data on users who completed all the To-Do tasks in the 2018 Back-to-School Challenge.
+ * User ID,Profile Name
+ */
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+const CHALLENGE_ID = '0acb1d56-1660-41a4-af80-9259f080b62b';
+
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+let dbTasks = monk(CONNECTION_STRING).get('tasks', { castIds: false });
+
+function usersReport() {
+  console.info('User ID,Profile Name');
+  let userCount = 0;
+
+  dbUsers.find(
+    {challenges: CHALLENGE_ID},
+    {fields:
+      {_id: 1, 'profile.name': 1}
+    },
+  ).each((user, {close, pause, resume}) => {
+    pause();
+    userCount++;
+    let completedTodos = 0;
+    return dbTasks.find(
+      {
+        userId: user._id,
+        'challenge.id': CHALLENGE_ID,
+        type: 'todo',
+      },
+      {fields: {completed: 1}}
+    ).each((task) => {
+      if (task.completed) completedTodos++;
+    }).then(() => {
+      if (completedTodos >= 7) {
+        console.info(`${user._id},${user.profile.name}`);
+      }
+      resume();
+    });
+  }).then(() => {
+    console.info(`${userCount} users reviewed`);
+    return process.exit(0);
+  });
+}
+
+module.exports = usersReport;
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,10 +1,45 @@
 version: "3"
 services:
-
  client:
+    build:
+      context: .
+      dockerfile: ./Dockerfile-Dev
+    command: ["npm", "run", "client:dev"]
+    depends_on:
+      - server
+    environment:
+      - BASE_URL=http://server:3000
+    image: habitica
+    networks:
+      - habitica
+    ports:
+      - "8080:8080"
    volumes:
-      - '.:/usr/src/habitrpg'
-
+      - .:/code
+      - /code/node_modules
  server:
+    build:
+      context: .
+      dockerfile: ./Dockerfile-Dev
+    command: ["npm", "start"]
+    depends_on:
+      - mongo
+    environment:
+      - NODE_DB_URI=mongodb://mongo/habitrpg
+    image: habitica
+    networks:
+      - habitica
+    ports:
+      - "3000:3000"
    volumes:
-      - '.:/usr/src/habitrpg'
+      - .:/code
+      - /code/node_modules
+  mongo:
+    image: mongo:3.4
+    networks:
+      - habitica
+    ports:
+      - "27017:27017"
+networks:
+  habitica:
+    driver: bridge
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -25,7 +25,7 @@ services:
      - mongo

  mongo:
-    image: mongo
+    image: mongo:3.4
    ports:
      - "27017:27017"
    networks:
--- a/gulp/gulp-sprites.js
+++ b/gulp/gulp-sprites.js
@@ -16,7 +16,7 @@ const IMG_DIST_PATH = 'website/client/assets/images/sprites/';
 const CSS_DIST_PATH = 'website/client/assets/css/sprites/';

 function checkForSpecialTreatment (name) {
-  let regex = /^hair|skin|beard|mustach|shirt|flower|^headAccessory_special_\w+Ears|^eyewear_special_\w+TopFrame/;
+  let regex = /^hair|skin|beard|mustach|shirt|flower|^headAccessory_special_\w+Ears|^eyewear_special_\w+TopFrame|^eyewear_special_\w+HalfMoon/;
  return name.match(regex) || name === 'head_0';
 }

--- a/gulp/gulp-tests.js
+++ b/gulp/gulp-tests.js
@@ -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('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,13 +179,13 @@ 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/unit/**/*', 'website/server/controllers/**/*'], gulp.series('test:api:unit', done => done()));
 });

 gulp.task('test:api-v3:integration', (done) => {
  let runner = exec(
-    testBin('node_modules/.bin/istanbul cover --dir coverage/api-v3-integration --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v3/integration --recursive --require ./test/helpers/start-server'),
+    testBin('istanbul cover --dir coverage/api-v3-integration --report lcovonly node_modules/mocha/bin/_mocha -- test/api/v3/integration --recursive --require ./test/helpers/start-server'),
    {maxBuffer: 500 * 1024},
    (err) => {
      if (err) {
@@ -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('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()
 ));
--- a/gulp/taskHelper.js
+++ b/gulp/taskHelper.js
@@ -2,7 +2,6 @@ import { exec }                   from 'child_process';
 import psTree                     from 'ps-tree';
 import nconf                      from 'nconf';
 import net                        from 'net';
-import Bluebird                   from 'bluebird';
 import { post }                   from 'superagent';
 import { sync as glob }           from 'glob';
 import Mocha                      from 'mocha';
@@ -45,7 +44,7 @@ export function kill (proc) {
 * before failing.
 */
 export function awaitPort (port, max = 60) {
-  return new Bluebird((rej, res) => {
+  return new Promise((rej, res) => {
    let socket;
    let timeout;
    let interval;
--- a/migrations/archive/2016/20160529_fix_challenges.js
+++ b/migrations/archive/2016/20160529_fix_challenges.js
@@ -16,7 +16,6 @@
 const authorName = 'Blade';
 const authorUuid = '75f270e8-c5db-4722-a5e6-a83f1b23f76b';

-global.Promise = require('bluebird');
 const MongoClient = require('mongodb').MongoClient;
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
--- a/migrations/archive/2016/20160530_fix_tasks_from_null_value_in_challenges_broken.js
+++ b/migrations/archive/2016/20160530_fix_tasks_from_null_value_in_challenges_broken.js
@@ -11,7 +11,6 @@
 * pm'ed each user asking if they would like their tasks reset to the previous day
 ***************************************/

-global.Promise = require('bluebird');
 const MongoClient = require('mongodb').MongoClient;
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
--- a/migrations/archive/2016/20160602_convert_quest_collection.js
+++ b/migrations/archive/2016/20160602_convert_quest_collection.js
@@ -12,7 +12,6 @@
 * from an object to a number, hence this migration.
 ***************************************/

-global.Promise = require('bluebird');
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
 const Timer = require('./utils/timer');
--- a/migrations/archive/2016/20160605_convert_quest_collection_again.js
+++ b/migrations/archive/2016/20160605_convert_quest_collection_again.js
@@ -9,7 +9,6 @@
 * and transfers a group's progress to it
 ***************************************/

-global.Promise = require('bluebird');
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
 const Timer = require('./utils/timer');
--- a/migrations/archive/2016/20160615_fix_bad_emails.js
+++ b/migrations/archive/2016/20160615_fix_bad_emails.js
@@ -12,7 +12,6 @@
 * <userid>@example.com
 ***************************************/

-global.Promise = require('bluebird');
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
 const Timer = require('./utils/timer');
--- a/migrations/archive/2016/20161002_add_missing_webhook_type.js
+++ b/migrations/archive/2016/20161002_add_missing_webhook_type.js
@@ -9,7 +9,6 @@
 * they support a type and options and label
 * ***************************************/

-global.Promise = require('bluebird');
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
 const Timer = require('./utils/timer');
--- a/migrations/archive/2017/20170111_announce_collection_quest_change_in_parties.js
+++ b/migrations/archive/2017/20170111_announce_collection_quest_change_in_parties.js
@@ -12,7 +12,6 @@
 * message into the chat for affected parties.
 ***************************************/

-global.Promise = require('bluebird');
 const uuid = require('uuid');
 const TaskQueue = require('cwait').TaskQueue;
 const logger = require('./utils/logger');
@@ -20,7 +19,7 @@ const Timer = require('./utils/timer');
 const connectToDb = require('./utils/connect').connectToDb;
 const closeDb = require('./utils/connect').closeDb;

-const message = '`This party\'s collection quest has been made easier! For details, refer to http://habitica.wikia.com/wiki/User_blog:LadyAlys/Collection_Quests_are_Now_Easier`';
+const message = '`This party\'s collection quest has been made easier! For details, refer to http://habitica.fandom.com/wiki/User_blog:LadyAlys/Collection_Quests_are_Now_Easier`';

 const timer = new Timer();

--- a/migrations/archive/2017/20171211_sanitize_emails.js
+++ b/migrations/archive/2017/20171211_sanitize_emails.js
@@ -0,0 +1,88 @@
+var migrationName = '20171211_sanitize_emails.js';
+var authorName = 'Julius'; // in case script author needs to know when their ...
+var authorUuid = 'dd16c270-1d6d-44bd-b4f9-737342e79be6'; //... own data is done
+
+/*
+  User creation saves email as lowercase, but updating an email did not.
+  Run this script to ensure all lowercased emails in db AFTER fix for updating emails is implemented.
+  This will fix inconsistent querying for an email when attempting to password reset.
+*/
+
+var monk = require('monk');
+var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+var dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers(lastId) {
+  var query = {
+    'auth.local.email': /[A-Z]/
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId
+    }
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [ // specify fields we are interested in to limit retrieved data (empty if we're not reading data)
+      'auth.local.email'
+    ],
+  })
+  .then(updateUsers)
+  .catch(function (err) {
+    console.log(err);
+    return exiting(1, 'ERROR! ' + err);
+  });
+}
+
+var progressCount = 1000;
+var count = 0;
+
+function updateUsers (users) {
+  if (!users || users.length === 0) {
+    console.warn('All appropriate users found and modified.');
+    displayData();
+    return;
+  }
+
+  var userPromises = users.map(updateUser);
+  var lastUser = users[users.length - 1];
+
+  return Promise.all(userPromises)
+  .then(function () {
+    processUsers(lastUser._id);
+  });
+}
+
+function updateUser (user) {
+  count++;
+
+  var push;
+  var set = {
+    'auth.local.email': user.auth.local.email.toLowerCase()
+  };
+
+  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;
--- a/migrations/archive/2018/20180724_summer_splash_orcas.js
+++ b/migrations/archive/2018/20180724_summer_splash_orcas.js
@@ -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;
--- a/migrations/archive/2018/20180731_naming_day.js
+++ b/migrations/archive/2018/20180731_naming_day.js
@@ -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;
--- a/migrations/archive/2018/20180811_inboxOutsideUser.js
+++ b/migrations/archive/2018/20180811_inboxOutsideUser.js
@@ -0,0 +1,147 @@
+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 uuid = require('uuid').v4;
+
+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();
+  });
+
+  const promises = newInboxMessages.map(newMsg => {
+    return (async function fn () {
+      const existing = await dbInboxes.find({_id: newMsg._id});
+
+      if (existing.length > 0) {
+        if (
+          existing[0].ownerId === newMsg.ownerId &&
+          existing[0].text === newMsg.text &&
+          existing[0].uuid === newMsg.uuid &&
+          existing[0].sent === newMsg.sent
+        ) {
+          return null;
+        }
+
+        newMsg.id = newMsg._id = uuid();
+      }
+
+      return newMsg;
+    })();
+  });
+
+  return Promise.all(promises)
+    .then((filteredNewMsg) => {
+      filteredNewMsg = filteredNewMsg.filter(m => Boolean(m && m.id && m._id && m.id == m._id));
+      return dbInboxes.insert(filteredNewMsg);
+    }).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;
--- a/migrations/archive/2018/20181001_generate_usernames.js
+++ b/migrations/archive/2018/20181001_generate_usernames.js
@@ -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;
--- a/migrations/archive/2018/20181002_username_email.js
+++ b/migrations/archive/2018/20181002_username_email.js
@@ -0,0 +1,107 @@
+const MIGRATION_NAME = '20181003_username_email.js';
+let authorName = 'Sabe'; // in case script author needs to know when their ...
+let authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Send emails to eligible users announcing upcoming username changes
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+import { sendTxn } from '../../website/server/libs/email';
+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: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-04-01')},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 100,
+    fields: [
+      '_id',
+      'auth',
+      'preferences',
+      'profile',
+    ], // 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(() => delay(7000))
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  dbUsers.update({_id: user._id}, {$set: {migration: MIGRATION_NAME}});
+
+  sendTxn(
+    user,
+    'username-change',
+    [{name: 'UNSUB_EMAIL_TYPE_URL', content: '/user/settings/notifications?unsubFrom=importantAnnouncements'},
+     {name: 'LOGIN_NAME', content: user.auth.local.username}]
+  );
+
+  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 delay (t, v) {
+  return new Promise(function batchPause (resolve) {
+    setTimeout(resolve.bind(null, v), t);
+  });
+}
+
+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;
--- a/migrations/archive/2018/20181023_veteran_pet_ladder.js
+++ b/migrations/archive/2018/20181023_veteran_pet_ladder.js
@@ -0,0 +1,66 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20181023_veteran_pet_ladder';
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+
+  set.migration = MIGRATION_NAME;
+
+  if (user.items.pets['Bear-Veteran']) {
+    set['items.pets.Fox-Veteran'] = 5;
+  } else if (user.items.pets['Lion-Veteran']) {
+    set['items.pets.Bear-Veteran'] = 5;
+  } else if (user.items.pets['Tiger-Veteran']) {
+    set['items.pets.Lion-Veteran'] = 5;
+  } else if (user.items.pets['Wolf-Veteran']) {
+    set['items.pets.Tiger-Veteran'] = 5;
+  } else {
+    set['items.pets.Wolf-Veteran'] = 5;
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'flags.verifiedUsername': true,
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+    migration: 1,
+    flags: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2018/20181030_habitoween_ladder.js
+++ b/migrations/archive/2018/20181030_habitoween_ladder.js
@@ -0,0 +1,116 @@
+/*
+ * Award Habitoween ladder items to participants in this month's Habitoween festivities
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+const MIGRATION_NAME = '20181030_habitoween_ladder.js'; // Update when running in future years
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+const AUTHOR_NAME = 'Sabe'; // in case script author needs to know when their ...
+const AUTHOR_UUID = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+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: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-10-01')},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+      '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}`);
+    });
+}
+
+const PROGRESS_COUNT = 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 inc = {
+    'items.food.Candy_Skeleton': 1,
+    'items.food.Candy_Base': 1,
+    'items.food.Candy_CottonCandyBlue': 1,
+    'items.food.Candy_CottonCandyPink': 1,
+    'items.food.Candy_Shade': 1,
+    'items.food.Candy_White': 1,
+    'items.food.Candy_Golden': 1,
+    'items.food.Candy_Zombie': 1,
+    'items.food.Candy_Desert': 1,
+    'items.food.Candy_Red': 1,
+  };
+
+  if (user && user.items && user.items.pets && user.items.mounts['JackOLantern-Ghost']) {
+    set['items.pets.JackOLantern-Glow'] = 5;
+  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Ghost']) {
+    set['items.mounts.JackOLantern-Ghost'] = true;
+  } else if (user && user.items && user.items.mounts && user.items.mounts['JackOLantern-Base']) {
+    set['items.pets.JackOLantern-Ghost'] = 5;
+  } else if (user && user.items && user.items.pets && user.items.pets['JackOLantern-Base']) {
+    set['items.mounts.JackOLantern-Base'] = true;
+  } else {
+    set['items.pets.JackOLantern-Base'] = 5;
+  }
+
+  dbUsers.update({_id: user._id}, {$set: set, $inc: inc});
+
+  if (count % PROGRESS_COUNT === 0) console.warn(`${count} ${user._id}`);
+  if (user._id === AUTHOR_UUID) console.warn(`${AUTHOR_NAME} 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;
--- a/migrations/archive/2018/20181108_username_email.js
+++ b/migrations/archive/2018/20181108_username_email.js
@@ -0,0 +1,109 @@
+const MIGRATION_NAME = '20181108_username_email.js';
+const AUTHOR_NAME = 'Sabe'; // in case script author needs to know when their ...
+const AUTHOR_UUID = '7f14ed62-5408-4e1b-be83-ada62d504931'; // ... own data is done
+
+/*
+ * Send emails to eligible users announcing upcoming username changes
+ */
+
+import monk from 'monk';
+import nconf from 'nconf';
+import { sendTxn } from '../../../website/server/libs/email';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+const BASE_URL = nconf.get('BASE_URL');
+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: MIGRATION_NAME},
+    'flags.verifiedUsername': {$ne: true},
+    'auth.timestamps.loggedin': {$gt: new Date('2018-10-25')},
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 100,
+    fields: [
+      '_id',
+      'auth',
+      'preferences',
+      'profile',
+    ], // 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(() => delay(7000))
+    .then(() => {
+      processUsers(lastUser._id);
+    });
+}
+
+function updateUser (user) {
+  count++;
+
+  dbUsers.update({_id: user._id}, {$set: {migration: MIGRATION_NAME}});
+
+  sendTxn(
+    user,
+    'username-change-follow-up',
+    [{name: 'LOGIN_NAME', content: user.auth.local.username},
+     {name: 'BASE_URL', content: BASE_URL}]
+  );
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+  if (user._id === AUTHOR_UUID) console.warn(`${AUTHOR_NAME} processed`);
+}
+
+function displayData () {
+  console.warn(`\n${count} users processed\n`);
+  return exiting(0);
+}
+
+function delay (t, v) {
+  return new Promise(function batchPause (resolve) {
+    setTimeout(resolve.bind(null, v), t);
+  });
+}
+
+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;
--- a/migrations/archive/2018/20181122_turkey_day.js
+++ b/migrations/archive/2018/20181122_turkey_day.js
@@ -0,0 +1,109 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20181122_turkey_day';
+import mongoose from 'mongoose';
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.armor_special_turkeyArmorBase !== 'undefined') {
+    set['items.gear.owned.head_special_turkeyHelmGilded'] = false;
+    set['items.gear.owned.armor_special_turkeyArmorGilded'] = false;
+    set['items.gear.owned.back_special_turkeyTailGilded'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_turkeyHelmGilded',
+        _id: new mongoose.Types.ObjectId(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.armor_special_turkeyArmorGilded',
+        _id: new mongoose.Types.ObjectId(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.back_special_turkeyTailGilded',
+        _id: new mongoose.Types.ObjectId(),
+      },
+    ];
+  } else if (user.items && user.items.mounts && user.items.mounts['Turkey-Gilded']) {
+    set['items.gear.owned.head_special_turkeyHelmBase'] = false;
+    set['items.gear.owned.armor_special_turkeyArmorBase'] = false;
+    set['items.gear.owned.back_special_turkeyTailBase'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_turkeyHelmBase',
+        _id: new mongoose.Types.ObjectId(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.armor_special_turkeyArmorBase',
+        _id: new mongoose.Types.ObjectId(),
+      },
+      {
+        type: 'marketGear',
+        path: 'gear.flat.back_special_turkeyTailBase',
+        _id: new mongoose.Types.ObjectId(),
+      },
+    ];
+  } else if (user.items && user.items.pets && user.items.pets['Turkey-Gilded']) {
+    set['items.mounts.Turkey-Gilded'] = true;
+  } else if (user.items && user.items.mounts && user.items.mounts['Turkey-Base']) {
+    set['items.pets.Turkey-Gilded'] = 5;
+  } else if (user.items && user.items.pets && user.items.pets['Turkey-Base']) {
+    set['items.mounts.Turkey-Base'] = true;
+  } else {
+    set['items.pets.Turkey-Base'] = 5;
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  if (push) {
+    return await User.update({_id: user._id}, {$set: set, $push: {pinnedItems: {$each: push}}}).exec();
+  } else {
+    return await User.update({_id: user._id}, {$set: set}).exec();
+  }
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2018/20181231_nye.js
+++ b/migrations/archive/2018/20181231_nye.js
@@ -0,0 +1,110 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20181231_nye';
+import { model as User } from '../../../website/server/models/user';
+import mongoose from 'mongoose';
+import { v4 as uuid } from 'uuid';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {'flags.newStuff': true};
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.head_special_nye2017 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2018'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2018',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2016 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2017'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2017',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2015 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2016'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2016',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye2014 !== 'undefined') {
+    set['items.gear.owned.head_special_nye2015'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2015',
+        _id: uuid(),
+      },
+    ];
+  } else if (typeof user.items.gear.owned.head_special_nye !== 'undefined') {
+    set['items.gear.owned.head_special_nye2014'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye2014',
+        _id: uuid(),
+      },
+    ];
+  } else {
+    set['items.gear.owned.head_special_nye'] = false;
+    push = [
+      {
+        type: 'marketGear',
+        path: 'gear.flat.head_special_nye',
+        _id: uuid(),
+      },
+    ];
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set, $push: {pinnedItems: {$each: push}}}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190131_habit_birthday.js
+++ b/migrations/archive/2019/20190131_habit_birthday.js
@@ -0,0 +1,88 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190131_habit_birthday';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const inc = {
+    'items.food.Cake_Skeleton': 1,
+    'items.food.Cake_Base': 1,
+    'items.food.Cake_CottonCandyBlue': 1,
+    'items.food.Cake_CottonCandyPink': 1,
+    'items.food.Cake_Shade': 1,
+    'items.food.Cake_White': 1,
+    'items.food.Cake_Golden': 1,
+    'items.food.Cake_Zombie': 1,
+    'items.food.Cake_Desert': 1,
+    'items.food.Cake_Red': 1,
+    'achievements.habitBirthdays': 1,
+  };
+  const set = {};
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.armor_special_birthday2018 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2019'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2019', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2017 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2018'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2018', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2016 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2017'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2017', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday2015 !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2016'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2016', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_birthday !== 'undefined') {
+    set['items.gear.owned.armor_special_birthday2015'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday2015', _id: uuid()}};
+  } else {
+    set['items.gear.owned.armor_special_birthday'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_birthday', _id: uuid()}};
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$inc: inc, $set: set, $push: push}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2019-01-15')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190530_halfmoon_glasses.js
+++ b/migrations/archive/2019/20190530_halfmoon_glasses.js
@@ -0,0 +1,62 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190530_halfmoon_glasses';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {
+    'items.gear.owned.eyewear_special_blackHalfMoon': true,
+    'items.gear.owned.eyewear_special_blueHalfMoon': true,
+    'items.gear.owned.eyewear_special_greenHalfMoon': true,
+    'items.gear.owned.eyewear_special_pinkHalfMoon': true,
+    'items.gear.owned.eyewear_special_redHalfMoon': true,
+    'items.gear.owned.eyewear_special_whiteHalfMoon': true,
+    'items.gear.owned.eyewear_special_yellowHalfMoon': true,
+  };
+
+  set.migration = MIGRATION_NAME;
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2019-05-01')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190618_summer_splash_orcas.js
+++ b/migrations/archive/2019/20190618_summer_splash_orcas.js
@@ -0,0 +1,59 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190618_summer_splash_orcas';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  let set;
+
+  if (user && user.items && user.items.pets && typeof user.items.pets['Orca-Base'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME };
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Orca-Base'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.pets.Orca-Base': 5 };
+  } else {
+    set = { migration: MIGRATION_NAME, 'items.mounts.Orca-Base': true };
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({ _id: user._id }, { $set: set }).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2019-05-18')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190716_groups_fix.js
+++ b/migrations/archive/2019/20190716_groups_fix.js
@@ -0,0 +1,84 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190716_groups_fix';
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+let backupUsers;
+
+async function updateUser (user) {
+  count++;
+
+  let set = { migration: MIGRATION_NAME };
+  let addToSet;
+
+  const monkPromise = new Promise((resolve, reject) => {
+     backupUsers.findOne(
+      { _id: user._id },
+      { fields: { _id: 1, party: 1, guilds: 1 }},
+    ).then(foundUserInBackup => {
+      resolve(foundUserInBackup);
+    }).catch(e => {
+      reject(e);
+    })
+  });
+  let backupUser = await monkPromise;
+  if (!backupUser) return;
+
+  if (!user.party._id) {
+    set.party = backupUser.party;
+  }
+  addToSet = { guilds: { $each: backupUser.guilds }};
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return User.update({ _id: user._id }, { $set: set, $addToSet: addToSet }).exec();
+}
+
+module.exports = async function processUsers () {
+  const query = {
+    'auth.timestamps.loggedin': {$gt: new Date('2019-07-15')},
+  };
+
+  let backupDb = monk(CONNECTION_STRING);
+  const backupDbPromise = new Promise((resolve, reject) => {
+    backupDb.then(() => resolve()).catch((e) => reject(e));
+  });
+
+  await backupDbPromise;
+  console.log('Connected to backup db');
+  backupUsers = backupDb.get('users', { castIds: false });
+
+  const fields = {
+    _id: 1,
+    party: 1,
+    guilds: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190717_groups_fix_2.js
+++ b/migrations/archive/2019/20190717_groups_fix_2.js
@@ -0,0 +1,88 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190717_groups_fix_2';
+
+import monk from 'monk';
+import nconf from 'nconf';
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+
+import { model as User } from '../../../website/server/models/user';
+import { sendTxn as sendTxnEmail } from '../../../website/server/libs/email';
+import shared from '../../../website/common';
+
+const questScrolls = shared.content.quests;
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateGroup (group) {
+  count++;
+
+  if (group && group.quest && group.quest.key && group.quest.leader) {
+    const quest = questScrolls[group.quest.key];
+    const leader = await User.findOne({_id: group.quest.leader}).exec();
+
+    if (leader && quest) {
+      await User.update({ 
+        _id: leader._id,
+        migration: {$ne: MIGRATION_NAME},
+      }, {
+        $set: {migration: MIGRATION_NAME},
+        $inc: { 
+          balance: 1,
+          [`items.quests.${group.quest.key}`]: 1,
+        },
+      }).exec();
+
+      // unsubscribe from all is already checked by sendTxnEmail
+      if (leader.preferences && leader.preferences.emailNotifications && leader.preferences.emailNotifications.majorUpdates !== false) {
+        sendTxnEmail(leader, 'groups-outage');
+      }
+    }
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${group._id}`);
+}
+
+module.exports = async function processUsers () {
+  const query = {
+    type: 'party'
+  };
+
+  let backupDb = monk(CONNECTION_STRING);
+  const backupDbPromise = new Promise((resolve, reject) => {
+    backupDb.then(() => resolve()).catch((e) => reject(e));
+  });
+
+  await backupDbPromise;
+  console.log('Connected to backup db');
+  const backupGroups = backupDb.get('groups', { castIds: false });
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const groupsPromise = new Promise((resolve, reject) => {
+      backupGroups
+      .find(query, {
+        limit: 250, 
+        sort: {_id: 1}
+      })
+      .then(foundGroupInBackup => {
+        resolve(foundGroupInBackup);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+
+    const groups = await groupsPromise;
+
+    if (groups.length === 0) {
+      console.warn('All appropriate groups found and modified.');
+      console.warn(`\n${count} groups processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: groups[groups.length - 1]._id,
+      };
+    }
+
+    await Promise.all(groups.map(updateGroup)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/2019/20190731_naming_day.js
+++ b/migrations/archive/2019/20190731_naming_day.js
@@ -0,0 +1,84 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190731_naming_day';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async 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.body_special_namingDay2018 !== 'undefined') {
+    set = { migration: MIGRATION_NAME };
+  } else if (user && user.items && user.items.gear && user.items.gear.owned && typeof user.items.gear.owned.head_special_namingDay2017 !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.gear.owned.body_special_namingDay2018': false };
+    push = { pinnedItems: { type: 'marketGear', path: 'gear.flat.body_special_namingDay2018', _id: uuid() }};
+  } else if (user && user.items && user.items.pets && typeof user.items.pets['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.gear.owned.head_special_namingDay2017': false };
+    push = { pinnedItems: { type: 'marketGear', path: 'gear.flat.head_special_namingDay2017', _id: uuid() }};
+  } else if (user && user.items && user.items.mounts && typeof user.items.mounts['Gryphon-RoyalPurple'] !== 'undefined') {
+    set = { migration: MIGRATION_NAME, 'items.pets.Gryphon-RoyalPurple': 5 };
+  } else {
+    set = { migration: MIGRATION_NAME, 'items.mounts.Gryphon-RoyalPurple': true };
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  if (push) {
+    return await User.update({ _id: user._id }, { $set: set, $inc: inc, $push: push }).exec();
+  } else {
+    return await User.update({ _id: user._id }, { $set: set, $inc: inc }).exec();
+  }
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: { $ne: MIGRATION_NAME },
+    'auth.timestamps.loggedin': { $gt: new Date('2019-07-01') },
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1]._id,
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/archive/README.md
+++ b/migrations/archive/README.md
@@ -1,4 +1,6 @@
 If you need to use a migration from this folder, move it to /migrations.

 Note that /migrations files (excluding /archive) are linted, so to pass test you'll have to make sure
-that the file is written correctly.
+that the file is written correctly.
+
+They might also be using some old deps that we don't use anymore like Bluebird, mongoskin, ...
--- a/migrations/archive/mystery-items-old.js
+++ b/migrations/archive/mystery-items-old.js
@@ -0,0 +1,110 @@
+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 = ['armor_mystery_201810', 'head_mystery_201810'];
+const CONNECTION_STRING = nconf.get('MIGRATION_CONNECT_STRING');
+
+let dbUsers = monk(CONNECTION_STRING).get('users', { castIds: false });
+let UserNotification = require('../../website/server/models/userNotification').model;
+
+function processUsers (lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  let query = {
+    migration: {$ne: migrationName},
+    'purchased.plan.customerId': { $ne: null },
+    $or: [
+      { 'purchased.plan.dateTerminated': { $gte: new Date() } },
+      { 'purchased.plan.dateTerminated': { $exists: false } },
+      { 'purchased.plan.dateTerminated': { $eq: null } },
+    ],
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId,
+    };
+  }
+
+  dbUsers.find(query, {
+    sort: {_id: 1},
+    limit: 250,
+    fields: [
+    ], // 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++;
+
+  const addToSet = {
+    'purchased.plan.mysteryItems': {
+      $each: MYSTERY_ITEMS,
+    },
+  };
+  const push = {
+    notifications: (new UserNotification({
+      type: 'NEW_MYSTERY_ITEMS',
+      data: {
+        MYSTERY_ITEMS,
+      },
+    })).toJSON(),
+  };
+
+  dbUsers.update({_id: user._id}, {$addToSet: addToSet, $push: push});
+
+  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;
--- a/migrations/archive/takeThis.js
+++ b/migrations/archive/takeThis.js
@@ -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) {
--- a/migrations/challenges/sync-all-challenges.js
+++ b/migrations/challenges/sync-all-challenges.js
@@ -1,5 +1,3 @@
-import Bluebird from 'Bluebird';
-
 import { model as Challenges } from '../../website/server/models/challenge';
 import { model as User } from '../../website/server/models/user';

@@ -17,10 +15,10 @@ async function syncChallengeToMembers (challenges) {
      promises.push(user.save());
    });

-    return Bluebird.all(promises);
+    return Promise.all(promises);
  });

-  return await Bluebird.all(challengSyncPromises);
+  return await Promise.all(challengSyncPromises);
 }

 async function syncChallenges (lastChallengeDate) {
--- a/migrations/groups/create-group.js
+++ b/migrations/groups/create-group.js
@@ -1,5 +1,3 @@
-import Bluebird from 'bluebird';
-
 import { model as Group } from '../../website/server/models/group';
 import { model as User } from '../../website/server/models/user';

@@ -16,7 +14,7 @@ async function createGroup (name, privacy, type, leaderId) {
  group.leader = user._id;
  user.guilds.push(group._id);

-  return Bluebird.all([group.save(), user.save()]);
+  return Promise.all([group.save(), user.save()]);
 }

 module.exports = async function groupCreator () {
--- a/migrations/groups/habitrpg-jackalopes.js
+++ b/migrations/groups/habitrpg-jackalopes.js
@@ -3,7 +3,6 @@
 /*
 * This migration will find users with unlimited subscriptions who are also eligible for Jackalope mounts, and award them
 */
-import Bluebird from 'bluebird';

 import { model as Group } from '../../website/server/models/group';
 import { model as User } from '../../website/server/models/user';
@@ -38,7 +37,7 @@ async function handOutJackalopes () {

  cursor.on('close', async () => {
    console.log('done');
-    return await Bluebird.all(promises);
+    return await Promise.all(promises);
  });
 }

--- a/migrations/groups/migrate-chat.js
+++ b/migrations/groups/migrate-chat.js
@@ -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;
--- a/migrations/groups/reconcile-group-plan-members.js
+++ b/migrations/groups/reconcile-group-plan-members.js
@@ -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;
--- a/migrations/groups/update-groups-with-group-plans.js
+++ b/migrations/groups/update-groups-with-group-plans.js
@@ -9,8 +9,6 @@ let authorUuid = ''; // ... own data is done
 * subscription to all members
 */

-import Bluebird from 'bluebird';
-
 import { model as Group } from '../../website/server/models/group';
 import * as payments from '../../website/server/libs/payments';

@@ -28,7 +26,7 @@ async function updateGroupsWithGroupPlans () {
  });

  cursor.on('close', async () => {
-    return await Bluebird.all(promises);
+    return await Promise.all(promises);
  });
 }

--- a/migrations/migration-runner.js
+++ b/migrations/migration-runner.js
@@ -1,14 +1,14 @@
 require('babel-register');
-require('babel-polyfill');

 // This file must use ES5, everything required can be in ES6

 function setUpServer () {
  const nconf = require('nconf'); // eslint-disable-line global-require, no-unused-vars
  const mongoose = require('mongoose'); // eslint-disable-line global-require, no-unused-vars
-  const Bluebird = require('bluebird'); // eslint-disable-line global-require, no-unused-vars
  const setupNconf = require('../website/server/libs/setupNconf'); // eslint-disable-line global-require
+
  setupNconf();
+
  // We require src/server and npt src/index because
  // 1. nconf is already setup
  // 2. we don't need clustering
@@ -17,5 +17,12 @@ function setUpServer () {
 setUpServer();

 // Replace this with your migration
-const processUsers = require('./20180125_clean_new_notifications.js');
-processUsers();
+const processUsers = require('');
+processUsers()
+  .then(function success () {
+    process.exit(0);
+  })
+  .catch(function failure (err) {
+    console.log(err);
+    process.exit(1);
+  });
--- a/migrations/s3-upload.js
+++ b/migrations/s3-upload.js
@@ -1,4 +1,3 @@
-let Bluebird = require('bluebird');
 let request = require('superagent');
 let last = require('lodash/last');
 let AWS = require('aws-sdk');
@@ -74,7 +73,7 @@ function uploadToS3 (start, end, filesUrls) {
  });
  console.log(promises.length);

-  return Bluebird.all(promises)
+  return Promise.all(promises)
    .then(() => {
      currentIndex += 50;
      uploadToS3(currentIndex, currentIndex + 50, filesUrls);
--- a/migrations/tasks/habits-one-history-entry-per-day-challenges.js
+++ b/migrations/tasks/habits-one-history-entry-per-day-challenges.js
@@ -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;
--- a/migrations/tasks/habits-one-history-entry-per-day-users.js
+++ b/migrations/tasks/habits-one-history-entry-per-day-users.js
@@ -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;
--- a/migrations/tasks/tasks-set-everyX.js
+++ b/migrations/tasks/tasks-set-everyX.js
@@ -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) {
--- a/migrations/users/bulk-email.js
+++ b/migrations/users/bulk-email.js
@@ -0,0 +1,61 @@
+/* eslint-disable no-console */
+import { sendTxn } from '../../website/server/libs/email';
+import { model as User } from '../../website/server/models/user';
+import moment from 'moment';
+import nconf from 'nconf';
+const BASE_URL = nconf.get('BASE_URL');
+const EMAIL_SLUG = 'mandrill-email-slug'; // Set email template to send
+const MIGRATION_NAME = 'bulk-email';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  sendTxn(
+    user,
+    EMAIL_SLUG,
+    [{name: 'BASE_URL', content: BASE_URL}] // Add variables from template
+  );
+
+  return await User.update({_id: user._id}, {$set: {migration: MIGRATION_NAME}}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: moment().subtract(2, 'weeks').toDate()}, // customize or remove to target different populations
+  };
+
+  const fields = {
+    _id: 1,
+    auth: 1,
+    preferences: 1,
+    profile: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/users/full-stable.js
+++ b/migrations/users/full-stable.js
@@ -0,0 +1,84 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = 'full-stable';
+import each from 'lodash/each';
+import keys from 'lodash/keys';
+import content from '../../website/common/script/content/index';
+
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+/*
+ * Award users every extant pet and mount
+ */
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+
+  set.migration = MIGRATION_NAME;
+
+  each(keys(content.pets), (pet) => {
+    set[`items.pets.${pet}`] = 5;
+  });
+  each(keys(content.premiumPets), (pet) => {
+    set[`items.pets.${pet}`] = 5;
+  });
+  each(keys(content.questPets), (pet) => {
+    set[`items.pets.${pet}`] = 5;
+  });
+  each(keys(content.specialPets), (pet) => {
+    set[`items.pets.${pet}`] = 5;
+  });
+  each(keys(content.mounts), (mount) => {
+    set[`items.mounts.${mount}`] = true;
+  });
+  each(keys(content.premiumMounts), (mount) => {
+    set[`items.mounts.${mount}`] = true;
+  });
+  each(keys(content.questMounts), (mount) => {
+    set[`items.mounts.${mount}`] = true;
+  });
+  each(keys(content.specialMounts), (mount) => {
+    set[`items.mounts.${mount}`] = true;
+  });
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$set: set}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.local.username': 'olson22',
+  };
+
+  const fields = {
+    _id: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/users/mystery-items.js
+++ b/migrations/users/mystery-items.js
@@ -1,68 +1,13 @@
-const migrationName = 'mystery-items-201802.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
+/* eslint-disable no-console */
+const MIGRATION_NAME = 'mystery_items_201907';
+const MYSTERY_ITEMS = ['head_mystery_201907', 'armor_mystery_201907', 'eyewear_mystery_201907'];
+import { model as User } from '../../website/server/models/user';
+import { model as UserNotification } from '../../website/server/models/userNotification';

-/*
- * Award this month's mystery items to subscribers
- */
-const MYSTERY_ITEMS = ['armor_mystery_201802', 'head_mystery_201802', 'shield_mystery_201802'];
-const connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
-
-let monk = require('monk');
-let dbUsers = monk(connectionString).get('users', { castIds: false });
-let UserNotification = require('../../website/server/models/userNotification').model;
-
-function processUsers (lastId) {
-  // specify a query to limit the affected users (empty for all users):
-  let query = {
-    migration: {$ne: migrationName},
-    'purchased.plan.customerId': { $ne: null },
-    $or: [
-      { 'purchased.plan.dateTerminated': { $gte: new Date() } },
-      { 'purchased.plan.dateTerminated': { $exists: false } },
-      { 'purchased.plan.dateTerminated': { $eq: null } },
-    ],
-  };
-
-  if (lastId) {
-    query._id = {
-      $gt: lastId,
-    };
-  }
-
-  dbUsers.find(query, {
-    sort: {_id: 1},
-    limit: 250,
-    fields: [
-    ], // 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;
+const 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) {
+async function updateUser (user) {
  count++;

  const addToSet = {
@@ -78,31 +23,49 @@ function updateUser (user) {
      },
    })).toJSON(),
  };
+  const set = {
+    migration: MIGRATION_NAME,
+  };

-  dbUsers.update({_id: user._id}, {$addToSet: addToSet, $push: push});
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);

-  if (count % progressCount === 0) console.warn(`${count  } ${  user._id}`);
-  if (user._id === authorUuid) console.warn(`${authorName  } processed`);
+  return await User.update({_id: user._id}, {$set: set, $push: push, $addToSet: addToSet}).exec();
 }

-function displayData () {
-  console.warn(`\n${  count  } users processed\n`);
-  return exiting(0);
-}
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'purchased.plan.customerId': { $ne: null },
+    $or: [
+      { 'purchased.plan.dateTerminated': { $gte: new Date() } },
+      { 'purchased.plan.dateTerminated': { $exists: false } },
+      { 'purchased.plan.dateTerminated': { $eq: null } },
+    ],
+  };

-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);
+  const fields = {
+    _id: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
    }
-  }
-  process.exit(code);
-}

-module.exports = processUsers;
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/users/pi-day.js
+++ b/migrations/users/pi-day.js
@@ -0,0 +1,73 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20190314_pi_day';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const inc = {
+    'items.food.Pie_Skeleton': 1,
+    'items.food.Pie_Base': 1,
+    'items.food.Pie_CottonCandyBlue': 1,
+    'items.food.Pie_CottonCandyPink': 1,
+    'items.food.Pie_Shade': 1,
+    'items.food.Pie_White': 1,
+    'items.food.Pie_Golden': 1,
+    'items.food.Pie_Zombie': 1,
+    'items.food.Pie_Desert': 1,
+    'items.food.Pie_Red': 1,
+  };
+  const set = {};
+
+  set.migration = MIGRATION_NAME;
+
+  set['items.gear.owned.head_special_piDay'] = false;
+  set['items.gear.owned.shield_special_piDay'] = false;
+  const push = [
+    {type: 'marketGear', path: 'gear.flat.head_special_piDay', _id: uuid()},
+    {type: 'marketGear', path: 'gear.flat.shield_special_piDay', _id: uuid()},
+  ];
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  return await User.update({_id: user._id}, {$inc: inc, $set: set, $push: {pinnedItems: {$each: push}}}).exec();
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    'auth.timestamps.loggedin': {$gt: new Date('2019-02-15')},
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/migrations/users/remove-social-users-extra-data.js
+++ b/migrations/users/remove-social-users-extra-data.js
@@ -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;
--- a/migrations/users/take-this.js
+++ b/migrations/users/take-this.js
@@ -0,0 +1,81 @@
+/* eslint-disable no-console */
+const MIGRATION_NAME = '20181203_take_this';
+import { v4 as uuid } from 'uuid';
+
+import { model as User } from '../../website/server/models/user';
+
+const progressCount = 1000;
+let count = 0;
+
+async function updateUser (user) {
+  count++;
+
+  const set = {};
+  let push;
+
+  set.migration = MIGRATION_NAME;
+
+  if (typeof user.items.gear.owned.back_special_takeThis !== 'undefined') {
+    push = false;
+  } else if (typeof user.items.gear.owned.body_special_takeThis !== 'undefined') {
+    set['items.gear.owned.back_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.back_special_takeThis', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.head_special_takeThis !== 'undefined') {
+    set['items.gear.owned.body_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.body_special_takeThis', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.armor_special_takeThis !== 'undefined') {
+    set['items.gear.owned.head_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.head_special_takeThis', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.weapon_special_takeThis !== 'undefined') {
+    set['items.gear.owned.armor_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.armor_special_takeThis', _id: uuid()}};
+  } else if (typeof user.items.gear.owned.shield_special_takeThis !== 'undefined') {
+    set['items.gear.owned.weapon_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.weapon_special_takeThis', _id: uuid()}};
+  } else {
+    set['items.gear.owned.shield_special_takeThis'] = false;
+    push = {pinnedItems: {type: 'marketGear', path: 'gear.flat.shield_special_takeThis', _id: uuid()}};
+  }
+
+  if (count % progressCount === 0) console.warn(`${count} ${user._id}`);
+
+  if (push) {
+    return await User.update({_id: user._id}, {$set: set, $push: push}).exec();
+  } else {
+    return await User.update({_id: user._id}, {$set: set}).exec();
+  }
+}
+
+module.exports = async function processUsers () {
+  let query = {
+    migration: {$ne: MIGRATION_NAME},
+    challenges: '00708425-d477-41a5-bf27-6270466e7976',
+  };
+
+  const fields = {
+    _id: 1,
+    items: 1,
+  };
+
+  while (true) { // eslint-disable-line no-constant-condition
+    const users = await User // eslint-disable-line no-await-in-loop
+      .find(query)
+      .limit(250)
+      .sort({_id: 1})
+      .select(fields)
+      .lean()
+      .exec();
+
+    if (users.length === 0) {
+      console.warn('All appropriate users found and modified.');
+      console.warn(`\n${count} users processed\n`);
+      break;
+    } else {
+      query._id = {
+        $gt: users[users.length - 1],
+      };
+    }
+
+    await Promise.all(users.map(updateUser)); // eslint-disable-line no-await-in-loop
+  }
+};
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,129 +1,133 @@
 {
  "name": "habitica",
  "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "4.31.1",
+  "version": "4.106.2",
  "main": "./website/server/index.js",
  "dependencies": {
+    "@google-cloud/trace-agent": "^4.0.0",
    "@slack/client": "^3.8.1",
    "accepts": "^1.3.5",
-    "amazon-payments": "^0.2.6",
+    "amazon-payments": "^0.2.7",
    "amplitude": "^3.5.0",
+    "amplitude-js": "^5.0.0",
    "apidoc": "^0.17.5",
-    "autoprefixer": "^8.1.0",
-    "aws-sdk": "^2.209.0",
-    "axios": "^0.18.0",
-    "axios-progress-bar": "^1.1.8",
-    "babel-core": "^6.0.0",
-    "babel-eslint": "^8.2.2",
+    "apn": "^2.2.0",
+    "autoprefixer": "^9.4.0",
+    "aws-sdk": "^2.432.0",
+    "axios": "^0.19.0",
+    "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-async-to-module-method": "^6.8.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",
-    "bluebird": "^3.3.5",
-    "body-parser": "^1.15.0",
-    "bootstrap": "^4.0.0",
-    "bootstrap-vue": "^2.0.0-rc.2",
-    "compression": "^1.7.2",
-    "cookie-session": "^1.2.0",
+    "bcrypt": "^3.0.5",
+    "body-parser": "^1.18.3",
+    "bootstrap": "^4.1.1",
+    "bootstrap-vue": "^2.0.0-rc.18",
+    "compression": "^1.7.4",
+    "cookie-session": "^1.3.3",
    "coupon-code": "^0.4.5",
-    "cross-env": "^5.1.4",
-    "css-loader": "^0.28.0",
-    "csv-stringify": "^2.0.4",
+    "cross-env": "^5.2.0",
+    "css-loader": "^0.28.11",
+    "csv-stringify": "^5.1.0",
    "cwait": "^1.1.1",
    "domain-middleware": "~0.1.0",
    "express": "^4.16.3",
-    "express-basic-auth": "^1.1.4",
-    "express-validator": "^5.0.3",
+    "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",
-    "gulp-nodemon": "^2.2.1",
+    "gulp-imagemin": "^6.0.0",
+    "gulp-nodemon": "^2.4.1",
    "gulp.spritesmith": "^6.9.0",
    "habitica-markdown": "^1.3.0",
-    "hellojs": "^1.15.1",
-    "html-webpack-plugin": "^2.8.1",
-    "image-size": "^0.6.2",
-    "in-app-purchase": "^1.8.9",
-    "intro.js": "^2.6.0",
+    "hellojs": "^1.18.1",
+    "html-webpack-plugin": "^3.2.0",
+    "image-size": "^0.7.0",
+    "in-app-purchase": "^1.11.3",
+    "intro.js": "^2.9.3",
    "jquery": ">=3.0.0",
-    "js2xmlparser": "^3.0.0",
-    "lodash": "^4.17.4",
-    "merge-stream": "^1.0.0",
-    "method-override": "^2.3.5",
-    "moment": "^2.21.0",
+    "js2xmlparser": "^4.0.0",
+    "lodash": "^4.17.10",
+    "merge-stream": "^2.0.0",
+    "method-override": "^3.0.0",
+    "moment": "^2.22.1",
    "moment-recur": "^1.0.7",
-    "mongoose": "^5.0.10",
+    "mongoose": "^5.4.19",
    "morgan": "^1.7.0",
    "nconf": "^0.10.0",
-    "node-gcm": "^0.14.4",
-    "node-sass": "^4.8.2",
-    "nodemailer": "^4.6.3",
-    "ora": "^2.0.0",
-    "pageres": "^4.1.1",
+    "node-gcm": "^1.0.2",
+    "node-sass": "^4.9.0",
+    "ora": "^3.2.0",
+    "pageres": "^5.1.0",
    "passport": "^0.4.0",
    "passport-facebook": "^2.0.0",
    "passport-google-oauth20": "1.0.0",
    "paypal-ipn": "3.0.0",
    "paypal-rest-sdk": "^1.8.1",
-    "popper.js": "^1.14.1",
+    "popper.js": "^1.14.3",
    "postcss-easy-import": "^3.0.0",
    "ps-tree": "^1.0.0",
-    "pug": "^2.0.1",
-    "push-notify": "git://github.com/habitrpg/push-notify.git#6bc2b5fdb1bdc9649b9ec1964d79ca50187fc8a9",
-    "pusher": "^1.3.0",
+    "pug": "^2.0.3",
    "rimraf": "^2.4.3",
-    "sass-loader": "^6.0.7",
-    "shelljs": "^0.8.1",
-    "stackimpact": "^1.2.1",
-    "stripe": "^5.5.0",
-    "superagent": "^3.4.3",
+    "sass-loader": "^7.0.3",
+    "shelljs": "^0.8.2",
+    "short-uuid": "^3.0.0",
+    "smartbanner.js": "^1.11.0",
+    "stripe": "^5.9.0",
+    "superagent": "^5.0.2",
    "svg-inline-loader": "^0.8.0",
-    "svg-url-loader": "^2.3.2",
-    "svgo": "^1.0.5",
+    "svg-url-loader": "^3.0.0",
+    "svgo": "^1.2.0",
    "svgo-loader": "^2.1.0",
-    "universal-analytics": "^0.4.16",
-    "url-loader": "^0.6.2",
+    "universal-analytics": "^0.4.17",
+    "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": "^11.0.0",
    "vinyl-buffer": "^1.0.1",
-    "vue": "^2.5.16",
-    "vue-loader": "^14.2.1",
+    "vue": "^2.6.10",
+    "vue-loader": "^14.2.2",
    "vue-mugen-scroll": "^0.2.1",
    "vue-router": "^3.0.0",
-    "vue-style-loader": "^4.0.2",
-    "vue-template-compiler": "^2.5.16",
-    "vuedraggable": "^2.15.0",
+    "vue-style-loader": "^4.1.0",
+    "vue-template-compiler": "^2.6.10",
+    "vuedraggable": "^2.20.0",
    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker.git#5d237615463a84a23dd6f3f77c6ab577d68593ec",
-    "webpack": "^3.11.0",
-    "webpack-merge": "^4.0.0",
-    "winston": "^2.4.1",
+    "webpack": "^3.12.0",
+    "webpack-merge": "^4.1.3",
+    "winston": "^2.4.3",
    "winston-loggly-bulk": "^2.0.2",
    "xml2js": "^0.4.4"
  },
  "private": true,
  "engines": {
-    "node": "^6.9.1",
-    "npm": "^5.0.0"
+    "node": "^10",
+    "npm": "^6"
  },
  "scripts": {
    "lint": "eslint --ext .js,.vue .",
    "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,51 +145,51 @@
    "apidoc": "gulp apidoc"
  },
  "devDependencies": {
+    "@vue/test-utils": "^1.0.0-beta.29",
    "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.36.0",
+    "chalk": "^2.4.1",
+    "chromedriver": "^76.0.0",
    "connect-history-api-fallback": "^1.1.0",
-    "coveralls": "^3.0.0",
+    "coveralls": "^3.0.3",
    "cross-spawn": "^6.0.5",
-    "eslint": "^4.18.2",
+    "eslint": "^4.19.1",
    "eslint-config-habitrpg": "^4.0.0",
-    "eslint-friendly-formatter": "^3.0.0",
-    "eslint-loader": "^1.3.0",
-    "eslint-plugin-html": "^4.0.2",
-    "eslint-plugin-mocha": "^4.12.1",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-loader": "^2.0.0",
+    "eslint-plugin-html": "^4.0.3",
+    "eslint-plugin-mocha": "^5.0.0",
    "eventsource-polyfill": "^0.9.6",
    "expect.js": "^0.3.1",
-    "http-proxy-middleware": "^0.17.0",
+    "http-proxy-middleware": "^0.19.0",
    "istanbul": "^1.1.0-alpha.1",
-    "karma": "^2.0.0",
+    "karma": "^4.0.1",
    "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.3",
+    "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": "^2.0.13",
-    "lcov-result-merger": "^2.0.0",
-    "mocha": "^5.0.4",
-    "monk": "^6.0.5",
-    "nightwatch": "^0.9.20",
-    "puppeteer": "^1.1.1",
+    "karma-webpack": "^3.0.0",
+    "lcov-result-merger": "^3.0.0",
+    "mocha": "^5.1.1",
+    "monk": "^6.0.6",
+    "nightwatch": "^1.0.16",
+    "puppeteer": "^1.14.0",
    "require-again": "^2.0.0",
-    "selenium-server": "^3.11.0",
-    "sinon": "^4.4.5",
-    "sinon-chai": "^2.8.0",
+    "selenium-server": "^3.12.0",
+    "sinon": "^7.2.4",
+    "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.21.2"
+    "webpack-hot-middleware": "^2.22.2"
  },
-  "optionalDependencies": {
-    "node-rdkafka": "^2.3.0"
-  }
+  "optionalDependencies": {}
 }
--- a/scripts/gdpr-delete-users.js
+++ b/scripts/gdpr-delete-users.js
@@ -0,0 +1,89 @@
+/* eslint-disable no-console */
+import axios from 'axios';
+import { model as User } from '../website/server/models/user';
+import nconf from 'nconf';
+
+const AMPLITUDE_KEY = nconf.get('AMPLITUDE_KEY');
+const AMPLITUDE_SECRET = nconf.get('AMPLITUDE_SECRET');
+const BASE_URL = nconf.get('BASE_URL');
+
+async function _deleteAmplitudeData (userId, email) {
+  const response = await axios.post(
+    'https://amplitude.com/api/2/deletions/users',
+    {
+      user_ids: userId, // eslint-disable-line camelcase
+      requester: email,
+    },
+    {
+      auth: {
+        username: AMPLITUDE_KEY,
+        password: AMPLITUDE_SECRET,
+      },
+    }
+  ).catch((err) => {
+    console.log(err.response.data);
+  });
+
+  if (response) console.log(`${response.status} ${response.statusText}`);
+}
+
+async function _deleteHabiticaData (user, email) {
+  await User.update(
+    {_id: user._id},
+    {$set: {
+      'auth.local.email': email,
+      'auth.local.hashed_password': '$2a$10$QDnNh1j1yMPnTXDEOV38xOePEWFd4X8DSYwAM8XTmqmacG5X0DKjW',
+      'auth.local.passwordHashMethod': 'bcrypt',
+    }}
+  );
+  const response = await axios.delete(
+    `${BASE_URL}/api/v3/user`,
+    {
+      data: {
+        password: 'test',
+      },
+      headers: {
+        'x-api-user': user._id,
+        'x-api-key': user.apiToken,
+      },
+    }
+  ).catch((err) => {
+    console.log(err.response.data);
+  });
+
+  if (response) {
+    console.log(`${response.status} ${response.statusText}`);
+    if (response.status === 200) console.log(`${user._id} (${email}) removed. Last login: ${user.auth.timestamps.loggedin}`);
+  }
+}
+
+async function _processEmailAddress (email) {
+  const emailRegex = new RegExp(`^${email}$`, 'i');
+  const users = await User.find({
+    $or: [
+      {'auth.local.email': emailRegex},
+      {'auth.facebook.emails.value': emailRegex},
+      {'auth.google.emails.value': emailRegex},
+    ]},
+  {
+    _id: 1,
+    apiToken: 1,
+    auth: 1,
+  }).exec();
+
+  if (users.length < 1) {
+    console.log(`No users found with email address ${email}`);
+  } else {
+    for (const user of users) {
+      await _deleteAmplitudeData(user._id, email); // eslint-disable-line no-await-in-loop
+      await _deleteHabiticaData(user, email); // eslint-disable-line no-await-in-loop
+    }
+  }
+}
+
+function deleteUserData (emails) {
+  const emailPromises = emails.map(_processEmailAddress);
+  return Promise.all(emailPromises);
+}
+
+module.exports = deleteUserData;
--- a/scripts/paypalBillingSetup.js
+++ b/scripts/paypalBillingSetup.js
@@ -1,5 +1,4 @@
 require('babel-register');
-require('babel-polyfill');

 // This file is used for creating paypal billing plans. PayPal doesn't have a web interface for setting up recurring
 // payment plan definitions, instead you have to create it via their REST SDK and keep it updated the same way. So this
@@ -13,28 +12,27 @@ const nconf = require('nconf');
 const _ = require('lodash');
 const paypal = require('paypal-rest-sdk');
 const blocks = require('../website/common').content.subscriptionBlocks;
-const live = nconf.get('PAYPAL:mode') === 'live';
+const live = nconf.get('PAYPAL_MODE') === 'live';

 nconf.argv().env().file('user', path.join(path.resolve(__dirname, '../config.json')));

-let OP = 'create'; // list create update remove
+let OP = 'create'; // list get update create create-webprofile

 paypal.configure({
-  mode: nconf.get('PAYPAL:mode'), // sandbox or live
-  client_id: nconf.get('PAYPAL:client_id'),
-  client_secret: nconf.get('PAYPAL:client_secret'),
+  mode: nconf.get('PAYPAL_MODE'), // sandbox or live
+  client_id: nconf.get('PAYPAL_CLIENT_ID'),
+  client_secret: nconf.get('PAYPAL_CLIENT_SECRET'),
 });

 // https://developer.paypal.com/docs/api/#billing-plans-and-agreements
 let billingPlanTitle = 'Habitica Subscription';
 let billingPlanAttributes = {
-  name: billingPlanTitle,
  description: billingPlanTitle,
  type: 'INFINITE',
  merchant_preferences: {
    auto_bill_amount: 'yes',
    cancel_url: live ? 'https://habitica.com' : 'http://localhost:3000',
-    return_url: `${live ? 'https://habitica.com' : 'http://localhost:3000'  }/paypal/subscribe/success`,
+    return_url: `${live ? 'https://habitica.com' : 'http://localhost:3000'}/paypal/subscribe/success`,
  },
  payment_definitions: [{
    type: 'REGULAR',
@@ -46,7 +44,7 @@ let billingPlanAttributes = {
 _.each(blocks, (block) => {
  block.definition = _.cloneDeep(billingPlanAttributes);
  _.merge(block.definition.payment_definitions[0], {
-    name: `${billingPlanTitle  } ($${block.price} every ${block.months} months, recurring)`,
+    name: `${billingPlanTitle} ($${block.price} every ${block.months} months, recurring)`,
    frequency_interval: `${block.months}`,
    amount: {
      currency: 'USD',
@@ -64,7 +62,7 @@ switch (OP) {
    });
    break;
  case 'get':
-    paypal.billingPlan.get(nconf.get('PAYPAL:billing_plans:12'), (err, plan) => {
+    paypal.billingPlan.get(nconf.get('PAYPAL_BILLING_PLANS_basic_12mo'), (err, plan) => {
      console.log({err, plan});
    });
    break;
@@ -76,7 +74,7 @@ switch (OP) {
        cancel_url: 'https://habitica.com',
      },
    };
-    paypal.billingPlan.update(nconf.get('PAYPAL:billing_plans:12'), updatePayload, (err, res) => {
+    paypal.billingPlan.update(nconf.get('PAYPAL_BILLING_PLANS_basic_12mo'), updatePayload, (err, res) => {
      console.log({err, plan: res});
    });
    break;
@@ -102,9 +100,6 @@ switch (OP) {
      });
    });
    break;
-
-  case 'remove': break;
-
  case 'create-webprofile':
    let webexpinfo = {
      name: 'HabiticaProfile',
@@ -117,4 +112,4 @@ switch (OP) {
      console.log(error, result);
    });
    break;
-}
+}
--- a/test/README.md
+++ b/test/README.md
@@ -1 +1 @@
-For information about writing and running tests, see [Using Your Local Install to Modify Habitica's Website and API](http://habitica.wikia.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API).
+For information about writing and running tests, see [Using Your Local Install to Modify Habitica's Website and API](http://habitica.fandom.com/wiki/Using_Your_Local_Install_to_Modify_Habitica%27s_Website_and_API).
--- a/test/api/v3/unit/libs/analyticsService.test.js
+++ b/test/api/v3/unit/libs/analyticsService.test.js
@@ -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';

@@ -335,14 +335,13 @@ describe('analyticsService', () => {
    let data, itemSpy;

    beforeEach(() => {
+      Visitor.prototype.event.yields();
+
      itemSpy = sandbox.stub().returnsThis();

-      Visitor.prototype.event.returns({
-        send: sandbox.stub(),
-      });
      Visitor.prototype.transaction.returns({
        item: itemSpy,
-        send: sandbox.stub().returnsThis(),
+        send: sandbox.stub().yields(),
      });

      data = {
--- a/test/api/v3/unit/libs/apiMessages.js
+++ b/test/api/v3/unit/libs/apiMessages.js
@@ -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;
--- a/test/api/v3/unit/libs/baseModel.test.js
+++ b/test/api/v3/unit/libs/baseModel.test.js
@@ -1,14 +1,21 @@
-import baseModel from '../../../../../website/server/libs/baseModel';
+import baseModel from '../../../../website/server/libs/baseModel';
 import mongoose from 'mongoose';

 describe('Base model plugin', () => {
  let schema;

  beforeEach(() => {
-    schema = new mongoose.Schema();
+    schema = new mongoose.Schema({}, {
+      typeKey: '$type',
+    });
    sandbox.stub(schema, 'add');
  });

+  it('throws if "typeKey" is not set to $type', () => {
+    const schemaWithoutTypeKey = new mongoose.Schema();
+    expect(() => schemaWithoutTypeKey.plugin(baseModel)).to.throw;
+  });
+
  it('adds a _id field to the schema', () => {
    schema.plugin(baseModel);

--- a/test/api/v3/unit/libs/collectionManipulators.test.js
+++ b/test/api/v3/unit/libs/collectionManipulators.test.js
@@ -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', () => {
--- a/test/api/v3/unit/libs/cron.test.js
+++ b/test/api/v3/unit/libs/cron.test.js
@@ -1,19 +1,19 @@
 /* eslint-disable global-require */
 import moment from 'moment';
 import nconf from 'nconf';
-import Bluebird from 'bluebird';
 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;
@@ -24,7 +24,7 @@ describe('cron', () => {
        local: {
          username: 'username',
          lowerCaseUsername: 'username',
-          email: 'email@email.email',
+          email: 'email@example.com',
          salt: 'salt',
          hashed_password: 'hashed_password', // eslint-disable-line camelcase
        },
@@ -35,6 +35,8 @@ describe('cron', () => {
  });

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

@@ -63,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';
@@ -83,14 +91,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').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', () => {
@@ -118,21 +124,6 @@ describe('cron', () => {
      expect(user.purchased.plan.consecutive.offset).to.equal(1);
    });

-    it('increments plan.consecutive.trinkets when user has reached a month that is a multiple of 3', () => {
-      user.purchased.plan.consecutive.count = 5;
-      user.purchased.plan.consecutive.offset = 1;
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.purchased.plan.consecutive.trinkets).to.equal(1);
-      expect(user.purchased.plan.consecutive.offset).to.equal(0);
-    });
-
-    it('increments plan.consecutive.trinkets multiple times if user has been absent with continuous subscription', () => {
-      user.purchased.plan.dateUpdated = moment().subtract(6, 'months').toDate();
-      user.purchased.plan.consecutive.count = 5;
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.purchased.plan.consecutive.trinkets).to.equal(2);
-    });
-
    it('does not award unearned plan.consecutive.trinkets if subscription ended during an absence', () => {
      user.purchased.plan.dateUpdated = moment().subtract(6, 'months').toDate();
      user.purchased.plan.dateTerminated = moment().subtract(3, 'months').toDate();
@@ -144,21 +135,6 @@ describe('cron', () => {
      expect(user.purchased.plan.consecutive.trinkets).to.equal(1);
    });

-    it('increments plan.consecutive.gemCapExtra when user has reached a month that is a multiple of 3', () => {
-      user.purchased.plan.consecutive.count = 5;
-      user.purchased.plan.consecutive.offset = 1;
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.purchased.plan.consecutive.gemCapExtra).to.equal(5);
-      expect(user.purchased.plan.consecutive.offset).to.equal(0);
-    });
-
-    it('increments plan.consecutive.gemCapExtra multiple times if user has been absent with continuous subscription', () => {
-      user.purchased.plan.dateUpdated = moment().subtract(6, 'months').toDate();
-      user.purchased.plan.consecutive.count = 5;
-      cron({user, tasksByType, daysMissed, analytics});
-      expect(user.purchased.plan.consecutive.gemCapExtra).to.equal(10);
-    });
-
    it('does not increment plan.consecutive.gemCapExtra when user has reached the gemCap limit', () => {
      user.purchased.plan.consecutive.gemCapExtra = 25;
      user.purchased.plan.consecutive.count = 5;
@@ -185,6 +161,427 @@ describe('cron', () => {
      expect(user.purchased.plan.consecutive.count).to.equal(0);
      expect(user.purchased.plan.consecutive.offset).to.equal(0);
    });
+
+    describe('for a 1-month recurring subscription', () => {
+      // create a user that will be used for all of these tests without a reset before each
+      let user1 = new User({
+        auth: {
+          local: {
+            username: 'username1',
+            lowerCaseUsername: 'username1',
+            email: 'email1@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // user1 has a 1-month recurring subscription starting today
+      user1.purchased.plan.customerId = 'subscribedId';
+      user1.purchased.plan.dateUpdated = moment().toDate();
+      user1.purchased.plan.planId = 'basic';
+      user1.purchased.plan.consecutive.count = 0;
+      user1.purchased.plan.consecutive.offset = 0;
+      user1.purchased.plan.consecutive.trinkets = 0;
+      user1.purchased.plan.consecutive.gemCapExtra = 0;
+
+      it('does not increment consecutive benefits after the first month', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        // Add 1 month to simulate what happens a month after the subscription was created.
+        // Add 2 days so that we're sure we're not affected by any start-of-month effects e.g., from time zone oddness.
+        cron({user: user1, tasksByType, daysMissed, analytics});
+        expect(user1.purchased.plan.consecutive.count).to.equal(1);
+        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);
+      });
+
+      it('does not increment consecutive benefits after the second month', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(2, 'months').add(2, 'days').toDate());
+        // Add 1 month to simulate what happens a month after the subscription was created.
+        // Add 2 days so that we're sure we're not affected by any start-of-month effects e.g., from time zone oddness.
+        cron({user: user1, tasksByType, daysMissed, analytics});
+        expect(user1.purchased.plan.consecutive.count).to.equal(2);
+        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);
+      });
+
+      it('increments consecutive benefits after the third month', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(3, 'months').add(2, 'days').toDate());
+        // Add 1 month to simulate what happens a month after the subscription was created.
+        // Add 2 days so that we're sure we're not affected by any start-of-month effects e.g., from time zone oddness.
+        cron({user: user1, tasksByType, daysMissed, analytics});
+        expect(user1.purchased.plan.consecutive.count).to.equal(3);
+        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);
+      });
+
+      it('does not increment consecutive benefits after the fourth month', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(4, 'months').add(2, 'days').toDate());
+        // Add 1 month to simulate what happens a month after the subscription was created.
+        // Add 2 days so that we're sure we're not affected by any start-of-month effects e.g., from time zone oddness.
+        cron({user: user1, tasksByType, daysMissed, analytics});
+        expect(user1.purchased.plan.consecutive.count).to.equal(4);
+        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);
+      });
+
+      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(10, 'months').add(2, 'days').toDate());
+        cron({user: user1, tasksByType, daysMissed, analytics});
+        expect(user1.purchased.plan.consecutive.count).to.equal(10);
+        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);
+      });
+    });
+
+    describe('for a 3-month recurring subscription', () => {
+      let user3 = new User({
+        auth: {
+          local: {
+            username: 'username3',
+            lowerCaseUsername: 'username3',
+            email: 'email3@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // user3 has a 3-month recurring subscription starting today
+      user3.purchased.plan.customerId = 'subscribedId';
+      user3.purchased.plan.dateUpdated = moment().toDate();
+      user3.purchased.plan.planId = 'basic_3mo';
+      user3.purchased.plan.consecutive.count = 0;
+      user3.purchased.plan.consecutive.offset = 3;
+      user3.purchased.plan.consecutive.trinkets = 1;
+      user3.purchased.plan.consecutive.gemCapExtra = 5;
+
+      it('does not increment consecutive benefits in the first month of the first paid period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(1);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the middle of the period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(2, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(2);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(3, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(3);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the second paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(4, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(4);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the second month of the second period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(5, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(5);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the final month of the second period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(6, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(6);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the third paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(7, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(7);
+        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);
+      });
+
+      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(10, 'months').add(2, 'days').toDate());
+        cron({user: user3, tasksByType, daysMissed, analytics});
+        expect(user3.purchased.plan.consecutive.count).to.equal(10);
+        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);
+      });
+    });
+
+    describe('for a 6-month recurring subscription', () => {
+      let user6 = new User({
+        auth: {
+          local: {
+            username: 'username6',
+            lowerCaseUsername: 'username6',
+            email: 'email6@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // user6 has a 6-month recurring subscription starting today
+      user6.purchased.plan.customerId = 'subscribedId';
+      user6.purchased.plan.dateUpdated = moment().toDate();
+      user6.purchased.plan.planId = 'google_6mo';
+      user6.purchased.plan.consecutive.count = 0;
+      user6.purchased.plan.consecutive.offset = 6;
+      user6.purchased.plan.consecutive.trinkets = 2;
+      user6.purchased.plan.consecutive.gemCapExtra = 10;
+
+      it('does not increment consecutive benefits in the first month of the first paid period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        cron({user: user6, tasksByType, daysMissed, analytics});
+        expect(user6.purchased.plan.consecutive.count).to.equal(1);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(6, 'months').add(2, 'days').toDate());
+        cron({user: user6, tasksByType, daysMissed, analytics});
+        expect(user6.purchased.plan.consecutive.count).to.equal(6);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the second paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(7, 'months').add(2, 'days').toDate());
+        cron({user: user6, tasksByType, daysMissed, analytics});
+        expect(user6.purchased.plan.consecutive.count).to.equal(7);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the third paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(13, 'months').add(2, 'days').toDate());
+        cron({user: user6, tasksByType, daysMissed, analytics});
+        expect(user6.purchased.plan.consecutive.count).to.equal(13);
+        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);
+      });
+
+      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(19, 'months').add(2, 'days').toDate());
+        cron({user: user6, tasksByType, daysMissed, analytics});
+        expect(user6.purchased.plan.consecutive.count).to.equal(19);
+        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);
+      });
+    });
+
+    describe('for a 12-month recurring subscription', () => {
+      let user12 = new User({
+        auth: {
+          local: {
+            username: 'username12',
+            lowerCaseUsername: 'username12',
+            email: 'email12@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // user12 has a 12-month recurring subscription starting today
+      user12.purchased.plan.customerId = 'subscribedId';
+      user12.purchased.plan.dateUpdated = moment().toDate();
+      user12.purchased.plan.planId = 'basic_12mo';
+      user12.purchased.plan.consecutive.count = 0;
+      user12.purchased.plan.consecutive.offset = 12;
+      user12.purchased.plan.consecutive.trinkets = 4;
+      user12.purchased.plan.consecutive.gemCapExtra = 20;
+
+      it('does not increment consecutive benefits in the first month of the first paid period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        cron({user: user12, tasksByType, daysMissed, analytics});
+        expect(user12.purchased.plan.consecutive.count).to.equal(1);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the final month of the period that they already have benefits for', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(12, 'months').add(2, 'days').toDate());
+        cron({user: user12, tasksByType, daysMissed, analytics});
+        expect(user12.purchased.plan.consecutive.count).to.equal(12);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the second paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(13, 'months').add(2, 'days').toDate());
+        cron({user: user12, tasksByType, daysMissed, analytics});
+        expect(user12.purchased.plan.consecutive.count).to.equal(13);
+        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);
+      });
+
+      it('increments consecutive benefits the month after the third paid period has started', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(25, 'months').add(2, 'days').toDate());
+        cron({user: user12, tasksByType, daysMissed, analytics});
+        expect(user12.purchased.plan.consecutive.count).to.equal(25);
+        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);
+      });
+
+      it('increments consecutive benefits correctly if user has been absent with continuous subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(37, 'months').add(2, 'days').toDate());
+        cron({user: user12, tasksByType, daysMissed, analytics});
+        expect(user12.purchased.plan.consecutive.count).to.equal(37);
+        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);
+      });
+    });
+
+    describe('for a 3-month gift subscription (non-recurring)', () => {
+      let user3g = new User({
+        auth: {
+          local: {
+            username: 'username3g',
+            lowerCaseUsername: 'username3g',
+            email: 'email3g@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // 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().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;
+      user3g.purchased.plan.consecutive.trinkets = 1;
+      user3g.purchased.plan.consecutive.gemCapExtra = 5;
+
+      it('does not increment consecutive benefits in the first month of the gift subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        cron({user: user3g, tasksByType, daysMissed, analytics});
+        expect(user3g.purchased.plan.consecutive.count).to.equal(1);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the second month of the gift subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(2, 'months').add(2, 'days').toDate());
+        cron({user: user3g, tasksByType, daysMissed, analytics});
+        expect(user3g.purchased.plan.consecutive.count).to.equal(2);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the third month of the gift subscription', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(3, 'months').add(2, 'days').toDate());
+        cron({user: user3g, tasksByType, daysMissed, analytics});
+        expect(user3g.purchased.plan.consecutive.count).to.equal(3);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the month after the gift subscription has ended', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(4, 'months').add(2, 'days').toDate());
+        cron({user: user3g, tasksByType, daysMissed, analytics});
+        expect(user3g.purchased.plan.consecutive.count).to.equal(0); // subscription has been erased by now
+        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
+      });
+    });
+
+    describe('for a 6-month recurring subscription where the user has incorrect consecutive month data from prior bugs', () => {
+      let user6x = new User({
+        auth: {
+          local: {
+            username: 'username6x',
+            lowerCaseUsername: 'username6x',
+            email: 'email6x@example.com',
+            salt: 'salt',
+            hashed_password: 'hashed_password', // eslint-disable-line camelcase
+          },
+        },
+      });
+      // user6x has a 6-month recurring subscription starting 8 months in the past before issue #4819 was fixed
+      user6x.purchased.plan.customerId = 'subscribedId';
+      user6x.purchased.plan.dateUpdated = moment().toDate();
+      user6x.purchased.plan.planId = 'basic_6mo';
+      user6x.purchased.plan.consecutive.count = 8;
+      user6x.purchased.plan.consecutive.offset = 0;
+      user6x.purchased.plan.consecutive.trinkets = 3;
+      user6x.purchased.plan.consecutive.gemCapExtra = 15;
+
+      it('increments consecutive benefits in the first month since the fix for #4819 goes live', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(1, 'months').add(2, 'days').toDate());
+        cron({user: user6x, tasksByType, daysMissed, analytics});
+        expect(user6x.purchased.plan.consecutive.count).to.equal(9);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the second month after the fix goes live', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(2, 'months').add(2, 'days').toDate());
+        cron({user: user6x, tasksByType, daysMissed, analytics});
+        expect(user6x.purchased.plan.consecutive.count).to.equal(10);
+        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);
+      });
+
+      it('does not increment consecutive benefits in the third month after the fix goes live', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(3, 'months').add(2, 'days').toDate());
+        cron({user: user6x, tasksByType, daysMissed, analytics});
+        expect(user6x.purchased.plan.consecutive.count).to.equal(11);
+        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);
+      });
+
+      it('increments consecutive benefits in the seventh month after the fix goes live', () => {
+        clock = sinon.useFakeTimers(moment().zone(0).startOf('month').add(7, 'months').add(2, 'days').toDate());
+        cron({user: user6x, tasksByType, daysMissed, analytics});
+        expect(user6x.purchased.plan.consecutive.count).to.equal(15);
+        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);
+      });
+    });
  });

  describe('end of the month perks when user is not subscribed', () => {
@@ -199,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', () => {
@@ -266,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 = {
@@ -457,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;
@@ -476,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;
@@ -483,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});
@@ -495,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;
@@ -541,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});

@@ -550,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});
@@ -612,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;
@@ -632,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;
@@ -870,7 +1232,7 @@ describe('cron', () => {
      cron({user, tasksByType, daysMissed, analytics});

      expect(user.history.exp).to.have.lengthOf(1);
-      expect(user.history.exp[0].value).to.equal(150);
+      expect(user.history.exp[0].value).to.equal(25);
    });

    it('increments perfect day achievement if all (at least 1) due dailies were completed', () => {
@@ -893,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});
@@ -932,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;
@@ -956,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;
@@ -988,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');
@@ -1129,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', () => {
@@ -1183,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);
@@ -1349,7 +1788,7 @@ describe('recoverCron', () => {
          local: {
            username: 'username',
            lowerCaseUsername: 'username',
-            email: 'email@email.email',
+            email: 'email@example.com',
            salt: 'salt',
            hashed_password: 'hashed_password', // eslint-disable-line camelcase
          },
@@ -1363,7 +1802,7 @@ describe('recoverCron', () => {
  });

  it('throws an error if user cannot be found', async () => {
-    execStub.returns(Bluebird.resolve(null));
+    execStub.returns(Promise.resolve(null));

    try {
      await recoverCron(status, locals);
@@ -1374,8 +1813,8 @@ describe('recoverCron', () => {
  });

  it('increases status.times count and reruns up to 4 times', async () => {
-    execStub.returns(Bluebird.resolve({_cronSignature: 'RUNNING_CRON'}));
-    execStub.onCall(4).returns(Bluebird.resolve({_cronSignature: 'NOT_RUNNING'}));
+    execStub.returns(Promise.resolve({_cronSignature: 'RUNNING_CRON'}));
+    execStub.onCall(4).returns(Promise.resolve({_cronSignature: 'NOT_RUNNING'}));

    await recoverCron(status, locals);

@@ -1384,7 +1823,7 @@ describe('recoverCron', () => {
  });

  it('throws an error if recoverCron runs 5 times', async () => {
-    execStub.returns(Bluebird.resolve({_cronSignature: 'RUNNING_CRON'}));
+    execStub.returns(Promise.resolve({_cronSignature: 'RUNNING_CRON'}));

    try {
      await recoverCron(status, locals);
--- a/test/api/v3/unit/libs/email.test.js
+++ b/test/api/v3/unit/libs/email.test.js
@@ -1,11 +1,9 @@
 /* eslint-disable global-require */
 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 { TAVERN_ID } from '../../../../website/server/models/group';
+import { defer } from '../../../helpers/api-unit.helper';

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

 describe('emails', () => {
-  let pathToEmailLib = '../../../../../website/server/libs/email';
-
-  describe('sendEmail', () => {
-    let sendMailSpy;
-
-    beforeEach(() => {
-      sendMailSpy = sandbox.stub().returns(defer().promise);
-      sandbox.stub(nodemailer, 'createTransport').returns({
-        sendMail: sendMailSpy,
-      });
-    });
-
-    afterEach(() => {
-      sandbox.restore();
-    });
-
-    it('can send an email using the default transport', () => {
-      let attachEmail = requireAgain(pathToEmailLib);
-      attachEmail.send();
-      expect(sendMailSpy).to.be.calledOnce;
-    });
-
-    it('logs errors', (done) => {
-      sandbox.stub(logger, 'error');
-
-      let attachEmail = requireAgain(pathToEmailLib);
-      attachEmail.send();
-      expect(sendMailSpy).to.be.calledOnce;
-      defer().reject();
-
-      // wait for unhandledRejection event to fire
-      setTimeout(() => {
-        expect(logger.error).to.be.calledOnce;
-        done();
-      }, 20);
-    });
-  });
+  let pathToEmailLib = '../../../../website/server/libs/email';

  describe('getUserInfo', () => {
    it('returns an empty object if no field request', () => {
@@ -85,7 +46,7 @@ describe('emails', () => {
      let user = getUser();
      let data = getUserInfo(user, ['name', 'email', '_id', 'canSend']);

-      expect(data).to.have.property('name', user.profile.name);
+      expect(data).to.have.property('name', user.auth.local.username);
      expect(data).to.have.property('email', user.auth.local.email);
      expect(data).to.have.property('_id', user._id);
      expect(data).to.have.property('canSend', true);
@@ -96,11 +57,11 @@ describe('emails', () => {
      let getUserInfo = attachEmail.getUserInfo;
      let user = getUser();
      delete user.profile.name;
-      delete user.auth.local;
+      delete user.auth.local.email;

      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.auth.local.username);
      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,7 +71,6 @@ 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;

--- a/test/api/v3/unit/libs/encryption.test.js
+++ b/test/api/v3/unit/libs/encryption.test.js
@@ -1,7 +1,7 @@
 import {
  encrypt,
  decrypt,
-} from '../../../../../website/server/libs/encryption';
+} from '../../../../website/server/libs/encryption';

 describe('encryption', () => {
  it('can encrypt and decrypt', () => {
--- a/test/api/v3/unit/libs/errors.test.js
+++ b/test/api/v3/unit/libs/errors.test.js
@@ -5,7 +5,9 @@ import {
  BadRequest,
  InternalServerError,
  NotFound,
-} from '../../../../../website/server/libs/errors';
+  NotificationNotFound,
+} from '../../../../website/server/libs/errors';
+import i18n from '../../../../website/common/script/i18n';

 describe('Custom Errors', () => {
  describe('CustomError', () => {
@@ -66,6 +68,23 @@ describe('Custom Errors', () => {

      expect(notAuthorizedError.message).to.eql('Custom Error Message');
    });
+
+    describe('NotificationNotFound', () => {
+      it('is an instance of NotFound', () => {
+        const notificationNotFoundErr = new NotificationNotFound();
+        expect(notificationNotFoundErr).to.be.an.instanceOf(NotFound);
+      });
+
+      it('it returns an http code of 404', () => {
+        const notificationNotFoundErr = new NotificationNotFound();
+        expect(notificationNotFoundErr.httpCode).to.eql(404);
+      });
+
+      it('returns a standard message', () => {
+        const notificationNotFoundErr = new NotificationNotFound();
+        expect(notificationNotFoundErr.message).to.eql(i18n.t('messageNotificationNotFound'));
+      });
+    });
  });

  describe('BadRequest', () => {
--- a/test/api/v3/unit/libs/i18n.test.js
+++ b/test/api/v3/unit/libs/i18n.test.js
@@ -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';

--- a/test/api/unit/libs/items/utils.test.js
+++ b/test/api/unit/libs/items/utils.test.js
@@ -0,0 +1,113 @@
+/* eslint-disable camelcase */
+import {
+  validateItemPath,
+  getDefaultOwnedGear,
+  castItemVal,
+} from '../../../../../website/server/libs/items/utils';
+
+describe('Items Utils', () => {
+  describe('getDefaultOwnedGear', () => {
+    it('clones the result object', () => {
+      const res1 = getDefaultOwnedGear();
+      res1.extraProperty = true;
+
+      const res2 = getDefaultOwnedGear();
+      expect(res2).not.to.have.property('extraProperty');
+    });
+  });
+
+  describe('validateItemPath', () => {
+    it('returns false if not an item path', () => {
+      expect(validateItemPath('notitems.gear.owned.item')).to.equal(false);
+    });
+
+    it('returns true if a valid schema path', () => {
+      expect(validateItemPath('items.gear.equipped.weapon')).to.equal(true);
+      expect(validateItemPath('items.currentPet')).to.equal(true);
+      expect(validateItemPath('items.special.snowball')).to.equal(true);
+    });
+
+    it('works with owned gear paths', () => {
+      expect(validateItemPath('items.gear.owned.head_armoire_crownOfHearts')).to.equal(true);
+      expect(validateItemPath('items.gear.owned.head_invalid')).to.equal(false);
+    });
+
+    it('works with pets paths', () => {
+      expect(validateItemPath('items.pets.Wolf-CottonCandyPink')).to.equal(true);
+      expect(validateItemPath('items.pets.Wolf-Invalid')).to.equal(false);
+    });
+
+    it('works with eggs paths', () => {
+      expect(validateItemPath('items.eggs.LionCub')).to.equal(true);
+      expect(validateItemPath('items.eggs.Armadillo')).to.equal(true);
+      expect(validateItemPath('items.eggs.NotAnArmadillo')).to.equal(false);
+    });
+
+    it('works with hatching potions paths', () => {
+      expect(validateItemPath('items.hatchingPotions.Base')).to.equal(true);
+      expect(validateItemPath('items.hatchingPotions.StarryNight')).to.equal(true);
+      expect(validateItemPath('items.hatchingPotions.Invalid')).to.equal(false);
+    });
+
+    it('works with food paths', () => {
+      expect(validateItemPath('items.food.Cake_Base')).to.equal(true);
+      expect(validateItemPath('items.food.Cake_Invalid')).to.equal(false);
+    });
+
+    it('works with mounts paths', () => {
+      expect(validateItemPath('items.mounts.Cactus-Base')).to.equal(true);
+      expect(validateItemPath('items.mounts.Aether-Invisible')).to.equal(true);
+      expect(validateItemPath('items.mounts.Aether-Invalid')).to.equal(false);
+    });
+
+    it('works with quests paths', () => {
+      expect(validateItemPath('items.quests.atom3')).to.equal(true);
+      expect(validateItemPath('items.quests.invalid')).to.equal(false);
+    });
+  });
+
+  describe('castItemVal', () => {
+    it('returns the item val untouched if not an item path', () => {
+      expect(castItemVal('notitems.gear.owned.item', 'a string')).to.equal('a string');
+    });
+
+    it('returns the item val untouched if an unsupported path', () => {
+      expect(castItemVal('items.gear.equipped.weapon', 'a string')).to.equal('a string');
+      expect(castItemVal('items.currentPet', 'a string')).to.equal('a string');
+      expect(castItemVal('items.special.snowball', 'a string')).to.equal('a string');
+    });
+
+    it('converts values for pets paths to numbers', () => {
+      expect(castItemVal('items.pets.Wolf-CottonCandyPink', '5')).to.equal(5);
+      expect(castItemVal('items.pets.Wolf-Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for eggs paths to numbers', () => {
+      expect(castItemVal('items.eggs.LionCub', '5')).to.equal(5);
+      expect(castItemVal('items.eggs.Armadillo', '5')).to.equal(5);
+      expect(castItemVal('items.eggs.NotAnArmadillo', '5')).to.equal(5);
+    });
+
+    it('converts values for hatching potions paths to numbers', () => {
+      expect(castItemVal('items.hatchingPotions.Base', '5')).to.equal(5);
+      expect(castItemVal('items.hatchingPotions.StarryNight', '5')).to.equal(5);
+      expect(castItemVal('items.hatchingPotions.Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for food paths to numbers', () => {
+      expect(castItemVal('items.food.Cake_Base', '5')).to.equal(5);
+      expect(castItemVal('items.food.Cake_Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for mounts paths to numbers', () => {
+      expect(castItemVal('items.mounts.Cactus-Base', '5')).to.equal(5);
+      expect(castItemVal('items.mounts.Aether-Invisible', '5')).to.equal(5);
+      expect(castItemVal('items.mounts.Aether-Invalid', '5')).to.equal(5);
+    });
+
+    it('converts values for quests paths to numbers', () => {
+      expect(castItemVal('items.quests.atom3', '5')).to.equal(5);
+      expect(castItemVal('items.quests.invalid', '5')).to.equal(5);
+    });
+  });
+});
--- a/test/api/v3/unit/libs/logger.js
+++ b/test/api/v3/unit/libs/logger.js
@@ -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;
--- a/test/api/v3/unit/libs/password.test.js
+++ b/test/api/v3/unit/libs/password.test.js
@@ -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({
@@ -226,7 +245,9 @@ describe('Password Utilities', () => {

    it('returns false if the user has no local auth', async () => {
      let user = await generateUser({
-        auth: 'not an object with valid fields',
+        auth: {
+          facebook: {},
+        },
      });
      let res = await validatePasswordResetCodeAndFindUser(encrypt(JSON.stringify({
        userId: user._id,
--- a/test/api/v3/unit/libs/payments/amazon/cancel.test.js
+++ b/test/api/v3/unit/libs/payments/amazon/cancel.test.js
@@ -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/amazonPayments';
-import payments from '../../../../../../../website/server/libs/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;
@@ -48,7 +48,6 @@ describe('Amazon Payments - Cancel Subscription', () => {

  function expectBillingAggreementDetailSpy () {
    getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails')
-      .returnsPromise()
      .resolves({
        BillingAgreementDetails: {
          BillingAgreementStatus: {State: 'Open'},
@@ -80,14 +79,14 @@ describe('Amazon Payments - Cancel Subscription', () => {
    headers = {};

    getBillingAgreementDetailsSpy = sinon.stub(amzLib, 'getBillingAgreementDetails');
-    getBillingAgreementDetailsSpy.returnsPromise().resolves({
+    getBillingAgreementDetailsSpy.resolves({
      BillingAgreementDetails: {
        BillingAgreementStatus: {State: 'Closed'},
      },
    });

    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription');
-    paymentCancelSubscriptionSpy.returnsPromise().resolves({});
+    paymentCancelSubscriptionSpy.resolves({});
  });

  afterEach(function () {
@@ -118,7 +117,7 @@ describe('Amazon Payments - Cancel Subscription', () => {
  it('should close a user subscription if amazon not closed', async () => {
    amzLib.getBillingAgreementDetails.restore();
    expectBillingAggreementDetailSpy();
-    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
+    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').resolves({});
    billingAgreementId = user.purchased.plan.customerId;

    await amzLib.cancelSubscription({user, headers});
@@ -164,7 +163,7 @@ describe('Amazon Payments - Cancel Subscription', () => {
  it('should close a group subscription if amazon not closed', async () => {
    amzLib.getBillingAgreementDetails.restore();
    expectBillingAggreementDetailSpy();
-    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').returnsPromise().resolves({});
+    let closeBillingAgreementSpy = sinon.stub(amzLib, 'closeBillingAgreement').resolves({});
    billingAgreementId = group.purchased.plan.customerId;

    await amzLib.cancelSubscription({user, groupId: group._id, headers});
--- a/test/api/v3/unit/libs/payments/amazon/checkout.test.js
+++ b/test/api/v3/unit/libs/payments/amazon/checkout.test.js
@@ -1,7 +1,7 @@
-import { model as User } from '../../../../../../../website/server/models/user';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import payments from '../../../../../../../website/server/libs/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;

@@ -68,22 +68,22 @@ describe('Amazon Payments - Checkout', () => {
    orderReferenceId = 'orderReferenceId';

    setOrderReferenceDetailsSpy = sinon.stub(amzLib, 'setOrderReferenceDetails');
-    setOrderReferenceDetailsSpy.returnsPromise().resolves({});
+    setOrderReferenceDetailsSpy.resolves({});

    confirmOrderReferenceSpy = sinon.stub(amzLib, 'confirmOrderReference');
-    confirmOrderReferenceSpy.returnsPromise().resolves({});
+    confirmOrderReferenceSpy.resolves({});

    authorizeSpy = sinon.stub(amzLib, 'authorize');
-    authorizeSpy.returnsPromise().resolves({});
+    authorizeSpy.resolves({});

    closeOrderReferenceSpy = sinon.stub(amzLib, 'closeOrderReference');
-    closeOrderReferenceSpy.returnsPromise().resolves({});
+    closeOrderReferenceSpy.resolves({});

    paymentBuyGemsStub = sinon.stub(payments, 'buyGems');
-    paymentBuyGemsStub.returnsPromise().resolves({});
+    paymentBuyGemsStub.resolves({});

    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription');
-    paymentCreateSubscritionStub.returnsPromise().resolves({});
+    paymentCreateSubscritionStub.resolves({});

    sinon.stub(common, 'uuid').returns('uuid-generated');
  });
@@ -111,7 +111,7 @@ describe('Amazon Payments - Checkout', () => {
  }

  it('should purchase gems', async () => {
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
+    sinon.stub(user, 'canGetGems').resolves(true);
    await amzLib.checkout({user, orderReferenceId, headers});

    expectBuyGemsStub(amzLib.constants.PAYMENT_METHOD);
@@ -140,7 +140,7 @@ describe('Amazon Payments - Checkout', () => {
  });

  it('should error if user cannot get gems gems', async () => {
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+    sinon.stub(user, 'canGetGems').resolves(false);
    await expect(amzLib.checkout({user, orderReferenceId, headers})).to.eventually.be.rejected.and.to.eql({
      httpCode: 401,
      message: i18n.t('groupPolicyCannotGetGems'),
--- a/test/api/v3/unit/libs/payments/amazon/subscribe.test.js
+++ b/test/api/v3/unit/libs/payments/amazon/subscribe.test.js
@@ -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/amazonPayments';
-import payments from '../../../../../../../website/server/libs/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;

@@ -46,16 +46,16 @@ describe('Amazon Payments - Subscribe', () => {
    headers = {};

    amazonSetBillingAgreementDetailsSpy = sinon.stub(amzLib, 'setBillingAgreementDetails');
-    amazonSetBillingAgreementDetailsSpy.returnsPromise().resolves({});
+    amazonSetBillingAgreementDetailsSpy.resolves({});

    amazonConfirmBillingAgreementSpy = sinon.stub(amzLib, 'confirmBillingAgreement');
-    amazonConfirmBillingAgreementSpy.returnsPromise().resolves({});
+    amazonConfirmBillingAgreementSpy.resolves({});

    amazonAuthorizeOnBillingAgreementSpy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
-    amazonAuthorizeOnBillingAgreementSpy.returnsPromise().resolves({});
+    amazonAuthorizeOnBillingAgreementSpy.resolves({});

    createSubSpy = sinon.stub(payments, 'createSubscription');
-    createSubSpy.returnsPromise().resolves({});
+    createSubSpy.resolves({});

    sinon.stub(common, 'uuid').returns('uuid-generated');
  });
--- a/test/api/v3/unit/libs/payments/amazon/upgrade-groupplan.test.js
+++ b/test/api/v3/unit/libs/payments/amazon/upgrade-groupplan.test.js
@@ -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/amazonPayments';
-import payments from '../../../../../../../website/server/libs/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;
@@ -37,7 +37,7 @@ describe('#upgradeGroupPlan', () => {
    await group.save();

    spy = sinon.stub(amzLib, 'authorizeOnBillingAgreement');
-    spy.returnsPromise().resolves([]);
+    spy.resolves([]);

    uuidString = 'uuid-v4';
    sinon.stub(uuid, 'v4').returns(uuidString);
--- a/test/api/v3/unit/libs/applePayments.test.js
+++ b/test/api/v3/unit/libs/applePayments.test.js
@@ -1,11 +1,12 @@
 /* eslint-disable camelcase */
 import iapModule from '../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../website/server/libs/payments';
-import applePayments from '../../../../../website/server/libs/applePayments';
+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';
+import {mockFindById, restoreFindById} from '../../../../helpers/mongoose.helper';

 const i18n = common.i18n;

@@ -24,16 +25,16 @@ describe('Apple Payments', ()  => {
      headers = {};

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({});
+        .resolves({});
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(true);
      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
        .returns([{productId: 'com.habitrpg.ios.Habitica.21gems',
                   transactionId: token,
        }]);
-      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
+      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
    });

    afterEach(() => {
@@ -49,7 +50,7 @@ describe('Apple Payments', ()  => {
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(false);

-      await expect(applePayments.verifyGemPurchase(user, receipt, headers))
+      await expect(applePayments.verifyGemPurchase({user, receipt, headers}))
        .to.eventually.be.rejected.and.to.eql({
          httpCode: 401,
          name: 'NotAuthorized',
@@ -57,9 +58,21 @@ describe('Apple Payments', ()  => {
        });
    });

+    it('should throw an error if getPurchaseData is invalid', async () => {
+      iapGetPurchaseDataStub.restore();
+      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData').returns([]);
+
+      await expect(applePayments.verifyGemPurchase({user, receipt, headers}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: applePayments.constants.RESPONSE_NO_ITEM_PURCHASED,
+        });
+    });
+
    it('errors if the user cannot purchase gems', async () => {
-      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
-      await expect(applePayments.verifyGemPurchase(user, receipt, headers))
+      sinon.stub(user, 'canGetGems').resolves(false);
+      await expect(applePayments.verifyGemPurchase({user, receipt, headers}))
        .to.eventually.be.rejected.and.to.eql({
          httpCode: 401,
          name: 'NotAuthorized',
@@ -69,9 +82,91 @@ describe('Apple Payments', ()  => {
      user.canGetGems.restore();
    });

-    it('purchases gems', async () => {
-      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
-      await applePayments.verifyGemPurchase(user, receipt, headers);
+    it('errors if amount does not exist', async () => {
+      sinon.stub(user, 'canGetGems').resolves(true);
+      iapGetPurchaseDataStub.restore();
+      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
+        .returns([{productId: 'badProduct',
+                   transactionId: token,
+        }]);
+
+      await expect(applePayments.verifyGemPurchase({user, receipt, headers}))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: applePayments.constants.RESPONSE_INVALID_ITEM,
+        });
+
+      user.canGetGems.restore();
+    });
+
+    const gemsCanPurchase = [
+      {
+        productId: 'com.habitrpg.ios.Habitica.4gems',
+        amount: 1,
+      },
+      {
+        productId: 'com.habitrpg.ios.Habitica.20gems',
+        amount: 5.25,
+      },
+      {
+        productId: 'com.habitrpg.ios.Habitica.21gems',
+        amount: 5.25,
+      },
+      {
+        productId: 'com.habitrpg.ios.Habitica.42gems',
+        amount: 10.5,
+      },
+      {
+        productId: 'com.habitrpg.ios.Habitica.84gems',
+        amount: 21,
+      },
+    ];
+
+    gemsCanPurchase.forEach(gemTest => {
+      it(`purchases ${gemTest.productId} gems`, async () => {
+        iapGetPurchaseDataStub.restore();
+        iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
+          .returns([{productId: gemTest.productId,
+                     transactionId: token,
+          }]);
+
+        sinon.stub(user, 'canGetGems').resolves(true);
+        await applePayments.verifyGemPurchase({user, receipt, headers});
+
+        expect(iapSetupStub).to.be.calledOnce;
+        expect(iapValidateStub).to.be.calledOnce;
+        expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
+        expect(iapIsValidatedStub).to.be.calledOnce;
+        expect(iapIsValidatedStub).to.be.calledWith({});
+        expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+        expect(paymentBuyGemsStub).to.be.calledOnce;
+        expect(paymentBuyGemsStub).to.be.calledWith({
+          user,
+          paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+          amount: gemTest.amount,
+          headers,
+        });
+        expect(user.canGetGems).to.be.calledOnce;
+        user.canGetGems.restore();
+      });
+    });
+
+    it('gifts gems', async () => {
+      const receivingUser = new User();
+      await receivingUser.save();
+
+      mockFindById(receivingUser);
+
+      iapGetPurchaseDataStub.restore();
+      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
+        .returns([{productId: gemsCanPurchase[0].productId,
+                   transactionId: token,
+        }]);
+
+      const gift = {uuid: receivingUser._id};
+      await applePayments.verifyGemPurchase({user, gift, receipt, headers});

      expect(iapSetupStub).to.be.calledOnce;
      expect(iapValidateStub).to.be.calledOnce;
@@ -82,13 +177,12 @@ describe('Apple Payments', ()  => {

      expect(paymentBuyGemsStub).to.be.calledOnce;
      expect(paymentBuyGemsStub).to.be.calledWith({
-        user,
+        user: receivingUser,
        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
-        amount: 5.25,
+        amount: gemsCanPurchase[0].amount,
        headers,
      });
-      expect(user.canGetGems).to.be.calledOnce;
-      user.canGetGems.restore();
+      restoreFindById();
    });
  });

@@ -106,9 +200,9 @@ describe('Apple Payments', ()  => {
      nextPaymentProcessing = moment.utc().add({days: 2});

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({});
+        .resolves({});
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(true);
      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
@@ -125,7 +219,7 @@ describe('Apple Payments', ()  => {
          productId: sku,
          transactionId: token,
        }]);
-      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').resolves({});
    });

    afterEach(() => {
@@ -133,7 +227,16 @@ describe('Apple Payments', ()  => {
      iapModule.validate.restore();
      iapModule.isValidated.restore();
      iapModule.getPurchaseData.restore();
-      payments.createSubscription.restore();
+      if (payments.createSubscription.restore) payments.createSubscription.restore();
+    });
+
+    it('should throw an error if sku is empty', async () => {
+      await expect(applePayments.subscribe('', user, receipt, headers, nextPaymentProcessing))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 400,
+          name: 'BadRequest',
+          message: i18n.t('missingSubscriptionCode'),
+        });
    });

    it('should throw an error if receipt is invalid', async () => {
@@ -149,26 +252,69 @@ describe('Apple Payments', ()  => {
        });
    });

-    it('creates a user subscription', async () => {
+    const subOptions = [
+      {
+        sku: 'subscription1month',
+        subKey: 'basic_earned',
+      },
+      {
+        sku: 'com.habitrpg.ios.habitica.subscription.3month',
+        subKey: 'basic_3mo',
+      },
+      {
+        sku: 'com.habitrpg.ios.habitica.subscription.6month',
+        subKey: 'basic_6mo',
+      },
+      {
+        sku: 'com.habitrpg.ios.habitica.subscription.12month',
+        subKey: 'basic_12mo',
+      },
+    ];
+    subOptions.forEach(option => {
+      it(`creates a user subscription for ${option.sku}`, async () => {
+        iapModule.getPurchaseData.restore();
+        iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
+          .returns([{
+            expirationDate: moment.utc().add({day: 1}).toDate(),
+            productId: option.sku,
+            transactionId: token,
+          }]);
+        sub = common.content.subscriptionBlocks[option.subKey];
+
+        await applePayments.subscribe(option.sku, user, receipt, headers, nextPaymentProcessing);
+
+        expect(iapSetupStub).to.be.calledOnce;
+        expect(iapValidateStub).to.be.calledOnce;
+        expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
+        expect(iapIsValidatedStub).to.be.calledOnce;
+        expect(iapIsValidatedStub).to.be.calledWith({});
+        expect(iapGetPurchaseDataStub).to.be.calledOnce;
+
+        expect(paymentsCreateSubscritionStub).to.be.calledOnce;
+        expect(paymentsCreateSubscritionStub).to.be.calledWith({
+          user,
+          customerId: token,
+          paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
+          sub,
+          headers,
+          additionalData: receipt,
+          nextPaymentProcessing,
+        });
+      });
+    });
+
+    it('errors when a user is already subscribed', async () => {
+      payments.createSubscription.restore();
+      user = new User();
+
      await applePayments.subscribe(sku, user, receipt, headers, nextPaymentProcessing);

-      expect(iapSetupStub).to.be.calledOnce;
-      expect(iapValidateStub).to.be.calledOnce;
-      expect(iapValidateStub).to.be.calledWith(iap.APPLE, receipt);
-      expect(iapIsValidatedStub).to.be.calledOnce;
-      expect(iapIsValidatedStub).to.be.calledWith({});
-      expect(iapGetPurchaseDataStub).to.be.calledOnce;
-
-      expect(paymentsCreateSubscritionStub).to.be.calledOnce;
-      expect(paymentsCreateSubscritionStub).to.be.calledWith({
-        user,
-        customerId: token,
-        paymentMethod: applePayments.constants.PAYMENT_METHOD_APPLE,
-        sub,
-        headers,
-        additionalData: receipt,
-        nextPaymentProcessing,
-      });
+      await expect(applePayments.subscribe(sku, user, receipt, headers, nextPaymentProcessing))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: applePayments.constants.RESPONSE_ALREADY_USED,
+        });
    });
  });

@@ -184,9 +330,9 @@ describe('Apple Payments', ()  => {
      expirationDate = moment.utc();

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({
+        .resolves({
          expirationDate,
        });
      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
@@ -201,7 +347,7 @@ describe('Apple Payments', ()  => {
      user.purchased.plan.planId = subKey;
      user.purchased.plan.additionalData = receipt;

-      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').resolves({});
    });

    afterEach(function () {
--- a/test/api/v3/unit/libs/googlePayments.test.js
+++ b/test/api/v3/unit/libs/googlePayments.test.js
@@ -1,11 +1,12 @@
 /* eslint-disable camelcase */
 import iapModule from '../../../../../website/server/libs/inAppPurchases';
-import payments from '../../../../../website/server/libs/payments';
-import googlePayments from '../../../../../website/server/libs/googlePayments';
+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';
+import {mockFindById, restoreFindById} from '../../../../helpers/mongoose.helper';

 const i18n = common.i18n;

@@ -24,12 +25,12 @@ describe('Google Payments', ()  => {
      headers = {};

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({});
+        .resolves({});
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(true);
-      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
+      paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
    });

    afterEach(() => {
@@ -44,7 +45,7 @@ describe('Google Payments', ()  => {
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(false);

-      await expect(googlePayments.verifyGemPurchase(user, receipt, signature, headers))
+      await expect(googlePayments.verifyGemPurchase({user, receipt, signature, headers}))
        .to.eventually.be.rejected.and.to.eql({
          httpCode: 401,
          name: 'NotAuthorized',
@@ -55,7 +56,7 @@ describe('Google Payments', ()  => {
    it('should throw an error if productId is invalid', async () => {
      receipt = `{"token": "${token}", "productId": "invalid"}`;

-      await expect(googlePayments.verifyGemPurchase(user, receipt, signature, headers))
+      await expect(googlePayments.verifyGemPurchase({user, receipt, signature, headers}))
        .to.eventually.be.rejected.and.to.eql({
          httpCode: 401,
          name: 'NotAuthorized',
@@ -64,9 +65,9 @@ describe('Google Payments', ()  => {
    });

    it('should throw an error if user cannot purchase gems', async () => {
-      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+      sinon.stub(user, 'canGetGems').resolves(false);

-      await expect(googlePayments.verifyGemPurchase(user, receipt, signature, headers))
+      await expect(googlePayments.verifyGemPurchase({user, receipt, signature, headers}))
        .to.eventually.be.rejected.and.to.eql({
          httpCode: 401,
          name: 'NotAuthorized',
@@ -77,8 +78,8 @@ describe('Google Payments', ()  => {
    });

    it('purchases gems', async () => {
-      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
-      await googlePayments.verifyGemPurchase(user, receipt, signature, headers);
+      sinon.stub(user, 'canGetGems').resolves(true);
+      await googlePayments.verifyGemPurchase({user, receipt, signature, headers});

      expect(iapSetupStub).to.be.calledOnce;
      expect(iapValidateStub).to.be.calledOnce;
@@ -99,6 +100,34 @@ describe('Google Payments', ()  => {
      expect(user.canGetGems).to.be.calledOnce;
      user.canGetGems.restore();
    });
+
+    it('gifts gems', async () => {
+      const receivingUser = new User();
+      await receivingUser.save();
+
+      mockFindById(receivingUser);
+
+      const gift = {uuid: receivingUser._id};
+      await googlePayments.verifyGemPurchase({user, gift, receipt, signature, headers});
+
+      expect(iapSetupStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledOnce;
+      expect(iapValidateStub).to.be.calledWith(iap.GOOGLE, {
+        data: receipt,
+        signature,
+      });
+      expect(iapIsValidatedStub).to.be.calledOnce;
+      expect(iapIsValidatedStub).to.be.calledWith({});
+
+      expect(paymentBuyGemsStub).to.be.calledOnce;
+      expect(paymentBuyGemsStub).to.be.calledWith({
+        user: receivingUser,
+        paymentMethod: googlePayments.constants.PAYMENT_METHOD_GOOGLE,
+        amount: 5.25,
+        headers,
+      });
+      restoreFindById();
+    });
  });

  describe('subscribe', () => {
@@ -116,12 +145,12 @@ describe('Google Payments', ()  => {
      nextPaymentProcessing = moment.utc().add({days: 2});

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({});
+        .resolves({});
      iapIsValidatedStub = sinon.stub(iapModule, 'isValidated')
        .returns(true);
-      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+      paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').resolves({});
    });

    afterEach(() => {
@@ -193,9 +222,9 @@ describe('Google Payments', ()  => {
      expirationDate = moment.utc();

      iapSetupStub = sinon.stub(iapModule, 'setup')
-        .returnsPromise().resolves();
+        .resolves();
      iapValidateStub = sinon.stub(iapModule, 'validate')
-        .returnsPromise().resolves({
+        .resolves({
          expirationDate,
        });
      iapGetPurchaseDataStub = sinon.stub(iapModule, 'getPurchaseData')
@@ -210,7 +239,7 @@ describe('Google Payments', ()  => {
      user.purchased.plan.planId = subKey;
      user.purchased.plan.additionalData = {data: receipt, signature};

-      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+      paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').resolves({});
    });

    afterEach(function () {
--- a/test/api/v3/unit/libs/payments/group-plans/group-payments-cancel.test.js
+++ b/test/api/v3/unit/libs/payments/group-plans/group-payments-cancel.test.js
@@ -1,13 +1,13 @@
 import moment from 'moment';

-import * as sender from '../../../../../../../website/server/libs/email';
-import * as api from '../../../../../../../website/server/libs/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;
--- a/test/api/v3/unit/libs/payments/group-plans/group-payments-create.test.js
+++ b/test/api/v3/unit/libs/payments/group-plans/group-payments-create.test.js
@@ -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';
-import amzLib from '../../../../../../../website/server/libs/amazonPayments';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-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';
@@ -69,11 +69,11 @@ describe('Purchasing a group plan for group', () => {
    };

    let subscriptionId = 'subId';
-    sinon.stub(stripe.customers, 'del').returnsPromise().resolves({});
+    sinon.stub(stripe.customers, 'del').resolves({});

    let currentPeriodEndTimeStamp = moment().add(3, 'months').unix();
    sinon.stub(stripe.customers, 'retrieve')
-      .returnsPromise().resolves({
+      .resolves({
        subscriptions: {
          data: [{id: subscriptionId, current_period_end: currentPeriodEndTimeStamp}], // eslint-disable-line camelcase
        },
@@ -216,7 +216,6 @@ describe('Purchasing a group plan for group', () => {

  it('sends one email to subscribed member of group, stating subscription is cancelled (Amazon)', async () => {
    sinon.stub(amzLib, 'getBillingAgreementDetails')
-      .returnsPromise()
      .resolves({
        BillingAgreementDetails: {
          BillingAgreementStatus: {State: 'Closed'},
@@ -251,9 +250,9 @@ describe('Purchasing a group plan for group', () => {
  });

  it('sends one email to subscribed member of group, stating subscription is cancelled (PayPal)', async () => {
-    sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
+    sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').resolves({});
    sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
-      .returnsPromise().resolves({
+      .resolves({
        agreement_details: { // eslint-disable-line camelcase
          next_billing_date: moment().add(3, 'months').toDate(), // eslint-disable-line camelcase
          cycles_completed: 1, // eslint-disable-line camelcase
@@ -443,14 +442,12 @@ 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);
  });

  it('adds months to members with existing recurring subscription (Amazon)', async () => {
    sinon.stub(amzLib, 'getBillingAgreementDetails')
-      .returnsPromise()
      .resolves({
        BillingAgreementDetails: {
          BillingAgreementStatus: {State: 'Closed'},
@@ -479,9 +476,9 @@ describe('Purchasing a group plan for group', () => {
  });

  it('adds months to members with existing recurring subscription (Paypal)', async () => {
-    sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
+    sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').resolves({});
    sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
-      .returnsPromise().resolves({
+      .resolves({
        agreement_details: { // eslint-disable-line camelcase
          next_billing_date: moment().add(3, 'months').toDate(), // eslint-disable-line camelcase
          cycles_completed: 1, // eslint-disable-line camelcase
--- a/test/api/v3/unit/libs/payments/paymentHelpers.js
+++ b/test/api/v3/unit/libs/payments/paymentHelpers.js
@@ -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();
--- a/test/api/unit/libs/payments/payments.test.js
+++ b/test/api/unit/libs/payments/payments.test.js
@@ -1,11 +1,11 @@
 import moment from 'moment';

 import * as sender from '../../../../../website/server/libs/email';
-import * as api from '../../../../../website/server/libs/payments';
+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 { translate as t } from '../../../../helpers/api-integration/v3';
 import {
  generateGroup,
 } from '../../../../helpers/api-unit.helper.js';
@@ -16,6 +16,7 @@ describe('payments/index', () => {
  beforeEach(async () => {
    user = new User();
    user.profile.name = 'sender';
+    user.auth.local.username = 'sender';
    await user.save();

    group = generateGroup({
@@ -210,7 +211,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 () => {
@@ -446,6 +447,19 @@ describe('payments/index', () => {
        fakeClock.restore();
      });

+      it('does not add a notification for mystery items if none was awarded', async () => {
+        const noMysteryItemTimeframe = 1462183920000; // May 2nd 2016
+        let fakeClock = sinon.useFakeTimers(noMysteryItemTimeframe);
+        data = { paymentMethod: 'PaymentMethod', user, sub: { key: 'basic_3mo' } };
+
+        await api.createSubscription(data);
+
+        expect(user.purchased.plan.mysteryItems).to.have.a.lengthOf(0);
+        expect(user.notifications.find(n => n.type === 'NEW_MYSTERY_ITEMS')).to.be.undefined;
+
+        fakeClock.restore();
+      });
+
      it('does not award mystery item when user already owns the item', async () => {
        let mayMysteryItemTimeframe = 1464725113000; // May 31st 2016
        let fakeClock = sinon.useFakeTimers(mayMysteryItemTimeframe);
@@ -629,7 +643,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 +681,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 });
      });
    });
  });
--- a/test/api/v3/unit/libs/payments/paypal/checkout-success.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/checkout-success.test.js
@@ -1,7 +1,7 @@
 /* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-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';
@@ -13,9 +13,9 @@ describe('checkout success', () => {
    customerId = 'customerId-test';
    paymentId = 'paymentId-test';

-    paypalPaymentExecuteStub = sinon.stub(paypalPayments, 'paypalPaymentExecute').returnsPromise().resolves({});
-    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
-    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+    paypalPaymentExecuteStub = sinon.stub(paypalPayments, 'paypalPaymentExecute').resolves({});
+    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
+    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').resolves({});
  });

  afterEach(() => {
--- a/test/api/v3/unit/libs/payments/paypal/checkout.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/checkout.test.js
@@ -1,9 +1,9 @@
 /* eslint-disable camelcase */
 import nconf from 'nconf';

-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-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;
@@ -15,6 +15,7 @@ describe('checkout', () => {

  function getPaypalCreateOptions (description, amount) {
    return {
+      experience_profile_id: 'xp_profile_id',
      intent: 'sale',
      payer: { payment_method: 'Paypal' },
      redirect_urls: {
@@ -42,7 +43,7 @@ describe('checkout', () => {
  beforeEach(() => {
    approvalHerf = 'approval_href';
    paypalPaymentCreateStub = sinon.stub(paypalPayments, 'paypalPaymentCreate')
-      .returnsPromise().resolves({
+      .resolves({
        links: [{ rel: 'approval_url', href: approvalHerf }],
      });
  });
@@ -80,7 +81,7 @@ describe('checkout', () => {

  it('should error if the user cannot get gems', async () => {
    let user = new User();
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+    sinon.stub(user, 'canGetGems').resolves(false);

    await expect(paypalPayments.checkout({user})).to.eventually.be.rejected.and.to.eql({
      httpCode: 401,
--- a/test/api/v3/unit/libs/payments/paypal/ipn.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/ipn.test.js
@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
+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';
@@ -34,8 +34,8 @@ describe('ipn', () => {
    group.purchased.plan.lastBillingDate = new Date();
    await group.save();

-    ipnVerifyAsyncStub = sinon.stub(paypalPayments, 'ipnVerifyAsync').returnsPromise().resolves({});
-    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+    ipnVerifyAsyncStub = sinon.stub(paypalPayments, 'ipnVerifyAsync').resolves({});
+    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').resolves({});
  });

  afterEach(function () {
--- a/test/api/v3/unit/libs/payments/paypal/subscribe-cancel.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/subscribe-cancel.test.js
@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
+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;
@@ -38,15 +38,15 @@ describe('subscribeCancel', () => {

    nextBillingDate = new Date();

-    paypalBillingAgreementCancelStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
+    paypalBillingAgreementCancelStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').resolves({});
    paypalBillingAgreementGetStub = sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
-      .returnsPromise().resolves({
+      .resolves({
        agreement_details: {
          next_billing_date: nextBillingDate,
          cycles_completed: 1,
        },
      });
-    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+    paymentCancelSubscriptionSpy = sinon.stub(payments, 'cancelSubscription').resolves({});
  });

  afterEach(function () {
--- a/test/api/v3/unit/libs/payments/paypal/subscribe-success.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/subscribe-success.test.js
@@ -1,11 +1,11 @@
 /* eslint-disable camelcase */
-import payments from '../../../../../../../website/server/libs/payments';
-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
+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';
@@ -28,10 +28,10 @@ describe('subscribeSuccess', () => {
    customerId = 'test-customerId';

    paypalBillingAgreementExecuteStub = sinon.stub(paypalPayments, 'paypalBillingAgreementExecute')
-      .returnsPromise({}).resolves({
+      .resolves({
        id: customerId,
      });
-    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+    paymentsCreateSubscritionStub = sinon.stub(payments, 'createSubscription').resolves({});
  });

  afterEach(() => {
--- a/test/api/v3/unit/libs/payments/paypal/subscribe.test.js
+++ b/test/api/v3/unit/libs/payments/paypal/subscribe.test.js
@@ -2,9 +2,9 @@
 import moment from 'moment';
 import cc from 'coupon-code';

-import paypalPayments from '../../../../../../../website/server/libs/paypalPayments';
-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;

@@ -18,7 +18,7 @@ describe('subscribe', () => {
    sub = Object.assign({}, common.content.subscriptionBlocks[subKey]);

    paypalBillingAgreementCreateStub = sinon.stub(paypalPayments, 'paypalBillingAgreementCreate')
-      .returnsPromise().resolves({
+      .resolves({
        links: [{ rel: 'approval_url', href: approvalHerf }],
      });
  });
--- a/test/api/v3/unit/libs/payments/stripe/cancel-subscription.test.js
+++ b/test/api/v3/unit/libs/payments/stripe/cancel-subscription.test.js
@@ -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/stripePayments';
-import payments from '../../../../../../../website/server/libs/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;

@@ -82,12 +82,12 @@ describe('cancel subscription', () => {

    beforeEach(() => {
      subscriptionId = 'subId';
-      stripeDeleteCustomerStub = sinon.stub(stripe.customers, 'del').returnsPromise().resolves({});
-      paymentsCancelSubStub = sinon.stub(payments, 'cancelSubscription').returnsPromise().resolves({});
+      stripeDeleteCustomerStub = sinon.stub(stripe.customers, 'del').resolves({});
+      paymentsCancelSubStub = sinon.stub(payments, 'cancelSubscription').resolves({});

      currentPeriodEndTimeStamp = (new Date()).getTime();
      stripeRetrieveStub = sinon.stub(stripe.customers, 'retrieve')
-        .returnsPromise().resolves({
+        .resolves({
          subscriptions: {
            data: [{id: subscriptionId, current_period_end: currentPeriodEndTimeStamp}], // eslint-disable-line camelcase
          },
--- a/test/api/v3/unit/libs/payments/stripe/checkout-subscription.test.js
+++ b/test/api/v3/unit/libs/payments/stripe/checkout-subscription.test.js
@@ -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/stripePayments';
-import payments from '../../../../../../../website/server/libs/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;

@@ -54,7 +54,7 @@ describe('checkout with subscription', () => {
    token = 'test-token';

    spy = sinon.stub(stripe.subscriptions, 'update');
-    spy.returnsPromise().resolves;
+    spy.resolves;

    stripeCreateCustomerSpy = sinon.stub(stripe.customers, 'create');
    let stripCustomerResponse = {
@@ -63,10 +63,10 @@ describe('checkout with subscription', () => {
        data: [{id: subscriptionId}],
      },
    };
-    stripeCreateCustomerSpy.returnsPromise().resolves(stripCustomerResponse);
+    stripeCreateCustomerSpy.resolves(stripCustomerResponse);

    stripePaymentsCreateSubSpy = sinon.stub(payments, 'createSubscription');
-    stripePaymentsCreateSubSpy.returnsPromise().resolves({});
+    stripePaymentsCreateSubSpy.resolves({});

    data.groupId = group._id;
    data.sub.quantity = 3;
--- a/test/api/v3/unit/libs/payments/stripe/checkout.test.js
+++ b/test/api/v3/unit/libs/payments/stripe/checkout.test.js
@@ -1,9 +1,9 @@
 import stripeModule from 'stripe';

-import { model as User } from '../../../../../../../website/server/models/user';
-import stripePayments from '../../../../../../../website/server/libs/stripePayments';
-import payments from '../../../../../../../website/server/libs/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;

@@ -26,9 +26,9 @@ describe('checkout', () => {
    let stripCustomerResponse = {
      id: customerIdResponse,
    };
-    stripeChargeStub = sinon.stub(stripe.charges, 'create').returnsPromise().resolves(stripCustomerResponse);
-    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').returnsPromise().resolves({});
-    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription').returnsPromise().resolves({});
+    stripeChargeStub = sinon.stub(stripe.charges, 'create').resolves(stripCustomerResponse);
+    paymentBuyGemsStub = sinon.stub(payments, 'buyGems').resolves({});
+    paymentCreateSubscritionStub = sinon.stub(payments, 'createSubscription').resolves({});
  });

  afterEach(() => {
@@ -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,10 +80,9 @@ describe('checkout', () => {
      });
  });

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

    await expect(stripePayments.checkout({
      token,
@@ -86,7 +101,7 @@ describe('checkout', () => {

  it('should purchase gems', async () => {
    gift = undefined;
-    sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
+    sinon.stub(user, 'canGetGems').resolves(true);

    await stripePayments.checkout({
      token,
--- a/Show More
+++ b/Show More