4.0.6

* Added sorting to dated filter

* Validated payment data type

.babelrc

@@ -1,6 +1,7 @@
 {
   "presets": ["es2015"],
   "plugins": [
+    "transform-object-rest-spread",
     ["transform-async-to-module-method", {
       "module": "bluebird",
       "method": "coroutine"

.ebextensions/deploy.config

@@ -14,7 +14,7 @@ files:
     owner: root
     group: users
     content: |
-      $(ls -td /opt/elasticbeanstalk/node-install/node-* | head -1)/bin/npm install -g npm@4
+      $(ls -td /opt/elasticbeanstalk/node-install/node-* | head -1)/bin/npm install -g npm@5
 container_commands:
   01_makeBabel:
     command: "touch /tmp/.babel.json"

.github/CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Reporting Bugs
 
-[Please see these instructions for reporting bugs](https://github.com/HabitRPG/habitrpg/issues/2760)
+[Please see these instructions for reporting bugs](https://github.com/HabitRPG/habitica/issues/2760)
 
 # Pull Request
 

.github/ISSUE_TEMPLATE.md

@@ -4,7 +4,7 @@
 
 [//]: # (If you have a feature request, use "Help > Request a Feature", not GitHub or the Report a Bug guild.)
 
-[//]: # (For more guidelines see https://github.com/HabitRPG/habitrpg/issues/2760)
+[//]: # (For more guidelines see https://github.com/HabitRPG/habitica/issues/2760)
 
 [//]: # (Fill out relevant information - UUID is found in Settings -> API)
 ### General Info

.travis.yml

@@ -2,6 +2,9 @@ language: node_js
 node_js:
   - '6'
 sudo: required
+dist: precise
+services:
+  - mongodb
 addons:
   apt:
     sources:
@@ -10,14 +13,14 @@ addons:
       - g++-4.8
 before_install:
   - $CXX --version
-  - npm install -g npm@4
+  - npm install -g npm@5
   - if [ $REQUIRES_SERVER ]; then sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10; echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list; sudo apt-get update; sudo apt-get install mongodb-org-server; fi
 install:
   - npm install &> npm.install.log || (cat npm.install.log; false)
 before_script:
   - npm run test:build
   - cp config.json.example config.json
-  - if [ $REQUIRES_SERVER ]; then until nc -z localhost 27017; do echo Waiting for MongoDB; sleep 1; done; export DISPLAY=:99; fi
+  - sleep 15
 script:
   - npm run $TEST
   - if [ $COVERAGE ]; then ./node_modules/.bin/lcov-result-merger 'coverage/**/*.info' | ./node_modules/coveralls/bin/coveralls.js; fi
@@ -31,5 +34,5 @@ env:
     - TEST="test:sanity"
     - TEST="test:content" COVERAGE=true
     - TEST="test:common" COVERAGE=true
-    - TEST="test:karma" COVERAGE=true
     - TEST="client:unit" COVERAGE=true
+    - TEST="apidoc"

Dockerfile

@@ -1,18 +1,22 @@
-FROM node:boron
-
-# Install global packages
-RUN npm install -g gulp grunt-cli bower 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 npm install
-RUN bower install --allow-root
-
-# Create Build dir
-RUN mkdir -p ./website/build
-
-# Start Habitica
-EXPOSE 3000
-CMD ["npm", "start"]
+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 grunt-cli bower 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
+RUN bower install --allow-root
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["npm", "start"]

Dockerfile-Production

@@ -0,0 +1,22 @@
+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 grunt-cli bower mocha
+
+# Clone Habitica repo and install dependencies
+RUN mkdir -p /usr/src/habitrpg
+WORKDIR /usr/src/habitrpg
+RUN git clone --branch v4.0.3 https://github.com/HabitRPG/habitica.git /usr/src/habitrpg
+RUN npm install
+RUN bower install --allow-root
+RUN gulp build:prod --force
+
+# Create Build dir
+RUN mkdir -p ./website/build
+
+# Start Habitica
+EXPOSE 3000
+CMD ["node", "./website/transpiled-babel/index.js"]

config.json.example

@@ -66,7 +66,8 @@
         },
         "mode":"sandbox",
         "client_id":"client_id",
-        "client_secret":"client_secret"
+        "client_secret":"client_secret",
+        "experience_profile_id": ""
     },
     "IAP_GOOGLE_KEYDIR": "/path/to/google/public/key/dir/",
     "LOGGLY_TOKEN": "token",

database_reports/count_users_who_own_specified_gear.js

@@ -3,7 +3,7 @@ var authorUuid = 'd904bd62-da08-416b-a816-ba797c9ee265'; //... own data is done
 
 /**
  * database_reports/count_users_who_own_specified_gear.js
- * https://github.com/HabitRPG/habitrpg/pull/3884
+ * https://github.com/HabitRPG/habitica/pull/3884
  */
 
 var thingsOfInterest = {

docker-compose.dev.yml

@@ -1,3 +1,3 @@
 web:
   volumes:
-    - '.:/habitrpg'
+    - '.:/usr/src/habitrpg'

gulp/gulp-bootstrap.js

@@ -0,0 +1,36 @@
+import gulp from 'gulp';
+import fs from 'fs';
+
+// Copy Bootstrap 4 config variables from /website /node_modules so we can check
+// them into Git
+
+const BOOSTRAP_NEW_CONFIG_PATH = 'website/client/assets/scss/bootstrap_config.scss';
+const BOOTSTRAP_ORIGINAL_CONFIG_PATH = 'node_modules/bootstrap/scss/_custom.scss';
+
+// https://stackoverflow.com/a/14387791/969528
+function copyFile(source, target, cb) {
+  let cbCalled = false;
+
+  function done(err) {
+    if (!cbCalled) {
+      cb(err);
+      cbCalled = true;
+    }
+  }
+
+  let rd = fs.createReadStream(source);
+  rd.on('error', done);
+  let wr = fs.createWriteStream(target);
+  wr.on('error', done);
+  wr.on('close', () => done());
+  rd.pipe(wr);
+}
+
+gulp.task('bootstrap', (done) => {
+  // use new config
+  copyFile(
+    BOOSTRAP_NEW_CONFIG_PATH,
+    BOOTSTRAP_ORIGINAL_CONFIG_PATH,
+    done,
+  );
+});

gulp/gulp-build.js

@@ -1,6 +1,7 @@
 import gulp from 'gulp';
 import runSequence from 'run-sequence';
 import babel from 'gulp-babel';
+import webpackProductionBuild from '../webpack/build';
 require('gulp-grunt')(gulp);
 
 gulp.task('build', () => {
@@ -25,6 +26,14 @@ gulp.task('build:common', () => {
 
 gulp.task('build:server', ['build:src', 'build:common']);
 
+// Client Production Build
+gulp.task('build:client', ['bootstrap'], (done) => {
+  webpackProductionBuild((err, output) => {
+    if (err) return done(err);
+    console.log(output);
+  });
+});
+
 gulp.task('build:dev', ['browserify', 'prepare:staticNewStuff'], (done) => {
   gulp.start('grunt-build:dev', done);
 });
@@ -33,7 +42,12 @@ gulp.task('build:dev:watch', ['build:dev'], () => {
   gulp.watch(['website/client-old/**/*.styl', 'website/common/script/*']);
 });
 
-gulp.task('build:prod', ['browserify', 'build:server', 'prepare:staticNewStuff'], (done) => {
+gulp.task('build:prod', [
+  'browserify', 
+  'build:server', 
+  'prepare:staticNewStuff', 
+  'build:client',
+], (done) => {
   runSequence(
     'grunt-build:prod',
     'apidoc',

gulp/gulp-sprites.js

@@ -49,7 +49,7 @@ gulp.task('sprites:checkCompiledDimensions', ['sprites:main', 'sprites:largeSpri
   });
 
   if (numberOfSheetsThatAreTooBig > 0) {
-    console.error(`${numberOfSheetsThatAreTooBig} sheets might too big for mobile Safari to be able to handle them, but there is a margin of error in these calculations so it is probably okay. Mention this to an admin so they can test a staging site on mobile Safari after your PR is merged.`); // https://github.com/HabitRPG/habitrpg/pull/6683#issuecomment-185462180
+    console.error(`${numberOfSheetsThatAreTooBig} sheets might too big for mobile Safari to be able to handle them, but there is a margin of error in these calculations so it is probably okay. Mention this to an admin so they can test a staging site on mobile Safari after your PR is merged.`); // https://github.com/HabitRPG/habitica/pull/6683#issuecomment-185462180
   } else {
     console.log('All images are within the correct dimensions');
   }

gulpfile.js

@@ -13,6 +13,7 @@ if (process.env.NODE_ENV === 'production') {
   require('./gulp/gulp-newstuff');
   require('./gulp/gulp-build');
   require('./gulp/gulp-babelify');
+  require('./gulp/gulp-bootstrap');
 } else {
   require('glob').sync('./gulp/gulp-*').forEach(require);
   require('gulp').task('default', ['test']);

kubernetes/README.md

@@ -0,0 +1,60 @@
+# Habitica in Kubernetes
+This is a set of sample Kubernetes configuration files to launch Habitica under AWS, both as a single-node web frontend as well as a multi-node web frontend.
+
+## Prerequisites
+* An AWS account.
+* A working Kubernetes installation.
+* A basic understanding of how to use Kubernetes. https://kubernetes.io/
+* A persistent volume for MongoDB data.
+* Docker images of Habitica.
+  + You can use your own, or use the one included in the YAML files.
+  + If you use your own, you'll need a fork of the Habitica GitHub repo and your own Docker Hub repo, both of which are free.
+
+## Before you begin
+1. Set up Kubernetes.
+2. Create an EBS volume for MongoDB data.
+   + Make a note of the name, you'll need it later.
+
+## Starting MongoDB
+1. Edit mongo.yaml
+  + Find the volumeID line.
+  + Change the volume to the one created in the section above.
+2. Run the following commands:
+  + `kubectl.sh create -f mongo.yaml`
+  + `kubectl.sh create -f mongo-service.yaml`
+3. Wait for the MongoDB pod to start up.
+
+## Starting a Single Web Frontend
+
+1. Run the following commands:
+  + `kubectl.sh create -f habitica.yaml`
+  + `kubectl.sh create -f habitica-service.yaml`
+2. Wait for the frontend to start up.
+
+## Starting Multi-node Web Frontend
+1. Run the following commands :
+  + `kubectl.sh create -f habitica-rc.yaml`
+  + `kubectl.sh create -f habitica-service.yaml`
+2. Wait for the frontend to start up.
+
+## Accessing Your Habitica web interface
+Using `kubectl describe svc habiticaweb` get the hostname generated for the Habitica service. Open a browser and go to http://hostname:3000 to access the web front-end for the installations above.
+
+## Shutting down
+Shutting down is basically done by reversing the steps above:
++ `kubectl.sh delete -f habitica-service.yaml`
++ `kubectl.sh delete -f habitica.yaml (or habitica-rc.yaml)`
++ `kubectl.sh delete -f mongo-service.yaml`
++ `kubectl.sh delete -f mongo.yaml`
+
+You can also just shut down all of Kubernetes as well.
+
+## Notes
++ MongoDB data will be persistent! If you need to start with a fresh database, you'll need to remove the volume and re-create it.
++ On AWS, you probably want to use at least t2.medium minion nodes for Kubernetes. The default t2.small is too small for more than two Habitica nodes.
+
+## Future Plans
++ Multi-node MongoDB.
++ Monitoring
++ Instructions for a better hostname. The default generated ones stink.
++ More to come....

kubernetes/habitica-rc.yaml

@@ -0,0 +1,25 @@
+apiVersion: v1
+kind: ReplicationController
+metadata:
+  name: habitica
+  labels:
+    name: habitica
+spec:
+  replicas: 4
+  selector:
+    name: habitica
+  template:
+    metadata:
+      labels:
+        name: habitica
+    spec:
+      containers:
+      - name: habitica
+        image: ksonney/habitrpg:latest
+        env:
+          - name: NODE_DB_URI
+            value: mongodb://mongosvc/habitrpg
+        ports:
+          - containerPort: 3000
+            hostPort: 3000
+            name: habitica

kubernetes/habitica-service.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: Service
+metadata: 
+  labels: 
+    name: habiticaweb
+  name: habiticaweb
+spec: 
+  ports:
+    # the port that this service should serve on
+    - port: 3000
+  # label keys and values that must match in order to receive traffic for this service
+  selector: 
+    name: habitica
+  type: LoadBalancer

kubernetes/habitica.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: habitica
+  labels:
+    name: habitica
+spec:
+  containers:
+#    - image: mongo:latest
+#      name: mongo
+#      ports:
+#        - containerPort: 27017
+#          name: mongo
+    - image: ksonney/habitrpg:latest
+      name: habitica
+      env:
+        - name: NODE_DB_URI
+          value: mongodb://mongosvc/habitrpg
+      ports: 
+        - containerPort: 3000
+          hostPort: 3000
+          name: habitica

kubernetes/mongo-service.yaml

@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Service
+metadata: 
+  labels: 
+    name: mongosvc
+  name: mongosvc
+spec: 
+  ports:
+    # the port that this service should serve on
+    - port: 27017
+  # label keys and values that must match in order to receive traffic for this service
+  selector: 
+    name: mongodb

kubernetes/mongo.yaml

@@ -0,0 +1,28 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: mongodb
+  labels: 
+    name: mongodb
+spec: 
+  containers: 
+    - resources:
+        limits :
+          cpu: 0.5
+      image: mongo
+      name: mongodb
+      ports: 
+        - containerPort: 27017
+          hostPort: 27017
+          name: mongo
+      volumeMounts:
+#         # name must match the volume name below
+        - name: mongo-persistent-storage
+#          # mount path within the container
+          mountPath: /data/db
+  volumes:
+    - name: mongo-persistent-storage
+      awsElasticBlockStore:
+        volumeID: aws://YOUR-REGION/YOUR-VOLNAME
+        fsType: ext3
+

migrations/20170111_announce_collection_quest_change_in_parties.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/****************************************
+ * Author: @Alys
+ *
+ * Reason: Collection quests are being changed
+ * to require fewer items collected:
+ * https://github.com/HabitRPG/habitrpg/pull/7987
+ * This will cause existing quests to end sooner
+ * than the party is expecting.
+ * This script inserts an explanatory `system`
+ * 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');
+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 timer = new Timer();
+
+// PROD: Enable prod db
+// const DB_URI = 'mongodb://username:password@dsXXXXXX-a0.mlab.com:XXXXX,dsXXXXXX-a1.mlab.com:XXXXX/habitica?replicaSet=rs-dsXXXXXX';
+const DB_URI = 'mongodb://localhost/habitrpg';
+
+const COLLECTION_QUESTS = [
+  'vice2',
+  'egg',
+  'moonstone1',
+  'goldenknight1',
+  'dilatoryDistress1',
+];
+
+let Groups;
+
+connectToDb(DB_URI).then((db) => {
+  Groups = db.collection('groups');
+
+  return Promise.resolve();
+})
+.then(findPartiesWithCollectionQuest)
+// .then(displayGroups) // for testing only
+.then(addMessageToGroups)
+.then(() => {
+  timer.stop();
+  closeDb();
+}).catch(reportError);
+
+function reportError (err) {
+  logger.error('Uh oh, an error occurred');
+  closeDb();
+  timer.stop();
+  throw err;
+}
+
+function findPartiesWithCollectionQuest () {
+  logger.info('Looking up groups on collection quests...');
+
+  return Groups.find({'quest.key': {$in: COLLECTION_QUESTS}}, ['name','quest']).toArray().then((groups) => {
+    logger.success('Found', groups.length, 'parties on collection quests');
+
+    return Promise.resolve(groups);
+  })
+}
+
+function displayGroups (groups) { // for testing only
+  logger.info('Displaying parties...');
+  console.log(groups);
+  return Promise.resolve(groups);
+}
+
+function updateGroupById (group) {
+  var newMessage = {
+    'id' : uuid.v4(),
+    'text' : message,
+    'timestamp': Date.now(),
+    'likes': {},
+    'flags': {},
+    'flagCount': 0,
+    'uuid': 'system'
+  };
+  return Groups.findOneAndUpdate({_id: group._id}, {$push:{"chat" :{$each: [newMessage], $position:0}}}, {returnOriginal: false});
+  // Does not set the newMessage flag for all party members because I don't think it's essential and
+  // I don't want to run the extra code (extra database load, extra opportunity for bugs).
+}
+
+function addMessageToGroups (groups) {
+  let queue = new TaskQueue(Promise, 300);
+
+  logger.info('About to update', groups.length, 'parties...');
+
+  return Promise.map(groups, queue.wrap(updateGroupById)).then((result) => {
+    let updates = result.filter(res => res.lastErrorObject && res.lastErrorObject.updatedExisting)
+    let failures = result.filter(res => !(res.lastErrorObject && res.lastErrorObject.updatedExisting));
+
+    logger.success(updates.length, 'parties have been notified');
+
+    if (failures.length > 0) {
+      logger.error(failures.length, 'parties could not be notified');
+    }
+
+    return Promise.resolve();
+  });
+}
+

migrations/20170616_achievements.js

@@ -0,0 +1,114 @@
+var migrationName = '20170616_achievements';
+var authorName = 'Sabe'; // in case script author needs to know when their ...
+var authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; //... own data is done
+
+/*
+ * Updates to achievements for June 16, 2017 biweekly merge
+ * 1. Multiply various collection quest achievements based on difficulty reduction
+ * 2. Award Joined Challenge achievement to those who should have it already
+ */
+
+import monk from 'monk';
+
+var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+var dbUsers = monk(connectionString).get('users', { castIds: false });
+
+function processUsers(lastId) {
+  // specify a query to limit the affected users (empty for all users):
+  var query = {
+    $or: [
+      {'achievements.quests.dilatoryDistress1': {$gt:0}},
+      {'achievements.quests.egg': {$gt:0}},
+      {'achievements.quests.goldenknight1': {$gt:0}},
+      {'achievements.quests.moonstone1': {$gt:0}},
+      {'achievements.quests.vice2': {$gt:0}},
+      {'achievements.challenges': {$exists: true, $ne: []}},
+      {'challenges': {$exists: true, $ne: []}},
+    ],
+  };
+
+  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):
+      'achievements',
+      'challenges',
+    ],
+  })
+  .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 set = {'migration': migrationName};
+
+  if (user.challenges.length > 0 || user.achievements.challenges.length > 0) {
+    set['achievements.joinedChallenge'] = true;
+  }
+  if (user.achievements.quests.dilatoryDistress1) {
+    set['achievements.quests.dilatoryDistress1'] = Math.ceil(user.achievements.quests.dilatoryDistress1 * 1.25);
+  }
+  if (user.achievements.quests.egg) {
+    set['achievements.quests.egg'] = Math.ceil(user.achievements.quests.egg * 2.5);
+  }
+  if (user.achievements.quests.goldenknight1) {
+    set['achievements.quests.goldenknight1'] = user.achievements.quests.goldenknight1 * 5;
+  }
+  if (user.achievements.quests.moonstone1) {
+    set['achievements.quests.moonstone1'] = user.achievements.quests.moonstone1 * 5;
+  }
+  if (user.achievements.quests.vice2) {
+    set['achievements.quests.vice2'] = Math.ceil(user.achievements.quests.vice2 * 1.5);
+  }
+
+  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;

migrations/20170711_orcas.js

@@ -0,0 +1,90 @@
+var migrationName = '20170711_orcas.js';
+var authorName = 'Sabe'; // in case script author needs to know when their ...
+var authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; //... own data is done
+
+/*
+ * Award Orca pets to owners of Orca mount, and Orca mount to everyone else
+ */
+
+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) {
+  // specify a query to limit the affected users (empty for all users):
+  var query = {
+    'migration':{$ne:migrationName},
+  };
+
+  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(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 set = {};
+
+  if (user.items.mounts['Orca-Base']) {
+    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;

migrations/20170731_naming_day.js

@@ -0,0 +1,109 @@
+var migrationName = '20170731_naming_day.js';
+var authorName = 'Sabe'; // in case script author needs to know when their ...
+var authorUuid = '7f14ed62-5408-4e1b-be83-ada62d504931'; //... own data is done
+
+/*
+ * Award Royal Purple Gryphon Helm to Royal Purple Gryphon pet owners,
+ * award Royal Purple Gryphon pet to Royal Purple Gryphon mount owners,
+ * award Royal Purple Gryphon mount to everyone else
+ */
+
+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) {
+  // specify a query to limit the affected users (empty for all users):
+  var query = {
+    'migration':{$ne:migrationName},
+    'auth.timestamps.loggedin': {$gt: new Date('2017-01-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(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 set = {};
+  var inc = {
+    'achievements.habiticaDays': 1,
+    '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
+  };
+
+  if (user.items.pets['Gryphon-RoyalPurple']) {
+    set = {'migration':migrationName, 'items.gear.owned.head_special_namingDay2017': false};
+  } else if (user.items.mounts['Gryphon-RoyalPurple']) {
+    set = {'migration':migrationName, 'items.pets.Gryphon-RoyalPurple': 5};
+  } else {
+    set = {'migration':migrationName, 'items.mounts.Gryphon-RoyalPurple': true};
+  }
+
+  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;

migrations/20170928_redesign_guilds.js

@@ -0,0 +1,97 @@
+var migrationName = '20170928_redesign_guilds.js';
+
+/*
+ * Copy Guild Leader messages to end of Guild descriptions
+ * Copy Guild logos to beginning of Guild descriptions
+ */
+
+var monk = require('monk');
+var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+var dbGroups = monk(connectionString).get('groups', { castIds: false });
+
+function processGroups(lastId) {
+  // specify a query to limit the affected groups (empty for all groups):
+  var query = {
+  };
+
+  var fields = {
+    'description': 1,
+    'logo': 1,
+    'leaderMessage': 1,
+  }
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId
+    }
+  }
+
+  return dbGroups.find(query, {
+    fields: fields,
+    sort: {_id: 1},
+    limit: 250,
+  })
+  .then(updateGroups)
+  .catch(function (err) {
+    console.log(err);
+    return exiting(1, 'ERROR! ' + err);
+  });
+}
+
+var progressCount = 1000;
+var count = 0;
+
+function updateGroups (groups) {
+  if (!groups || groups.length === 0) {
+    console.warn('All appropriate groups found and modified.');
+    displayData();
+    return;
+  }
+
+  var groupPromises = groups.map(updateGroup);
+  var lastGroup = groups[groups.length - 1];
+
+  return Promise.all(groupPromises)
+  .then(function () {
+    processGroups(lastGroup._id);
+  });
+}
+
+function updateGroup (group) {
+  count++;
+
+  var description = group.description;
+
+  if (group.logo) {
+    description = '![Guild Logo](' + group.logo + ')\n\n \n\n' + description;
+  }
+
+  if (group.leaderMessage) {
+    description = description + '\n\n \n\n' + group.leaderMessage;
+  }
+
+  var set = {
+    description: description,
+  };
+
+  if (count % progressCount == 0) console.warn(count + ' ' + group._id);
+
+  return dbGroups.update({_id: group._id}, {$set:set});
+}
+
+function displayData() {
+  console.warn('\n' + count + ' groups 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 = processGroups;

migrations/20170928_redesign_launch.js

@@ -0,0 +1,127 @@
+var updateStore = require('../website/common/script/libs/updateStore');
+var getItemInfo = require('../website/common/script/libs/getItemInfo');
+
+var migrationName = '20170928_redesign_launch.js';
+var authorName = 'paglias'; // in case script author needs to know when their ...
+var authorUuid = 'ed4c688c-6652-4a92-9d03-a5a79844174a'; //... own data is done
+
+/*
+ * Migrate existing in app rewards lists to pinned items
+ * Award Veteran Pets
+ */
+
+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) {
+  // specify a query to limit the affected users (empty for all users):
+  var query = {
+    'migration': {$ne:migrationName},
+    'auth.timestamps.loggedin': {$gt: new Date('2017-09-21')},
+  };
+
+  var fields = {
+    'items.pets': 1,
+    'items.gear': 1,
+    'stats.class': 1,
+  }
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId
+    }
+  }
+
+  return dbUsers.find(query, {
+    fields: fields,
+    sort: {_id: 1},
+    limit: 250,
+  })
+  .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 set = {'migration': migrationName};
+
+  var oldRewardsList = updateStore(user);
+  var newPinnedItems = [
+    {
+      type: 'armoire',
+      path: 'armoire',
+    },
+    {
+      type: 'potion',
+      path: 'potion',
+    },
+  ];
+
+  oldRewardsList.forEach(item => {
+    var type = 'marketGear';
+
+    var itemInfo = getItemInfo(user, 'marketGear', item);
+    newPinnedItems.push({
+      type,
+      path: itemInfo.path,
+    })
+  });
+
+  set.pinnedItems = newPinnedItems;
+
+  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);
+  if (user._id == authorUuid) console.warn(authorName + ' processed');
+
+  return dbUsers.update({_id: user._id}, {$set:set});
+}
+
+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;

migrations/challenges/sync-all-challenges.js

@@ -1,47 +1,47 @@
-import Bluebird from 'Bluebird';
-
-import { model as Challenges } from '../../website/server/models/challenge';
-import { model as User } from '../../website/server/models/user';
-
-async function syncChallengeToMembers (challenges) {
-  let challengSyncPromises = challenges.map(async function (challenge) {
-    let users = await User.find({
-      // _id: '',
-      challenges: challenge._id,
-    }).exec();
-
-    let promises = [];
-    users.forEach(function (user) {
-      promises.push(challenge.syncToUser(user));
-      promises.push(challenge.save());
-      promises.push(user.save());
-    });
-
-    return Bluebird.all(promises);
-  });
-
-  return await Bluebird.all(challengSyncPromises);
-}
-
-async function syncChallenges (lastChallengeDate) {
-  let query = {
-    // _id: '',
-  };
-
-  if (lastChallengeDate) {
-    query.createdOn = { $lte: lastChallengeDate };
-  }
-
-  let challengesFound = await Challenges.find(query)
-    .limit(10)
-    .sort('-createdAt')
-    .exec();
-
-  let syncedChallenges = await syncChallengeToMembers(challengesFound)
-    .catch(reason => console.error(reason));
-  let lastChallenge = challengesFound[challengesFound.length - 1];
-  if (lastChallenge) syncChallenges(lastChallenge.createdAt);
-  return syncedChallenges;
-};
-
-module.exports = syncChallenges;
+import Bluebird from 'Bluebird';
+
+import { model as Challenges } from '../../website/server/models/challenge';
+import { model as User } from '../../website/server/models/user';
+
+async function syncChallengeToMembers (challenges) {
+  let challengSyncPromises = challenges.map(async function (challenge) {
+    let users = await User.find({
+      // _id: '',
+      challenges: challenge._id,
+    }).exec();
+
+    let promises = [];
+    users.forEach(function (user) {
+      promises.push(challenge.syncToUser(user));
+      promises.push(challenge.save());
+      promises.push(user.save());
+    });
+
+    return Bluebird.all(promises);
+  });
+
+  return await Bluebird.all(challengSyncPromises);
+}
+
+async function syncChallenges (lastChallengeDate) {
+  let query = {
+    // _id: '',
+  };
+
+  if (lastChallengeDate) {
+    query.createdOn = { $lte: lastChallengeDate };
+  }
+
+  let challengesFound = await Challenges.find(query)
+    .limit(10)
+    .sort('-createdAt')
+    .exec();
+
+  let syncedChallenges = await syncChallengeToMembers(challengesFound)
+    .catch(reason => console.error(reason));
+  let lastChallenge = challengesFound[challengesFound.length - 1];
+  if (lastChallenge) syncChallenges(lastChallenge.createdAt);
+  return syncedChallenges;
+};
+
+module.exports = syncChallenges;

migrations/migration-runner.js

@@ -21,4 +21,4 @@ var processUsers = require('./groups/update-groups-with-group-plans');
 processUsers()
   .catch(function (err) {
       console.log(err)
-  })
+  })

migrations/mystery_items.js

@@ -2,7 +2,7 @@ var _id = '';
 var update = {
   $addToSet: {
     'purchased.plan.mysteryItems':{
-      $each:['back_mystery_201704','armor_mystery_201704']
+      $each:['shield_mystery_201709','back_mystery_201709']
     }
   }
 };

migrations/s3-upload.js

@@ -0,0 +1,98 @@
+let Bluebird = require('bluebird');
+let request = require('superagent');
+let last = require('lodash/last');
+let AWS = require('aws-sdk');
+
+let config = require('../config');
+const S3_DIRECTORY = 'mobileApp/images'; //config.S3.SPRITES_DIRECTORY;
+
+AWS.config.update({
+  accessKeyId: config.S3.accessKeyId,
+  secretAccessKey: config.S3.secretAccessKey,
+  // region: config.get('S3_REGION'),
+});
+
+let BUCKET_NAME = config.S3.bucket;
+let s3 = new AWS.S3();
+
+// Adapted from http://stackoverflow.com/a/22210077/2601552
+function uploadFile (buffer, fileName) {
+  return new Promise((resolve, reject) => {
+    s3.putObject({
+      Body: buffer,
+      Key: fileName,
+      Bucket: BUCKET_NAME,
+    }, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        // console.info(`${fileName} uploaded to ${BUCKET_NAME} succesfully.`);
+        resolve(fileName);
+      }
+    });
+  });
+}
+
+function getFileName (file) {
+  let piecesOfPath = file.split('/');
+  let name = last(piecesOfPath);
+  let fullName = S3_DIRECTORY + name;
+
+  return fullName;
+}
+
+function getFileFromUrl (url) {
+  return new Promise((resolve, reject) => {
+    request.get(url).end((err, res) => {
+      if (err) return reject(err);
+      let file = res.body;
+      resolve(file);
+    });
+  });
+}
+
+let commit = '78f94e365c72cc58f66857d5941105638db7d35c';
+commit = 'df0dbaba636c9ce424cc7040f7bd7fc1aa311015';
+let gihuburl = `https://api.github.com/repos/HabitRPG/habitica/commits/${commit}`
+
+
+let currentIndex = 0;
+
+function uploadToS3(start, end, filesUrls) {
+  let urls = filesUrls.slice(start, end);
+
+  if (urls.length === 0) {
+    console.log("done");
+    return;
+  }
+
+  let promises = urls.map(fullUrl => {
+    return getFileFromUrl(fullUrl)
+    .then((buffer) => {
+      return uploadFile(buffer, getFileName(fullUrl));
+    });
+  });
+  console.log(promises.length)
+
+  return Bluebird.all(promises)
+    .then(() => {
+      currentIndex += 50;
+      uploadToS3(currentIndex, currentIndex + 50, filesUrls);
+    })
+    .catch(e => {
+      console.log(e);
+    });
+}
+
+request.get(gihuburl)
+  .end((err, res) => {
+    console.log(err);
+    let files = res.body.files;
+
+    let filesUrls = [''];
+    filesUrls = files.map(file => {
+      return file.raw_url;
+    })
+
+    uploadToS3(currentIndex, currentIndex + 50, filesUrls);
+  });

migrations/tasks/tasks-set-yesterdailies.js

@@ -0,0 +1,83 @@
+var migrationName = 'tasks-set-yesterdaily';
+var authorName = 'TheHollidayInn'; // in case script author needs to know when their ...
+var authorUuid = ''; //... own data is done
+
+/*
+ * Iterates over all tasks and sets the yseterDaily field to True
+ */
+
+import monk from 'monk';
+
+var connectionString = 'mongodb://localhost:27017/habitrpg?auto_reconnect=true'; // FOR TEST DATABASE
+var dbTasks = monk(connectionString).get('tasks', { castIds: false });
+
+function processTasks(lastId) {
+  // specify a query to limit the affected tasks (empty for all tasks):
+  var query = {
+    yesterDaily: false,
+  };
+
+  if (lastId) {
+    query._id = {
+      $gt: lastId
+    }
+  }
+
+  dbTasks.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(updateTasks)
+  .catch(function (err) {
+    console.log(err);
+    return exiting(1, 'ERROR! ' + err);
+  });
+}
+
+var progressCount = 1000;
+var count = 0;
+
+function updateTasks (tasks) {
+  if (!tasks || tasks.length === 0) {
+    console.warn('All appropriate tasks found and modified.');
+    displayData();
+    return;
+  }
+
+  var taskPromises = tasks.map(updatetask);
+  var lasttask = tasks[tasks.length - 1];
+
+  return Promise.all(taskPromises)
+  .then(function () {
+    processtasks(lasttask._id);
+  });
+}
+
+function updatetask (task) {
+  count++;
+  var set = {'yesterDaily': true};
+
+  dbTasks.update({_id: task._id}, {$set:set});
+
+  if (count % progressCount == 0) console.warn(count + ' ' + task._id);
+  if (task._id == authorUuid) console.warn(authorName + ' 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 = processtasks;

migrations/users/users-to-test.js

@@ -0,0 +1,109 @@
+var migrationName = 'UserFromProdToTest';
+var authorName = 'TheHollidayInn'; // in case script author needs to know when their ...
+var authorUuid = ''; //... own data is done
+
+/*
+ * This migraition will copy user data from prod to test
+ */
+
+var monk = require('monk');
+var testConnectionSting = ''; // FOR TEST DATABASE
+var usersTest = monk(testConnectionSting).get('users', { castIds: false });
+var groupsTest = monk(testConnectionSting).get('groups', { castIds: false });
+var challengesTest = monk(testConnectionSting).get('challenges', { castIds: false });
+var tasksTest = monk(testConnectionSting).get('tasks', { castIds: false });
+
+var monk2 = require('monk');
+var liveConnectString = ''; // FOR TEST DATABASE
+var userLive = monk2(liveConnectString).get('users', { castIds: false });
+var groupsLive = monk2(liveConnectString).get('groups', { castIds: false });
+var challengesLive = monk2(liveConnectString).get('challenges', { castIds: false });
+var tasksLive = monk2(liveConnectString).get('tasks', { castIds: false });
+
+import uniq from 'lodash/uniq';
+import Bluebird from 'bluebird';
+
+// Variabls for updating
+let userIds = [
+  '206039c6-24e4-4b9f-8a31-61cbb9aa3f66',
+];
+
+let groupIds = [];
+let challengeIds = [];
+let tasksIds = [];
+
+async function processUsers () {
+  let userPromises = [];
+  //{_id: {$in: userIds}}
+
+  return userLive.find({guilds: 'b0764d64-8276-45a1-afa5-5ca9a5c64ca0'})
+    .each((user, {close, pause, resume}) => {
+      if (user.guilds.length > 0) groupIds = groupIds.concat(user.guilds);
+      if (user.party._id) groupIds.push(user.party._id);
+      if (user.challenges.length > 0) challengeIds = challengeIds.concat(user.challenges);
+      if (user.tasksOrder.rewards.length > 0) tasksIds = tasksIds.concat(user.tasksOrder.rewards);
+      if (user.tasksOrder.todos.length > 0) tasksIds = tasksIds.concat(user.tasksOrder.todos);
+      if (user.tasksOrder.dailys.length > 0) tasksIds = tasksIds.concat(user.tasksOrder.dailys);
+      if (user.tasksOrder.habits.length > 0) tasksIds = tasksIds.concat(user.tasksOrder.habits);
+
+      let userPromise = usersTest.update({'_id': user._id}, user, {upsert:true});
+      userPromises.push(userPromise);
+    }).then(() => {
+      return Bluebird.all(userPromises);
+    })
+    .then(() => {
+      console.log("Done User");
+    });
+}
+
+function processGroups () {
+  let promises = [];
+  let groupsToQuery = uniq(groupIds);
+  return groupsLive.find({_id: {$in: groupsToQuery}})
+    .each((group, {close, pause, resume}) => {
+      let promise = groupsTest.update({_id: group._id}, group, {upsert:true});
+      promises.push(promise);
+    }).then(() => {
+      return Bluebird.all(promises);
+    })
+    .then(() => {
+      console.log("Done Group");
+    });
+}
+
+function processChallenges () {
+  let promises = [];
+  let challengesToQuery = uniq(challengeIds);
+  return challengesLive.find({_id: {$in: challengesToQuery}})
+    .each((challenge, {close, pause, resume}) => {
+      let promise = challengesTest.update({_id: challenge._id}, challenge, {upsert:true});
+      promises.push(promise);
+    }).then(() => {
+      return Bluebird.all(promises);
+    })
+    .then(() => {
+      console.log("Done Challenge");
+    });
+}
+
+function processTasks () {
+  let promises = [];
+  let tasksToQuery = uniq(tasksIds);
+  return tasksLive.find({_id: {$in: tasksToQuery}})
+    .each((task, {close, pause, resume}) => {
+      let promise = tasksTest.update({_id: task._id}, task, {upsert:true});
+      promises.push(promise);
+    }).then(() => {
+      return Bluebird.all(promises);
+    })
+    .then(() => {
+      console.log("Done Tasks");
+    });
+}
+
+module.exports = async function prodToTest () {
+  await processUsers();
+  await processGroups();
+  await processChallenges();
+  await processTasks();
+};

package.json

@@ -1,7 +1,7 @@
 {
   "name": "habitica",
   "description": "A habit tracker app which treats your goals like a Role Playing Game.",
-  "version": "3.91.2",
+  "version": "4.0.6",
   "main": "./website/server/index.js",
   "dependencies": {
     "@slack/client": "^3.8.1",
@@ -15,8 +15,10 @@
     "aws-sdk": "^2.0.25",
     "axios": "^0.16.0",
     "babel-core": "^6.0.0",
+    "babel-eslint": "^7.2.3",
     "babel-loader": "^6.0.0",
     "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-object-rest-spread": "^6.16.0",
     "babel-plugin-transform-regenerator": "^6.16.1",
@@ -28,17 +30,18 @@
     "bcrypt": "^1.0.2",
     "bluebird": "^3.3.5",
     "body-parser": "^1.15.0",
-    "bootstrap": "^4.0.0-alpha.6",
-    "bootstrap-vue": "^0.15.8",
+    "bootstrap": "4.0.0-alpha.6",
+    "bootstrap-vue": "^1.0.0-beta.6",
     "bower": "~1.3.12",
     "browserify": "~12.0.1",
     "compression": "^1.6.1",
     "connect-ratelimit": "0.0.7",
     "cookie-session": "^1.2.0",
     "coupon-code": "^0.4.5",
+    "cross-env": "^4.0.0",
     "css-loader": "^0.28.0",
     "csv-stringify": "^1.0.2",
-    "cwait": "^1.0.0",
+    "cwait": "~1.0.1",
     "domain-middleware": "~0.1.0",
     "estraverse": "^4.1.1",
     "express": "~4.14.0",
@@ -57,7 +60,7 @@
     "grunt-contrib-stylus": "~0.20.0",
     "grunt-contrib-uglify": "~0.6.0",
     "grunt-contrib-watch": "~0.6.1",
-    "grunt-hashres": "habitrpg/grunt-hashres#v0.4.2",
+    "grunt-hashres": "git://github.com/habitrpg/grunt-hashres#dc85db6d3002e29e1b7c5ee186b80d708d2f0e0b",
     "gulp": "^3.9.0",
     "gulp-babel": "^6.1.2",
     "gulp-grunt": "^0.5.2",
@@ -67,18 +70,20 @@
     "gulp-uglify": "^1.4.2",
     "gulp.spritesmith": "^4.1.0",
     "habitica-markdown": "^1.3.0",
+    "hellojs": "^1.15.1",
     "html-webpack-plugin": "^2.8.1",
     "image-size": "~0.3.2",
     "in-app-purchase": "^1.1.6",
+    "intro.js": "^2.6.0",
     "jade": "~1.11.0",
-    "jquery": "^3.1.1",
+    "jquery": ">=3.0.0",
     "js2xmlparser": "~1.0.0",
     "lodash": "^4.17.4",
     "merge-stream": "^1.0.0",
     "method-override": "^2.3.5",
     "moment": "^2.13.0",
-    "moment-recur": "habitrpg/moment-recur#v1.0.6",
-    "mongoose": "^4.8.6",
+    "moment-recur": "git://github.com/habitrpg/moment-recur#f147ef27bbc26ca67638385f3db4a44084c76626",
+    "mongoose": "~4.8.6",
     "mongoose-id-autoinc": "~2013.7.14-4",
     "morgan": "^1.7.0",
     "nconf": "~0.8.2",
@@ -94,11 +99,12 @@
     "passport-google-oauth20": "1.0.0",
     "paypal-ipn": "3.0.0",
     "paypal-rest-sdk": "^1.2.1",
+    "popper.js": "^1.11.0",
     "postcss-easy-import": "^2.0.0",
     "pretty-data": "^0.40.0",
     "ps-tree": "^1.0.0",
     "pug": "^2.0.0-beta.12",
-    "push-notify": "habitrpg/push-notify#v1.2.0",
+    "push-notify": "git://github.com/habitrpg/push-notify#6bc2b5fdb1bdc9649b9ec1964d79ca50187fc8a9",
     "pusher": "^1.3.0",
     "request": "~2.74.0",
     "rimraf": "^2.4.3",
@@ -107,8 +113,12 @@
     "sass-loader": "^6.0.2",
     "serve-favicon": "^2.3.0",
     "shelljs": "^0.7.6",
+    "sortablejs": "^1.6.1",
     "stripe": "^4.2.0",
     "superagent": "^3.4.3",
+    "svg-inline-loader": "^0.7.1",
+    "svg-url-loader": "^2.0.2",
+    "svgo-loader": "^1.2.1",
     "universal-analytics": "~0.3.2",
     "url-loader": "^0.5.7",
     "useragent": "^2.1.9",
@@ -122,6 +132,7 @@
     "vue-router": "^2.0.0-rc.5",
     "vue-style-loader": "^3.0.0",
     "vue-template-compiler": "^2.1.10",
+    "vuejs-datepicker": "git://github.com/habitrpg/vuejs-datepicker#45e607a7bccf4e3e089761b3b7b33e3f2c5dc21f",
     "webpack": "^2.2.1",
     "webpack-merge": "^4.0.0",
     "winston": "^2.1.0",
@@ -131,11 +142,11 @@
   "private": true,
   "engines": {
     "node": "^6.9.1",
-    "npm": "^4.0.2"
+    "npm": "^5.0.0"
   },
   "scripts": {
     "lint": "eslint --ext .js,.vue .",
-    "test": "npm run lint && gulp test && npm run client:unit",
+    "test": "npm run lint && gulp test && npm run client:unit && gulp apidoc",
     "test:build": "gulp test:prepare:build",
     "test:api-v3": "gulp test:api-v3",
     "test:api-v3:unit": "gulp test:api-v3:unit",
@@ -152,14 +163,15 @@
     "test:nodemon": "gulp test:nodemon",
     "coverage": "COVERAGE=true mocha --require register-handlers.js --reporter html-cov > coverage.html; open coverage.html",
     "sprites": "gulp sprites:compile",
-    "client:dev": "node webpack/dev-server.js",
-    "client:build": "node webpack/build.js",
+    "client:dev": "gulp bootstrap && node webpack/dev-server.js",
+    "client:build": "gulp build:client",
     "client:unit": "cross-env NODE_ENV=test karma start test/client/unit/karma.conf.js --single-run",
     "client:unit:watch": "cross-env NODE_ENV=test karma start test/client/unit/karma.conf.js",
     "client:e2e": "node test/client/e2e/runner.js",
     "client:test": "npm run client:unit && npm run client:e2e",
     "start": "gulp run:dev",
-    "postinstall": "bower --config.interactive=false install -f; gulp build; npm run client:build"
+    "postinstall": "gulp build",
+    "apidoc": "gulp apidoc"
   },
   "devDependencies": {
     "babel-plugin-istanbul": "^4.0.0",
@@ -169,7 +181,6 @@
     "chromedriver": "^2.27.2",
     "connect-history-api-fallback": "^1.1.0",
     "coveralls": "^2.11.2",
-    "cross-env": "^4.0.0",
     "cross-spawn": "^5.0.1",
     "csv": "~0.3.6",
     "deep-diff": "~0.1.4",
@@ -207,6 +218,7 @@
     "nightwatch": "^0.9.12",
     "phantomjs-prebuilt": "^2.1.12",
     "protractor": "^3.1.1",
+    "raw-loader": "^0.5.1",
     "require-again": "^2.0.0",
     "rewire": "^2.3.3",
     "selenium-server": "^3.0.1",

scripts/paypalBillingSetup.js

@@ -1,3 +1,5 @@
+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
 // file will be used once for initing your billing plan (then you get the resultant plan.id to store in config.json),
@@ -7,10 +9,10 @@ var path = require('path');
 var nconf = require('nconf');
 var _ = require('lodash');
 var paypal = require('paypal-rest-sdk');
-var blocks = require('../../../../common').content.subscriptionBlocks;
+var blocks = require('../website/common').content.subscriptionBlocks;
 var live = nconf.get('PAYPAL:mode')=='live';
 
-nconf.argv().env().file('user', path.join(path.resolve(__dirname, '../../../config.json')));
+nconf.argv().env().file('user', path.join(path.resolve(__dirname, '../config.json')));
 
 var OP = 'create'; // list create update remove
 
@@ -49,6 +51,8 @@ _.each(blocks, function(block){
   });
 })
 
+// @TODO: Add cli library for this
+
 switch(OP) {
   case "list":
     paypal.billingPlan.list({status: 'ACTIVE'}, function(err, plans){
@@ -91,4 +95,17 @@ switch(OP) {
     });
     break;
   case "remove": break;
+
+  case 'create-webprofile':
+    let webexpinfo = {
+      "name": "HabiticaProfile",
+      "input_fields": {
+        "no_shipping": 1,
+      },
+    };
+
+    paypal.webProfile.create(webexpinfo, (error, result) => {
+      console.log(error, result)
+    })
+    break;
 }

test/api/v3/integration/challenges/GET-challenges_challengeId.test.js

@@ -48,8 +48,10 @@ describe('GET /challenges/:challengeId', () => {
       });
       expect(chal.group).to.eql({
         _id: group._id,
+        categories: [],
         id: group.id,
         name: group.name,
+        summary: group.name,
         type: group.type,
         privacy: group.privacy,
         leader: groupLeader.id,
@@ -100,8 +102,10 @@ describe('GET /challenges/:challengeId', () => {
       });
       expect(chal.group).to.eql({
         _id: group._id,
+        categories: [],
         id: group.id,
         name: group.name,
+        summary: group.name,
         type: group.type,
         privacy: group.privacy,
         leader: groupLeader.id,
@@ -153,7 +157,9 @@ describe('GET /challenges/:challengeId', () => {
       expect(chal.group).to.eql({
         _id: group._id,
         id: group.id,
+        categories: [],
         name: group.name,
+        summary: group.name,
         type: group.type,
         privacy: group.privacy,
         leader: groupLeader.id,

test/api/v3/integration/challenges/GET-challenges_user.test.js

@@ -41,10 +41,12 @@ describe('GET challenges/user', () => {
       });
       expect(foundChallenge.group).to.eql({
         _id: publicGuild._id,
+        categories: [],
         id: publicGuild._id,
         type: publicGuild.type,
         privacy: publicGuild.privacy,
         name: publicGuild.name,
+        summary: publicGuild.name,
         leader: publicGuild.leader._id,
       });
     });
@@ -61,10 +63,12 @@ describe('GET challenges/user', () => {
       });
       expect(foundChallenge1.group).to.eql({
         _id: publicGuild._id,
+        categories: [],
         id: publicGuild._id,
         type: publicGuild.type,
         privacy: publicGuild.privacy,
         name: publicGuild.name,
+        summary: publicGuild.name,
         leader: publicGuild.leader._id,
       });
       let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
@@ -76,10 +80,12 @@ describe('GET challenges/user', () => {
       });
       expect(foundChallenge2.group).to.eql({
         _id: publicGuild._id,
+        categories: [],
         id: publicGuild._id,
         type: publicGuild.type,
         privacy: publicGuild.privacy,
         name: publicGuild.name,
+        summary: publicGuild.name,
         leader: publicGuild.leader._id,
       });
     });
@@ -96,10 +102,12 @@ describe('GET challenges/user', () => {
       });
       expect(foundChallenge1.group).to.eql({
         _id: publicGuild._id,
+        categories: [],
         id: publicGuild._id,
         type: publicGuild.type,
         privacy: publicGuild.privacy,
         name: publicGuild.name,
+        summary: publicGuild.name,
         leader: publicGuild.leader._id,
       });
       let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
@@ -111,14 +119,26 @@ describe('GET challenges/user', () => {
       });
       expect(foundChallenge2.group).to.eql({
         _id: publicGuild._id,
+        categories: [],
         id: publicGuild._id,
         type: publicGuild.type,
         privacy: publicGuild.privacy,
         name: publicGuild.name,
+        summary: publicGuild.name,
         leader: publicGuild.leader._id,
       });
     });
 
+    it('should return not return challenges in user groups if we send member true param', async () => {
+      let challenges = await member.get(`/challenges/user?member=${true}`);
+
+      let foundChallenge1 = _.find(challenges, { _id: challenge._id });
+      expect(foundChallenge1).to.not.exist;
+
+      let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+      expect(foundChallenge2).to.not.exist;
+    });
+
     it('should return newest challenges first', async () => {
       let challenges = await user.get('/challenges/user');
 
@@ -137,6 +157,7 @@ describe('GET challenges/user', () => {
       let { group, groupLeader } = await createAndPopulateGroup({
         groupDetails: {
           name: 'TestPrivateGuild',
+          summary: 'summary for TestPrivateGuild',
           type: 'guild',
           privacy: 'private',
         },
@@ -158,6 +179,7 @@ describe('GET challenges/user', () => {
       let { group, groupLeader } = await createAndPopulateGroup({
         groupDetails: {
           name: 'TestGuild',
+          summary: 'summary for TestGuild',
           type: 'guild',
           privacy: 'public',
         },

test/api/v3/integration/challenges/POST-challenges.test.js

@@ -304,5 +304,15 @@ describe('POST /challenges', () => {
 
       await expect(groupLeader.sync()).to.eventually.have.property('challenges').to.include(challenge._id);
     });
+
+    it('awards achievement if this is creator\'s first challenge', async () => {
+      await groupLeader.post('/challenges', {
+        group: group._id,
+        name: 'Test Challenge',
+        shortName: 'TC Label',
+      });
+      groupLeader = await groupLeader.sync();
+      expect(groupLeader.achievements.joinedChallenge).to.be.true;
+    });
   });
 });

test/api/v3/integration/challenges/POST-challenges_challengeId_join.test.js

@@ -123,5 +123,12 @@ describe('POST /challenges/:challengeId/join', () => {
 
       await expect(authorizedUser.get('/tags')).to.eventually.have.length(userTagsLength + 1);
     });
+
+    it('awards achievement if this is user\'s first challenge', async () => {
+      await authorizedUser.post(`/challenges/${challenge._id}/join`);
+
+      await authorizedUser.sync();
+      expect(authorizedUser.achievements.joinedChallenge).to.be.true;
+    });
   });
 });

test/api/v3/integration/challenges/POST-challenges_challengeId_leave.test.js

@@ -32,18 +32,20 @@ describe('POST /challenges/:challengeId/leave', () => {
     let group;
     let challenge;
     let notInChallengeUser;
+    let notInGroupLeavingUser;
     let leavingUser;
     let taskText;
 
     beforeEach(async () => {
       let populatedGroup = await createAndPopulateGroup({
-        members: 2,
+        members: 3,
       });
 
       groupLeader = populatedGroup.groupLeader;
       group = populatedGroup.group;
       leavingUser = populatedGroup.members[0];
       notInChallengeUser = populatedGroup.members[1];
+      notInGroupLeavingUser = populatedGroup.members[2];
 
       challenge = await generateChallenge(groupLeader, group);
 
@@ -55,17 +57,16 @@ describe('POST /challenges/:challengeId/leave', () => {
 
       await leavingUser.post(`/challenges/${challenge._id}/join`);
 
+      await notInGroupLeavingUser.post(`/challenges/${challenge._id}/join`);
+      await notInGroupLeavingUser.post(`/groups/${group._id}/leave`, {
+        keepChallenges: 'remain-in-challenges',
+      });
+
       await challenge.sync();
     });
 
-    it('returns an error when user doesn\'t have permissions to view the challenge', async () => {
-      let unauthorizedUser = await generateUser();
-
-      await expect(unauthorizedUser.post(`/challenges/${challenge._id}/leave`)).to.eventually.be.rejected.and.eql({
-        code: 404,
-        error: 'NotFound',
-        message: t('challengeNotFound'),
-      });
+    it('lets user leave when not a member of the challenge group', async () => {
+      await expect(notInGroupLeavingUser.post(`/challenges/${challenge._id}/leave`)).to.eventually.be.ok;
     });
 
     it('returns an error when user isn\'t a member of the challenge', async () => {

test/api/v3/integration/challenges/POST-challenges_challengeId_winner_winnerId.test.js

@@ -100,8 +100,8 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
       await sleep(0.5);
 
       await expect(winningUser.sync()).to.eventually.have.deep.property('achievements.challenges').to.include(challenge.name);
-      expect(winningUser.notifications.length).to.equal(1);
-      expect(winningUser.notifications[0].type).to.equal('WON_CHALLENGE');
+      expect(winningUser.notifications.length).to.equal(2); // 2 because winningUser just joined the challenge, which now awards an achievement
+      expect(winningUser.notifications[1].type).to.equal('WON_CHALLENGE');
     });
 
     it('gives winner gems as reward', async () => {
@@ -114,6 +114,26 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
       await expect(winningUser.sync()).to.eventually.have.property('balance', oldBalance + challenge.prize / 4);
     });
 
+    it('doesn\'t gives winner gems if group policy prevents it', async () => {
+      let oldBalance = winningUser.balance;
+      let oldLeaderBalance = (await groupLeader.sync()).balance;
+
+      await winningUser.update({
+        'purchased.plan.customerId': 'group-plan',
+      });
+      await group.update({
+        'leaderOnly.getGems': true,
+        'purchased.plan.customerId': 123,
+      });
+
+      await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
+
+      await sleep(0.5);
+
+      await expect(winningUser.sync()).to.eventually.have.property('balance', oldBalance);
+      await expect(groupLeader.sync()).to.eventually.have.property('balance', oldLeaderBalance + challenge.prize / 4);
+    });
+
     it('doesn\'t refund gems to group leader', async () => {
       let oldBalance = (await groupLeader.sync()).balance;
 

test/api/v3/integration/chat/POST-chat.flag.test.js

@@ -84,6 +84,10 @@ describe('POST /chat/:chatId/flag', () => {
       type: 'party',
       privacy: 'private',
     });
+    await user.post(`/groups/${privateGroup._id}/invite`, {
+      uuids: [anotherUser._id],
+    });
+    await anotherUser.post(`/groups/${privateGroup._id}/join`);
     let { message } = await user.post(`/groups/${privateGroup._id}/chat`, {message: TEST_MESSAGE});
 
     let flagResult = await admin.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`);
@@ -91,7 +95,7 @@ describe('POST /chat/:chatId/flag', () => {
     expect(flagResult.flags[admin._id]).to.equal(true);
     expect(flagResult.flagCount).to.equal(5);
 
-    let groupWithFlags = await user.get(`/groups/${privateGroup._id}`);
+    let groupWithFlags = await anotherUser.get(`/groups/${privateGroup._id}`);
     let messageToCheck = find(groupWithFlags.chat, {id: message.id});
 
     expect(messageToCheck).to.not.exist;
@@ -125,4 +129,20 @@ describe('POST /chat/:chatId/flag', () => {
         message: t('messageGroupChatFlagAlreadyReported'),
       });
   });
+
+  it('shows a hidden message to the original poster', async () => {
+    let { message } = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
+
+    await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
+
+    let groupWithFlags = await user.get(`/groups/${group._id}`);
+    let messageToCheck = find(groupWithFlags.chat, {id: message.id});
+
+    expect(messageToCheck).to.exist;
+
+    let auGroupWithFlags = await anotherUser.get(`/groups/${group._id}`);
+    let auMessageToCheck = find(auGroupWithFlags.chat, {id: message.id});
+
+    expect(auMessageToCheck).to.not.exist;
+  });
 });

test/api/v3/integration/chat/POST-chat.test.js

@@ -10,11 +10,22 @@ import {
   TAVERN_ID,
 } from '../../../../../website/server/models/group';
 import { v4 as generateUUID } from 'uuid';
+import { getMatchesByWordArray, removePunctuationFromString } from '../../../../../website/server/libs/stringUtils';
+import bannedWords from '../../../../../website/server/libs/bannedWords';
+import * as email from '../../../../../website/server/libs/email';
+import { IncomingWebhook } from '@slack/client';
+import nconf from 'nconf';
+
+const BASE_URL = nconf.get('BASE_URL');
 
 describe('POST /chat', () => {
   let user, groupWithChat, member, additionalMember;
   let testMessage = 'Test Message';
   let testBannedWordMessage = 'TEST_PLACEHOLDER_SWEAR_WORD_HERE';
+  let testSlurMessage = 'message with TEST_PLACEHOLDER_SLUR_WORD_HERE';
+  let bannedWordErrorMessage = t('bannedWordUsed').split('.');
+  bannedWordErrorMessage[0] += ` (${removePunctuationFromString(testBannedWordMessage.toLowerCase())})`;
+  bannedWordErrorMessage = bannedWordErrorMessage.join('.');
 
   before(async () => {
     let { group, groupLeader, members } = await createAndPopulateGroup({
@@ -25,7 +36,6 @@ describe('POST /chat', () => {
       },
       members: 2,
     });
-
     user = groupLeader;
     groupWithChat = group;
     member = members[0];
@@ -70,20 +80,20 @@ describe('POST /chat', () => {
   it('returns an error when chat privileges are revoked when sending a message to a public guild', async () => {
     let userWithChatRevoked = await member.update({'flags.chatRevoked': true});
     await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
-      code: 404,
-      error: 'NotFound',
-      message: 'Your chat privileges have been revoked.',
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('chatPrivilegesRevoked'),
     });
   });
 
   context('banned word', () => {
     it('returns an error when chat message contains a banned word in tavern', async () => {
       await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage}))
-      .to.eventually.be.rejected.and.eql({
-        code: 400,
-        error: 'BadRequest',
-        message: t('bannedWordUsed'),
-      });
+        .to.eventually.be.rejected.and.eql({
+          code: 400,
+          error: 'BadRequest',
+          message: bannedWordErrorMessage,
+        });
     });
 
     it('errors when word is part of a phrase', async () => {
@@ -92,7 +102,7 @@ describe('POST /chat', () => {
       .to.eventually.be.rejected.and.eql({
         code: 400,
         error: 'BadRequest',
-        message: t('bannedWordUsed'),
+        message: bannedWordErrorMessage,
       });
     });
 
@@ -102,10 +112,26 @@ describe('POST /chat', () => {
       .to.eventually.be.rejected.and.eql({
         code: 400,
         error: 'BadRequest',
-        message: t('bannedWordUsed'),
+        message: bannedWordErrorMessage,
       });
     });
 
+    it('checks error message has the banned words used', async () => {
+      let randIndex = Math.floor(Math.random() * (bannedWords.length + 1));
+      let testBannedWords = bannedWords.slice(randIndex, randIndex + 2).map((w) => w.replace(/\\/g, ''));
+      let chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
+      await expect(user.post('/groups/habitrpg/chat', { message: chatMessage}))
+        .to.eventually.be.rejected
+        .and.have.property('message')
+        .that.includes(testBannedWords.join(', '));
+    });
+
+    it('check all banned words are matched', async () => {
+      let message = bannedWords.join(',').replace(/\\/g, '');
+      let matches = getMatchesByWordArray(message, bannedWords);
+      expect(matches.length).to.equal(bannedWords.length);
+    });
+
     it('does not error when bad word is suffix of a word', async () => {
       let wordAsSuffix = `prefix${testBannedWordMessage}`;
       let message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix});
@@ -166,6 +192,114 @@ describe('POST /chat', () => {
     });
   });
 
+  context('banned slur', () => {
+    beforeEach(() => {
+      sandbox.spy(email, 'sendTxn');
+      sandbox.stub(IncomingWebhook.prototype, 'send');
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('errors and revokes privileges when chat message contains a banned slur', async () => {
+      await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('bannedSlurUsed'),
+      });
+
+      // Email sent to mods
+      await sleep(0.5);
+      expect(email.sendTxn).to.be.calledOnce;
+      expect(email.sendTxn.args[0][1]).to.be.eql('slur-report-to-mods');
+
+      // Slack message to mods
+      expect(IncomingWebhook.prototype.send).to.be.calledOnce;
+      /* eslint-disable camelcase */
+      expect(IncomingWebhook.prototype.send).to.be.calledWith({
+        text: `${user.profile.name} (${user.id}) tried to post a slur`,
+        attachments: [{
+          fallback: 'Slur Message',
+          color: 'danger',
+          author_name: `${user.profile.name} - ${user.auth.local.email} - ${user._id}`,
+          title: 'Slur in Test Guild',
+          title_link: `${BASE_URL}/groups/guild/${groupWithChat.id}`,
+          text: testSlurMessage,
+          // footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
+          mrkdwn_in: [
+            'text',
+          ],
+        }],
+      });
+      /* eslint-enable camelcase */
+
+      // Chat privileges are revoked
+      await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('chatPrivilegesRevoked'),
+      });
+
+      // Restore chat privileges to continue testing
+      user.flags.chatRevoked = false;
+      await user.update({'flags.chatRevoked': false});
+    });
+
+    it('does not allow slurs in private groups', async () => {
+      let { group, members } = await createAndPopulateGroup({
+        groupDetails: {
+          name: 'Party',
+          type: 'party',
+          privacy: 'private',
+        },
+        members: 1,
+      });
+
+      await expect(members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('bannedSlurUsed'),
+      });
+
+      // Email sent to mods
+      await sleep(0.5);
+      expect(email.sendTxn).to.be.calledThrice;
+      expect(email.sendTxn.args[2][1]).to.be.eql('slur-report-to-mods');
+
+      // Slack message to mods
+      expect(IncomingWebhook.prototype.send).to.be.calledOnce;
+      /* eslint-disable camelcase */
+      expect(IncomingWebhook.prototype.send).to.be.calledWith({
+        text: `${members[0].profile.name} (${members[0].id}) tried to post a slur`,
+        attachments: [{
+          fallback: 'Slur Message',
+          color: 'danger',
+          author_name: `${members[0].profile.name} - ${members[0].auth.local.email} - ${members[0]._id}`,
+          title: 'Slur in Party - (private party)',
+          title_link: undefined,
+          text: testSlurMessage,
+          // footer: sandbox.match(/<.*?groupId=group-id&chatId=chat-id\|Flag this message>/),
+          mrkdwn_in: [
+            'text',
+          ],
+        }],
+      });
+      /* eslint-enable camelcase */
+
+      // Chat privileges are revoked
+      await expect(members[0].post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('chatPrivilegesRevoked'),
+      });
+
+      // Restore chat privileges to continue testing
+      members[0].flags.chatRevoked = false;
+      await members[0].update({'flags.chatRevoked': false});
+    });
+  });
+
   it('does not error when sending a message to a private guild with a user with revoked chat', async () => {
     let { group, members } = await createAndPopulateGroup({
       groupDetails: {

test/api/v3/integration/groups/GET-group-plans.test.js

@@ -0,0 +1,32 @@
+import {
+  generateUser,
+  generateGroup,
+} from '../../../../helpers/api-v3-integration.helper';
+
+describe('GET /group-plans', () => {
+  let user;
+  let groupPlan;
+
+  before(async () => {
+    user = await generateUser({balance: 4});
+    groupPlan = await generateGroup(user,
+      {
+        name: 'public guild - is member',
+        type: 'guild',
+        privacy: 'public',
+      },
+      {
+        purchased: {
+          plan: {
+            customerId: 'existings',
+          },
+        },
+      });
+  });
+
+  it('returns group plans for the user', async () => {
+    let groupPlans = await user.get('/group-plans');
+
+    expect(groupPlans[0]._id).to.eql(groupPlan._id);
+  });
+});

test/api/v3/integration/groups/GET-groups.test.js

@@ -16,6 +16,12 @@ describe('GET /groups', () => {
   const NUMBER_OF_USERS_PRIVATE_GUILDS = 1;
   const NUMBER_OF_GROUPS_USER_CAN_VIEW = 5;
   const GUILD_PER_PAGE = 30;
+  let categories = [{
+    slug: 'newCat',
+    name: 'New Category',
+  }];
+  let publicGuildNotMember;
+  let privateGuildUserIsMemberOf;
 
   before(async () => {
     await resetHabiticaDB();
@@ -31,16 +37,18 @@ describe('GET /groups', () => {
     await leader.post(`/groups/${publicGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
     await user.post(`/groups/${publicGuildUserIsMemberOf._id}/join`);
 
-    await generateGroup(leader, {
+    publicGuildNotMember = await generateGroup(leader, {
       name: 'public guild - is not member',
       type: 'guild',
       privacy: 'public',
+      categories,
     });
 
-    let privateGuildUserIsMemberOf = await generateGroup(leader, {
+    privateGuildUserIsMemberOf = await generateGroup(leader, {
       name: 'private guild - is member',
       type: 'guild',
       privacy: 'private',
+      categories,
     });
     await leader.post(`/groups/${privateGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
     await user.post(`/groups/${privateGuildUserIsMemberOf._id}/join`);
@@ -100,6 +108,50 @@ describe('GET /groups', () => {
       .to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
   });
 
+  describe('filters', () => {
+    it('returns public guilds filtered by category', async () => {
+      let guilds = await user.get(`/groups?type=publicGuilds&categories=${categories[0].slug}`);
+
+      expect(guilds[0]._id).to.equal(publicGuildNotMember._id);
+    });
+
+    it('returns private guilds filtered by category', async () => {
+      let guilds = await user.get(`/groups?type=privateGuilds&categories=${categories[0].slug}`);
+
+      expect(guilds[0]._id).to.equal(privateGuildUserIsMemberOf._id);
+    });
+
+    it('filters public guilds by size', async () => {
+      await generateGroup(user, {
+        name: 'guild1',
+        type: 'guild',
+        privacy: 'public',
+        memberCount: 1,
+      });
+
+      // @TODO: anyway to set higher memberCount in tests right now?
+
+      let guilds = await user.get('/groups?type=publicGuilds&minMemberCount=3');
+
+      expect(guilds.length).to.equal(0);
+    });
+
+    it('filters private guilds by size', async () => {
+      await generateGroup(user, {
+        name: 'guild1',
+        type: 'guild',
+        privacy: 'private',
+        memberCount: 1,
+      });
+
+      // @TODO: anyway to set higher memberCount in tests right now?
+
+      let guilds = await user.get('/groups?type=privateGuilds&minMemberCount=3');
+
+      expect(guilds.length).to.equal(0);
+    });
+  });
+
   describe('public guilds pagination', () => {
     it('req.query.paginate must be a boolean string', async () => {
       await expect(user.get('/groups?paginate=aString&type=publicGuilds'))
@@ -149,8 +201,8 @@ describe('GET /groups', () => {
       await expect(user.get('/groups?type=publicGuilds&paginate=true&page=1'))
         .to.eventually.have.a.lengthOf(GUILD_PER_PAGE);
       let page2 = await expect(user.get('/groups?type=publicGuilds&paginate=true&page=2'))
-        .to.eventually.have.a.lengthOf(1 + 2); // 1 created now, 2 by other tests
-      expect(page2[2].name).to.equal('guild with less members');
+        .to.eventually.have.a.lengthOf(1 + 3); // 1 created now, 3 by other tests
+      expect(page2[3].name).to.equal('guild with less members');
     });
   });
 

test/api/v3/integration/groups/GET-groups_groupId_members.test.js

@@ -66,11 +66,25 @@ describe('GET /groups/:groupId/members', () => {
     expect(res[0].profile).to.have.all.keys(['name']);
   });
 
-  it('req.query.includeAllPublicFields === true only works with parties', async () => {
+  it('req.query.includeAllPublicFields === true works with guilds', async () => {
     let group = await generateGroup(user, {type: 'guild', name: generateUUID()});
-    let res = await user.get(`/groups/${group._id}/members?includeAllPublicFields=true`);
-    expect(res[0]).to.have.all.keys(['_id', 'id', 'profile']);
-    expect(res[0].profile).to.have.all.keys(['name']);
+    let [memberRes] = await user.get(`/groups/${group._id}/members?includeAllPublicFields=true`);
+
+    expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
+      '_id', 'id', 'preferences', 'profile', 'stats', 'achievements', 'party',
+      'backer', 'contributor', 'auth', 'items', 'inbox',
+    ]);
+    expect(Object.keys(memberRes.auth)).to.eql(['timestamps']);
+    expect(Object.keys(memberRes.preferences).sort()).to.eql([
+      'size', 'hair', 'skin', 'shirt',
+      'chair', 'costume', 'sleep', 'background', 'tasks',
+    ].sort());
+
+    expect(memberRes.stats.maxMP).to.exist;
+    expect(memberRes.stats.maxHealth).to.equal(common.maxHealth);
+    expect(memberRes.stats.toNextLevel).to.equal(common.tnl(memberRes.stats.lvl));
+    expect(memberRes.inbox.optOut).to.exist;
+    expect(memberRes.inbox.messages).to.not.exist;
   });
 
   it('populates all public fields if req.query.includeAllPublicFields === true and it is a party', async () => {

test/api/v3/integration/groups/POST-groups_groupId_join.test.js

@@ -220,7 +220,7 @@ describe('POST /group/:groupId/join', () => {
       it('clears invitation from user when joining party', async () => {
         await invitedUser.post(`/groups/${party._id}/join`);
 
-        await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.party.id');
+        await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.parties[0].id');
       });
 
       it('increments memberCount when joining party', async () => {

test/api/v3/integration/groups/POST-groups_groupId_leave.js

@@ -247,7 +247,7 @@ describe('POST /groups/:groupId/leave', () => {
 
         let userWithoutInvitation = await invitedUser.get('/user');
 
-        expect(userWithoutInvitation.invitations.party).to.be.empty;
+        expect(userWithoutInvitation.invitations.parties[0]).to.be.empty;
       });
     });
 

test/api/v3/integration/groups/POST-groups_groupId_reject.test.js

@@ -107,7 +107,7 @@ describe('POST /group/:groupId/reject-invite', () => {
     it('clears invitation from user', async () => {
       await invitedUser.post(`/groups/${party._id}/reject-invite`);
 
-      await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.party.id');
+      await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.parties[0].id');
     });
   });
 });

test/api/v3/integration/groups/POST-groups_id_removeMember.test.js

@@ -11,6 +11,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
   let guild;
   let member;
   let member2;
+  let adminUser;
 
   beforeEach(async () => {
     let { group, groupLeader, invitees, members } = await createAndPopulateGroup({
@@ -28,6 +29,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
     invitedUser = invitees[0];
     member = members[0];
     member2 = members[1];
+    adminUser = await generateUser({ 'contributor.admin': true });
   });
 
   context('All Groups', () => {
@@ -42,7 +44,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
         });
     });
 
-    it('returns an error when user is a non-leader member of a group', async () => {
+    it('returns an error when user is a non-leader member of a group and not an admin', async () => {
       expect(member2.post(`/groups/${guild._id}/removeMember/${member._id}`))
         .to.eventually.be.rejected.and.eql({
           code: 401,
@@ -87,7 +89,30 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
 
       let invitedUserWithoutInvite = await invitedUser.get('/user');
 
-      expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, {id: guild._id})).eql(-1);
+      expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, { id: guild._id })).eql(-1);
+    });
+
+    it('allows an admin to remove other members', async () => {
+      await adminUser.post(`/groups/${guild._id}/removeMember/${member._id}`);
+      let memberRemoved = await member.get('/user');
+
+      expect(memberRemoved.guilds.indexOf(guild._id)).eql(-1);
+    });
+
+    it('allows an admin to remove other invites', async () => {
+      await adminUser.post(`/groups/${guild._id}/removeMember/${invitedUser._id}`);
+
+      let invitedUserWithoutInvite = await invitedUser.get('/user');
+
+      expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, { id: guild._id })).eql(-1);
+    });
+
+    it('does not allow an admin to remove a leader', async () => {
+      expect(adminUser.post(`/groups/${guild._id}/removeMember/${leader._id}`))
+        .to.eventually.be.rejected.and.eql({
+          code: 401,
+          text: t('cannotRemoveCurrentLeader'),
+        });
     });
 
     it('sends email to user with rescinded invite', async () => {
@@ -152,13 +177,13 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
     });
 
     it('can remove other invites', async () => {
-      expect(partyInvitedUser.invitations.party).to.not.be.empty;
+      expect(partyInvitedUser.invitations.parties[0]).to.not.be.empty;
 
       await partyLeader.post(`/groups/${party._id}/removeMember/${partyInvitedUser._id}`);
 
       let invitedUserWithoutInvite = await partyInvitedUser.get('/user');
 
-      expect(invitedUserWithoutInvite.invitations.party).to.be.empty;
+      expect(invitedUserWithoutInvite.invitations.parties[0]).to.be.empty;
     });
 
     it('removes new messages from a member who is removed', async () => {

test/api/v3/integration/groups/POST-groups_invite.test.js

@@ -440,7 +440,38 @@ describe('Post /groups/:groupId/invite', () => {
       await inviter.post(`/groups/${party._id}/invite`, {
         uuids: [userToInvite._id],
       });
-      expect((await userToInvite.get('/user')).invitations.party.id).to.equal(party._id);
+      expect((await userToInvite.get('/user')).invitations.parties[0].id).to.equal(party._id);
+    });
+
+    it('allow inviting a user to 2 different parties', async () => {
+      // Create another inviter
+      let inviter2 = await generateUser();
+
+      // Create user to invite
+      let userToInvite = await generateUser();
+
+      // Create second group
+      let party2 = await inviter2.post('/groups', {
+        name: 'Test Party 2',
+        type: 'party',
+      });
+
+      // Invite to first party
+      await inviter.post(`/groups/${party._id}/invite`, {
+        uuids: [userToInvite._id],
+      });
+
+      // Invite to second party
+      await inviter2.post(`/groups/${party2._id}/invite`, {
+        uuids: [userToInvite._id],
+      });
+
+      // Get updated user
+      let invitedUser = await userToInvite.get('/user');
+
+      expect(invitedUser.invitations.parties.length).to.equal(2);
+      expect(invitedUser.invitations.parties[0].id).to.equal(party._id);
+      expect(invitedUser.invitations.parties[1].id).to.equal(party2._id);
     });
 
     it('allow inviting a user if party id is not associated with a real party', async () => {
@@ -451,7 +482,7 @@ describe('Post /groups/:groupId/invite', () => {
       await inviter.post(`/groups/${party._id}/invite`, {
         uuids: [userToInvite._id],
       });
-      expect((await userToInvite.get('/user')).invitations.party.id).to.equal(party._id);
+      expect((await userToInvite.get('/user')).invitations.parties[0].id).to.equal(party._id);
     });
 
     it('allows 30 members in a party', async () => {

test/api/v3/integration/groups/PUT-groups.test.js

@@ -1,10 +1,11 @@
 import {
   createAndPopulateGroup,
+  generateUser,
   translate as t,
 } from '../../../../helpers/api-v3-integration.helper';
 
 describe('PUT /group', () => {
-  let leader, nonLeader, groupToUpdate;
+  let leader, nonLeader, groupToUpdate, adminUser;
   let groupName = 'Test Public Guild';
   let groupType = 'guild';
   let groupUpdatedName = 'Test Public Guild Updated';
@@ -18,13 +19,13 @@ describe('PUT /group', () => {
       },
       members: 1,
     });
-
+    adminUser = await generateUser({ 'contributor.admin': true });
     groupToUpdate = group;
     leader = groupLeader;
     nonLeader = members[0];
   });
 
-  it('returns an error when a non group leader tries to update', async () => {
+  it('returns an error when a user that is not an admin or group leader tries to update', async () => {
     await expect(nonLeader.put(`/groups/${groupToUpdate._id}`, {
       name: groupUpdatedName,
     })).to.eventually.be.rejected.and.eql({
@@ -44,6 +45,29 @@ describe('PUT /group', () => {
     expect(updatedGroup.name).to.equal(groupUpdatedName);
   });
 
+  it('updates a group categories', async () => {
+    let categories = [{
+      slug: 'newCat',
+      name: 'New Category',
+    }];
+
+    let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
+      categories,
+    });
+
+    expect(updatedGroup.categories[0].slug).to.eql(categories[0].slug);
+    expect(updatedGroup.categories[0].name).to.eql(categories[0].name);
+  });
+
+  it('allows an admin to update a guild', async () => {
+    let updatedGroup = await adminUser.put(`/groups/${groupToUpdate._id}`, {
+      name: groupUpdatedName,
+    });
+    expect(updatedGroup.leader._id).to.eql(leader._id);
+    expect(updatedGroup.leader.profile.name).to.eql(leader.profile.name);
+    expect(updatedGroup.name).to.equal(groupUpdatedName);
+  });
+
   it('allows a leader to change leaders', async () => {
     let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
       name: groupUpdatedName,

test/api/v3/integration/members/GET-objections_interaction.test.js

@@ -0,0 +1,64 @@
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-v3-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('GET /members/:toUserId/objections/:interaction', () => {
+  let user;
+
+  before(async () => {
+    user = await generateUser();
+  });
+
+  it('validates req.params.memberId', async () => {
+    await expect(
+      user.get('/members/invalidUUID/objections/send-private-message')
+    ).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('handles non-existing members', async () => {
+    let dummyId = generateUUID();
+    await expect(
+      user.get(`/members/${dummyId}/objections/send-private-message`)
+    ).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('userWithIDNotFound', {userId: dummyId}),
+    });
+  });
+
+  it('handles non-existing interactions', async () => {
+    let receiver = await generateUser();
+
+    await expect(
+      user.get(`/members/${receiver._id}/objections/hug-a-whole-forest-of-trees`)
+    ).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('returns an empty array if there are no objections', async () => {
+    let receiver = await generateUser();
+
+    await expect(
+      user.get(`/members/${receiver._id}/objections/send-private-message`)
+    ).to.eventually.be.fulfilled.and.eql([]);
+  });
+
+  it('returns an array of objections if any exist', async () => {
+    let receiver = await generateUser({'inbox.blocks': [user._id]});
+
+    await expect(
+      user.get(`/members/${receiver._id}/objections/send-private-message`)
+    ).to.eventually.be.fulfilled.and.eql([
+      t('notAuthorizedToSendMessageToThisUser'),
+    ]);
+  });
+});

test/api/v3/integration/members/POST-send_private_message.test.js

@@ -82,6 +82,20 @@ describe('POST /members/send-private-message', () => {
     });
   });
 
+  it('returns an error when chat privileges are revoked', async () => {
+    let userWithChatRevoked = await generateUser({'flags.chatRevoked': true});
+    let receiver = await generateUser();
+
+    await expect(userWithChatRevoked.post('/members/send-private-message', {
+      message: messageToSend,
+      toUserId: receiver._id,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('chatPrivilegesRevoked'),
+    });
+  });
+
   it('sends a private message to a user', async () => {
     let receiver = await generateUser();
 

test/api/v3/integration/members/POST-transfer_gems.test.js

@@ -43,7 +43,7 @@ describe('POST /members/transfer-gems', () => {
     });
   });
 
-  it('returns error when to user is not found', async () => {
+  it('returns error when recipient is not found', async () => {
     await expect(userToSendMessage.post('/members/transfer-gems', {
       message,
       gemAmount,
@@ -55,7 +55,7 @@ describe('POST /members/transfer-gems', () => {
     });
   });
 
-  it('returns error when to user attempts to send gems to themselves', async () => {
+  it('returns error when user attempts to send gems to themselves', async () => {
     await expect(userToSendMessage.post('/members/transfer-gems', {
       message,
       gemAmount,
@@ -67,6 +67,64 @@ describe('POST /members/transfer-gems', () => {
     });
   });
 
+  it('returns error when recipient has blocked the sender', async () => {
+    let receiverWhoBlocksUser = await generateUser({'inbox.blocks': [userToSendMessage._id]});
+
+    await expect(userToSendMessage.post('/members/transfer-gems', {
+      message,
+      gemAmount,
+      toUserId: receiverWhoBlocksUser._id,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('notAuthorizedToSendMessageToThisUser'),
+    });
+  });
+
+  it('returns error when sender has blocked recipient', async () => {
+    let sender = await generateUser({'inbox.blocks': [receiver._id]});
+
+    await expect(sender.post('/members/transfer-gems', {
+      message,
+      gemAmount,
+      toUserId: receiver._id,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('notAuthorizedToSendMessageToThisUser'),
+    });
+  });
+
+  it('returns an error when chat privileges are revoked', async () => {
+    let userWithChatRevoked = await generateUser({'flags.chatRevoked': true});
+
+    await expect(userWithChatRevoked.post('/members/transfer-gems', {
+      message,
+      gemAmount,
+      toUserId: receiver._id,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('chatPrivilegesRevoked'),
+    });
+  });
+
+  it('works when only the recipient\'s chat privileges are revoked', async () => {
+    let receiverWithChatRevoked = await generateUser({'flags.chatRevoked': true});
+
+    await expect(userToSendMessage.post('/members/transfer-gems', {
+      message,
+      gemAmount,
+      toUserId: receiverWithChatRevoked._id,
+    })).to.eventually.be.fulfilled;
+
+    let updatedReceiver = await receiverWithChatRevoked.get('/user');
+    let updatedSender = await userToSendMessage.get('/user');
+
+    expect(updatedReceiver.balance).to.equal(gemAmount / 4);
+    expect(updatedSender.balance).to.equal(0);
+  });
+
   it('returns error when there is no gemAmount', async () => {
     await expect(userToSendMessage.post('/members/transfer-gems', {
       message,
@@ -144,7 +202,7 @@ describe('POST /members/transfer-gems', () => {
     expect(updatedSender.balance).to.equal(0);
   });
 
-  it('does not requrie a message', async () => {
+  it('does not require a message', async () => {
     await userToSendMessage.post('/members/transfer-gems', {
       gemAmount,
       toUserId: receiver._id,

test/api/v3/integration/qrcodes/GET-qrcodes_user.test.js

@@ -6,7 +6,7 @@ import superagent from 'superagent';
 import nconf from 'nconf';
 
 const API_TEST_SERVER_PORT = nconf.get('PORT');
-describe('GET /qr-code/user/:memberId', () => {
+xdescribe('GET /qr-code/user/:memberId', () => {
   let user;
 
   before(async () => {

test/api/v3/integration/shops/GET-shops_backgrounds.test.js

@@ -0,0 +1,25 @@
+import {
+  generateUser,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('GET /shops/backgrounds', () => {
+  let user;
+
+  beforeEach(async () => {
+    user = await generateUser();
+  });
+
+  it('returns a valid shop object', async () => {
+    let shop = await user.get('/shops/backgrounds');
+    expect(shop.identifier).to.equal('backgroundShop');
+    expect(shop.text).to.eql(t('backgroundShop'));
+    expect(shop.notes).to.eql(t('backgroundShopText'));
+    expect(shop.imageName).to.equal('background_shop');
+    expect(shop.sets).to.be.an('array');
+
+    let sets = shop.sets.map(set => set.identifier);
+    expect(sets).to.include('incentiveBackgrounds');
+    expect(sets).to.include('backgrounds062014');
+  });
+});

test/api/v3/integration/tasks/GET-tasks_user.test.js

@@ -1,3 +1,4 @@
+import moment from 'moment';
 import {
   generateUser,
 } from '../../../../helpers/api-integration/v3';
@@ -12,7 +13,7 @@ describe('GET /tasks/user', () => {
   it('returns all user\'s tasks', async () => {
     let createdTasks = await user.post('/tasks/user', [{text: 'test habit', type: 'habit'}, {text: 'test todo', type: 'todo'}]);
     let tasks = await user.get('/tasks/user');
-    expect(tasks.length).to.equal(createdTasks.length + 1); // + 1 because 1 is a default task
+    expect(tasks.length).to.equal(createdTasks.length + 1); // Plus one for generated todo
   });
 
   it('returns only a type of user\'s tasks if req.query.type is specified', async () => {
@@ -127,4 +128,106 @@ describe('GET /tasks/user', () => {
     let allCompletedTodos = await user.get('/tasks/user?type=_allCompletedTodos');
     expect(allCompletedTodos.length).to.equal(numberOfTodos);
   });
+
+  it('returns dailies with isDue for the date specified', async () => {
+    // @TODO Add required format
+    let startDate = moment().subtract('1', 'days').toISOString();
+    let createdTasks = await user.post('/tasks/user', [
+      {
+        text: 'test daily',
+        type: 'daily',
+        startDate,
+        frequency: 'daily',
+        everyX: 2,
+      },
+    ]);
+    let dailys = await user.get('/tasks/user?type=dailys');
+
+    expect(dailys.length).to.be.at.least(1);
+    expect(dailys[0]._id).to.equal(createdTasks._id);
+    expect(dailys[0].isDue).to.be.false;
+
+    let dailys2 = await user.get(`/tasks/user?type=dailys&dueDate=${startDate}`);
+    expect(dailys2[0]._id).to.equal(createdTasks._id);
+    expect(dailys2[0].isDue).to.be.true;
+  });
+
+  xit('returns dailies with isDue for the date specified and will add CDS offset if time is not supplied and assumes timezones', async () => {
+    let timezone = 420;
+    await user.update({
+      'preferences.dayStart': 0,
+      'preferences.timezoneOffset': timezone,
+    });
+    let startDate = moment().zone(timezone).subtract('4', 'days').startOf('day').toISOString();
+    await user.post('/tasks/user', [
+      {
+        text: 'test daily',
+        type: 'daily',
+        startDate,
+        frequency: 'daily',
+        everyX: 2,
+      },
+    ]);
+
+    let today = moment().format('YYYY-MM-DD');
+    let dailys = await user.get(`/tasks/user?type=dailys&dueDate=${today}`);
+    expect(dailys[0].isDue).to.be.true;
+
+    let yesterday = moment().subtract('1', 'days').format('YYYY-MM-DD');
+    let dailys2 = await user.get(`/tasks/user?type=dailys&dueDate=${yesterday}`);
+    expect(dailys2[0].isDue).to.be.false;
+  });
+
+
+  xit('returns dailies with isDue for the date specified and will add CDS offset if time is not supplied and assumes timezones', async () => {
+    let timezone = 240;
+    await user.update({
+      'preferences.dayStart': 0,
+      'preferences.timezoneOffset': timezone,
+    });
+    let startDate = moment().zone(timezone).subtract('4', 'days').startOf('day').toISOString();
+    await user.post('/tasks/user', [
+      {
+        text: 'test daily',
+        type: 'daily',
+        startDate,
+        frequency: 'daily',
+        everyX: 2,
+      },
+    ]);
+
+    let today = moment().format('YYYY-MM-DD');
+    let dailys = await user.get(`/tasks/user?type=dailys&dueDate=${today}`);
+    expect(dailys[0].isDue).to.be.true;
+
+    let yesterday = moment().subtract('1', 'days').format('YYYY-MM-DD');
+    let dailys2 = await user.get(`/tasks/user?type=dailys&dueDate=${yesterday}`);
+    expect(dailys2[0].isDue).to.be.false;
+  });
+
+  xit('returns dailies with isDue for the date specified and will add CDS offset if time is not supplied and assumes timezones', async () => {
+    let timezone = 540;
+    await user.update({
+      'preferences.dayStart': 0,
+      'preferences.timezoneOffset': timezone,
+    });
+    let startDate = moment().zone(timezone).subtract('4', 'days').startOf('day').toISOString();
+    await user.post('/tasks/user', [
+      {
+        text: 'test daily',
+        type: 'daily',
+        startDate,
+        frequency: 'daily',
+        everyX: 2,
+      },
+    ]);
+
+    let today = moment().format('YYYY-MM-DD');
+    let dailys = await user.get(`/tasks/user?type=dailys&dueDate=${today}`);
+    expect(dailys[0].isDue).to.be.true;
+
+    let yesterday = moment().subtract('1', 'days').format('YYYY-MM-DD');
+    let dailys2 = await user.get(`/tasks/user?type=dailys&dueDate=${yesterday}`);
+    expect(dailys2[0].isDue).to.be.false;
+  });
 });

test/api/v3/integration/tasks/POST-tasks_id_score_direction.test.js

@@ -215,6 +215,13 @@ describe('POST /tasks/:id/score/:direction', () => {
       expect(task.isDue).to.equal(true);
     });
 
+    it('computes nextDue', async () => {
+      await user.post(`/tasks/${daily._id}/score/up`);
+      let task = await user.get(`/tasks/${daily._id}`);
+
+      expect(task.nextDue.length).to.eql(6);
+    });
+
     it('scores up daily even if it is already completed'); // Yes?
 
     it('scores down daily even if it is already uncompleted'); // Yes?

test/api/v3/integration/tasks/POST-tasks_unlink-all_challengeId.test.js

@@ -0,0 +1,109 @@
+import {
+  generateUser,
+  generateGroup,
+  generateChallenge,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+
+describe('POST /tasks/unlink-all/:challengeId', () => {
+  let user;
+  let guild;
+  let challenge;
+  let tasksToTest = {
+    habit: {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+    },
+    todo: {
+      text: 'test todo',
+      type: 'todo',
+    },
+    daily: {
+      text: 'test daily',
+      type: 'daily',
+      frequency: 'daily',
+      everyX: 5,
+      startDate: new Date(),
+    },
+    reward: {
+      text: 'test reward',
+      type: 'reward',
+    },
+  };
+
+  beforeEach(async () => {
+    user = await generateUser();
+    guild = await generateGroup(user);
+    challenge = await generateChallenge(user, guild);
+  });
+
+  it('fails if no keep query', async () => {
+    await expect(user.post(`/tasks/unlink-all/${challenge._id}`))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('fails if invalid challenge id', async () => {
+    await expect(user.post('/tasks/unlink-all/123?keep=remove-all'))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('fails on an unbroken challenge', async () => {
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    await expect(user.post(`/tasks/unlink-all/${challenge._id}?keep=remove-all`))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('cantOnlyUnlinkChalTask'),
+    });
+  });
+
+  it('unlinks all tasks from a challenge and deletes them on keep=remove-all', async () => {
+    const daily = await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.habit);
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.reward);
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.todo);
+    await user.del(`/challenges/${challenge._id}`);
+    const response = await user.post(`/tasks/unlink-all/${challenge._id}?keep=remove-all`);
+    expect(response).to.eql({});
+
+    await expect(user.get(`/tasks/${daily._id}`)).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+
+  it('unlinks a task from a challenge on keep=keep-all', async () => {
+    const daily = await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    const anotherUser = await generateUser();
+    await user.post(`/groups/${guild._id}/invite`, {
+        uuids: [anotherUser._id],
+    });
+    // Have the second user join the group and challenge
+    await anotherUser.post(`/groups/${guild._id}/join`);
+    await anotherUser.post(`/challenges/${challenge._id}/join`);
+    // Have the leader delete the challenge and unlink the tasks
+    await user.del(`/challenges/${challenge._id}`);
+    await user.post(`/tasks/unlink-all/${challenge._id}?keep=keep-all`);
+    // Get the task for the second user
+    const [, anotherUserTask] = await anotherUser.get('/tasks/user');
+    // Expect the second user to still have the task, but unlinked
+    expect(anotherUserTask.challenge).to.eql({
+      taskId: daily._id,
+      id: challenge._id,
+      shortName: challenge.shortName,
+      broken: 'CHALLENGE_DELETED',
+      winner: null,
+    });
+  });
+});

test/api/v3/integration/tasks/POST-tasks_unlink-one_taskId.test.js

@@ -0,0 +1,110 @@
+import {
+  generateUser,
+  generateGroup,
+  generateChallenge,
+  translate as t,
+} from '../../../../helpers/api-integration/v3';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/unlink-one/:taskId', () => {
+  let user;
+  let guild;
+  let challenge;
+  let tasksToTest = {
+    habit: {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+    },
+    todo: {
+      text: 'test todo',
+      type: 'todo',
+    },
+    daily: {
+      text: 'test daily',
+      type: 'daily',
+      frequency: 'daily',
+      everyX: 5,
+      startDate: new Date(),
+    },
+    reward: {
+      text: 'test reward',
+      type: 'reward',
+    },
+  };
+
+  beforeEach(async () => {
+    user = await generateUser();
+    guild = await generateGroup(user);
+    challenge = await generateChallenge(user, guild);
+  });
+
+  it('fails if no keep query', async () => {
+    const daily = await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    await expect(user.post(`/tasks/unlink-one/${daily._id}`))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('fails if invalid task id', async () => {
+    await expect(user.post('/tasks/unlink-one/123?keep=remove'))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
+  });
+
+  it('fails on task not found', async () => {
+    await expect(user.post(`/tasks/unlink-one/${generateUUID()}?keep=keep`))
+    .to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('taskNotFound'),
+    });
+  });
+
+  it('fails on task unlinked to challenge', async () => {
+    let daily = await user.post('/tasks/user', tasksToTest.daily);
+    await expect(user.post(`/tasks/unlink-one/${daily._id}?keep=keep`))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('cantOnlyUnlinkChalTask'),
+    });
+  });
+
+  it('fails on unbroken challenge', async () => {
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    let [daily] = await user.get('/tasks/user');
+    await expect(user.post(`/tasks/unlink-one/${daily._id}?keep=keep`))
+    .to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('cantOnlyUnlinkChalTask'),
+    });
+  });
+
+  it('unlinks a task from a challenge and saves it on keep=keep', async () => {
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    let [, daily] = await user.get('/tasks/user');
+    await user.del(`/challenges/${challenge._id}`);
+    await user.post(`/tasks/unlink-one/${daily._id}?keep=keep`);
+    [, daily] = await user.get('/tasks/user');
+    expect(daily.challenge).to.eql({});
+  });
+
+  it('unlinks a task from a challenge and deletes it on keep=remove', async () => {
+    await user.post(`/tasks/challenge/${challenge._id}`, tasksToTest.daily);
+    let [, daily] = await user.get('/tasks/user');
+    await user.del(`/challenges/${challenge._id}`);
+    await user.post(`/tasks/unlink-one/${daily._id}?keep=remove`);
+    const tasks = await user.get('/tasks/user');
+    // Only the default task should remain
+    expect(tasks.length).to.eql(1);
+  });
+});

test/api/v3/integration/tasks/POST-tasks_user.test.js

@@ -131,8 +131,9 @@ describe('POST /tasks/user', () => {
       expect(task.updatedAt).not.to.equal('tomorrow');
       expect(task.challenge).not.to.equal('no');
       expect(task.completed).to.equal(false);
-      expect(task.streak).not.to.equal('never');
+      expect(task.dateCompleted).not.to.equal('never');
       expect(task.value).not.to.equal(324);
+      expect(task.yesterDaily).to.equal(true);
     });
 
     it('ignores invalid fields', async () => {
@@ -510,6 +511,7 @@ describe('POST /tasks/user', () => {
       expect(task.weeksOfMonth).to.eql([3]);
       expect(new Date(task.startDate)).to.eql(now);
       expect(task.isDue).to.be.true;
+      expect(task.nextDue.length).to.eql(6);
     });
 
     it('creates multiple dailys', async () => {
@@ -614,6 +616,18 @@ describe('POST /tasks/user', () => {
       expect((new Date(task.startDate)).getDay()).to.eql(today);
     });
 
+    it('returns an error if the start date is empty', async () => {
+      await expect(user.post('/tasks/user', {
+        text: 'test daily',
+        type: 'daily',
+        startDate: '',
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: 'daily validation failed',
+      });
+    });
+
     it('can create checklists', async () => {
       let task = await user.post('/tasks/user', {
         text: 'test daily',

test/api/v3/integration/tasks/PUT-tasks_id.test.js

@@ -396,6 +396,7 @@ describe('PUT /tasks/:id', () => {
         notes: 'some new notes',
         frequency: 'daily',
         everyX: 5,
+        yesterDaily: false,
         startDate: moment().add(1, 'days').toDate(),
       });
 
@@ -404,6 +405,8 @@ describe('PUT /tasks/:id', () => {
       expect(savedDaily.frequency).to.eql('daily');
       expect(savedDaily.everyX).to.eql(5);
       expect(savedDaily.isDue).to.be.false;
+      expect(savedDaily.nextDue.length).to.eql(6);
+      expect(savedDaily.yesterDaily).to.be.false;
     });
 
     it('can update checklists (replace it)', async () => {

test/api/v3/integration/user/DELETE-user.test.js

@@ -16,214 +16,336 @@ import {
   sha1MakeSalt,
   sha1Encrypt as sha1EncryptPassword,
 } from '../../../../../website/server/libs/password';
+import * as email from '../../../../../website/server/libs/email';
+
+const DELETE_CONFIRMATION = 'DELETE';
 
 describe('DELETE /user', () => {
   let user;
   let password = 'password'; // from habitrpg/test/helpers/api-integration/v3/object-generators.js
 
-  beforeEach(async () => {
-    user = await generateUser({balance: 10});
-  });
-
-  it('returns an errors if password is wrong', async () => {
-    await expect(user.del('/user', {
-      password: 'wrong-password',
-    })).to.eventually.be.rejected.and.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('wrongPassword'),
-    });
-  });
-
-  it('returns an error if user has active subscription', async () => {
-    let userWithSubscription = await generateUser({'purchased.plan.customerId': 'fake-customer-id'});
-
-    await expect(userWithSubscription.del('/user', {
-      password,
-    })).to.be.rejected.and.to.eventually.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('cannotDeleteActiveAccount'),
-    });
-  });
-
-  it('deletes the user\'s tasks', async () => {
-    // gets the user's tasks ids
-    let ids = [];
-    each(user.tasksOrder, (idsForOrder) => {
-      ids.push(...idsForOrder);
-    });
-
-    expect(ids.length).to.be.above(0); // make sure the user has some task to delete
-
-    await user.del('/user', {
-      password,
-    });
-
-    await Bluebird.all(map(ids, id => {
-      return expect(checkExistence('tasks', id)).to.eventually.eql(false);
-    }));
-  });
-
-  it('reduces memberCount in challenges user is linked to', async () => {
-    let populatedGroup = await createAndPopulateGroup({
-      members: 2,
-    });
-
-    let group = populatedGroup.group;
-    let authorizedUser = populatedGroup.members[1];
-
-    let challenge = await generateChallenge(populatedGroup.groupLeader, group);
-    await authorizedUser.post(`/challenges/${challenge._id}/join`);
-
-    await challenge.sync();
-
-    expect(challenge.memberCount).to.eql(2);
-
-    await authorizedUser.del('/user', {
-      password,
-    });
-
-    await challenge.sync();
-
-    expect(challenge.memberCount).to.eql(1);
-  });
-
-  it('deletes the user', async () => {
-    await user.del('/user', {
-      password,
-    });
-    await expect(checkExistence('users', user._id)).to.eventually.eql(false);
-  });
-
-  it('deletes the user with a legacy sha1 password', async () => {
-    let textPassword = 'mySecretPassword';
-    let salt = sha1MakeSalt();
-    let sha1HashedPassword = sha1EncryptPassword(textPassword, salt);
-
-    await user.update({
-      'auth.local.hashed_password': sha1HashedPassword,
-      'auth.local.passwordHashMethod': 'sha1',
-      'auth.local.salt': salt,
-    });
-
-    await user.sync();
-
-    expect(user.auth.local.passwordHashMethod).to.equal('sha1');
-    expect(user.auth.local.salt).to.equal(salt);
-    expect(user.auth.local.hashed_password).to.equal(sha1HashedPassword);
-
-    // delete the user
-    await user.del('/user', {
-      password: textPassword,
-    });
-    await expect(checkExistence('users', user._id)).to.eventually.eql(false);
-  });
-
-  context('last member of a party', () => {
-    let party;
-
+  context('user with local auth', async () => {
     beforeEach(async () => {
-      party = await generateGroup(user, {
-        type: 'party',
-        privacy: 'private',
+      user = await generateUser({balance: 10});
+    });
+
+    it('returns an error if password is wrong', async () => {
+      await expect(user.del('/user', {
+        password: 'wrong-password',
+      })).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('wrongPassword'),
       });
     });
 
-    it('deletes party when user is the only member', async () => {
+    it('returns an error if password is not supplied', async () => {
+      await expect(user.del('/user', {
+        password: '',
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('missingPassword'),
+      });
+    });
+
+    it('deletes the user', async () => {
       await user.del('/user', {
         password,
       });
-      await expect(checkExistence('party', party._id)).to.eventually.eql(false);
+      await expect(checkExistence('users', user._id)).to.eventually.eql(false);
     });
-  });
 
-  context('last member of a private guild', () => {
-    let privateGuild;
+    it('returns an error if excessive feedback is supplied', async () => {
+      let feedbackText = 'spam feedback ';
+      let feedback = feedbackText;
+      while (feedback.length < 10000) {
+        feedback = feedback + feedbackText;
+      }
 
-    beforeEach(async () => {
-      privateGuild = await generateGroup(user, {
-        type: 'guild',
-        privacy: 'private',
+      await expect(user.del('/user', {
+        password,
+        feedback,
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: 'Account deletion feedback is limited to 10,000 characters. For lengthy feedback, email admin@habitica.com.',
       });
     });
 
-    it('deletes guild when user is the only member', async () => {
+    it('returns an error if user has active subscription', async () => {
+      let userWithSubscription = await generateUser({'purchased.plan.customerId': 'fake-customer-id'});
+
+      await expect(userWithSubscription.del('/user', {
+        password,
+      })).to.be.rejected.and.to.eventually.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('cannotDeleteActiveAccount'),
+      });
+    });
+
+    it('deletes the user\'s tasks', async () => {
+      await user.post('/tasks/user', {
+        text: 'test habit',
+        type: 'habit',
+      });
+      await user.sync();
+
+      // gets the user's tasks ids
+      let ids = [];
+      each(user.tasksOrder, (idsForOrder) => {
+        ids.push(...idsForOrder);
+      });
+
+      expect(ids.length).to.be.above(0); // make sure the user has some task to delete
+
       await user.del('/user', {
         password,
       });
-      await expect(checkExistence('groups', privateGuild._id)).to.eventually.eql(false);
+
+      await Bluebird.all(map(ids, id => {
+        return expect(checkExistence('tasks', id)).to.eventually.eql(false);
+      }));
     });
-  });
 
-  context('groups user is leader of', () => {
-    let guild, oldLeader, newLeader;
-
-    beforeEach(async () => {
-      let { group, groupLeader, members } = await createAndPopulateGroup({
-        groupDetails: {
-          type: 'guild',
-          privacy: 'public',
-        },
-        members: 1,
+    it('reduces memberCount in challenges user is linked to', async () => {
+      let populatedGroup = await createAndPopulateGroup({
+        members: 2,
       });
 
-      guild = group;
-      newLeader = members[0];
-      oldLeader = groupLeader;
-    });
+      let group = populatedGroup.group;
+      let authorizedUser = populatedGroup.members[1];
 
-    it('chooses new group leader for any group user was the leader of', async () => {
-      await oldLeader.del('/user', {
+      let challenge = await generateChallenge(populatedGroup.groupLeader, group);
+      await authorizedUser.post(`/challenges/${challenge._id}/join`);
+
+      await challenge.sync();
+
+      expect(challenge.memberCount).to.eql(2);
+
+      await authorizedUser.del('/user', {
         password,
       });
 
-      let updatedGuild = await newLeader.get(`/groups/${guild._id}`);
+      await challenge.sync();
 
-      expect(updatedGuild.leader).to.exist;
-      expect(updatedGuild.leader._id).to.not.eql(oldLeader._id);
-    });
-  });
-
-  context('groups user is a part of', () => {
-    let group1, group2, userToDelete, otherUser;
-
-    beforeEach(async () => {
-      userToDelete = await generateUser({balance: 10});
-
-      group1 = await generateGroup(userToDelete, {
-        type: 'guild',
-        privacy: 'public',
-      });
-
-      let {group, members} = await createAndPopulateGroup({
-        groupDetails: {
-          type: 'guild',
-          privacy: 'public',
-        },
-        members: 3,
-      });
-
-      group2 = group;
-      otherUser = members[0];
-
-      await userToDelete.post(`/groups/${group2._id}/join`);
+      expect(challenge.memberCount).to.eql(1);
     });
 
-    it('removes user from all groups user was a part of', async () => {
-      await userToDelete.del('/user', {
+    it('sends feedback to the admin email', async () => {
+      sandbox.spy(email, 'sendTxn');
+
+      let feedback = 'Reasons for Deletion';
+      await user.del('/user', {
+        password,
+        feedback,
+      });
+
+      expect(email.sendTxn).to.be.calledOnce;
+
+      sandbox.restore();
+    });
+
+    it('does not send email if no feedback is supplied', async () => {
+      sandbox.spy(email, 'sendTxn');
+
+      await user.del('/user', {
         password,
       });
 
-      let updatedGroup1Members = await otherUser.get(`/groups/${group1._id}/members`);
-      let updatedGroup2Members = await otherUser.get(`/groups/${group2._id}/members`);
-      let userInGroup = find(updatedGroup2Members, (member) => {
-        return member._id === userToDelete._id;
+      expect(email.sendTxn).to.not.be.called;
+
+      sandbox.restore();
+    });
+
+    it('deletes the user with a legacy sha1 password', async () => {
+      let textPassword = 'mySecretPassword';
+      let salt = sha1MakeSalt();
+      let sha1HashedPassword = sha1EncryptPassword(textPassword, salt);
+
+      await user.update({
+        'auth.local.hashed_password': sha1HashedPassword,
+        'auth.local.passwordHashMethod': 'sha1',
+        'auth.local.salt': salt,
       });
 
-      expect(updatedGroup1Members).to.be.empty;
-      expect(updatedGroup2Members).to.not.be.empty;
-      expect(userInGroup).to.not.exist;
+      await user.sync();
+
+      expect(user.auth.local.passwordHashMethod).to.equal('sha1');
+      expect(user.auth.local.salt).to.equal(salt);
+      expect(user.auth.local.hashed_password).to.equal(sha1HashedPassword);
+
+      // delete the user
+      await user.del('/user', {
+        password: textPassword,
+      });
+      await expect(checkExistence('users', user._id)).to.eventually.eql(false);
+    });
+
+    context('last member of a party', () => {
+      let party;
+
+      beforeEach(async () => {
+        party = await generateGroup(user, {
+          type: 'party',
+          privacy: 'private',
+        });
+      });
+
+      it('deletes party when user is the only member', async () => {
+        await user.del('/user', {
+          password,
+        });
+        await expect(checkExistence('party', party._id)).to.eventually.eql(false);
+      });
+    });
+
+    context('last member of a private guild', () => {
+      let privateGuild;
+
+      beforeEach(async () => {
+        privateGuild = await generateGroup(user, {
+          type: 'guild',
+          privacy: 'private',
+        });
+      });
+
+      it('deletes guild when user is the only member', async () => {
+        await user.del('/user', {
+          password,
+        });
+        await expect(checkExistence('groups', privateGuild._id)).to.eventually.eql(false);
+      });
+    });
+
+    context('groups user is leader of', () => {
+      let guild, oldLeader, newLeader;
+
+      beforeEach(async () => {
+        let { group, groupLeader, members } = await createAndPopulateGroup({
+          groupDetails: {
+            type: 'guild',
+            privacy: 'public',
+          },
+          members: 1,
+        });
+
+        guild = group;
+        newLeader = members[0];
+        oldLeader = groupLeader;
+      });
+
+      it('chooses new group leader for any group user was the leader of', async () => {
+        await oldLeader.del('/user', {
+          password,
+        });
+
+        let updatedGuild = await newLeader.get(`/groups/${guild._id}`);
+
+        expect(updatedGuild.leader).to.exist;
+        expect(updatedGuild.leader._id).to.not.eql(oldLeader._id);
+      });
+    });
+
+    context('groups user is a part of', () => {
+      let group1, group2, userToDelete, otherUser;
+
+      beforeEach(async () => {
+        userToDelete = await generateUser({balance: 10});
+
+        group1 = await generateGroup(userToDelete, {
+          type: 'guild',
+          privacy: 'public',
+        });
+
+        let {group, members} = await createAndPopulateGroup({
+          groupDetails: {
+            type: 'guild',
+            privacy: 'public',
+          },
+          members: 3,
+        });
+
+        group2 = group;
+        otherUser = members[0];
+
+        await userToDelete.post(`/groups/${group2._id}/join`);
+      });
+
+      it('removes user from all groups user was a part of', async () => {
+        await userToDelete.del('/user', {
+          password,
+        });
+
+        let updatedGroup1Members = await otherUser.get(`/groups/${group1._id}/members`);
+        let updatedGroup2Members = await otherUser.get(`/groups/${group2._id}/members`);
+        let userInGroup = find(updatedGroup2Members, (member) => {
+          return member._id === userToDelete._id;
+        });
+
+        expect(updatedGroup1Members).to.be.empty;
+        expect(updatedGroup2Members).to.not.be.empty;
+        expect(userInGroup).to.not.exist;
+      });
+    });
+  });
+
+  context('user with Facebook auth', async () => {
+    beforeEach(async () => {
+      user = await generateUser({
+        auth: {
+          facebook: {
+            id: 'facebook-id',
+          },
+        },
+      });
+    });
+
+    it('returns an error if confirmation phrase is wrong', async () => {
+      await expect(user.del('/user', {
+        password: 'just-do-it',
+      })).to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('incorrectDeletePhrase'),
+      });
+    });
+
+    it('returns an error if confirmation phrase is not supplied', async () => {
+      await expect(user.del('/user', {
+        password: '',
+      })).to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('missingPassword'),
+      });
+    });
+
+    it('deletes a Facebook user', async () => {
+      await user.del('/user', {
+        password: DELETE_CONFIRMATION,
+      });
+      await expect(checkExistence('users', user._id)).to.eventually.eql(false);
+    });
+  });
+
+  context('user with Google auth', async () => {
+    beforeEach(async () => {
+      user = await generateUser({
+        auth: {
+          google: {
+            id: 'google-id',
+          },
+        },
+      });
+    });
+
+    it('deletes a Google user', async () => {
+      await user.del('/user', {
+        password: DELETE_CONFIRMATION,
+      });
+      await expect(checkExistence('users', user._id)).to.eventually.eql(false);
     });
   });
 });

test/api/v3/integration/user/GET-user_anonymized.test.js

@@ -82,7 +82,7 @@ describe('GET /user/anonymized', () => {
     });
     // tasks
     expect(tasks2).to.exist;
-    expect(tasks2.length).to.eql(5); // +1 because generateUser() assigns one todo
+    expect(tasks2.length).to.eql(5);
     expect(tasks2[0].checklist).to.exist;
     _.forEach(tasks2, (task) => {
       expect(task.text).to.eql('task text');

test/api/v3/integration/user/POST-user_class_cast_spellId.test.js

@@ -221,6 +221,27 @@ describe('POST /user/class/cast/:spellId', () => {
     expect(syncedGroupTask.value).to.equal(0);
   });
 
+  it('increases both user\'s achievement values', async () => {
+    let party = await createAndPopulateGroup({
+      members: 1,
+    });
+    let leader = party.groupLeader;
+    let recipient = party.members[0];
+    await leader.update({'stats.gp': 10});
+    await leader.post(`/user/class/cast/birthday?targetId=${recipient._id}`);
+    await leader.sync();
+    await recipient.sync();
+    expect(leader.achievements.birthday).to.equal(1);
+    expect(recipient.achievements.birthday).to.equal(1);
+  });
+
+  it('only increases user\'s achievement one if target == caster', async () => {
+    await user.update({'stats.gp': 10});
+    await user.post(`/user/class/cast/birthday?targetId=${user._id}`);
+    await user.sync();
+    expect(user.achievements.birthday).to.equal(1);
+  });
+
   // TODO find a way to have sinon working in integration tests
   // it doesn't work when tests are running separately from server
   it('passes correct target to spell when targetType === \'task\'');

test/api/v3/integration/user/POST-user_purchase.test.js

@@ -1,5 +1,6 @@
 import {
   generateUser,
+  createAndPopulateGroup,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
 
@@ -31,4 +32,70 @@ describe('POST /user/purchase/:type/:key', () => {
 
     expect(user.items[type][key]).to.equal(1);
   });
+
+  it('can convert gold to gems if subscribed', async () => {
+    let oldBalance = user.balance;
+    await user.update({
+      'purchased.plan.customerId': 'group-plan',
+      'stats.gp': 1000,
+    });
+    await user.post('/user/purchase/gems/gem');
+    await user.sync();
+    expect(user.balance).to.equal(oldBalance + 0.25);
+  });
+
+  it('leader can convert gold to gems even if the group plan prevents it', async () => {
+    let { group, groupLeader } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'test',
+        type: 'guild',
+        privacy: 'private',
+      },
+    });
+    await group.update({
+      'leaderOnly.getGems': true,
+      'purchased.plan.customerId': 123,
+    });
+    await groupLeader.sync();
+    let oldBalance = groupLeader.balance;
+
+    await groupLeader.update({
+      'purchased.plan.customerId': 'group-plan',
+      'stats.gp': 1000,
+    });
+    await groupLeader.post('/user/purchase/gems/gem');
+
+    await groupLeader.sync();
+    expect(groupLeader.balance).to.equal(oldBalance + 0.25);
+  });
+
+  it('cannot convert gold to gems if the group plan prevents it', async () => {
+    let { group, members } = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'test',
+        type: 'guild',
+        privacy: 'private',
+      },
+      members: 1,
+    });
+    await group.update({
+      'leaderOnly.getGems': true,
+      'purchased.plan.customerId': 123,
+    });
+    let oldBalance = members[0].balance;
+
+    await members[0].update({
+      'purchased.plan.customerId': 'group-plan',
+      'stats.gp': 1000,
+    });
+    await expect(members[0].post('/user/purchase/gems/gem'))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('groupPolicyCannotGetGems'),
+      });
+
+    await members[0].sync();
+    expect(members[0].balance).to.equal(oldBalance);
+  });
 });

test/api/v3/integration/user/POST-user_release_both.test.js

@@ -2,17 +2,34 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import content from '../../../../../website/common/script/content/index';
 
 describe('POST /user/release-both', () => {
   let user;
   let animal = 'Wolf-Base';
+  const loadPets = () => {
+    let pets = {};
+    for (let p in content.pets) {
+      pets[p] = content.pets[p];
+      pets[p] = 5;
+    }
+    return pets;
+  };
+  const loadMounts = () => {
+    let mounts = {};
+    for (let m in content.pets) {
+      mounts[m] = content.pets[m];
+      mounts[m] = true;
+    }
+    return mounts;
+  };
 
   beforeEach(async () => {
     user = await generateUser({
       'items.currentMount': animal,
       'items.currentPet': animal,
-      'items.pets': {animal: 5},
-      'items.mounts': {animal: true},
+      'items.pets': loadPets(),
+      'items.mounts': loadMounts(),
     });
   });
 

test/api/v3/integration/user/POST-user_release_mounts.test.js

@@ -2,15 +2,25 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import content from '../../../../../website/common/script/content/index';
 
 describe('POST /user/release-mounts', () => {
   let user;
   let animal = 'Wolf-Base';
 
+  const loadMounts = () => {
+    let mounts = {};
+    for (let m in content.pets) {
+      mounts[m] = content.pets[m];
+      mounts[m] = true;
+    }
+    return mounts;
+  };
+
   beforeEach(async () => {
     user = await generateUser({
       'items.currentMount': animal,
-      'items.mounts': {animal: true},
+      'items.mounts': loadMounts(),
     });
   });
 

test/api/v3/integration/user/POST-user_release_pets.test.js

@@ -2,15 +2,25 @@ import {
   generateUser,
   translate as t,
 } from '../../../../helpers/api-integration/v3';
+import content from '../../../../../website/common/script/content/index';
 
 describe('POST /user/release-pets', () => {
   let user;
   let animal = 'Wolf-Base';
 
+  const loadPets = () => {
+    let pets = {};
+    for (let p in content.pets) {
+      pets[p] = content.pets[p];
+      pets[p] = 5;
+    }
+    return pets;
+  };
+
   beforeEach(async () => {
     user = await generateUser({
       'items.currentPet': animal,
-      'items.pets': {animal: 5},
+      'items.pets': loadPets(),
     });
   });
 

test/api/v3/integration/user/auth/GET-auth_reset-password-set-new-one.js

@@ -10,43 +10,31 @@ import nconf from 'nconf';
 
 const API_TEST_SERVER_PORT = nconf.get('PORT');
 
-describe('GET /user/auth/local/reset-password-set-new-one', () => {
+// @TODO skipped because on travis the client isn't available and the redirect fails
+xdescribe('GET /user/auth/local/reset-password-set-new-one', () => {
   let endpoint = `http://localhost:${API_TEST_SERVER_PORT}/static/user/auth/local/reset-password-set-new-one`;
 
   // Tests to validate the validatePasswordResetCodeAndFindUser function
 
   it('renders an error page if the code is missing', async () => {
-    try {
-      await superagent.get(endpoint);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(endpoint);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the code is invalid json', async () => {
-    try {
-      await superagent.get(`${endpoint}?code=invalid`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(`${endpoint}?code=invalid`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the code cannot be decrypted', async () => {
     let user = await generateUser();
 
-    try {
-      let code = JSON.stringify({ // not encrypted
-        userId: user._id,
-        expiresAt: new Date(),
-      });
-      await superagent.get(`${endpoint}?code=${code}`);
-
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    let code = JSON.stringify({ // not encrypted
+      userId: user._id,
+      expiresAt: new Date(),
+    });
+    const res = await superagent.get(`${endpoint}?code=${code}`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the code is expired', async () => {
@@ -60,12 +48,8 @@ describe('GET /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    try {
-      await superagent.get(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(`${endpoint}?code=${code}`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the user does not exist', async () => {
@@ -74,12 +58,8 @@ describe('GET /user/auth/local/reset-password-set-new-one', () => {
       expiresAt: moment().add({days: 1}),
     }));
 
-    try {
-      await superagent.get(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(`${endpoint}?code=${code}`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the user has no local auth', async () => {
@@ -93,12 +73,8 @@ describe('GET /user/auth/local/reset-password-set-new-one', () => {
       auth: 'not an object with valid fields',
     });
 
-    try {
-      await superagent.get(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(`${endpoint}?code=${code}`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   it('renders an error page if the code doesn\'t match the one saved at user.auth.passwordResetCode', async () => {
@@ -112,12 +88,8 @@ describe('GET /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': 'invalid',
     });
 
-    try {
-      await superagent.get(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    const res = await superagent.get(`${endpoint}?code=${code}`);
+    expect(res.req.path.indexOf('hasError=true') !== -1).to.equal(true);
   });
 
   //
@@ -134,7 +106,8 @@ describe('GET /user/auth/local/reset-password-set-new-one', () => {
     });
 
     let res = await superagent.get(`${endpoint}?code=${code}`);
-    expect(res.status).to.equal(200);
+    expect(res.req.path.indexOf('hasError=false') !== -1).to.equal(true);
+    expect(res.req.path.indexOf('code=') !== -1).to.equal(true);
   });
 });
 

test/api/v3/integration/user/auth/POST-auth_reset-password-set-new-one.js

@@ -10,49 +10,46 @@ import {
 import moment from 'moment';
 import {
   generateUser,
+  requester,
+  translate as t,
 } from '../../../../../helpers/api-integration/v3';
-import superagent from 'superagent';
-import nconf from 'nconf';
 
-const API_TEST_SERVER_PORT = nconf.get('PORT');
-
-describe('POST /user/auth/local/reset-password-set-new-one', () => {
-  let endpoint = `http://localhost:${API_TEST_SERVER_PORT}/static/user/auth/local/reset-password-set-new-one`;
+describe('POST /user/auth/reset-password-set-new-one', () => {
+  const endpoint = '/user/auth/reset-password-set-new-one';
+  const api = requester();
 
   // Tests to validate the validatePasswordResetCodeAndFindUser function
-
   it('renders an error page if the code is missing', async () => {
-    try {
-      await superagent.post(endpoint);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(endpoint)).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the code is invalid json', async () => {
-    try {
-      await superagent.post(`${endpoint}?code=invalid`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}?code=invalid`)).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the code cannot be decrypted', async () => {
     let user = await generateUser();
 
-    try {
-      let code = JSON.stringify({ // not encrypted
-        userId: user._id,
-        expiresAt: new Date(),
-      });
-      await superagent.post(`${endpoint}?code=${code}`);
+    let code = JSON.stringify({ // not encrypted
+      userId: user._id,
+      expiresAt: new Date(),
+    });
 
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the code is expired', async () => {
@@ -66,12 +63,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    try {
-      await superagent.post(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the user does not exist', async () => {
@@ -80,12 +78,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       expiresAt: moment().add({days: 1}),
     }));
 
-    try {
-      await superagent.post(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the user has no local auth', async () => {
@@ -99,12 +98,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       auth: 'not an object with valid fields',
     });
 
-    try {
-      await superagent.post(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   it('renders an error page if the code doesn\'t match the one saved at user.auth.passwordResetCode', async () => {
@@ -118,12 +118,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': 'invalid',
     });
 
-    try {
-      await superagent.post(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('invalidPasswordResetCode'),
+    });
   });
 
   //
@@ -139,12 +140,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    try {
-      await superagent.post(`${endpoint}?code=${code}`);
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
   });
 
   it('renders the error page if the password confirmation is missing', async () => {
@@ -158,14 +160,14 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    try {
-      await superagent
-        .post(`${endpoint}?code=${code}`)
-        .send({newPassword: 'my new password'});
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      newPassword: 'my new password',
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('invalidReqParams'),
+    });
   });
 
   it('renders the error page if the password confirmation does not match', async () => {
@@ -179,17 +181,15 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    try {
-      await superagent
-        .post(`${endpoint}?code=${code}`)
-        .send({
-          newPassword: 'my new password',
-          confirmPassword: 'not matching',
-        });
-      throw new Error('Request should fail.');
-    } catch (err) {
-      expect(err.status).to.equal(401);
-    }
+    await expect(api.post(`${endpoint}`, {
+      newPassword: 'my new password',
+      confirmPassword: 'not matching',
+      code,
+    })).to.eventually.be.rejected.and.eql({
+      code: 400,
+      error: 'BadRequest',
+      message: t('passwordConfirmationMatch'),
+    });
   });
 
   it('renders the success page and save the user', async () => {
@@ -203,14 +203,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    let res = await superagent
-      .post(`${endpoint}?code=${code}`)
-      .send({
-        newPassword: 'my new password',
-        confirmPassword: 'my new password',
-      });
+    let res = await api.post(`${endpoint}`, {
+      newPassword: 'my new password',
+      confirmPassword: 'my new password',
+      code,
+    });
 
-    expect(res.status).to.equal(200);
+    expect(res.message).to.equal(t('passwordChangeSuccess'));
 
     await user.sync();
     expect(user.auth.local.passwordResetCode).to.equal(undefined);
@@ -246,14 +245,13 @@ describe('POST /user/auth/local/reset-password-set-new-one', () => {
       'auth.local.passwordResetCode': code,
     });
 
-    let res = await superagent
-      .post(`${endpoint}?code=${code}`)
-      .send({
-        newPassword: 'my new password',
-        confirmPassword: 'my new password',
-      });
+    let res = await api.post(`${endpoint}`, {
+      newPassword: 'my new password',
+      confirmPassword: 'my new password',
+      code,
+    });
 
-    expect(res.status).to.equal(200);
+    expect(res.message).to.equal(t('passwordChangeSuccess'));
 
     await user.sync();
     expect(user.auth.local.passwordResetCode).to.equal(undefined);

test/api/v3/integration/user/auth/POST-register_local.test.js

@@ -59,13 +59,8 @@ describe('POST /user/auth/local/register', () => {
         let tags = await requests.get('/tags');
 
         expect(habits).to.have.a.lengthOf(0);
-
         expect(dailys).to.have.a.lengthOf(0);
-
         expect(todos).to.have.a.lengthOf(1);
-        expect(todos[0].text).to.eql(t('defaultTodo1Text'));
-        expect(todos[0].notes).to.eql(t('defaultTodoNotes'));
-
         expect(rewards).to.have.a.lengthOf(0);
 
         expect(tags).to.have.a.lengthOf(7);
@@ -78,7 +73,7 @@ describe('POST /user/auth/local/register', () => {
         expect(tags[6].name).to.eql(t('defaultTag7'));
       });
 
-      it('for Web', async () => {
+      xit('for Web', async () => {
         api = requester(
           null,
           {'x-client': 'habitica-web'},
@@ -129,7 +124,9 @@ describe('POST /user/auth/local/register', () => {
         expect(tags[5].name).to.eql(t('defaultTag6'));
         expect(tags[6].name).to.eql(t('defaultTag7'));
       });
+    });
 
+    context('does not provide default tags and tasks', async () => {
       it('for Android', async () => {
         api = requester(
           null,
@@ -154,34 +151,11 @@ describe('POST /user/auth/local/register', () => {
         let rewards = await requests.get('/tasks/user?type=rewards');
         let tags = await requests.get('/tags');
 
-        expect(habits).to.have.a.lengthOf(2);
-        expect(habits[0].text).to.eql(t('defaultHabit4Text'));
-        expect(habits[0].notes).to.eql(t('defaultHabit4Notes'));
-        expect(habits[1].text).to.eql(t('defaultHabit5Text'));
-        expect(habits[1].notes).to.eql(t('defaultHabit5Notes'));
-
-        expect(dailys).to.have.a.lengthOf(1);
-        expect(dailys[0].text).to.eql(t('defaultDaily1Text'));
-        expect(dailys[0].notes).to.eql('');
-
-        expect(todos).to.have.a.lengthOf(2);
-        expect(todos[0].text).to.eql(t('defaultTodo1Text'));
-        expect(todos[0].notes).to.eql(t('defaultTodoNotes'));
-        expect(todos[1].text).to.eql(t('defaultTodo2Text'));
-        expect(todos[1].notes).to.eql(t('defaultTodo2Notes'));
-
-        expect(rewards).to.have.a.lengthOf(1);
-        expect(rewards[0].text).to.eql(t('defaultReward2Text'));
-        expect(rewards[0].notes).to.eql(t('defaultReward2Notes'));
-
-        expect(tags).to.have.a.lengthOf(7);
-        expect(tags[0].name).to.eql(t('defaultTag1'));
-        expect(tags[1].name).to.eql(t('defaultTag2'));
-        expect(tags[2].name).to.eql(t('defaultTag3'));
-        expect(tags[3].name).to.eql(t('defaultTag4'));
-        expect(tags[4].name).to.eql(t('defaultTag5'));
-        expect(tags[5].name).to.eql(t('defaultTag6'));
-        expect(tags[6].name).to.eql(t('defaultTag7'));
+        expect(habits).to.have.a.lengthOf(0);
+        expect(dailys).to.have.a.lengthOf(0);
+        expect(todos).to.have.a.lengthOf(0);
+        expect(rewards).to.have.a.lengthOf(0);
+        expect(tags).to.have.a.lengthOf(0);
       });
 
       it('for iOS', async () => {
@@ -208,34 +182,11 @@ describe('POST /user/auth/local/register', () => {
         let rewards = await requests.get('/tasks/user?type=rewards');
         let tags = await requests.get('/tags');
 
-        expect(habits).to.have.a.lengthOf(2);
-        expect(habits[0].text).to.eql(t('defaultHabit4Text'));
-        expect(habits[0].notes).to.eql(t('defaultHabit4Notes'));
-        expect(habits[1].text).to.eql(t('defaultHabit5Text'));
-        expect(habits[1].notes).to.eql(t('defaultHabit5Notes'));
-
-        expect(dailys).to.have.a.lengthOf(1);
-        expect(dailys[0].text).to.eql(t('defaultDaily1Text'));
-        expect(dailys[0].notes).to.eql('');
-
-        expect(todos).to.have.a.lengthOf(2);
-        expect(todos[0].text).to.eql(t('defaultTodo1Text'));
-        expect(todos[0].notes).to.eql(t('defaultTodoNotes'));
-        expect(todos[1].text).to.eql(t('defaultTodo2Text'));
-        expect(todos[1].notes).to.eql(t('defaultTodo2Notes'));
-
-        expect(rewards).to.have.a.lengthOf(1);
-        expect(rewards[0].text).to.eql(t('defaultReward2Text'));
-        expect(rewards[0].notes).to.eql(t('defaultReward2Notes'));
-
-        expect(tags).to.have.a.lengthOf(7);
-        expect(tags[0].name).to.eql(t('defaultTag1'));
-        expect(tags[1].name).to.eql(t('defaultTag2'));
-        expect(tags[2].name).to.eql(t('defaultTag3'));
-        expect(tags[3].name).to.eql(t('defaultTag4'));
-        expect(tags[4].name).to.eql(t('defaultTag5'));
-        expect(tags[5].name).to.eql(t('defaultTag6'));
-        expect(tags[6].name).to.eql(t('defaultTag7'));
+        expect(habits).to.have.a.lengthOf(0);
+        expect(dailys).to.have.a.lengthOf(0);
+        expect(todos).to.have.a.lengthOf(0);
+        expect(rewards).to.have.a.lengthOf(0);
+        expect(tags).to.have.a.lengthOf(0);
       });
     });
 
@@ -509,7 +460,73 @@ describe('POST /user/auth/local/register', () => {
         confirmPassword: password,
       });
 
-      expect(user.invitations.party).to.eql({
+      expect(user.invitations.parties[0].id).to.eql(group._id);
+      expect(user.invitations.parties[0].name).to.eql(group.name);
+      expect(user.invitations.parties[0].inviter).to.eql(groupLeader._id);
+    });
+
+    it('awards achievement to inviter', async () => {
+      let { group, groupLeader } = await createAndPopulateGroup({
+        groupDetails: { type: 'party', privacy: 'private' },
+      });
+
+      let invite = encrypt(JSON.stringify({
+        id: group._id,
+        inviter: groupLeader._id,
+        sentAt: Date.now(),
+      }));
+
+      await api.post(`/user/auth/local/register?groupInvite=${invite}`, {
+        username,
+        email,
+        password,
+        confirmPassword: password,
+      });
+
+      await groupLeader.sync();
+      expect(groupLeader.achievements.invitedFriend).to.be.true;
+    });
+
+    it('user not added to a party on expired invite', async () => {
+      let { group, groupLeader } = await createAndPopulateGroup({
+        groupDetails: { type: 'party', privacy: 'private' },
+      });
+
+      let invite = encrypt(JSON.stringify({
+        id: group._id,
+        inviter: groupLeader._id,
+        sentAt: Date.now() - 6.912e8, // 8 days old
+      }));
+
+      let user = await api.post(`/user/auth/local/register?groupInvite=${invite}`, {
+        username,
+        email,
+        password,
+        confirmPassword: password,
+      });
+
+      expect(user.invitations.party).to.eql({});
+    });
+
+    it('adds a user to a guild on an invite of type other than party', async () => {
+      let { group, groupLeader } = await createAndPopulateGroup({
+          groupDetails: { type: 'guild', privacy: 'private' },
+      });
+
+      let invite = encrypt(JSON.stringify({
+        id: group._id,
+        inviter: groupLeader._id,
+        sentAt: Date.now(),
+      }));
+
+      let user = await api.post(`/user/auth/local/register?groupInvite=${invite}`, {
+        username,
+        email,
+        password,
+        confirmPassword: password,
+      });
+
+      expect(user.invitations.guilds[0]).to.eql({
         id: group._id,
         name: group.name,
         inviter: groupLeader._id,
@@ -601,10 +618,10 @@ describe('POST /user/auth/local/register', () => {
         confirmPassword: password,
       });
 
-      expect(user.tasksOrder.todos).to.not.be.empty;
+      expect(user.tasksOrder.todos).to.be.empty;
       expect(user.tasksOrder.dailys).to.be.empty;
-      expect(user.tasksOrder.habits).to.not.be.empty;
-      expect(user.tasksOrder.rewards).to.not.be.empty;
+      expect(user.tasksOrder.habits).to.be.empty;
+      expect(user.tasksOrder.rewards).to.be.empty;
     });
 
     it('populates user with default tags', async () => {
@@ -631,23 +648,8 @@ describe('POST /user/auth/local/register', () => {
       let habits = await requests.get('/tasks/user?type=habits');
       let todos = await requests.get('/tasks/user?type=todos');
 
-      function findTag (tagName) {
-        let tag = user.tags.find((userTag) => {
-          return userTag.name === t(tagName);
-        });
-        return tag.id;
-      }
-
-      expect(habits[0].tags).to.have.a.lengthOf(3);
-      expect(habits[0].tags).to.include.members(['defaultTag1', 'defaultTag4', 'defaultTag6'].map(findTag));
-
-      expect(habits[1].tags).to.have.a.lengthOf(1);
-      expect(habits[1].tags).to.include.members(['defaultTag3'].map(findTag));
-
-      expect(habits[2].tags).to.have.a.lengthOf(2);
-      expect(habits[2].tags).to.include.members(['defaultTag2', 'defaultTag3'].map(findTag));
-
-      expect(todos[0].tags).to.have.a.lengthOf(0);
+      expect(habits).to.have.a.lengthOf(0);
+      expect(todos).to.have.a.lengthOf(0);
     });
   });
 });

test/api/v3/unit/libs/amazonPayments.test.js

@@ -102,6 +102,7 @@ describe('Amazon Payments', () => {
     });
 
     it('should purchase gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
       await amzLib.checkout({user, orderReferenceId, headers});
 
       expect(paymentBuyGemsStub).to.be.calledOnce;
@@ -111,22 +112,52 @@ describe('Amazon Payments', () => {
         headers,
       });
       expectAmazonStubs();
+      expect(user.canGetGems).to.be.calledOnce;
+      user.canGetGems.restore();
     });
 
-    it('should gift gems', async () => {
+    it('should error if gem amount is too low', async () => {
       let receivingUser = new User();
       receivingUser.save();
       let gift = {
         type: 'gems',
         gems: {
-          amount: 16,
+          amount: 0,
           uuid: receivingUser._id,
         },
       };
+
+      await expect(amzLib.checkout({gift, user, orderReferenceId, headers}))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Amount must be at least 1.',
+        name: 'BadRequest',
+      });
+    });
+
+    it('should error if user cannot get gems gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+      await expect(amzLib.checkout({user, orderReferenceId, headers})).to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        message: i18n.t('groupPolicyCannotGetGems'),
+        name: 'NotAuthorized',
+      });
+      user.canGetGems.restore();
+    });
+
+    it('should gift gems', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      let gift = {
+        type: 'gems',
+        uuid: receivingUser._id,
+        gems: {
+          amount: 16,
+        },
+      };
       amount = 16 / 4;
       await amzLib.checkout({gift, user, orderReferenceId, headers});
 
-      gift.member = receivingUser;
       expect(paymentBuyGemsStub).to.be.calledOnce;
       expect(paymentBuyGemsStub).to.be.calledWith({
         user,
@@ -525,6 +556,7 @@ describe('Amazon Payments', () => {
         nextBill: moment(user.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
         paymentMethod: amzLib.constants.PAYMENT_METHOD,
         headers,
+        cancellationReason: undefined,
       });
       expectAmazonStubs();
     });
@@ -555,6 +587,7 @@ describe('Amazon Payments', () => {
         nextBill: moment(user.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
         paymentMethod: amzLib.constants.PAYMENT_METHOD,
         headers,
+        cancellationReason: undefined,
       });
       amzLib.closeBillingAgreement.restore();
     });
@@ -593,6 +626,7 @@ describe('Amazon Payments', () => {
         nextBill: moment(group.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
         paymentMethod: amzLib.constants.PAYMENT_METHOD,
         headers,
+        cancellationReason: undefined,
       });
       expectAmazonStubs();
     });
@@ -623,6 +657,7 @@ describe('Amazon Payments', () => {
         nextBill: moment(group.purchased.plan.lastBillingDate).add({ days: subscriptionLength }),
         paymentMethod: amzLib.constants.PAYMENT_METHOD,
         headers,
+        cancellationReason: undefined,
       });
       amzLib.closeBillingAgreement.restore();
     });

test/api/v3/unit/libs/applePayments.test.js

@@ -57,7 +57,20 @@ describe('Apple Payments', ()  => {
         });
     });
 
+    it('errors if the user cannot purchase gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+      await expect(applePayments.verifyGemPurchase(user, receipt, headers))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('groupPolicyCannotGetGems'),
+        });
+
+      user.canGetGems.restore();
+    });
+
     it('purchases gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
       await applePayments.verifyGemPurchase(user, receipt, headers);
 
       expect(iapSetupStub).to.be.calledOnce;
@@ -74,6 +87,8 @@ describe('Apple Payments', ()  => {
         amount: 5.25,
         headers,
       });
+      expect(user.canGetGems).to.be.calledOnce;
+      user.canGetGems.restore();
     });
   });
 

test/api/v3/unit/libs/cron.test.js

@@ -79,6 +79,13 @@ describe('cron', () => {
       expect(user.purchased.plan.gemsBought).to.equal(0);
     });
 
+    it('resets plan.gemsBought on a new month if user does not have purchased.plan.dateUpdated', () => {
+      user.purchased.plan.gemsBought = 10;
+      user.purchased.plan.dateUpdated = undefined;
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(user.purchased.plan.gemsBought).to.equal(0);
+    });
+
     it('does not reset plan.gemsBought within the month', () => {
       let clock = sinon.useFakeTimers(moment().startOf('month').add(2, 'days').unix());
       user.purchased.plan.dateUpdated = moment().startOf('month').toDate();
@@ -313,6 +320,24 @@ describe('cron', () => {
       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', () => {
@@ -366,6 +391,14 @@ describe('cron', () => {
       expect(tasksByType.dailys[0].isDue).to.be.false;
     });
 
+    it('computes nextDue', () => {
+      tasksByType.dailys[0].frequency = 'daily';
+      tasksByType.dailys[0].everyX = 5;
+      tasksByType.dailys[0].startDate = moment().add(1, 'days').toDate();
+      cron({user, tasksByType, daysMissed, analytics});
+      expect(tasksByType.dailys[0].nextDue.length).to.eql(6);
+    });
+
     it('should add history', () => {
       cron({user, tasksByType, daysMissed, analytics});
       expect(tasksByType.dailys[0].history).to.be.lengthOf(1);
@@ -450,6 +483,25 @@ describe('cron', () => {
 
       expect(progress.down).to.equal(-1);
     });
+
+    it('should do damage for only yesterday\'s dailies', () => {
+      daysMissed = 3;
+      tasksByType.dailys[0].startDate = moment(new Date()).subtract({days: 1});
+
+      let daily = {
+        text: 'test daily',
+        type: 'daily',
+      };
+      let task = new Tasks.daily(Tasks.Task.sanitize(daily)); // eslint-disable-line new-cap
+      tasksByType.dailys.push(task);
+      tasksByType.dailys[1].startDate = moment(new Date()).subtract({days: 2});
+      tasksByType.dailys[1].everyX = 2;
+      tasksByType.dailys[1].frequency = 'daily';
+
+      cron({user, tasksByType, daysMissed, analytics});
+
+      expect(user.stats.hp).to.equal(48);
+    });
   });
 
   describe('habits', () => {
@@ -514,6 +566,17 @@ describe('cron', () => {
         expect(tasksByType.habits[0].counterDown).to.equal(0);
       });
 
+      it('should reset habit counters even if user is resting in the Inn', () => {
+        user.preferences.sleep = true;
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
+
       it('should reset a weekly habit counter each Monday', () => {
         tasksByType.habits[0].frequency = 'weekly';
         tasksByType.habits[0].counterUp = 1;
@@ -533,6 +596,114 @@ describe('cron', () => {
         expect(tasksByType.habits[0].counterDown).to.equal(0);
       });
 
+      it('should reset a weekly habit counter with custom daily start', () => {
+        clock.restore();
+
+        // Server clock: Monday 12am UTC
+        let monday = new Date('May 22, 2017 00:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // cron runs at 2am
+        user.preferences.dayStart = 2;
+
+        tasksByType.habits[0].frequency = 'weekly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should not reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(1);
+        expect(tasksByType.habits[0].counterDown).to.equal(1);
+
+        clock.restore();
+
+        // Server clock: Monday 3am UTC
+        monday = new Date('May 22, 2017 03:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // should reset after user CDS
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
+
+      it('should not reset a weekly habit counter when server tz is Monday but user\'s tz is Tuesday', () => {
+        clock.restore();
+
+        // Server clock: Monday 11pm UTC
+        let monday = new Date('May 22, 2017 23:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // User clock: Tuesday 1am UTC + 2
+        user.preferences.timezoneOffset = -120;
+
+        tasksByType.habits[0].frequency = 'weekly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should not reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(1);
+        expect(tasksByType.habits[0].counterDown).to.equal(1);
+
+        // User missed one cron, which will subtract User clock back to Monday 1am UTC + 2
+        // should reset
+        daysMissed = 2;
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
+
+      it('should reset a weekly habit counter when server tz is Sunday but user\'s tz is Monday', () => {
+        clock.restore();
+
+        // Server clock: Sunday 11pm UTC
+        let sunday = new Date('May 21, 2017 23:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(sunday);
+
+        // User clock: Monday 2am UTC + 3
+        user.preferences.timezoneOffset = -180;
+
+        tasksByType.habits[0].frequency = 'weekly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
+
+      it('should not reset a weekly habit counter when server tz is Monday but user\'s tz is Sunday', () => {
+        clock.restore();
+
+        // Server clock: Monday 2am UTC
+        let monday = new Date('May 22, 2017 02:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // User clock: Sunday 11pm UTC - 3
+        user.preferences.timezoneOffset = 180;
+
+        tasksByType.habits[0].frequency = 'weekly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should not reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(1);
+        expect(tasksByType.habits[0].counterDown).to.equal(1);
+      });
+
       it('should reset a monthly habit counter the first day of each month', () => {
         tasksByType.habits[0].frequency = 'monthly';
         tasksByType.habits[0].counterUp = 1;
@@ -551,6 +722,59 @@ describe('cron', () => {
         expect(tasksByType.habits[0].counterUp).to.equal(0);
         expect(tasksByType.habits[0].counterDown).to.equal(0);
       });
+
+      it('should reset a monthly habit counter when server tz is last day of month but user tz is first day of the month', () => {
+        clock.restore();
+        daysMissed = 0;
+
+        // Server clock: 4/30/17 11pm UTC
+        let monday = new Date('April 30, 2017 23:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // User clock: 5/1/17 2am UTC + 3
+        user.preferences.timezoneOffset = -180;
+
+        tasksByType.habits[0].frequency = 'monthly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
+
+      it('should not reset a monthly habit counter when server tz is first day of month but user tz is 2nd day of the month', () => {
+        clock.restore();
+
+        // Server clock: 5/1/17 11pm UTC
+        let monday = new Date('May 1, 2017 23:00:00 GMT').getTime();
+        clock = sinon.useFakeTimers(monday);
+
+        // User clock: 5/2/17 2am UTC + 3
+        user.preferences.timezoneOffset = -180;
+
+        tasksByType.habits[0].frequency = 'monthly';
+        tasksByType.habits[0].counterUp = 1;
+        tasksByType.habits[0].counterDown = 1;
+        daysMissed = 1;
+
+        // should not reset
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(1);
+        expect(tasksByType.habits[0].counterDown).to.equal(1);
+
+        // User missed one day, which will subtract User clock back to 5/1/17 2am UTC + 3
+        // should reset
+        daysMissed = 2;
+        cron({user, tasksByType, daysMissed, analytics});
+
+        expect(tasksByType.habits[0].counterUp).to.equal(0);
+        expect(tasksByType.habits[0].counterDown).to.equal(0);
+      });
     });
   });
 

test/api/v3/unit/libs/email.test.js

@@ -142,12 +142,12 @@ describe('emails', () => {
   describe('getGroupUrl', () => {
     it('returns correct url if group is the tavern', () => {
       let getGroupUrl = require(pathToEmailLib).getGroupUrl;
-      expect(getGroupUrl({_id: TAVERN_ID, type: 'guild'})).to.eql('/#/options/groups/tavern');
+      expect(getGroupUrl({_id: TAVERN_ID, type: 'guild'})).to.eql('/groups/tavern');
     });
 
     it('returns correct url if group is a guild', () => {
       let getGroupUrl = require(pathToEmailLib).getGroupUrl;
-      expect(getGroupUrl({_id: 'random _id', type: 'guild'})).to.eql('/#/options/groups/guilds/random _id');
+      expect(getGroupUrl({_id: 'random _id', type: 'guild'})).to.eql('/groups/guild/random _id');
     });
 
     it('returns correct url if group is a party', () => {

test/api/v3/unit/libs/googlePayments.test.js

@@ -63,7 +63,21 @@ describe('Google Payments', ()  => {
         });
     });
 
+    it('should throw an error if user cannot purchase gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+
+      await expect(googlePayments.verifyGemPurchase(user, receipt, signature, headers))
+        .to.eventually.be.rejected.and.to.eql({
+          httpCode: 401,
+          name: 'NotAuthorized',
+          message: i18n.t('groupPolicyCannotGetGems'),
+        });
+
+      user.canGetGems.restore();
+    });
+
     it('purchases gems', async () => {
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
       await googlePayments.verifyGemPurchase(user, receipt, signature, headers);
 
       expect(iapSetupStub).to.be.calledOnce;
@@ -82,6 +96,8 @@ describe('Google Payments', ()  => {
         amount: 5.25,
         headers,
       });
+      expect(user.canGetGems).to.be.calledOnce;
+      user.canGetGems.restore();
     });
   });
 

test/api/v3/unit/libs/payments.test.js

@@ -16,6 +16,7 @@ describe('payments/index', () => {
   beforeEach(async () => {
     user = new User();
     user.profile.name = 'sender';
+    await user.save();
 
     group = generateGroup({
       name: 'test group',
@@ -504,6 +505,18 @@ describe('payments/index', () => {
         expect(daysTillTermination).to.be.within(13, 15);
       });
 
+      it('terminates at next billing date even if dateUpdated is prior to now', async () => {
+        data.nextBill = moment().add({ days: 15 });
+        data.user.purchased.plan.dateUpdated = moment().subtract({ days: 10 });
+
+        await api.cancelSubscription(data);
+
+        let now = new Date();
+        let daysTillTermination = moment(user.purchased.plan.dateTerminated).diff(now, 'days');
+
+        expect(daysTillTermination).to.be.within(13, 15);
+      });
+
       it('resets plan.extraMonths', async () => {
         user.purchased.plan.extraMonths = 5;
 
@@ -653,5 +666,32 @@ describe('payments/index', () => {
 
       expect(updatedUser.items.pets['Jackalope-RoyalPurple']).to.eql(5);
     });
+
+    it('saves previously unused Mystery Items and Hourglasses for an expired subscription', async () => {
+      let planExpirationDate = new Date();
+      planExpirationDate.setDate(planExpirationDate.getDate() - 2);
+      let mysteryItem = 'item';
+      let mysteryItems = [mysteryItem];
+      let consecutive = {
+        trinkets: 3,
+      };
+
+      // set expired plan with unused items
+      plan.mysteryItems = mysteryItems;
+      plan.consecutive = consecutive;
+      plan.dateCreated = planExpirationDate;
+      plan.dateTerminated = planExpirationDate;
+      plan.customerId = null;
+
+      user.purchased.plan = plan;
+
+      await user.save();
+      await api.addSubToGroupUser(user, group);
+
+      let updatedUser = await User.findById(user._id).exec();
+
+      expect(updatedUser.purchased.plan.mysteryItems[0]).to.eql(mysteryItem);
+      expect(updatedUser.purchased.plan.consecutive.trinkets).to.equal(consecutive.trinkets);
+    });
   });
 });

test/api/v3/unit/libs/payments/group-plans/group-payments-cancel.test.js

@@ -138,7 +138,7 @@ describe('Canceling a subscription for group', () => {
     ]);
   });
 
-  it('prevents non group leader from manging subscription', async () => {
+  it('prevents non group leader from managing subscription', async () => {
     let groupMember = new User();
     data.user = groupMember;
     data.groupId = group._id;

test/api/v3/unit/libs/payments/group-plans/group-payments-create.test.js

@@ -1,5 +1,6 @@
 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';
@@ -12,17 +13,24 @@ import {
   generateGroup,
 } from '../../../../../../helpers/api-unit.helper.js';
 
-describe('Purchasing a subscription for group', () => {
+describe('Purchasing a group plan for group', () => {
+  const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_GOOGLE = 'Google_subscription';
+  const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_IOS = 'iOS_subscription';
+  const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NORMAL = 'normal_subscription';
+  const EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NONE = 'no_subscription';
+
   let plan, group, user, data;
   let stripe = stripeModule('test');
+  let groupLeaderName = 'sender';
+  let groupName = 'test group';
 
   beforeEach(async () => {
     user = new User();
-    user.profile.name = 'sender';
+    user.profile.name = groupLeaderName;
     await user.save();
 
     group = generateGroup({
-      name: 'test group',
+      name: groupName,
       type: 'guild',
       privacy: 'public',
       leader: user._id,
@@ -81,7 +89,7 @@ describe('Purchasing a subscription for group', () => {
     sender.sendTxn.restore();
   });
 
-  it('creates a subscription', async () => {
+  it('creates a group plan', async () => {
     expect(group.purchased.plan.planId).to.not.exist;
     data.groupId = group._id;
 
@@ -157,7 +165,7 @@ describe('Purchasing a subscription for group', () => {
     expect(updatedLeader.items.mounts['Jackalope-RoyalPurple']).to.be.true;
   });
 
-  it('sends an email to members of group', async () => {
+  it('sends an email to member of group who was not a subscriber', async () => {
     let recipient = new User();
     recipient.profile.name = 'recipient';
     recipient.guilds.push(group._id);
@@ -169,11 +177,181 @@ describe('Purchasing a subscription for group', () => {
 
     expect(sender.sendTxn).to.be.calledTwice;
     expect(sender.sendTxn.firstCall.args[0]._id).to.equal(recipient._id);
-    expect(sender.sendTxn.firstCall.args[1]).to.equal('group-member-joining');
+    expect(sender.sendTxn.firstCall.args[1]).to.equal('group-member-join');
     expect(sender.sendTxn.firstCall.args[2]).to.eql([
       {name: 'LEADER', content: user.profile.name},
       {name: 'GROUP_NAME', content: group.name},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NONE},
     ]);
+    // confirm that the other email sent is appropriate:
+    expect(sender.sendTxn.secondCall.args[0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.secondCall.args[1]).to.equal('group-subscription-begins');
+  });
+
+  it('sends one email to subscribed member of group, stating subscription is cancelled (Stripe)', async () => {
+    let recipient = new User();
+    recipient.profile.name = 'recipient';
+    plan.key = 'basic_earned';
+    plan.paymentMethod = stripePayments.constants.PAYMENT_METHOD;
+    recipient.purchased.plan = plan;
+    recipient.guilds.push(group._id);
+    await recipient.save();
+
+    data.groupId = group._id;
+
+    await api.createSubscription(data);
+
+    expect(sender.sendTxn).to.be.calledTwice;
+    expect(sender.sendTxn.firstCall.args[0]._id).to.equal(recipient._id);
+    expect(sender.sendTxn.firstCall.args[1]).to.equal('group-member-join');
+    expect(sender.sendTxn.firstCall.args[2]).to.eql([
+      {name: 'LEADER', content: user.profile.name},
+      {name: 'GROUP_NAME', content: group.name},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NORMAL},
+    ]);
+    // confirm that the other email sent is not a cancel-subscription email:
+    expect(sender.sendTxn.secondCall.args[0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.secondCall.args[1]).to.equal('group-subscription-begins');
+  });
+
+  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'},
+        },
+      });
+
+    let recipient = new User();
+    recipient.profile.name = 'recipient';
+    plan.planId = 'basic_earned';
+    plan.paymentMethod = amzLib.constants.PAYMENT_METHOD;
+    recipient.purchased.plan = plan;
+    recipient.guilds.push(group._id);
+    await recipient.save();
+
+    data.groupId = group._id;
+
+    await api.createSubscription(data);
+
+    expect(sender.sendTxn).to.be.calledTwice;
+    expect(sender.sendTxn.firstCall.args[0]._id).to.equal(recipient._id);
+    expect(sender.sendTxn.firstCall.args[1]).to.equal('group-member-join');
+    expect(sender.sendTxn.firstCall.args[2]).to.eql([
+      {name: 'LEADER', content: user.profile.name},
+      {name: 'GROUP_NAME', content: group.name},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NORMAL},
+    ]);
+    // confirm that the other email sent is not a cancel-subscription email:
+    expect(sender.sendTxn.secondCall.args[0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.secondCall.args[1]).to.equal('group-subscription-begins');
+
+    amzLib.getBillingAgreementDetails.restore();
+  });
+
+  it('sends one email to subscribed member of group, stating subscription is cancelled (PayPal)', async () => {
+    sinon.stub(paypalPayments, 'paypalBillingAgreementCancel').returnsPromise().resolves({});
+    sinon.stub(paypalPayments, 'paypalBillingAgreementGet')
+      .returnsPromise().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
+        },
+      });
+
+    let recipient = new User();
+    recipient.profile.name = 'recipient';
+    plan.planId = 'basic_earned';
+    plan.paymentMethod = paypalPayments.constants.PAYMENT_METHOD;
+    recipient.purchased.plan = plan;
+    recipient.guilds.push(group._id);
+    await recipient.save();
+
+    data.groupId = group._id;
+
+    await api.createSubscription(data);
+
+    expect(sender.sendTxn).to.be.calledTwice;
+    expect(sender.sendTxn.firstCall.args[0]._id).to.equal(recipient._id);
+    expect(sender.sendTxn.firstCall.args[1]).to.equal('group-member-join');
+    expect(sender.sendTxn.firstCall.args[2]).to.eql([
+      {name: 'LEADER', content: user.profile.name},
+      {name: 'GROUP_NAME', content: group.name},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_NORMAL},
+    ]);
+    // confirm that the other email sent is not a cancel-subscription email:
+    expect(sender.sendTxn.secondCall.args[0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.secondCall.args[1]).to.equal('group-subscription-begins');
+
+    paypalPayments.paypalBillingAgreementGet.restore();
+    paypalPayments.paypalBillingAgreementCancel.restore();
+  });
+
+  it('sends appropriate emails when subscribed member of group must manually cancel recurring Android subscription', async () => {
+    const TECH_ASSISTANCE_EMAIL = nconf.get('TECH_ASSISTANCE_EMAIL');
+    plan.customerId = 'random';
+    plan.paymentMethod = api.constants.GOOGLE_PAYMENT_METHOD;
+
+    let recipient = new User();
+    recipient.profile.name = 'recipient';
+    recipient.purchased.plan = plan;
+    recipient.guilds.push(group._id);
+    await recipient.save();
+
+    user.guilds.push(group._id);
+    await user.save();
+    data.groupId = group._id;
+
+    await api.createSubscription(data);
+
+    expect(sender.sendTxn).to.be.calledFourTimes;
+    expect(sender.sendTxn.args[0][0]._id).to.equal(TECH_ASSISTANCE_EMAIL);
+    expect(sender.sendTxn.args[0][1]).to.equal('admin-user-subscription-details');
+    expect(sender.sendTxn.args[1][0]._id).to.equal(recipient._id);
+    expect(sender.sendTxn.args[1][1]).to.equal('group-member-join');
+    expect(sender.sendTxn.args[1][2]).to.eql([
+      {name: 'LEADER', content: groupLeaderName},
+      {name: 'GROUP_NAME', content: groupName},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_GOOGLE},
+    ]);
+    expect(sender.sendTxn.args[2][0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.args[2][1]).to.equal('group-member-join');
+    expect(sender.sendTxn.args[3][0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.args[3][1]).to.equal('group-subscription-begins');
+  });
+
+  it('sends appropriate emails when subscribed member of group must manually cancel recurring iOS subscription', async () => {
+    const TECH_ASSISTANCE_EMAIL = nconf.get('TECH_ASSISTANCE_EMAIL');
+    plan.customerId = 'random';
+    plan.paymentMethod = api.constants.IOS_PAYMENT_METHOD;
+
+    let recipient = new User();
+    recipient.profile.name = 'recipient';
+    recipient.purchased.plan = plan;
+    recipient.guilds.push(group._id);
+    await recipient.save();
+
+    user.guilds.push(group._id);
+    await user.save();
+    data.groupId = group._id;
+
+    await api.createSubscription(data);
+
+    expect(sender.sendTxn).to.be.calledFourTimes;
+    expect(sender.sendTxn.args[0][0]._id).to.equal(TECH_ASSISTANCE_EMAIL);
+    expect(sender.sendTxn.args[0][1]).to.equal('admin-user-subscription-details');
+    expect(sender.sendTxn.args[1][0]._id).to.equal(recipient._id);
+    expect(sender.sendTxn.args[1][1]).to.equal('group-member-join');
+    expect(sender.sendTxn.args[1][2]).to.eql([
+      {name: 'LEADER', content: groupLeaderName},
+      {name: 'GROUP_NAME', content: groupName},
+      {name: 'PREVIOUS_SUBSCRIPTION_TYPE', content: EMAIL_TEMPLATE_SUBSCRIPTION_TYPE_IOS},
+    ]);
+    expect(sender.sendTxn.args[2][0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.args[2][1]).to.equal('group-member-join');
+    expect(sender.sendTxn.args[3][0]._id).to.equal(group.leader);
+    expect(sender.sendTxn.args[3][1]).to.equal('group-subscription-begins');
   });
 
   it('adds months to members with existing gift subscription', async () => {
@@ -333,7 +511,7 @@ describe('Purchasing a subscription for group', () => {
   });
 
   it('adds months to members with existing recurring subscription (Android)');
-  it('adds months to members with existing recurring subscription (iOs)');
+  it('adds months to members with existing recurring subscription (iOS)');
 
   it('adds months to members who already cancelled but not yet terminated recurring subscription', async () => {
     let recipient = new User();
@@ -418,7 +596,7 @@ describe('Purchasing a subscription for group', () => {
 
     let updatedUser = await User.findById(recipient._id).exec();
 
-    expect(updatedUser.purchased.plan.extraMonths).to.within(7, 8);
+    expect(updatedUser.purchased.plan.extraMonths).to.within(7, 9);
   });
 
   it('adds months to members with existing recurring subscription and ignores existing negative extraMonths', async () => {
@@ -603,7 +781,7 @@ describe('Purchasing a subscription for group', () => {
     expect(updatedUser.purchased.plan.dateCreated).to.exist;
   });
 
-  it('does not modify a user with a Google subscription', async () => {
+  it('does not modify a user with an Android subscription', async () => {
     plan.customerId = 'random';
     plan.paymentMethod = api.constants.GOOGLE_PAYMENT_METHOD;
 

test/api/v3/unit/libs/paypalPayments.test.js

@@ -61,23 +61,54 @@ describe('Paypal Payments', ()  => {
     });
 
     it('creates a link for gem purchases', async () => {
-      let link = await paypalPayments.checkout();
+      let link = await paypalPayments.checkout({user: new User()});
 
       expect(paypalPaymentCreateStub).to.be.calledOnce;
       expect(paypalPaymentCreateStub).to.be.calledWith(getPaypalCreateOptions('Habitica Gems', 5.00));
       expect(link).to.eql(approvalHerf);
     });
 
-    it('creates a link for gifting gems', async () => {
+    it('should error if gem amount is too low', async () => {
       let receivingUser = new User();
+      receivingUser.save();
       let gift = {
         type: 'gems',
         gems: {
-          amount: 16,
+          amount: 0,
           uuid: receivingUser._id,
         },
       };
 
+      await expect(paypalPayments.checkout({gift}))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Amount must be at least 1.',
+        name: 'BadRequest',
+      });
+    });
+
+    it('should error if the user cannot get gems', async () => {
+      let user = new User();
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+
+      await expect(paypalPayments.checkout({user})).to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        message: i18n.t('groupPolicyCannotGetGems'),
+        name: 'NotAuthorized',
+      });
+    });
+
+    it('creates a link for gifting gems', async () => {
+      let receivingUser = new User();
+      await receivingUser.save();
+      let gift = {
+        type: 'gems',
+        uuid: receivingUser._id,
+        gems: {
+          amount: 16,
+        },
+      };
+
       let link = await paypalPayments.checkout({gift});
 
       expect(paypalPaymentCreateStub).to.be.calledOnce;
@@ -447,6 +478,7 @@ describe('Paypal Payments', ()  => {
         groupId,
         paymentMethod: 'Paypal',
         nextBill: nextBillingDate,
+        cancellationReason: undefined,
       });
     });
 
@@ -464,6 +496,7 @@ describe('Paypal Payments', ()  => {
         groupId: group._id,
         paymentMethod: 'Paypal',
         nextBill: nextBillingDate,
+        cancellationReason: undefined,
       });
     });
   });

test/api/v3/unit/libs/slack.js

@@ -71,7 +71,7 @@ describe('slack', () => {
       expect(IncomingWebhook.prototype.send).to.be.calledWithMatch({
         attachments: [sandbox.match({
           title: 'Flag in Some group',
-          title_link: sandbox.match(/.*\/#\/options\/groups\/guilds\/group-id/),
+          title_link: sandbox.match(/.*\/groups\/guild\/group-id/),
         })],
       });
     });
@@ -86,7 +86,7 @@ describe('slack', () => {
       expect(IncomingWebhook.prototype.send).to.be.calledWithMatch({
         attachments: [sandbox.match({
           title: 'Flag in Tavern',
-          title_link: sandbox.match(/.*\/#\/options\/groups\/tavern/),
+          title_link: sandbox.match(/.*\/groups\/tavern/),
         })],
       });
     });

test/api/v3/unit/libs/stripePayments.test.js

@@ -48,7 +48,57 @@ describe('Stripe Payments', () => {
       payments.createSubscription.restore();
     });
 
+    it('should error if gem amount is too low', async () => {
+      let receivingUser = new User();
+      receivingUser.save();
+      gift = {
+        type: 'gems',
+        gems: {
+          amount: 0,
+          uuid: receivingUser._id,
+        },
+      };
+
+      await expect(stripePayments.checkout({
+        token,
+        user,
+        gift,
+        groupId,
+        email,
+        headers,
+        coupon,
+      }, stripe))
+      .to.eventually.be.rejected.and.to.eql({
+        httpCode: 400,
+        message: 'Amount must be at least 1.',
+        name: 'BadRequest',
+      });
+    });
+
+
+    it('should error if user cannot get gems', async () => {
+      gift = undefined;
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(false);
+
+      await expect(stripePayments.checkout({
+        token,
+        user,
+        gift,
+        groupId,
+        email,
+        headers,
+        coupon,
+      }, stripe)).to.eventually.be.rejected.and.to.eql({
+        httpCode: 401,
+        message: i18n.t('groupPolicyCannotGetGems'),
+        name: 'NotAuthorized',
+      });
+    });
+
     it('should purchase gems', async () => {
+      gift = undefined;
+      sinon.stub(user, 'canGetGems').returnsPromise().resolves(true);
+
       await stripePayments.checkout({
         token,
         user,
@@ -73,16 +123,18 @@ describe('Stripe Payments', () => {
         paymentMethod: 'Stripe',
         gift,
       });
+      expect(user.canGetGems).to.be.calledOnce;
+      user.canGetGems.restore();
     });
 
     it('should gift gems', async () => {
       let receivingUser = new User();
-      receivingUser.save();
+      await receivingUser.save();
       gift = {
         type: 'gems',
+        uuid: receivingUser._id,
         gems: {
           amount: 16,
-          uuid: receivingUser._id,
         },
       };
 
@@ -96,7 +148,6 @@ describe('Stripe Payments', () => {
         coupon,
       }, stripe);
 
-      gift.member = receivingUser;
       expect(stripeChargeStub).to.be.calledOnce;
       expect(stripeChargeStub).to.be.calledWith({
         amount: '400',
@@ -683,6 +734,7 @@ describe('Stripe Payments', () => {
           groupId: undefined,
           nextBill: currentPeriodEndTimeStamp * 1000, // timestamp in seconds
           paymentMethod: 'Stripe',
+          cancellationReason: undefined,
         });
       });
 
@@ -702,6 +754,7 @@ describe('Stripe Payments', () => {
           groupId,
           nextBill: currentPeriodEndTimeStamp * 1000, // timestamp in seconds
           paymentMethod: 'Stripe',
+          cancellationReason: undefined,
         });
       });
     });

test/api/v3/unit/middlewares/response.js

@@ -33,6 +33,7 @@ describe('response middleware', () => {
       success: true,
       data: {field: 1},
       notifications: [],
+      userV: res.locals.user._v,
     });
   });
 
@@ -49,6 +50,7 @@ describe('response middleware', () => {
       data: {field: 1},
       message: 'hello',
       notifications: [],
+      userV: res.locals.user._v,
     });
   });
 
@@ -64,12 +66,12 @@ describe('response middleware', () => {
       success: false,
       data: {field: 1},
       notifications: [],
+      userV: res.locals.user._v,
     });
   });
 
-  it('returns userV if a user is authenticated req.query.userV is passed', () => {
+  it('returns userV if a user is authenticated', () => {
     responseMiddleware(req, res, next);
-    req.query.userV = 3;
     res.respond(200, {field: 1});
 
     expect(res.json).to.be.calledOnce;
@@ -101,6 +103,7 @@ describe('response middleware', () => {
           data: {},
         },
       ],
+      userV: res.locals.user._v,
     });
   });
 });

test/api/v3/unit/models/group.test.js

@@ -228,7 +228,7 @@ describe('Group Model', () => {
         });
 
         it('applies damage only to participating members of party even under buggy conditions', async () => {
-          // stops unfair damage from mbugs like https://github.com/HabitRPG/habitrpg/issues/7653
+          // stops unfair damage from mbugs like https://github.com/HabitRPG/habitica/issues/7653
           party.quest.members = {
             [questLeader._id]: true,
             [participatingMember._id]: true,

test/api/v3/unit/models/user.test.js

@@ -1,6 +1,7 @@
 import Bluebird from 'bluebird';
 import moment from 'moment';
 import { model as User } from '../../../../../website/server/models/user';
+import { model as Group } from '../../../../../website/server/models/group';
 import common from '../../../../../website/common';
 
 describe('User Model', () => {
@@ -179,6 +180,75 @@ describe('User Model', () => {
     });
   });
 
+  context('canGetGems', () => {
+    let user;
+    let group;
+    beforeEach(() => {
+      user = new User();
+      let leader = new User();
+      group = new Group({
+        name: 'test',
+        type: 'guild',
+        privacy: 'private',
+        leader: leader._id,
+      });
+    });
+
+    it('returns true if user is not subscribed', async () => {
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if user is not subscribed with a group plan', async () => {
+      user.purchased.plan.customerId = 123;
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if user is subscribed with a group plan', async () => {
+      user.purchased.plan.customerId = 'group-plan';
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if user is part of a group', async () => {
+      user.guilds.push(group._id);
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if user is part of a group with a subscription', async () => {
+      user.guilds.push(group._id);
+      user.purchased.plan.customerId = 'group-plan';
+      group.purchased.plan.customerId = 123;
+      await group.save();
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if leader is part of a group with a subscription and canGetGems: false', async () => {
+      user.guilds.push(group._id);
+      user.purchased.plan.customerId = 'group-plan';
+      group.purchased.plan.customerId = 123;
+      group.leader = user._id;
+      group.leaderOnly.getGems = true;
+      await group.save();
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns true if user is part of a group with no subscription but canGetGems: false', async () => {
+      user.guilds.push(group._id);
+      user.purchased.plan.customerId = 'group-plan';
+      group.leaderOnly.getGems = true;
+      await group.save();
+      expect(await user.canGetGems()).to.equal(true);
+    });
+
+    it('returns false if user is part of a group with a subscription and canGetGems: false', async () => {
+      user.guilds.push(group._id);
+      user.purchased.plan.customerId = 'group-plan';
+      group.purchased.plan.customerId = 123;
+      group.leaderOnly.getGems = true;
+      await group.save();
+      expect(await user.canGetGems()).to.equal(false);
+    });
+  });
+
   context('hasNotCancelled', () => {
     let user;
     beforeEach(() => {

test/client-old/spec/controllers/groupCtrlSpec.js

@@ -112,6 +112,41 @@ describe('Groups Controller', function() {
     });
   });
 
+  describe('isAbleToEditGroup', () => {
+    var guild;
+
+    beforeEach(() => {
+      user.contributor = {};
+      guild = specHelper.newGroup({
+        _id: 'unique-guild-id',
+        type: 'guild',
+        members: ['not-user-id'],
+        $save: sandbox.spy(),
+      });
+    });
+
+    it('returns true if user is an admin', () => {
+      guild.leader = 'not-user-id';
+      user.contributor.admin = true;
+      expect(scope.isAbleToEditGroup(guild)).to.be.ok;
+    });
+
+    it('returns true if user is group leader', () => {
+      guild.leader = {_id: user._id}
+      expect(scope.isAbleToEditGroup(guild)).to.be.ok;
+    });
+
+    it('returns false is user is not a leader or admin', () => {
+      expect(scope.isAbleToEditGroup(guild)).to.not.be.ok;
+    });
+
+    it('returns false is user is an admin but group is a party', () => {
+      guild.type = 'party';
+      user.contributor.admin = true;
+      expect(scope.isAbleToEditGroup(guild)).to.not.be.ok;
+    });
+  });
+
   describe('editGroup', () => {
     var guild;
 

test/client-old/spec/controllers/groupTaskActionsCtrlSpec.js

@@ -1,63 +1,63 @@
-describe('Group Tasks Meta Actions Controller', () => {
-  let rootScope, scope, user, userSerivce;
-
-  beforeEach(() => {
-    module(function($provide) {
-      $provide.value('User', {});
-    });
-
-    inject(($rootScope, $controller) => {
-      rootScope = $rootScope;
-
-      user = specHelper.newUser();
-      user._id = "unique-user-id";
-      userSerivce = {user: user};
-
-      scope = $rootScope.$new();
-
-      scope.task = {
-        group: {
-          assignedUsers: [],
-          approval: {
-            required: false,
-          }
-        },
-      };
-      scope.task._edit = angular.copy(scope.task);
-
-      $controller('GroupTaskActionsCtrl', {$scope: scope, User: userSerivce});
-    });
-  });
-
-  describe('toggleTaskRequiresApproval', function () {
-    it('toggles task approval required field from false to true', function () {
-      scope.toggleTaskRequiresApproval();
-      expect(scope.task._edit.group.approval.required).to.be.true;
-    });
-
-    it('toggles task approval required field from true to false', function () {
-      scope.task._edit.group.approval.required = true;
-      scope.toggleTaskRequiresApproval();
-      expect(scope.task._edit.group.approval.required).to.be.false;
-    });
-  });
-
-
-  describe('assign events', function () {
-    it('adds a group member to assigned users on "addedGroupMember" event ', () => {
-      var testId = 'test-id';
-      rootScope.$broadcast('addedGroupMember', testId);
-      expect(scope.task.group.assignedUsers).to.contain(testId);
-      expect(scope.task._edit.group.assignedUsers).to.contain(testId);
-    });
-
-    it('removes a group member to assigned users on "addedGroupMember" event ', () => {
-      var testId = 'test-id';
-      scope.task.group.assignedUsers.push(testId);
-      scope.task._edit.group.assignedUsers.push(testId);
-      rootScope.$broadcast('removedGroupMember', testId);
-      expect(scope.task.group.assignedUsers).to.not.contain(testId);
-      expect(scope.task._edit.group.assignedUsers).to.not.contain(testId);
-    });
-  });
-});
+describe('Group Tasks Meta Actions Controller', () => {
+  let rootScope, scope, user, userSerivce;
+
+  beforeEach(() => {
+    module(function($provide) {
+      $provide.value('User', {});
+    });
+
+    inject(($rootScope, $controller) => {
+      rootScope = $rootScope;
+
+      user = specHelper.newUser();
+      user._id = "unique-user-id";
+      userSerivce = {user: user};
+
+      scope = $rootScope.$new();
+
+      scope.task = {
+        group: {
+          assignedUsers: [],
+          approval: {
+            required: false,
+          }
+        },
+      };
+      scope.task._edit = angular.copy(scope.task);
+
+      $controller('GroupTaskActionsCtrl', {$scope: scope, User: userSerivce});
+    });
+  });
+
+  describe('toggleTaskRequiresApproval', function () {
+    it('toggles task approval required field from false to true', function () {
+      scope.toggleTaskRequiresApproval();
+      expect(scope.task._edit.group.approval.required).to.be.true;
+    });
+
+    it('toggles task approval required field from true to false', function () {
+      scope.task._edit.group.approval.required = true;
+      scope.toggleTaskRequiresApproval();
+      expect(scope.task._edit.group.approval.required).to.be.false;
+    });
+  });
+
+
+  describe('assign events', function () {
+    it('adds a group member to assigned users on "addedGroupMember" event ', () => {
+      var testId = 'test-id';
+      rootScope.$broadcast('addedGroupMember', testId);
+      expect(scope.task.group.assignedUsers).to.contain(testId);
+      expect(scope.task._edit.group.assignedUsers).to.contain(testId);
+    });
+
+    it('removes a group member to assigned users on "addedGroupMember" event ', () => {
+      var testId = 'test-id';
+      scope.task.group.assignedUsers.push(testId);
+      scope.task._edit.group.assignedUsers.push(testId);
+      rootScope.$broadcast('removedGroupMember', testId);
+      expect(scope.task.group.assignedUsers).to.not.contain(testId);
+      expect(scope.task._edit.group.assignedUsers).to.not.contain(testId);
+    });
+  });
+});

test/client-old/spec/controllers/notificationCtrlSpec.js

@@ -6,6 +6,7 @@ describe('Notification Controller', function() {
   beforeEach(function() {
     user = specHelper.newUser();
     user._id = "unique-user-id";
+    user.needsCron = false;
 
     var userSync = sinon.stub().returns({
       then: function then (f) { f(); }
@@ -99,7 +100,7 @@ describe('Notification Controller', function() {
   });
 
   describe('User challenge won notification watch', function() {
-    it('opens challenge won modal when a challenge-won notification is recieved', function() {
+    it('opens challenge won modal when a challenge-won notification is received', function() {
       rootScope.$digest();
       rootScope.userNotifications.push({type: 'WON_CHALLENGE'});
       rootScope.$digest();
@@ -108,7 +109,7 @@ describe('Notification Controller', function() {
       expect(achievement.displayAchievement).to.be.calledWith('wonChallenge');
     });
 
-    it('does not open challenge won modal if no new challenge-won notification is recieved', function() {
+    it('does not open challenge won modal if no new challenge-won notification is received', function() {
       rootScope.$digest();
       rootScope.$digest();
 
@@ -117,7 +118,7 @@ describe('Notification Controller', function() {
   });
 
   describe('User streak achievement notification watch', function() {
-    it('opens streak achievement modal when a streak-achievement notification is recieved', function() {
+    it('opens streak achievement modal when a streak-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.userNotifications.push({type: 'STREAK_ACHIEVEMENT'});
       rootScope.$digest();
@@ -126,7 +127,7 @@ describe('Notification Controller', function() {
       expect(achievement.displayAchievement).to.be.calledWith('streak', {size: 'md'});
     });
 
-    it('does not open streak achievement modal if no new streak-achievement notification is recieved', function() {
+    it('does not open streak achievement modal if no new streak-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.$digest();
 
@@ -135,7 +136,7 @@ describe('Notification Controller', function() {
   });
 
   describe('User ultimate gear set achievement notification watch', function() {
-    it('opens ultimate gear set achievement modal when an ultimate-gear-achievement notification is recieved', function() {
+    it('opens ultimate gear set achievement modal when an ultimate-gear-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.userNotifications.push({type: 'ULTIMATE_GEAR_ACHIEVEMENT'});
       rootScope.$digest();
@@ -144,7 +145,7 @@ describe('Notification Controller', function() {
       expect(achievement.displayAchievement).to.be.calledWith('ultimateGear', {size: 'md'});
     });
 
-    it('does not open ultimate gear set achievement modal if no new ultimate-gear-achievement notification is recieved', function() {
+    it('does not open ultimate gear set achievement modal if no new ultimate-gear-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.$digest();
 
@@ -153,7 +154,7 @@ describe('Notification Controller', function() {
   });
 
   describe('User rebirth achievement notification watch', function() {
-    it('opens rebirth achievement modal when a rebirth-achievement notification is recieved', function() {
+    it('opens rebirth achievement modal when a rebirth-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.userNotifications.push({type: 'REBIRTH_ACHIEVEMENT'});
       rootScope.$digest();
@@ -162,7 +163,7 @@ describe('Notification Controller', function() {
       expect(achievement.displayAchievement).to.be.calledWith('rebirth');
     });
 
-    it('does not open rebirth achievement modal if no new rebirth-achievement notification is recieved', function() {
+    it('does not open rebirth achievement modal if no new rebirth-achievement notification is received', function() {
       rootScope.$digest();
       rootScope.$digest();
 
@@ -171,7 +172,7 @@ describe('Notification Controller', function() {
   });
 
   describe('User contributor achievement notification watch', function() {
-    it('opens contributor achievement modal when a new-contributor-level notification is recieved', function() {
+    it('opens contributor achievement modal when a new-contributor-level notification is received', function() {
       rootScope.$digest();
       rootScope.userNotifications.push({type: 'NEW_CONTRIBUTOR_LEVEL'});
       rootScope.$digest();
@@ -180,7 +181,7 @@ describe('Notification Controller', function() {
       expect(achievement.displayAchievement).to.be.calledWith('contributor', {size: 'md'});
     });
 
-    it('does not open contributor achievement modal if no new new-contributor-level notification is recieved', function() {
+    it('does not open contributor achievement modal if no new new-contributor-level notification is received', function() {
       rootScope.$digest();
       rootScope.$digest();
 

test/client-old/spec/directives/close-menu.directive.js

@@ -1,35 +0,0 @@
-'use strict';
-
-describe('closeMenu Directive', function() {
-  var scope;
-
-  beforeEach(module('habitrpg'));
-
-  beforeEach(inject(function($rootScope) {
-    scope = $rootScope.$new();
-
-    scope.$digest();
-  }));
-
-  it('closes a connected menu when element is clicked', inject(function($compile) {
-    var menuElement = $compile('<a data-close-menu menu="mobile">')(scope);
-    scope._expandedMenu = { menu: 'mobile' };
-
-    menuElement.appendTo(document.body);
-    menuElement.triggerHandler('click');
-
-    expect(scope._expandedMenu.menu).to.eql(null)
-  }));
-
-  it('closes a connected menu when child element is clicked', inject(function($compile) {
-    var menuElementWithChild = $compile('<li></li>')(scope);
-    var menuElementChild = $compile('<a data-close-menu></a>')(scope);
-    scope._expandedMenu = { menu: 'mobile' };
-
-    menuElementWithChild.appendTo(document.body);
-    menuElementChild.appendTo(menuElementWithChild);
-    menuElementChild.triggerHandler('click');
-
-    expect(scope._expandedMenu.menu).to.eql(null)
-  }));
-});

test/client-old/spec/directives/expand-menu.directive.js

@@ -1,35 +0,0 @@
-'use strict';
-
-describe('expandMenu Directive', function() {
-  var menuElement, scope;
-
-  beforeEach(module('habitrpg'));
-
-  beforeEach(inject(function($rootScope, $compile) {
-    scope = $rootScope.$new();
-
-    var element = '<a data-expand-menu menu="mobile"></a>';
-
-    menuElement = $compile(element)(scope);
-    scope.$digest();
-  }));
-
-  it('expands a connected menu when element is clicked', function() {
-    expect(scope._expandedMenu).to.not.exist;
-    menuElement.appendTo(document.body);
-
-    menuElement.triggerHandler('click');
-
-    expect(scope._expandedMenu.menu).to.eql('mobile')
-  });
-
-  it('closes a connected menu when it is already open', function() {
-    scope._expandedMenu = {};
-    scope._expandedMenu.menu = 'mobile';
-    menuElement.appendTo(document.body);
-
-    menuElement.triggerHandler('click');
-
-    expect(scope._expandedMenu.menu).to.eql(null)
-  });
-});

test/client-old/spec/services/memberServicesSpec.js

@@ -47,7 +47,7 @@ describe('memberServices', function() {
 
   it('calls get challenge members', function() {
     var challengeId = 1;
-    var memberUrl = apiV3Prefix + '/challenges/' + challengeId + '/members?includeAllMembers=true';
+    var memberUrl = apiV3Prefix + '/challenges/' + challengeId + '/members';
     $httpBackend.expectGET(memberUrl).respond({});
     members.getChallengeMembers(challengeId);
     $httpBackend.flush();

test/client/unit/specs/components/ui/drawer.js

@@ -1,5 +1,5 @@
 import Vue from 'vue';
-import DrawerComponent from 'client/components/inventory/drawer.vue';
+import DrawerComponent from 'client/components/ui/drawer.vue';
 
 describe('DrawerComponent', () => {
   it('sets the correct default data', () => {

test/client/unit/specs/filters/roundBigNumber.js

@@ -0,0 +1,20 @@
+import roundBigNumberFilter from 'client/filters/roundBigNumber';
+
+describe('round big number filter', () => {
+  it('can round a decimal number', () => {
+    expect(roundBigNumberFilter(4.567)).to.equal(4.57);
+    expect(roundBigNumberFilter(4.562)).to.equal(4.56);
+  });
+
+  it('can round thousands', () => {
+    expect(roundBigNumberFilter(70065)).to.equal('70.1k');
+  });
+
+  it('can round milions', () => {
+    expect(roundBigNumberFilter(10000987)).to.equal('10.0m');
+  });
+
+  it('can round bilions', () => {
+    expect(roundBigNumberFilter(1000000000)).to.equal('1.0b');
+  });
+});

test/client/unit/specs/libs/i18n.js

@@ -4,7 +4,13 @@ import Vue from 'vue';
 
 describe('i18n plugin', () => {
   before(() => {
-    Vue.use(i18n);
+    Vue.use(i18n, {
+      i18nData: {
+        strings: {
+          reportBug: 'Report a Bug',
+        },
+      },
+    });
   });
 
   it('adds $t to Vue.prototype', () => {

test/client/unit/specs/store/actions/tasks.js

@@ -9,7 +9,7 @@ describe('tasks actions', () => {
   });
 
   describe('fetchUserTasks', () => {
-    it('fetches user tasks', async () => {
+    xit('fetches user tasks', async () => {
       expect(store.state.tasks.loadingStatus).to.equal('NOT_LOADED');
       const tasks = [{_id: 1}];
       sandbox.stub(axios, 'get').withArgs('/api/v3/tasks/user').returns(Promise.resolve({data: {data: tasks}}));
@@ -36,7 +36,7 @@ describe('tasks actions', () => {
       expect(store.state.tasks.loadingStatus).to.equal('LOADED');
     });
 
-    it('can reload tasks if forceLoad is true', async () => {
+    xit('can reload tasks if forceLoad is true', async () => {
       store.state.tasks = {
         loadingStatus: 'LOADED',
         data: [{_id: 1}],

test/client/unit/specs/store/actions/user.js

@@ -1,7 +1,7 @@
 import axios from 'axios';
 import generateStore from 'client/store';
 
-describe('tasks actions', () => {
+describe('user actions', () => {
   let store;
 
   beforeEach(() => {
@@ -45,7 +45,7 @@ describe('tasks actions', () => {
       const user = {_id: 2};
       sandbox.stub(axios, 'get').withArgs('/api/v3/user').returns(Promise.resolve({data: {data: user}}));
 
-      await store.dispatch('user:fetch', true);
+      await store.dispatch('user:fetch', {forceLoad: true});
 
       expect(store.state.user.data).to.equal(user);
       expect(store.state.user.loadingStatus).to.equal('LOADED');

test/common/libs/achievements.test.js

@@ -121,6 +121,17 @@ describe('achievements', () => {
       });
     });
 
+    it('card achievements exist with counts', () => {
+      let cardTypes = ['greeting', 'thankyou', 'birthday', 'congrats', 'getwell', 'goodluck'];
+      cardTypes.forEach((card) => {
+        let cardAchiev = basicAchievs[`${card}Cards`];
+
+        expect(cardAchiev).to.exist;
+        expect(cardAchiev).to.have.property('optionalCount')
+          .that.is.a('number');
+      });
+    });
+
     it('rebirth achievement exists with no count', () => {
       let rebirth = basicAchievs.rebirth;
 
@@ -174,7 +185,7 @@ describe('achievements', () => {
     });
 
     it('card achievements exist with counts', () => {
-      let cardTypes = ['greeting', 'thankyou', 'nye', 'valentine', 'birthday'];
+      let cardTypes = ['nye', 'valentine'];
       cardTypes.forEach((card) => {
         let cardAchiev = seasonalAchievs[`${card}Cards`];