krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-17 22:57:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

migrate user model to new code style and es6

Browse Source
This commit is contained in:
Matteo Pagliazzi
2015-11-08 16:11:55 +01:00
parent f26737ab79
commit 4b60698527
3 changed files with 414 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.eslintrc
View File

@@ -22,8 +22,6 @@
"no-loop-func": 2, "no-loop-func": 2,
"no-implicit-coercion": 2, "no-implicit-coercion": 2,
"no-implied-eval": 2, "no-implied-eval": 2,
"no-invalid-this": 2,
"no-magic-numbers": 2,
"no-native-reassign": 2, "no-native-reassign": 2,
"no-new-func": 2, "no-new-func": 2,
"no-new-wrappers": 2, "no-new-wrappers": 2,
@@ -97,7 +95,7 @@
"no-nested-ternary": 2, "no-nested-ternary": 2,
"one-var": [2, "never"], "one-var": [2, "never"],
"operator-linebreak": [2, "after"], "operator-linebreak": [2, "after"],
"quote-props": [2, "as-needed", { "keywords": true }], "quote-props": [2, "as-needed"],
"semi-spacing": [2, {"before": false, "after": true}], "semi-spacing": [2, {"before": false, "after": true}],
"space-after-keywords": 2, "space-after-keywords": 2,
"space-before-blocks": 2, "space-before-blocks": 2,

5
tasks/gulp-eslint.js
View File

@@ -9,7 +9,10 @@ import eslint from 'gulp-eslint';
gulp.task('lint:server', () => { gulp.task('lint:server', () => {
// Ignore .coffee files // Ignore .coffee files
return gulp return gulp
.src(['./website/src/**/api-v3/**/*.js']) .src([
'./website/src/**/api-v3/**/*.js',
'./website/src/models/user.js'
])
.pipe(eslint()) .pipe(eslint())
.pipe(eslint.format()) .pipe(eslint.format())
.pipe(eslint.failAfterError()); .pipe(eslint.failAfterError());

721
website/src/models/user.js
View File

@@ -1,39 +1,52 @@
// User.js // User schema and model
// ======= import mongoose from 'mongoose';
// Defines the user data model (schema) for use via the API. import shared from '../../../common';
import _ from 'lodash';
import moment from 'moment';
import TaskSchemas from './task';
// import {model as Challenge} from './challenge';
// Dependencies let Schema = mongoose.Schema;
// ------------
var mongoose = require("mongoose");
var Schema = mongoose.Schema;
var shared = require('../../../common');
var _ = require('lodash');
var TaskSchemas = require('./task');
var Challenge = require('./challenge').model;
var moment = require('moment');
// User Schema // User schema definition
// ----------- export let schema = new Schema({
// The user _id, stored as a string
var UserSchema = new Schema({ // TODO validation
// ### UUID and API Token
_id: { _id: {
type: String, type: String,
'default': shared.uuid default: shared.uuid,
}, },
// TODO validation
apiToken: { apiToken: {
type: String, type: String,
'default': shared.uuid default: shared.uuid,
},
auth: {
blocked: Boolean,
facebook: Schema.Types.Mixed, // TODO validate
local: {
email: String,
hashed_password: String,
salt: String,
username: String,
// Store a lowercase version of username to check for duplicates
lowerCaseUsername: String,
},
timestamps: {
created: {type: Date, default: Date.now},
loggedin: {type: Date, default: Date.now},
},
}, },
// ### Mongoose Update Object
// We want to know *every* time an object updates. Mongoose uses __v to designate when an object contains arrays which // We want to know *every* time an object updates. Mongoose uses __v to designate when an object contains arrays which
// have been updated (http://goo.gl/gQLz41), but we want *every* update // have been updated (http://goo.gl/gQLz41), but we want *every* update
_v: { type: Number, 'default': 0 }, _v: { type: Number, default: 0 },
achievements: { achievements: {
originalUser: Boolean, originalUser: Boolean,
habitSurveys: Number, habitSurveys: Number,
ultimateGearSets: Schema.Types.Mixed, ultimateGearSets: Schema.Types.Mixed, // TODO remove, use dictionary?
beastMaster: Boolean, beastMaster: Boolean,
beastMasterCount: Number, beastMasterCount: Number,
mountMaster: Boolean, mountMaster: Boolean,
@@ -47,7 +60,7 @@ var UserSchema = new Schema({
seafoam: Number, seafoam: Number,
streak: Number, streak: Number,
challenges: Array, challenges: Array,
quests: Schema.Types.Mixed, quests: Schema.Types.Mixed, // TODO remove, use dictionary?
rebirths: Number, rebirths: Number,
rebirthLevel: Number, rebirthLevel: Number,
perfect: Number, perfect: Number,
@@ -57,49 +70,40 @@ var UserSchema = new Schema({
nye: Number, nye: Number,
habiticaDays: Number, habiticaDays: Number,
greeting: Number, greeting: Number,
thankyou: Number thankyou: Number,
},
auth: {
blocked: Boolean,
facebook: Schema.Types.Mixed,
local: {
email: String,
hashed_password: String,
salt: String,
username: String,
lowerCaseUsername: String // Store a lowercase version of username to check for duplicates
},
timestamps: {
created: {type: Date,'default': Date.now},
loggedin: {type: Date,'default': Date.now}
}
}, },
backer: { backer: {
tier: Number, tier: Number,
npc: String, npc: String,
tokensApplied: Boolean tokensApplied: Boolean,
}, },
contributor: { contributor: {
level: Number, // 1-9, see https://trello.com/c/wkFzONhE/277-contributor-gear https://github.com/HabitRPG/habitrpg/issues/3801 // 1-9, see https://trello.com/c/wkFzONhE/277-contributor-gear https://github.com/HabitRPG/habitrpg/issues/3801
// TODO validate
level: Number,
admin: Boolean, admin: Boolean,
sudo: Boolean, sudo: Boolean,
text: String, // Artisan, Friend, Blacksmith, etc // Artisan, Friend, Blacksmith, etc
contributions: String, // a markdown textarea to list their contributions + links text: String,
critical: String // a markdown textarea to list their contributions + links
contributions: String,
critical: String,
}, },
balance: {type: Number, 'default':0}, balance: {type: Number, default: 0},
filters: {type: Schema.Types.Mixed, 'default': {}}, filters: {type: Schema.Types.Mixed, default: {}}, // TODO dictionary
purchased: { purchased: {
ads: {type: Boolean, 'default': false}, ads: {type: Boolean, default: false},
skin: {type: Schema.Types.Mixed, 'default': {}}, // eg, {skeleton: true, pumpkin: true, eb052b: true} // eg, {skeleton: true, pumpkin: true, eb052b: true}
hair: {type: Schema.Types.Mixed, 'default': {}}, // TODO dictionary
shirt: {type: Schema.Types.Mixed, 'default': {}}, skin: {type: Schema.Types.Mixed, default: {}},
background: {type: Schema.Types.Mixed, 'default': {}}, hair: {type: Schema.Types.Mixed, default: {}},
txnCount: {type: Number, 'default':0}, shirt: {type: Schema.Types.Mixed, default: {}},
background: {type: Schema.Types.Mixed, default: {}},
txnCount: {type: Number, default: 0},
mobileChat: Boolean, mobileChat: Boolean,
plan: { plan: {
planId: String, planId: String,
@@ -108,132 +112,136 @@ var UserSchema = new Schema({
dateCreated: Date, dateCreated: Date,
dateTerminated: Date, dateTerminated: Date,
dateUpdated: Date, dateUpdated: Date,
extraMonths: {type:Number, 'default':0}, extraMonths: {type: Number, default: 0},
gemsBought: {type: Number, 'default': 0}, gemsBought: {type: Number, default: 0},
mysteryItems: {type: Array, 'default': []}, mysteryItems: {type: Array, default: []},
lastBillingDate: Date, // Used only for Amazon Payments to keep track of billing date lastBillingDate: Date, // Used only for Amazon Payments to keep track of billing date
consecutive: { consecutive: {
count: {type:Number, 'default':0}, count: {type: Number, default: 0},
offset: {type:Number, 'default':0}, // when gifted subs, offset++ for each month. offset-- each new-month (cron). count doesn't ++ until offset==0 offset: {type: Number, default: 0}, // when gifted subs, offset++ for each month. offset-- each new-month (cron). count doesn't ++ until offset==0
gemCapExtra: {type:Number, 'default':0}, gemCapExtra: {type: Number, default: 0},
trinkets: {type:Number, 'default':0} trinkets: {type: Number, default: 0},
} },
} },
}, },
flags: { flags: {
customizationsNotification: {type: Boolean, 'default': false}, customizationsNotification: {type: Boolean, default: false},
showTour: {type: Boolean, 'default': true}, showTour: {type: Boolean, default: true},
tour: { tour: {
// -1 indicates "uninitiated", -2 means "complete", any other number is the current tour step (0-index) // -1 indicates "uninitiated", -2 means "complete", any other number is the current tour step (0-index)
intro: {type: Number, 'default': -1}, intro: {type: Number, default: -1},
classes: {type: Number, 'default': -1}, classes: {type: Number, default: -1},
stats: {type: Number, 'default': -1}, stats: {type: Number, default: -1},
tavern: {type: Number, 'default': -1}, tavern: {type: Number, default: -1},
party: {type: Number, 'default': -1}, party: {type: Number, default: -1},
guilds: {type: Number, 'default': -1}, guilds: {type: Number, default: -1},
challenges: {type: Number, 'default': -1}, challenges: {type: Number, default: -1},
market: {type: Number, 'default': -1}, market: {type: Number, default: -1},
pets: {type: Number, 'default': -1}, pets: {type: Number, default: -1},
mounts: {type: Number, 'default': -1}, mounts: {type: Number, default: -1},
hall: {type: Number, 'default': -1}, hall: {type: Number, default: -1},
equipment: {type: Number, 'default': -1} equipment: {type: Number, default: -1},
}, },
tutorial: { tutorial: {
common: { common: {
habits: {type: Boolean, 'default': false}, habits: {type: Boolean, default: false},
dailies: {type: Boolean, 'default': false}, dailies: {type: Boolean, default: false},
todos: {type: Boolean, 'default': false}, todos: {type: Boolean, default: false},
rewards: {type: Boolean, 'default': false}, rewards: {type: Boolean, default: false},
party: {type: Boolean, 'default': false}, party: {type: Boolean, default: false},
pets: {type: Boolean, 'default': false}, pets: {type: Boolean, default: false},
gems: {type: Boolean, 'default': false}, gems: {type: Boolean, default: false},
skills: {type: Boolean, 'default': false}, skills: {type: Boolean, default: false},
classes: {type: Boolean, 'default': false}, classes: {type: Boolean, default: false},
tavern: {type: Boolean, 'default': false}, tavern: {type: Boolean, default: false},
equipment: {type: Boolean, 'default': false}, equipment: {type: Boolean, default: false},
items: {type: Boolean, 'default': false}, items: {type: Boolean, default: false},
}, },
ios: { ios: {
addTask: {type: Boolean, 'default': false}, addTask: {type: Boolean, default: false},
editTask: {type: Boolean, 'default': false}, editTask: {type: Boolean, default: false},
deleteTask: {type: Boolean, 'default': false}, deleteTask: {type: Boolean, default: false},
filterTask: {type: Boolean, 'default': false}, filterTask: {type: Boolean, default: false},
groupPets: {type: Boolean, 'default': false}, groupPets: {type: Boolean, default: false},
}
}, },
dropsEnabled: {type: Boolean, 'default': false}, },
itemsEnabled: {type: Boolean, 'default': false}, dropsEnabled: {type: Boolean, default: false},
newStuff: {type: Boolean, 'default': false}, itemsEnabled: {type: Boolean, default: false},
rewrite: {type: Boolean, 'default': true}, newStuff: {type: Boolean, default: false},
rewrite: {type: Boolean, default: true},
contributor: Boolean, contributor: Boolean,
classSelected: {type: Boolean, 'default': false}, classSelected: {type: Boolean, default: false},
mathUpdates: Boolean, mathUpdates: Boolean,
rebirthEnabled: {type: Boolean, 'default': false}, rebirthEnabled: {type: Boolean, default: false},
levelDrops: {type:Schema.Types.Mixed, 'default':{}}, levelDrops: {type: Schema.Types.Mixed, default: {}},
chatRevoked: Boolean, chatRevoked: Boolean,
// Used to track the status of recapture emails sent to each user, // Used to track the status of recapture emails sent to each user,
// can be 0 - no email sent - 1, 2, 3 or 4 - 4 means no more email will be sent to the user // can be 0 - no email sent - 1, 2, 3 or 4 - 4 means no more email will be sent to the user
recaptureEmailsPhase: {type: Number, 'default': 0}, recaptureEmailsPhase: {type: Number, default: 0},
// Needed to track the tip to send inside the email // Needed to track the tip to send inside the email
weeklyRecapEmailsPhase: {type: Number, 'default': 0}, weeklyRecapEmailsPhase: {type: Number, default: 0},
// Used to track when the next weekly recap should be sent // Used to track when the next weekly recap should be sent
lastWeeklyRecap: {type: Date, 'default': Date.now}, lastWeeklyRecap: {type: Date, default: Date.now},
// Used to enable weekly recap emails as users login // Used to enable weekly recap emails as users login
lastWeeklyRecapDiscriminator: Boolean, lastWeeklyRecapDiscriminator: Boolean,
communityGuidelinesAccepted: {type: Boolean, 'default': false}, communityGuidelinesAccepted: {type: Boolean, default: false},
cronCount: {type:Number, 'default':0}, cronCount: {type: Number, default: 0},
welcomed: {type: Boolean, 'default': false}, welcomed: {type: Boolean, default: false},
armoireEnabled: {type: Boolean, 'default': false}, armoireEnabled: {type: Boolean, default: false},
armoireOpened: {type: Boolean, 'default': false}, armoireOpened: {type: Boolean, default: false},
armoireEmpty: {type: Boolean, 'default': false}, armoireEmpty: {type: Boolean, default: false},
cardReceived: {type: Boolean, 'default': false}, cardReceived: {type: Boolean, default: false},
warnedLowHealth: {type: Boolean, 'default': false} warnedLowHealth: {type: Boolean, default: false},
}, },
history: { history: {
// TODO absolutely preen these for everyone
exp: Array, // [{date: Date, value: Number}], // big peformance issues if these are defined exp: Array, // [{date: Date, value: Number}], // big peformance issues if these are defined
todos: Array //[{data: Date, value: Number}] // big peformance issues if these are defined todos: Array, // [{data: Date, value: Number}] // big peformance issues if these are defined
}, },
invitations: { invitations: {
guilds: {type: Array, 'default': []}, guilds: {type: Array, default: []},
party: Schema.Types.Mixed party: Schema.Types.Mixed, // TODO dictionary
}, },
items: { items: {
gear: { gear: {
owned: _.transform(shared.content.gear.flat, function(m,v,k){ owned: _.transform(shared.content.gear.flat, (m, v, k) => {
m[v.key] = {type: Boolean}; m[v.key] = {type: Boolean};
if (v.key.match(/[armor|head|shield]_warrior_0/)) if (v.key.match(/[armor|head|shield]_warrior_0/)) {
m[v.key]['default'] = true; m[v.key].default = true;
}
}), }),
equipped: { equipped: {
weapon: String, weapon: String,
armor: {type: String, 'default': 'armor_base_0'}, armor: {type: String, default: 'armor_base_0'},
head: {type: String, 'default': 'head_base_0'}, head: {type: String, default: 'head_base_0'},
shield: {type: String, 'default': 'shield_base_0'}, shield: {type: String, default: 'shield_base_0'},
back: String, back: String,
headAccessory: String, headAccessory: String,
eyewear: String, eyewear: String,
body: String body: String,
}, },
costume: { costume: {
weapon: String, weapon: String,
armor: {type: String, 'default': 'armor_base_0'}, armor: {type: String, default: 'armor_base_0'},
head: {type: String, 'default': 'head_base_0'}, head: {type: String, default: 'head_base_0'},
shield: {type: String, 'default': 'shield_base_0'}, shield: {type: String, default: 'shield_base_0'},
back: String, back: String,
headAccessory: String, headAccessory: String,
eyewear: String, eyewear: String,
body: String body: String,
} },
}, },
special: { special: {
snowball: {type: Number, 'default': 0}, snowball: {type: Number, default: 0},
spookDust: {type: Number, 'default': 0}, spookDust: {type: Number, default: 0},
shinySeed: {type: Number, 'default': 0}, shinySeed: {type: Number, default: 0},
seafoam: {type: Number, 'default': 0}, seafoam: {type: Number, default: 0},
valentine: Number, valentine: Number,
valentineReceived: Array, // array of strings, by sender name valentineReceived: Array, // array of strings, by sender name
nye: Number, nye: Number,
@@ -241,7 +249,7 @@ var UserSchema = new Schema({
greeting: Number, greeting: Number,
greetingReceived: Array, greetingReceived: Array,
thankyou: Number, thankyou: Number,
thankyouReceived: Array thankyouReceived: Array,
}, },
// -------------- Animals ------------------- // -------------- Animals -------------------
@@ -251,14 +259,13 @@ var UserSchema = new Schema({
// 'PandaCub-Red': 10, // Number represents "Growth Points" // 'PandaCub-Red': 10, // Number represents "Growth Points"
// etc... // etc...
// } // }
pets: pets: _.defaults(
_.defaults(
// First transform to a 1D eggs/potions mapping // First transform to a 1D eggs/potions mapping
_.transform(shared.content.pets, function(m,v,k){ m[k] = Number; }), _.transform(shared.content.pets, (m, v, k) => m[k] = Number),
// Then add additional pets (quest, backer, contributor, premium) // Then add additional pets (quest, backer, contributor, premium)
_.transform(shared.content.questPets, function(m,v,k){ m[k] = Number; }), _.transform(shared.content.questPets, (m, v, k) => m[k] = Number),
_.transform(shared.content.specialPets, function(m,v,k){ m[k] = Number; }), _.transform(shared.content.specialPets, (m, v, k) => m[k] = Number),
_.transform(shared.content.premiumPets, function(m,v,k){ m[k] = Number; }) _.transform(shared.content.premiumPets, (m, v, k) => m[k] = Number)
), ),
currentPet: String, // Cactus-Desert currentPet: String, // Cactus-Desert
@@ -266,19 +273,19 @@ var UserSchema = new Schema({
// 'PandaCub': 0, // 0 indicates "doesn't own" // 'PandaCub': 0, // 0 indicates "doesn't own"
// 'Wolf': 5 // Number indicates "stacking" // 'Wolf': 5 // Number indicates "stacking"
// } // }
eggs: _.transform(shared.content.eggs, function(m,v,k){ m[k] = Number; }), eggs: _.transform(shared.content.eggs, (m, v, k) => m[k] = Number),
// hatchingPotions: { // hatchingPotions: {
// 'Desert': 0, // 0 indicates "doesn't own" // 'Desert': 0, // 0 indicates "doesn't own"
// 'CottonCandyBlue': 5 // Number indicates "stacking" // 'CottonCandyBlue': 5 // Number indicates "stacking"
// } // }
hatchingPotions: _.transform(shared.content.hatchingPotions, function(m,v,k){ m[k] = Number; }), hatchingPotions: _.transform(shared.content.hatchingPotions, (m, v, k) => m[k] = Number),
// Food: { // Food: {
// 'Watermelon': 0, // 0 indicates "doesn't own" // 'Watermelon': 0, // 0 indicates "doesn't own"
// 'RottenMeat': 5 // Number indicates "stacking" // 'RottenMeat': 5 // Number indicates "stacking"
// } // }
food: _.transform(shared.content.food, function(m,v,k){ m[k] = Number; }), food: _.transform(shared.content.food, (m, v, k) => m[k] = Number),
// mounts: { // mounts: {
// 'Wolf-Desert': true, // 'Wolf-Desert': true,
@@ -287,12 +294,12 @@ var UserSchema = new Schema({
// } // }
mounts: _.defaults( mounts: _.defaults(
// First transform to a 1D eggs/potions mapping // First transform to a 1D eggs/potions mapping
_.transform(shared.content.pets, function(m,v,k){ m[k] = Boolean; }), _.transform(shared.content.pets, (m, v, k) => m[k] = Boolean),
// Then add quest and premium pets // Then add quest and premium pets
_.transform(shared.content.questPets, function(m,v,k){ m[k] = Boolean; }), _.transform(shared.content.questPets, (m, v, k) => m[k] = Boolean),
_.transform(shared.content.premiumPets, function(m,v,k){ m[k] = Boolean; }), _.transform(shared.content.premiumPets, (m, v, k) => m[k] = Boolean),
// Then add additional mounts (backer, contributor) // Then add additional mounts (backer, contributor)
_.transform(shared.content.specialMounts, function(m,v,k){ m[k] = Boolean; }) _.transform(shared.content.specialMounts, (m, v, k) => m[k] = Boolean)
), ),
currentMount: String, currentMount: String,
@@ -300,139 +307,139 @@ var UserSchema = new Schema({
// 'boss_0': 0, // 0 indicates "doesn't own" // 'boss_0': 0, // 0 indicates "doesn't own"
// 'collection_honey': 5 // Number indicates "stacking" // 'collection_honey': 5 // Number indicates "stacking"
// } // }
quests: _.transform(shared.content.quests, function(m,v,k){ m[k] = Number; }), quests: _.transform(shared.content.quests, (m, v, k) => m[k] = Number),
lastDrop: { lastDrop: {
date: {type: Date, 'default': Date.now}, date: {type: Date, default: Date.now},
count: {type: Number, 'default': 0} count: {type: Number, default: 0},
} },
}, },
lastCron: {type: Date, 'default': Date.now}, lastCron: {type: Date, default: Date.now},
// {GROUP_ID: Boolean}, represents whether they have unseen chat messages // {GROUP_ID: Boolean}, represents whether they have unseen chat messages
newMessages: {type: Schema.Types.Mixed, 'default': {}}, newMessages: {type: Schema.Types.Mixed, default: {}},
party: { party: {
// id // FIXME can we use a populated doc instead of fetching party separate from user? // id // FIXME can we use a populated doc instead of fetching party separate from user?
order: {type:String, 'default':'level'}, order: {type: String, default: 'level'},
orderAscending: {type:String, 'default':'ascending'}, orderAscending: {type: String, default: 'ascending'},
quest: { quest: {
key: String, key: String,
progress: { progress: {
up: {type: Number, 'default': 0}, up: {type: Number, default: 0},
down: {type: Number, 'default': 0}, down: {type: Number, default: 0},
collect: {type: Schema.Types.Mixed, 'default': {}} // {feather:1, ingot:2} collect: {type: Schema.Types.Mixed, default: {}}, // {feather:1, ingot:2}
}, },
completed: String, // When quest is done, we move it from key => completed, and it's a one-time flag (for modal) that they unset by clicking "ok" in browser completed: String, // When quest is done, we move it from key => completed, and it's a one-time flag (for modal) that they unset by clicking "ok" in browser
RSVPNeeded: {type: Boolean, 'default': false} // Set to true when invite is pending, set to false when quest invite is accepted or rejected, quest starts, or quest is cancelled RSVPNeeded: {type: Boolean, default: false}, // Set to true when invite is pending, set to false when quest invite is accepted or rejected, quest starts, or quest is cancelled
} },
}, },
preferences: { preferences: {
dayStart: {type:Number, 'default': 0, min: 0, max: 23}, dayStart: {type: Number, default: 0, min: 0, max: 23},
size: {type:String, enum: ['broad','slim'], 'default': 'slim'}, size: {type: String, enum: ['broad', 'slim'], default: 'slim'},
hair: { hair: {
color: {type: String, 'default': 'red'}, color: {type: String, default: 'red'},
base: {type: Number, 'default': 3}, base: {type: Number, default: 3},
bangs: {type: Number, 'default': 1}, bangs: {type: Number, default: 1},
beard: {type: Number, 'default': 0}, beard: {type: Number, default: 0},
mustache: {type: Number, 'default': 0}, mustache: {type: Number, default: 0},
flower: {type: Number, 'default': 1} flower: {type: Number, default: 1},
}, },
hideHeader: {type:Boolean, 'default':false}, hideHeader: {type: Boolean, default: false},
skin: {type:String, 'default':'915533'}, skin: {type: String, default: '915533'},
shirt: {type: String, 'default': 'blue'}, shirt: {type: String, default: 'blue'},
timezoneOffset: Number, timezoneOffset: Number,
sound: {type:String, 'default':'off', enum: ['off', 'danielTheBard', 'gokulTheme', 'luneFoxTheme', 'wattsTheme']}, sound: {type: String, default: 'off', enum: ['off', 'danielTheBard', 'gokulTheme', 'luneFoxTheme', 'wattsTheme']},
language: String, language: String,
automaticAllocation: Boolean, automaticAllocation: Boolean,
allocationMode: {type:String, enum: ['flat','classbased','taskbased'], 'default': 'flat'}, allocationMode: {type: String, enum: ['flat', 'classbased', 'taskbased'], default: 'flat'},
autoEquip: {type: Boolean, 'default': true}, autoEquip: {type: Boolean, default: true},
costume: Boolean, costume: Boolean,
dateFormat: {type: String, enum:['MM/dd/yyyy', 'dd/MM/yyyy', 'yyyy/MM/dd'], 'default': 'MM/dd/yyyy'}, dateFormat: {type: String, enum: ['MM/dd/yyyy', 'dd/MM/yyyy', 'yyyy/MM/dd'], default: 'MM/dd/yyyy'},
sleep: {type: Boolean, 'default': false}, sleep: {type: Boolean, default: false},
stickyHeader: {type: Boolean, 'default': true}, stickyHeader: {type: Boolean, default: true},
disableClasses: {type: Boolean, 'default': false}, disableClasses: {type: Boolean, default: false},
newTaskEdit: {type: Boolean, 'default': false}, newTaskEdit: {type: Boolean, default: false},
dailyDueDefaultView: {type: Boolean, 'default': false}, dailyDueDefaultView: {type: Boolean, default: false},
tagsCollapsed: {type: Boolean, 'default': false}, tagsCollapsed: {type: Boolean, default: false},
advancedCollapsed: {type: Boolean, 'default': false}, advancedCollapsed: {type: Boolean, default: false},
toolbarCollapsed: {type:Boolean, 'default':false}, toolbarCollapsed: {type: Boolean, default: false},
background: String, background: String,
displayInviteToPartyWhenPartyIs1: { type:Boolean, 'default':true}, displayInviteToPartyWhenPartyIs1: {type: Boolean, default: true},
webhooks: {type: Schema.Types.Mixed, 'default': {}}, webhooks: {type: Schema.Types.Mixed, default: {}},
// For this fields make sure to use strict comparison when searching for falsey values (=== false) // For the following fields make sure to use strict comparison when searching for falsey values (=== false)
// As users who didn't login after these were introduced may have them undefined/null // As users who didn't login after these were introduced may have them undefined/null
emailNotifications: { emailNotifications: {
unsubscribeFromAll: {type: Boolean, 'default': false}, unsubscribeFromAll: {type: Boolean, default: false},
newPM: {type: Boolean, 'default': true}, newPM: {type: Boolean, default: true},
kickedGroup: {type: Boolean, 'default': true}, kickedGroup: {type: Boolean, default: true},
wonChallenge: {type: Boolean, 'default': true}, wonChallenge: {type: Boolean, default: true},
giftedGems: {type: Boolean, 'default': true}, giftedGems: {type: Boolean, default: true},
giftedSubscription: {type: Boolean, 'default': true}, giftedSubscription: {type: Boolean, default: true},
invitedParty: {type: Boolean, 'default': true}, invitedParty: {type: Boolean, default: true},
invitedGuild: {type: Boolean, 'default': true}, invitedGuild: {type: Boolean, default: true},
questStarted: {type: Boolean, 'default': true}, questStarted: {type: Boolean, default: true},
invitedQuest: {type: Boolean, 'default': true}, invitedQuest: {type: Boolean, default: true},
//remindersToLogin: {type: Boolean, 'default': true}, // remindersToLogin: {type: Boolean, default: true},
// Those importantAnnouncements are in fact the recapture emails // importantAnnouncements are in fact the recapture emails
importantAnnouncements: {type: Boolean, 'default': true}, importantAnnouncements: {type: Boolean, default: true},
weeklyRecaps: {type: Boolean, 'default': true} weeklyRecaps: {type: Boolean, default: true},
} },
}, },
profile: { profile: {
blurb: String, blurb: String,
imageUrl: String, imageUrl: String,
name: String name: String,
}, },
stats: { stats: {
hp: {type: Number, 'default': shared.maxHealth}, hp: {type: Number, default: shared.maxHealth},
mp: {type: Number, 'default': 10}, mp: {type: Number, default: 10},
exp: {type: Number, 'default': 0}, exp: {type: Number, default: 0},
gp: {type: Number, 'default': 0}, gp: {type: Number, default: 0},
lvl: {type: Number, 'default': 1}, lvl: {type: Number, default: 1},
// Class System // Class System
'class': {type: String, enum: ['warrior','rogue','wizard','healer'], 'default': 'warrior'}, class: {type: String, enum: ['warrior', 'rogue', 'wizard', 'healer'], default: 'warrior'},
points: {type: Number, 'default': 0}, points: {type: Number, default: 0},
str: {type: Number, 'default': 0}, str: {type: Number, default: 0},
con: {type: Number, 'default': 0}, con: {type: Number, default: 0},
int: {type: Number, 'default': 0}, int: {type: Number, default: 0},
per: {type: Number, 'default': 0}, per: {type: Number, default: 0},
buffs: { buffs: {
str: {type: Number, 'default': 0}, str: {type: Number, default: 0},
int: {type: Number, 'default': 0}, int: {type: Number, default: 0},
per: {type: Number, 'default': 0}, per: {type: Number, default: 0},
con: {type: Number, 'default': 0}, con: {type: Number, default: 0},
stealth: {type: Number, 'default': 0}, stealth: {type: Number, default: 0},
streaks: {type: Boolean, 'default': false}, streaks: {type: Boolean, default: false},
snowball: {type: Boolean, 'default': false}, snowball: {type: Boolean, default: false},
spookDust: {type: Boolean, 'default': false}, spookDust: {type: Boolean, default: false},
shinySeed: {type: Boolean, 'default': false}, shinySeed: {type: Boolean, default: false},
seafoam: {type: Boolean, 'default': false} seafoam: {type: Boolean, default: false},
}, },
training: { training: {
int: {type: Number, 'default': 0}, int: {type: Number, default: 0},
per: {type: Number, 'default': 0}, per: {type: Number, default: 0},
str: {type: Number, 'default': 0}, str: {type: Number, default: 0},
con: {type: Number, 'default': 0} con: {type: Number, default: 0},
} },
}, },
tags: {type: [{ tags: {type: [{
_id: false, _id: false,
id: { type: String, 'default': shared.uuid }, id: {type: String, default: shared.uuid},
name: String, name: String,
challenge: String challenge: String,
}]}, }]},
challenges: [{type: 'String', ref:'Challenge'}], challenges: [{type: String, ref: 'Challenge'}],
inbox: { inbox: {
newMessages: {type:Number, 'default':0}, newMessages: {type: Number, default: 0},
blocks: {type:Array, 'default':[]}, blocks: {type: Array, default: []},
messages: {type:Schema.Types.Mixed, 'default':{}}, //reflist messages: {type: Schema.Types.Mixed, default: {}},
optOut: {type:Boolean, 'default':false} optOut: {type: Boolean, default: false},
}, },
habits: {type: [TaskSchemas.HabitSchema]}, habits: {type: [TaskSchemas.HabitSchema]},
@@ -442,22 +449,25 @@ var UserSchema = new Schema({
extra: Schema.Types.Mixed, extra: Schema.Types.Mixed,
pushDevices: {type: [{ pushDevices: {
type: [{
regId: {type: String}, regId: {type: String},
type: {type: String} type: {type: String},
}],'default': []} }],
default: [],
},
}, { }, {
strict: true, strict: true,
minimize: false // So empty objects are returned minimize: false, // So empty objects are returned
}); });
UserSchema.methods.deleteTask = function(tid) { schema.methods.deleteTask = function (tid) {
this.ops.deleteTask({params:{id:tid}},function(){}); // TODO remove this whole method, since it just proxies, and change all references to this method this.ops.deleteTask({params: {id: tid}}, () => {}); // TODO remove this whole method, since it just proxies, and change all references to this method
} };
schema.methods.toJSON = function () {
let doc = this.toObject();
UserSchema.methods.toJSON = function() {
var doc = this.toObject();
doc.id = doc._id; doc.id = doc._id;
// FIXME? Is this a reference to `doc.filters` or just disabled code? Remove? // FIXME? Is this a reference to `doc.filters` or just disabled code? Remove?
@@ -467,18 +477,99 @@ UserSchema.methods.toJSON = function() {
return doc; return doc;
}; };
//UserSchema.virtual('tasks').get(function () { // schema.virtual('tasks').get(function () {
// var tasks = this.habits.concat(this.dailys).concat(this.todos).concat(this.rewards); // var tasks = this.habits.concat(this.dailys).concat(this.todos).concat(this.rewards);
// var tasks = _.object(_.pluck(tasks,'id'), tasks); // var tasks = _.object(_.pluck(tasks,'id'), tasks);
// return tasks; // return tasks;
// }); // });
UserSchema.post('init', function(doc){ schema.post('init', function postInitUser (doc) {
shared.wrap(doc); shared.wrap(doc);
}) });
UserSchema.pre('save', function(next) { function _populateDefaultTasks (user, taskTypes) {
_.each(taskTypes, (taskType) => {
user[taskType] = _.map(shared.content.userDefaults[taskType], (task) => {
let newTask = _.cloneDeep(task);
// Render task's text and notes in user's language
if (taskType === 'tags') {
// tasks automatically get id=helpers.uuid() from TaskSchema id.default, but tags are Schema.Types.Mixed - so we need to manually invoke here
newTask.id = shared.uuid();
newTask.name = newTask.name(user.preferences.language);
} else {
newTask.text = newTask.text(user.preferences.language);
if (newTask.notes) {
newTask.notes = newTask.notes(user.preferences.language);
}
if (newTask.checklist) {
newTask.checklist = _.map(newTask.checklist, (checklistItem) => {
checklistItem.text = checklistItem.text(user.preferences.language);
return checklistItem;
});
}
}
return newTask;
});
});
}
function _populateDefaultsForNewUser (user) {
let taskTypes;
if (user.registeredThrough === 'habitica-web') {
taskTypes = ['habits', 'dailys', 'todos', 'rewards', 'tags'];
let tutorialCommonSections = [
'habits',
'dailies',
'todos',
'rewards',
'party',
'pets',
'gems',
'skills',
'classes',
'tavern',
'equipment',
'items',
];
_.each(tutorialCommonSections, (section) => {
user.flags.tutorial.common[section] = true;
});
} else {
taskTypes = ['todos', 'tags'];
user.flags.showTour = false;
let tourSections = [
'showTour',
'intro',
'classes',
'stats',
'tavern',
'party',
'guilds',
'challenges',
'market',
'pets',
'mounts',
'hall',
'equipment',
];
_.each(tourSections, (section) => {
user.flags.tour[section] = -2;
});
}
_populateDefaultTasks(user, taskTypes);
}
schema.pre('save', function postSaveUser (next) {
// Populate new users with default content // Populate new users with default content
if (this.isNew) { if (this.isNew) {
_populateDefaultsForNewUser(this); _populateDefaultsForNewUser(this);
@@ -490,30 +581,32 @@ UserSchema.pre('save', function(next) {
} }
if (!this.profile.name) { if (!this.profile.name) {
var fb = this.auth.facebook; let fb = this.auth.facebook;
this.profile.name = this.profile.name =
(this.auth.local && this.auth.local.username) || (this.auth.local && this.auth.local.username) ||
(fb && (fb.displayName || fb.name || fb.username || (fb.first_name && fb.first_name + ' ' + fb.last_name))) || (fb && (fb.displayName || fb.name || fb.username || `${fb.first_name && fb.first_name} ${fb.last_name}`)) ||
'Anonymous'; 'Anonymous';
} }
// Determines if Beast Master should be awarded // Determines if Beast Master should be awarded
var beastMasterProgress = shared.count.beastMasterProgress(this.items.pets); let beastMasterProgress = shared.count.beastMasterProgress(this.items.pets);
if (beastMasterProgress >= 90 || this.achievements.beastMasterCount > 0) { if (beastMasterProgress >= 90 || this.achievements.beastMasterCount > 0) {
this.achievements.beastMaster = true; this.achievements.beastMaster = true;
} }
// Determines if Mount Master should be awarded // Determines if Mount Master should be awarded
var mountMasterProgress = shared.count.mountMasterProgress(this.items.mounts); let mountMasterProgress = shared.count.mountMasterProgress(this.items.mounts);
if (mountMasterProgress >= 90 || this.achievements.mountMasterCount > 0) { if (mountMasterProgress >= 90 || this.achievements.mountMasterCount > 0) {
this.achievements.mountMaster = true this.achievements.mountMaster = true;
} }
// Determines if Triad Bingo should be awarded // Determines if Triad Bingo should be awarded
var dropPetCount = shared.count.dropPetsCurrentlyOwned(this.items.pets); let dropPetCount = shared.count.dropPetsCurrentlyOwned(this.items.pets);
var qualifiesForTriad = dropPetCount >= 90 && mountMasterProgress >= 90; let qualifiesForTriad = dropPetCount >= 90 && mountMasterProgress >= 90;
if (qualifiesForTriad || this.achievements.triadBingoCount > 0) { if (qualifiesForTriad || this.achievements.triadBingoCount > 0) {
this.achievements.triadBingo = true; this.achievements.triadBingo = true;
@@ -539,12 +632,17 @@ UserSchema.pre('save', function(next) {
next(); next();
}); });
UserSchema.methods.unlink = function(options, cb) { schema.methods.unlink = function (options, cb) {
var cid = options.cid, keep = options.keep, tid = options.tid; let cid = options.cid;
let keep = options.keep;
let tid = options.tid;
if (!cid) { if (!cid) {
return cb("Could not remove challenge tasks. Please delete them manually."); return cb('Could not remove challenge tasks. Please delete them manually.');
} }
var self = this;
let self = this;
switch (keep) { switch (keep) {
case 'keep': case 'keep':
self.tasks[tid].challenge = {}; self.tasks[tid].challenge = {};
@@ -553,121 +651,44 @@ UserSchema.methods.unlink = function(options, cb) {
self.deleteTask(tid); self.deleteTask(tid);
break; break;
case 'keep-all': case 'keep-all':
_.each(self.tasks, function(t){ _.each(self.tasks, (t) => {
if (t.challenge && t.challenge.id == cid) { if (t.challenge && t.challenge.id === cid) {
t.challenge = {}; t.challenge = {};
} }
}); });
break; break;
case 'remove-all': case 'remove-all':
_.each(self.tasks, function(t){ _.each(self.tasks, (t) => {
if (t.challenge && t.challenge.id == cid) { if (t.challenge && t.challenge.id === cid) {
self.deleteTask(t.id); self.deleteTask(t.id);
} }
}) });
break; break;
} }
self.markModified('habits'); self.markModified('habits');
self.markModified('dailys'); self.markModified('dailys');
self.markModified('todos'); self.markModified('todos');
self.markModified('rewards'); self.markModified('rewards');
self.save(cb); self.save(cb);
} };
function _populateDefaultsForNewUser(user) { export let model = mongoose.model('User', schema);
var taskTypes;
if (user.registeredThrough === "habitica-web") {
taskTypes = ['habits', 'dailys', 'todos', 'rewards', 'tags'];
var tutorialCommonSections = [
'habits',
'dailies',
'todos',
'rewards',
'party',
'pets',
'gems',
'skills',
'classes',
'tavern',
'equipment',
'items',
];
_.each(tutorialCommonSections, function(section) {
user.flags.tutorial.common[section] = true;
});
} else {
taskTypes = ['todos', 'tags']
user.flags.showTour = false;
var tourSections = [
'showTour',
'intro',
'classes',
'stats',
'tavern',
'party',
'guilds',
'challenges',
'market',
'pets',
'mounts',
'hall',
'equipment',
];
_.each(tourSections, function(section) {
user.flags.tour[section] = -2;
});
}
_populateDefaultTasks(user, taskTypes);
}
function _populateDefaultTasks (user, taskTypes) {
_.each(taskTypes, function(taskType){
user[taskType] = _.map(shared.content.userDefaults[taskType], function(task){
var newTask = _.cloneDeep(task);
// Render task's text and notes in user's language
if(taskType === 'tags'){
// tasks automatically get id=helpers.uuid() from TaskSchema id.default, but tags are Schema.Types.Mixed - so we need to manually invoke here
newTask.id = shared.uuid();
newTask.name = newTask.name(user.preferences.language);
}else{
newTask.text = newTask.text(user.preferences.language);
if(newTask.notes) {
newTask.notes = newTask.notes(user.preferences.language);
}
if(newTask.checklist){
newTask.checklist = _.map(newTask.checklist, function(checklistItem){
checklistItem.text = checklistItem.text(user.preferences.language);
return checklistItem;
});
}
}
return newTask;
});
});
}
module.exports.schema = UserSchema;
module.exports.model = mongoose.model("User", UserSchema);
// Initially export an empty object so external requires will get // Initially export an empty object so external requires will get
// the right object by reference when it's defined later // the right object by reference when it's defined later
// Otherwise it would remain undefined if requested before the query executes // Otherwise it would remain undefined if requested before the query executes
module.exports.mods = []; export let mods = [];
mongoose.model("User") mongoose.model('User')
.find({'contributor.admin': true}) .find({'contributor.admin': true})
.sort('-contributor.level -backer.npc profile.name') .sort('-contributor.level -backer.npc profile.name')
.select('profile contributor backer') .select('profile contributor backer')
.exec(function(err,mods){ .exec()
.then((foundMods) => {
// Using push to maintain the reference to mods // Using push to maintain the reference to mods
module.exports.mods.push.apply(module.exports.mods, mods); mods.push(...foundMods);
})
.catch((err) => {
throw err; // TODO ?
}); });