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

Mongoose: use $type as the typeKey (#10789)

Browse Source 
* use $type as the typeKey in mongoose

* fix and add tests
This commit is contained in:
Matteo Pagliazzi
2018-10-28 15:23:41 +01:00
committed by Sabe Jones
parent 490531cc76
commit 79c0499672
15 changed files with 383 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
test/api/unit/libs/baseModel.test.js
View File

@@ -5,10 +5,17 @@ describe('Base model plugin', () => {
let schema; let schema;
beforeEach(() => { beforeEach(() => {
schema = new mongoose.Schema(); schema = new mongoose.Schema({}, {
typeKey: '$type',
});
sandbox.stub(schema, 'add'); sandbox.stub(schema, 'add');
}); });
it('throws if "typeKey" is not set to $type', () => {
const schemaWithoutTypeKey = new mongoose.Schema();
expect(() => schemaWithoutTypeKey.plugin(baseModel)).to.throw;
});
it('adds a _id field to the schema', () => { it('adds a _id field to the schema', () => {
schema.plugin(baseModel); schema.plugin(baseModel);

10
website/server/libs/baseModel.js
View File

@@ -3,10 +3,14 @@ import validator from 'validator';
import _ from 'lodash'; import _ from 'lodash';
module.exports = function baseModel (schema, options = {}) { module.exports = function baseModel (schema, options = {}) {
if (schema.options.typeKey !== '$type') {
throw new Error('Every schema must use $type as the typeKey, see https://mongoosejs.com/docs/guide.html#typeKey');
}
if (options._id !== false) { if (options._id !== false) {
schema.add({ schema.add({
_id: { _id: {
type: String, $type: String,
default: uuid, default: uuid,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
}, },
@@ -16,11 +20,11 @@ module.exports = function baseModel (schema, options = {}) {
if (options.timestamps) { if (options.timestamps) {
schema.add({ schema.add({
createdAt: { createdAt: {
type: Date, $type: Date,
default: Date.now, default: Date.now,
}, },
updatedAt: { updatedAt: {
type: Date, $type: Date,
default: Date.now, default: Date.now,
}, },
}); });

29
website/server/models/challenge.js
View File

@@ -20,28 +20,29 @@ const MIN_SHORTNAME_SIZE_FOR_CHALLENGES = shared.constants.MIN_SHORTNAME_SIZE_FO
const MAX_SUMMARY_SIZE_FOR_CHALLENGES = shared.constants.MAX_SUMMARY_SIZE_FOR_CHALLENGES; const MAX_SUMMARY_SIZE_FOR_CHALLENGES = shared.constants.MAX_SUMMARY_SIZE_FOR_CHALLENGES;
let schema = new Schema({ let schema = new Schema({
name: {type: String, required: true}, name: {$type: String, required: true},
shortName: {type: String, required: true, minlength: MIN_SHORTNAME_SIZE_FOR_CHALLENGES}, shortName: {$type: String, required: true, minlength: MIN_SHORTNAME_SIZE_FOR_CHALLENGES},
summary: {type: String, maxlength: MAX_SUMMARY_SIZE_FOR_CHALLENGES}, summary: {$type: String, maxlength: MAX_SUMMARY_SIZE_FOR_CHALLENGES},
description: String, description: String,
official: {type: Boolean, default: false}, official: {$type: Boolean, default: false},
tasksOrder: { tasksOrder: {
habits: [{type: String, ref: 'Task'}], habits: [{$type: String, ref: 'Task'}],
dailys: [{type: String, ref: 'Task'}], dailys: [{$type: String, ref: 'Task'}],
todos: [{type: String, ref: 'Task'}], todos: [{$type: String, ref: 'Task'}],
rewards: [{type: String, ref: 'Task'}], rewards: [{$type: String, ref: 'Task'}],
}, },
leader: {type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true}, leader: {$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true},
group: {type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true}, group: {$type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true},
memberCount: {type: Number, default: 0}, memberCount: {$type: Number, default: 0},
prize: {type: Number, default: 0, min: 0}, prize: {$type: Number, default: 0, min: 0},
categories: [{ categories: [{
slug: {type: String}, slug: {$type: String},
name: {type: String}, name: {$type: String},
}], }],
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

7
website/server/models/coupon.js
View File

@@ -11,12 +11,13 @@ import {
} from '../libs/errors'; } from '../libs/errors';
export let schema = new mongoose.Schema({ export let schema = new mongoose.Schema({
_id: {type: String, default: couponCode.generate, required: true}, _id: {$type: String, default: couponCode.generate, required: true},
event: {type: String, enum: ['wondercon', 'google_6mo']}, event: {$type: String, enum: ['wondercon', 'google_6mo']},
user: {type: String, ref: 'User'}, user: {$type: String, ref: 'User'},
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

3
website/server/models/emailUnsubscription.js
View File

@@ -5,7 +5,7 @@ import baseModel from '../libs/baseModel';
// A collection used to store mailing list unsubscription for non registered email addresses // A collection used to store mailing list unsubscription for non registered email addresses
export let schema = new mongoose.Schema({ export let schema = new mongoose.Schema({
email: { email: {
type: String, $type: String,
required: true, required: true,
trim: true, trim: true,
lowercase: true, lowercase: true,
@@ -14,6 +14,7 @@ export let schema = new mongoose.Schema({
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

49
website/server/models/group.js
View File

@@ -69,31 +69,31 @@ export const MAX_CHAT_COUNT = 200;
export const MAX_SUBBED_GROUP_CHAT_COUNT = 400; export const MAX_SUBBED_GROUP_CHAT_COUNT = 400;
export let schema = new Schema({ export let schema = new Schema({
name: {type: String, required: true}, name: {$type: String, required: true},
summary: {type: String, maxlength: MAX_SUMMARY_SIZE_FOR_GUILDS}, summary: {$type: String, maxlength: MAX_SUMMARY_SIZE_FOR_GUILDS},
description: String, description: String,
leader: {type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true}, leader: {$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.'], required: true},
type: {type: String, enum: ['guild', 'party'], required: true}, type: {$type: String, enum: ['guild', 'party'], required: true},
privacy: {type: String, enum: ['private', 'public'], default: 'private', required: true}, privacy: {$type: String, enum: ['private', 'public'], default: 'private', required: true},
chat: Array, // Used for backward compatibility, but messages aren't stored here chat: Array, // Used for backward compatibility, but messages aren't stored here
leaderOnly: { // restrict group actions to leader (members can't do them) leaderOnly: { // restrict group actions to leader (members can't do them)
challenges: {type: Boolean, default: false, required: true}, challenges: {$type: Boolean, default: false, required: true},
// invites: {type: Boolean, default: false, required: true}, // invites: {$type: Boolean, default: false, required: true},
// Some group plans prevent members from getting gems // Some group plans prevent members from getting gems
getGems: {type: Boolean, default: false}, getGems: {$type: Boolean, default: false},
}, },
memberCount: {type: Number, default: 1}, memberCount: {$type: Number, default: 1},
challengeCount: {type: Number, default: 0}, challengeCount: {$type: Number, default: 0},
balance: {type: Number, default: 0}, balance: {$type: Number, default: 0},
logo: String, logo: String,
leaderMessage: String, leaderMessage: String,
quest: { quest: {
key: String, key: String,
active: {type: Boolean, default: false}, active: {$type: Boolean, default: false},
leader: {type: String, ref: 'User'}, leader: {$type: String, ref: 'User'},
progress: { progress: {
hp: Number, hp: Number,
collect: {type: Schema.Types.Mixed, default: () => { collect: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, // {feather: 5, ingot: 3} }}, // {feather: 5, ingot: 3}
rage: Number, // limit break / "energy stored in shell", for explosion-attacks rage: Number, // limit break / "energy stored in shell", for explosion-attacks
@@ -102,34 +102,35 @@ export let schema = new Schema({
// Shows boolean for each party-member who has accepted the quest. Eg {UUID: true, UUID: false}. Once all users click // Shows boolean for each party-member who has accepted the quest. Eg {UUID: true, UUID: false}. Once all users click
// 'Accept', the quest begins. If a false user waits too long, probably a good sign to prod them or boot them. // 'Accept', the quest begins. If a false user waits too long, probably a good sign to prod them or boot them.
// TODO when booting user, remove from .joined and check again if we can now start the quest // TODO when booting user, remove from .joined and check again if we can now start the quest
members: {type: Schema.Types.Mixed, default: () => { members: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
extra: {type: Schema.Types.Mixed, default: () => { extra: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
}, },
tasksOrder: { tasksOrder: {
habits: [{type: String, ref: 'Task'}], habits: [{$type: String, ref: 'Task'}],
dailys: [{type: String, ref: 'Task'}], dailys: [{$type: String, ref: 'Task'}],
todos: [{type: String, ref: 'Task'}], todos: [{$type: String, ref: 'Task'}],
rewards: [{type: String, ref: 'Task'}], rewards: [{$type: String, ref: 'Task'}],
}, },
purchased: { purchased: {
plan: {type: SubscriptionPlanSchema, default: () => { plan: {$type: SubscriptionPlanSchema, default: () => {
return {}; return {};
}}, }},
}, },
managers: {type: Schema.Types.Mixed, default: () => { managers: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
categories: [{ categories: [{
slug: {type: String}, slug: {$type: String},
name: {type: String}, name: {$type: String},
}], }],
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

7
website/server/models/iapPurchaseReceipt.js
View File

@@ -5,12 +5,13 @@ import validator from 'validator';
const Schema = mongoose.Schema; const Schema = mongoose.Schema;
export let schema = new Schema({ export let schema = new Schema({
_id: {type: String, required: true}, // Use a custom string as _id _id: {$type: String, required: true}, // Use a custom string as _id
consumed: {type: Boolean, default: false, required: true}, consumed: {$type: Boolean, default: false, required: true},
userId: {type: String, ref: 'User', required: true, validate: [v => validator.isUUID(v), 'Invalid uuid.']}, userId: {$type: String, ref: 'User', required: true, validate: [v => validator.isUUID(v), 'Invalid uuid.']},
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

22
website/server/models/message.js
View File

@@ -10,22 +10,23 @@ const defaultSchema = () => ({
// sender properties // sender properties
user: String, // profile name user: String, // profile name
contributor: {type: mongoose.Schema.Types.Mixed}, contributor: {$type: mongoose.Schema.Types.Mixed},
backer: {type: mongoose.Schema.Types.Mixed}, backer: {$type: mongoose.Schema.Types.Mixed},
uuid: String, // sender uuid uuid: String, // sender uuid
userStyles: {type: mongoose.Schema.Types.Mixed}, userStyles: {$type: mongoose.Schema.Types.Mixed},
flags: {type: mongoose.Schema.Types.Mixed, default: {}}, flags: {$type: mongoose.Schema.Types.Mixed, default: {}},
flagCount: {type: Number, default: 0}, flagCount: {$type: Number, default: 0},
likes: {type: mongoose.Schema.Types.Mixed}, likes: {$type: mongoose.Schema.Types.Mixed},
_meta: {type: mongoose.Schema.Types.Mixed}, _meta: {$type: mongoose.Schema.Types.Mixed},
}); });
const chatSchema = new mongoose.Schema({ const chatSchema = new mongoose.Schema({
...defaultSchema(), ...defaultSchema(),
groupId: {type: String, ref: 'Group'}, groupId: {$type: String, ref: 'Group'},
}, { }, {
minimize: false, // Allow for empty flags to be saved minimize: false, // Allow for empty flags to be saved
typeKey: '$type', // So that we can use fields named `type`
}); });
chatSchema.plugin(baseModel, { chatSchema.plugin(baseModel, {
@@ -33,14 +34,15 @@ chatSchema.plugin(baseModel, {
}); });
const inboxSchema = new mongoose.Schema({ const inboxSchema = new mongoose.Schema({
sent: {type: Boolean, default: false}, // if the owner sent this message sent: {$type: Boolean, default: false}, // if the owner sent this message
// the uuid of the user where the message is stored, // the uuid of the user where the message is stored,
// we store two copies of each inbox messages: // we store two copies of each inbox messages:
// one for the sender and one for the receiver // one for the sender and one for the receiver
ownerId: {type: String, ref: 'User'}, ownerId: {$type: String, ref: 'User'},
...defaultSchema(), ...defaultSchema(),
}, { }, {
minimize: false, // Allow for empty flags to be saved minimize: false, // Allow for empty flags to be saved
typeKey: '$type', // So that we can use fields named `type`
}); });
inboxSchema.plugin(baseModel, { inboxSchema.plugin(baseModel, {

5
website/server/models/pushDevice.js
View File

@@ -4,12 +4,13 @@ import baseModel from '../libs/baseModel';
const Schema = mongoose.Schema; const Schema = mongoose.Schema;
export let schema = new Schema({ export let schema = new Schema({
regId: {type: String, required: true}, regId: {$type: String, required: true},
type: {type: String, required: true, enum: ['ios', 'android']}, type: {$type: String, required: true, enum: ['ios', 'android']},
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
_id: false, _id: false,
typeKey: '$type', // So that we can use a field named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

19
website/server/models/subscriptionPlan.js
View File

@@ -5,30 +5,31 @@ import validator from 'validator';
export let schema = new mongoose.Schema({ export let schema = new mongoose.Schema({
planId: String, planId: String,
subscriptionId: String, subscriptionId: String,
owner: {type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, owner: {$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']},
quantity: {type: Number, default: 1}, quantity: {$type: Number, default: 1},
paymentMethod: String, // enum: ['Paypal', 'Stripe', 'Gift', 'Amazon Payments', 'Google', '']} paymentMethod: String, // enum: ['Paypal', 'Stripe', 'Gift', 'Amazon Payments', 'Google', '']}
customerId: String, // Billing Agreement Id in case of Amazon Payments customerId: String, // Billing Agreement Id in case of Amazon Payments
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
additionalData: mongoose.Schema.Types.Mixed, // Example for Google: {'receipt': 'serialized receipt json', 'signature': 'signature string'} additionalData: mongoose.Schema.Types.Mixed, // Example for Google: {'receipt': 'serialized receipt json', 'signature': 'signature string'}
nextPaymentProcessing: Date, // indicates when the queue server should process this subscription again. nextPaymentProcessing: Date, // indicates when the queue server should process this subscription again.
nextBillingDate: Date, // Next time google will bill this user. nextBillingDate: Date, // Next time google will bill this user.
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},
}, },
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
_id: false, _id: false,
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

9
website/server/models/tag.js
View File

@@ -7,18 +7,19 @@ const Schema = mongoose.Schema;
export let schema = new Schema({ export let schema = new Schema({
id: { id: {
type: String, $type: String,
default: uuid, default: uuid,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
required: true, required: true,
}, },
name: {type: String, required: true}, name: {$type: String, required: true},
challenge: {type: String}, challenge: {$type: String},
group: {type: String}, group: {$type: String},
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
_id: false, // use id instead of _id _id: false, // use id instead of _id
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {

112
website/server/models/task.js
View File

@@ -16,6 +16,7 @@ let discriminatorOptions = {
let subDiscriminatorOptions = _.defaults(_.cloneDeep(discriminatorOptions), { let subDiscriminatorOptions = _.defaults(_.cloneDeep(discriminatorOptions), {
_id: false, _id: false,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
export let tasksTypes = ['habit', 'daily', 'todo', 'reward']; export let tasksTypes = ['habit', 'daily', 'todo', 'reward'];
@@ -39,11 +40,11 @@ export const taskIsGroupOrChallengeQuery = {
// Important // Important
// When something changes here remember to update the client side model at common/script/libs/taskDefaults // When something changes here remember to update the client side model at common/script/libs/taskDefaults
export let TaskSchema = new Schema({ export let TaskSchema = new Schema({
type: {type: String, enum: tasksTypes, required: true, default: tasksTypes[0]}, type: {$type: String, enum: tasksTypes, required: true, default: tasksTypes[0]},
text: {type: String, required: true}, text: {$type: String, required: true},
notes: {type: String, default: ''}, notes: {$type: String, default: ''},
alias: { alias: {
type: String, $type: String,
match: [/^[a-zA-Z0-9-_]+$/, 'Task short names can only contain alphanumeric characters, underscores and dashes.'], match: [/^[a-zA-Z0-9-_]+$/, 'Task short names can only contain alphanumeric characters, underscores and dashes.'],
validate: [{ validate: [{
validator () { validator () {
@@ -75,12 +76,12 @@ export let TaskSchema = new Schema({
}], }],
}, },
tags: [{ tags: [{
type: String, $type: String,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
}], }],
value: {type: Number, default: 0, required: true}, // redness or cost for rewards Required because it must be settable (for rewards) value: {$type: Number, default: 0, required: true}, // redness or cost for rewards Required because it must be settable (for rewards)
priority: { priority: {
type: Number, $type: Number,
default: 1, default: 1,
required: true, required: true,
validate: [ validate: [
@@ -88,42 +89,43 @@ export let TaskSchema = new Schema({
'Valid priority values are 0.1, 1, 1.5, 2.', 'Valid priority values are 0.1, 1, 1.5, 2.',
], ],
}, },
attribute: {type: String, default: 'str', enum: ['str', 'con', 'int', 'per']}, attribute: {$type: String, default: 'str', enum: ['str', 'con', 'int', 'per']},
userId: {type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When not set it belongs to a challenge userId: {$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When not set it belongs to a challenge
challenge: { challenge: {
shortName: {type: String}, shortName: {$type: String},
id: {type: String, ref: 'Challenge', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When set (and userId not set) it's the original task id: {$type: String, ref: 'Challenge', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When set (and userId not set) it's the original task
taskId: {type: String, ref: 'Task', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When not set but challenge.id defined it's the original task taskId: {$type: String, ref: 'Task', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, // When not set but challenge.id defined it's the original task
broken: {type: String, enum: ['CHALLENGE_DELETED', 'TASK_DELETED', 'UNSUBSCRIBED', 'CHALLENGE_CLOSED', 'CHALLENGE_TASK_NOT_FOUND']}, // CHALLENGE_TASK_NOT_FOUND comes from v3 migration broken: {$type: String, enum: ['CHALLENGE_DELETED', 'TASK_DELETED', 'UNSUBSCRIBED', 'CHALLENGE_CLOSED', 'CHALLENGE_TASK_NOT_FOUND']}, // CHALLENGE_TASK_NOT_FOUND comes from v3 migration
winner: String, // user.profile.name of the winner winner: String, // user.profile.name of the winner
}, },
group: { group: {
id: {type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, id: {$type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.']},
broken: {type: String, enum: ['GROUP_DELETED', 'TASK_DELETED', 'UNSUBSCRIBED']}, broken: {$type: String, enum: ['GROUP_DELETED', 'TASK_DELETED', 'UNSUBSCRIBED']},
assignedUsers: [{type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}], assignedUsers: [{$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}],
taskId: {type: String, ref: 'Task', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, taskId: {$type: String, ref: 'Task', validate: [v => validator.isUUID(v), 'Invalid uuid.']},
approval: { approval: {
required: {type: Boolean, default: false}, required: {$type: Boolean, default: false},
approved: {type: Boolean, default: false}, approved: {$type: Boolean, default: false},
dateApproved: {type: Date}, dateApproved: {$type: Date},
approvingUser: {type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']}, approvingUser: {$type: String, ref: 'User', validate: [v => validator.isUUID(v), 'Invalid uuid.']},
requested: {type: Boolean, default: false}, requested: {$type: Boolean, default: false},
requestedDate: {type: Date}, requestedDate: {$type: Date},
}, },
sharedCompletion: {type: String, enum: _.values(SHARED_COMPLETION), default: SHARED_COMPLETION.default}, sharedCompletion: {$type: String, enum: _.values(SHARED_COMPLETION), default: SHARED_COMPLETION.default},
}, },
reminders: [{ reminders: [{
_id: false, _id: false,
id: {type: String, validate: [v => validator.isUUID(v), 'Invalid uuid.'], default: shared.uuid, required: true}, id: {$type: String, validate: [v => validator.isUUID(v), 'Invalid uuid.'], default: shared.uuid, required: true},
startDate: {type: Date}, startDate: {$type: Date},
time: {type: Date, required: true}, time: {$type: Date, required: true},
}], }],
}, _.defaults({ }, _.defaults({
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
strict: true, strict: true,
typeKey: '$type', // So that we can use fields named `type`
}, discriminatorOptions)); }, discriminatorOptions));
TaskSchema.plugin(baseModel, { TaskSchema.plugin(baseModel, {
@@ -258,32 +260,32 @@ let habitDailySchema = () => {
// dailys and todos shared fields // dailys and todos shared fields
let dailyTodoSchema = () => { let dailyTodoSchema = () => {
return { return {
completed: {type: Boolean, default: false}, completed: {$type: Boolean, default: false},
// Checklist fields (dailies and todos) // Checklist fields (dailies and todos)
collapseChecklist: {type: Boolean, default: false}, collapseChecklist: {$type: Boolean, default: false},
checklist: [{ checklist: [{
completed: {type: Boolean, default: false}, completed: {$type: Boolean, default: false},
text: {type: String, required: false, default: ''}, // required:false because it can be empty on creation text: {$type: String, required: false, default: ''}, // required:false because it can be empty on creation
_id: false, _id: false,
id: {type: String, default: shared.uuid, required: true, validate: [v => validator.isUUID(v), 'Invalid uuid.']}, id: {$type: String, default: shared.uuid, required: true, validate: [v => validator.isUUID(v), 'Invalid uuid.']},
linkId: {type: String}, linkId: {$type: String},
}], }],
}; };
}; };
export let HabitSchema = new Schema(_.defaults({ export let HabitSchema = new Schema(_.defaults({
up: {type: Boolean, default: true}, up: {$type: Boolean, default: true},
down: {type: Boolean, default: true}, down: {$type: Boolean, default: true},
counterUp: {type: Number, default: 0}, counterUp: {$type: Number, default: 0},
counterDown: {type: Number, default: 0}, counterDown: {$type: Number, default: 0},
frequency: {type: String, default: 'daily', enum: ['daily', 'weekly', 'monthly']}, frequency: {$type: String, default: 'daily', enum: ['daily', 'weekly', 'monthly']},
}, habitDailySchema()), subDiscriminatorOptions); }, habitDailySchema()), subDiscriminatorOptions);
export let habit = Task.discriminator('habit', HabitSchema); export let habit = Task.discriminator('habit', HabitSchema);
export let DailySchema = new Schema(_.defaults({ export let DailySchema = new Schema(_.defaults({
frequency: {type: String, default: 'weekly', enum: ['daily', 'weekly', 'monthly', 'yearly']}, frequency: {$type: String, default: 'weekly', enum: ['daily', 'weekly', 'monthly', 'yearly']},
everyX: { everyX: {
type: Number, $type: Number,
default: 1, default: 1,
validate: [ validate: [
(val) => val % 1 === 0 && val >= 0 && val <= 9999, (val) => val % 1 === 0 && val >= 0 && val <= 9999,
@@ -291,33 +293,33 @@ export let DailySchema = new Schema(_.defaults({
], ],
}, },
startDate: { startDate: {
type: Date, $type: Date,
default () { default () {
return moment().startOf('day').toDate(); return moment().startOf('day').toDate();
}, },
required: true, required: true,
}, },
repeat: { // used only for 'weekly' frequency, repeat: { // used only for 'weekly' frequency,
m: {type: Boolean, default: true}, m: {$type: Boolean, default: true},
t: {type: Boolean, default: true}, t: {$type: Boolean, default: true},
w: {type: Boolean, default: true}, w: {$type: Boolean, default: true},
th: {type: Boolean, default: true}, th: {$type: Boolean, default: true},
f: {type: Boolean, default: true}, f: {$type: Boolean, default: true},
s: {type: Boolean, default: true}, s: {$type: Boolean, default: true},
su: {type: Boolean, default: true}, su: {$type: Boolean, default: true},
}, },
streak: {type: Number, default: 0}, streak: {$type: Number, default: 0},
daysOfMonth: {type: [Number], default: []}, // Days of the month that the daily should repeat on daysOfMonth: {$type: [Number], default: []}, // Days of the month that the daily should repeat on
weeksOfMonth: {type: [Number], default: []}, // Weeks of the month that the daily should repeat on weeksOfMonth: {$type: [Number], default: []}, // Weeks of the month that the daily should repeat on
isDue: {type: Boolean}, isDue: {$type: Boolean},
nextDue: [{type: String}], nextDue: [{$type: String}],
yesterDaily: {type: Boolean, default: true, required: true}, yesterDaily: {$type: Boolean, default: true, required: true},
}, habitDailySchema(), dailyTodoSchema()), subDiscriminatorOptions); }, habitDailySchema(), dailyTodoSchema()), subDiscriminatorOptions);
export let daily = Task.discriminator('daily', DailySchema); export let daily = Task.discriminator('daily', DailySchema);
export let TodoSchema = new Schema(_.defaults({ export let TodoSchema = new Schema(_.defaults({
dateCompleted: Date, dateCompleted: Date,
// TODO we're getting parse errors, people have stored as "today" and "3/13". Need to run a migration & put this back to type: Date see http://stackoverflow.com/questions/1353684/detecting-an-invalid-date-date-instance-in-javascript // TODO we're getting parse errors, people have stored as "today" and "3/13". Need to run a migration & put this back to $type: Date see http://stackoverflow.com/questions/1353684/detecting-an-invalid-date-date-instance-in-javascript
date: String, // due date for todos date: String, // due date for todos
}, dailyTodoSchema()), subDiscriminatorOptions); }, dailyTodoSchema()), subDiscriminatorOptions);
export let todo = Task.discriminator('todo', TodoSchema); export let todo = Task.discriminator('todo', TodoSchema);

435
website/server/models/user/schema.js
View File

@@ -19,21 +19,21 @@ const RESTRICTED_EMAIL_DOMAINS = Object.freeze(['habitica.com', 'habitrpg.com'])
// User schema definition // User schema definition
let schema = new Schema({ let schema = new Schema({
apiToken: { apiToken: {
type: String, $type: String,
default: shared.uuid, default: shared.uuid,
}, },
auth: { auth: {
blocked: Boolean, blocked: Boolean,
facebook: {type: Schema.Types.Mixed, default: () => { facebook: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
google: {type: Schema.Types.Mixed, default: () => { google: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
local: { local: {
email: { email: {
type: String, $type: String,
validate: [{ validate: [{
validator: (v) => validator.isEmail(v), validator: (v) => validator.isEmail(v),
message: shared.i18n.t('invalidEmail'), message: shared.i18n.t('invalidEmail'),
@@ -49,14 +49,14 @@ let schema = new Schema({
}], }],
}, },
username: { username: {
type: String, $type: String,
}, },
// Store a lowercase version of username to check for duplicates // Store a lowercase version of username to check for duplicates
lowerCaseUsername: String, lowerCaseUsername: String,
hashed_password: String, // eslint-disable-line camelcase hashed_password: String, // eslint-disable-line camelcase
// Legacy password are hashed with SHA1, new ones with bcrypt // Legacy password are hashed with SHA1, new ones with bcrypt
passwordHashMethod: { passwordHashMethod: {
type: String, $type: String,
enum: ['bcrypt', 'sha1'], enum: ['bcrypt', 'sha1'],
}, },
salt: String, // Salt for SHA1 encrypted passwords, not stored for bcrypt, salt: String, // Salt for SHA1 encrypted passwords, not stored for bcrypt,
@@ -64,22 +64,22 @@ let schema = new Schema({
passwordResetCode: String, passwordResetCode: String,
}, },
timestamps: { timestamps: {
created: {type: Date, default: Date.now}, created: {$type: Date, default: Date.now},
loggedin: {type: Date, default: Date.now}, loggedin: {$type: Date, default: Date.now},
}, },
}, },
// 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 },
migration: String, migration: String,
achievements: { achievements: {
originalUser: Boolean, originalUser: Boolean,
habitSurveys: Number, habitSurveys: Number,
ultimateGearSets: { ultimateGearSets: {
healer: {type: Boolean, default: false}, healer: {$type: Boolean, default: false},
wizard: {type: Boolean, default: false}, wizard: {$type: Boolean, default: false},
rogue: {type: Boolean, default: false}, rogue: {$type: Boolean, default: false},
warrior: {type: Boolean, default: false}, warrior: {$type: Boolean, default: false},
}, },
beastMaster: Boolean, beastMaster: Boolean,
beastMasterCount: Number, beastMasterCount: Number,
@@ -94,12 +94,12 @@ let schema = new Schema({
seafoam: Number, seafoam: Number,
streak: Number, streak: Number,
challenges: Array, challenges: Array,
quests: {type: Schema.Types.Mixed, default: () => { quests: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
rebirths: Number, rebirths: Number,
rebirthLevel: Number, rebirthLevel: Number,
perfect: {type: Number, default: 0}, perfect: {$type: Number, default: 0},
habitBirthdays: Number, habitBirthdays: Number,
valentine: Number, valentine: Number,
nye: Number, nye: Number,
@@ -129,7 +129,7 @@ let schema = new Schema({
contributor: { contributor: {
// 1-9, see https://trello.com/c/wkFzONhE/277-contributor-gear https://github.com/HabitRPG/habitica/issues/3801 // 1-9, see https://trello.com/c/wkFzONhE/277-contributor-gear https://github.com/HabitRPG/habitica/issues/3801
level: { level: {
type: Number, $type: Number,
min: 0, min: 0,
max: 9, max: 9,
}, },
@@ -142,106 +142,106 @@ let schema = new Schema({
critical: String, critical: String,
}, },
balance: {type: Number, default: 0}, balance: {$type: Number, default: 0},
purchased: { purchased: {
ads: {type: Boolean, default: false}, ads: {$type: Boolean, default: false},
// eg, {skeleton: true, pumpkin: true, eb052b: true} // eg, {skeleton: true, pumpkin: true, eb052b: true}
skin: {type: Schema.Types.Mixed, default: () => { skin: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
hair: {type: Schema.Types.Mixed, default: () => { hair: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
shirt: {type: Schema.Types.Mixed, default: () => { shirt: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
background: {type: Schema.Types.Mixed, default: () => { background: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
txnCount: {type: Number, default: 0}, txnCount: {$type: Number, default: 0},
mobileChat: Boolean, mobileChat: Boolean,
plan: {type: SubscriptionPlanSchema, default: () => { plan: {$type: SubscriptionPlanSchema, default: () => {
return {}; return {};
}}, }},
}, },
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},
mounts: {type: Boolean, default: false}, mounts: {$type: Boolean, default: false},
inbox: {type: Boolean, default: false}, inbox: {$type: Boolean, default: false},
stats: {type: Boolean, default: false}, stats: {$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},
inviteParty: {type: Boolean, default: false}, inviteParty: {$type: Boolean, default: false},
reorderTask: {type: Boolean, default: false}, reorderTask: {$type: Boolean, default: false},
}, },
}, },
dropsEnabled: {type: Boolean, default: false}, dropsEnabled: {$type: Boolean, default: false},
itemsEnabled: {type: Boolean, default: false}, itemsEnabled: {$type: Boolean, default: false},
newStuff: {type: Boolean, default: false}, newStuff: {$type: Boolean, default: false},
rewrite: {type: Boolean, default: true}, rewrite: {$type: Boolean, default: true},
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: () => {
return {}; return {};
}}, }},
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,
onboardingEmailsPhase: String, // Keep track of the latest onboarding email sent onboardingEmailsPhase: String, // Keep track of the latest onboarding email sent
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: true}, armoireEnabled: {$type: Boolean, default: true},
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},
verifiedUsername: {type: Boolean, default: false}, verifiedUsername: {$type: Boolean, default: false},
}, },
history: { history: {
@@ -252,7 +252,7 @@ let schema = new Schema({
items: { items: {
gear: { gear: {
owned: _.transform(shared.content.gear.flat, (m, v) => { owned: _.transform(shared.content.gear.flat, (m, v) => {
m[v.key] = {type: Boolean}; m[v.key] = {$type: Boolean};
if (v.key.match(/(armor|head|shield)_warrior_0/) || v.gearSet === 'glasses' || v.gearSet === 'headband') { if (v.key.match(/(armor|head|shield)_warrior_0/) || v.gearSet === 'glasses' || v.gearSet === 'headband') {
m[v.key].default = true; m[v.key].default = true;
} }
@@ -260,9 +260,9 @@ let schema = new Schema({
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,
@@ -270,9 +270,9 @@ let schema = new Schema({
}, },
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,
@@ -281,25 +281,25 @@ let schema = new Schema({
}, },
special: { special: {
snowball: {type: Number, default: 0}, snowball: {$type: Number, default: 0},
spookySparkles: {type: Number, default: 0}, spookySparkles: {$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: {type: Number, default: 0}, valentine: {$type: Number, default: 0},
valentineReceived: Array, // array of strings, by sender name valentineReceived: Array, // array of strings, by sender name
nye: {type: Number, default: 0}, nye: {$type: Number, default: 0},
nyeReceived: Array, nyeReceived: Array,
greeting: {type: Number, default: 0}, greeting: {$type: Number, default: 0},
greetingReceived: Array, greetingReceived: Array,
thankyou: {type: Number, default: 0}, thankyou: {$type: Number, default: 0},
thankyouReceived: Array, thankyouReceived: Array,
birthday: {type: Number, default: 0}, birthday: {$type: Number, default: 0},
birthdayReceived: Array, birthdayReceived: Array,
congrats: {type: Number, default: 0}, congrats: {$type: Number, default: 0},
congratsReceived: Array, congratsReceived: Array,
getwell: {type: Number, default: 0}, getwell: {$type: Number, default: 0},
getwellReceived: Array, getwellReceived: Array,
goodluck: {type: Number, default: 0}, goodluck: {$type: Number, default: 0},
goodluckReceived: Array, goodluckReceived: Array,
}, },
@@ -361,44 +361,44 @@ let schema = new Schema({
quests: _.transform(shared.content.quests, (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},
_cronSignature: {type: String, default: 'NOT_RUNNING'}, // Private property used to avoid double cron _cronSignature: {$type: String, default: 'NOT_RUNNING'}, // Private property used to avoid double cron
// {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: () => {
return {}; return {};
}}, }},
challenges: [{type: String, ref: 'Challenge', validate: [v => validator.isUUID(v), 'Invalid uuid.']}], challenges: [{$type: String, ref: 'Challenge', validate: [v => validator.isUUID(v), 'Invalid uuid.']}],
invitations: { invitations: {
// Using an array without validation because otherwise mongoose treat this as a subdocument and applies _id by default // Using an array without validation because otherwise mongoose treat this as a subdocument and applies _id by default
// Schema is (id, name, inviter, publicGuild) // Schema is (id, name, inviter, publicGuild)
// TODO one way to fix is http://mongoosejs.com/docs/guide.html#_id // TODO one way to fix is http://mongoosejs.com/docs/guide.html#_id
guilds: {type: Array, default: () => []}, guilds: {$type: Array, default: () => []},
// Using a Mixed type because otherwise user.invitations.party = {} // to reset invitation, causes validation to fail TODO // Using a Mixed type because otherwise user.invitations.party = {} // to reset invitation, causes validation to fail TODO
// schema is the same as for guild invitations (id, name, inviter) // schema is the same as for guild invitations (id, name, inviter)
party: {type: Schema.Types.Mixed, default: () => { party: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
parties: [{ parties: [{
id: { id: {
type: String, $type: String,
ref: 'Group', ref: 'Group',
required: true, required: true,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
}, },
name: { name: {
type: String, $type: String,
required: true, required: true,
}, },
inviter: { inviter: {
type: String, $type: String,
ref: 'User', ref: 'User',
required: true, required: true,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
@@ -406,105 +406,105 @@ let schema = new Schema({
}], }],
}, },
guilds: [{type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.']}], guilds: [{$type: String, ref: 'Group', validate: [v => validator.isUUID(v), 'Invalid uuid.']}],
party: { party: {
_id: {type: String, validate: [v => validator.isUUID(v), 'Invalid uuid.'], ref: 'Group'}, _id: {$type: String, validate: [v => validator.isUUID(v), 'Invalid uuid.'], ref: 'Group'},
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: () => { collect: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
collectedItems: {type: Number, default: 0}, collectedItems: {$type: Number, default: 0},
}, },
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: {type: Number, default: 0}, timezoneOffset: {$type: Number, default: 0},
sound: {type: String, default: 'rosstavoTheme', enum: ['off', ...shared.content.audioThemes]}, sound: {$type: String, default: 'rosstavoTheme', enum: ['off', ...shared.content.audioThemes]},
chair: {type: String, default: 'none'}, chair: {$type: String, default: 'none'},
timezoneOffsetAtLastCron: Number, timezoneOffsetAtLastCron: Number,
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},
advancedCollapsed: {type: Boolean, default: false}, advancedCollapsed: {$type: Boolean, default: false},
toolbarCollapsed: {type: Boolean, default: false}, toolbarCollapsed: {$type: Boolean, default: false},
reverseChatOrder: {type: Boolean, default: false}, reverseChatOrder: {$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: () => {
return {}; return {};
}}, }},
// For the following 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},
// 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},
onboarding: {type: Boolean, default: true}, onboarding: {$type: Boolean, default: true},
}, },
pushNotifications: { pushNotifications: {
unsubscribeFromAll: {type: Boolean, default: false}, unsubscribeFromAll: {$type: Boolean, default: false},
newPM: {type: Boolean, default: true}, newPM: {$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},
}, },
suppressModals: { suppressModals: {
levelUp: {type: Boolean, default: false}, levelUp: {$type: Boolean, default: false},
hatchPet: {type: Boolean, default: false}, hatchPet: {$type: Boolean, default: false},
raisePet: {type: Boolean, default: false}, raisePet: {$type: Boolean, default: false},
streak: {type: Boolean, default: false}, streak: {$type: Boolean, default: false},
}, },
tasks: { tasks: {
groupByChallenge: {type: Boolean, default: false}, // @TODO remove? not used groupByChallenge: {$type: Boolean, default: false}, // @TODO remove? not used
confirmScoreNotes: {type: Boolean, default: false}, // @TODO remove? not used confirmScoreNotes: {$type: Boolean, default: false}, // @TODO remove? not used
}, },
improvementCategories: { improvementCategories: {
type: Array, $type: Array,
validate: (categories) => { validate: (categories) => {
const validCategories = ['work', 'exercise', 'healthWellness', 'school', 'teams', 'chores', 'creativity']; const validCategories = ['work', 'exercise', 'healthWellness', 'school', 'teams', 'chores', 'creativity'];
let isValidCategory = categories.every(category => validCategories.indexOf(category) !== -1); let isValidCategory = categories.every(category => validCategories.indexOf(category) !== -1);
@@ -516,42 +516,42 @@ let schema = new Schema({
blurb: String, blurb: String,
imageUrl: String, imageUrl: String,
name: { name: {
type: String, $type: String,
required: true, required: true,
trim: true, trim: true,
}, },
}, },
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, min: 1}, lvl: {$type: Number, default: 1, min: 1},
// Class System // Class System
class: {type: String, enum: ['warrior', 'rogue', 'wizard', 'healer'], default: 'warrior', required: true}, class: {$type: String, enum: ['warrior', 'rogue', 'wizard', 'healer'], default: 'warrior', required: true},
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},
spookySparkles: {type: Boolean, default: false}, spookySparkles: {$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},
}, },
}, },
@@ -560,45 +560,46 @@ let schema = new Schema({
inbox: { inbox: {
// messages are stored in the Inbox collection // messages are stored in the Inbox collection
newMessages: {type: Number, default: 0}, newMessages: {$type: Number, default: 0},
blocks: {type: Array, default: () => []}, blocks: {$type: Array, default: () => []},
optOut: {type: Boolean, default: false}, optOut: {$type: Boolean, default: false},
}, },
tasksOrder: { tasksOrder: {
habits: [{type: String, ref: 'Task'}], habits: [{$type: String, ref: 'Task'}],
dailys: [{type: String, ref: 'Task'}], dailys: [{$type: String, ref: 'Task'}],
todos: [{type: String, ref: 'Task'}], todos: [{$type: String, ref: 'Task'}],
rewards: [{type: String, ref: 'Task'}], rewards: [{$type: String, ref: 'Task'}],
}, },
extra: {type: Schema.Types.Mixed, default: () => { extra: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
pushDevices: [PushDeviceSchema], pushDevices: [PushDeviceSchema],
_ABtests: {type: Schema.Types.Mixed, default: () => { _ABtests: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
webhooks: [WebhookSchema], webhooks: [WebhookSchema],
loginIncentives: {type: Number, default: 0}, loginIncentives: {$type: Number, default: 0},
invitesSent: {type: Number, default: 0}, invitesSent: {$type: Number, default: 0},
// Items manually pinned by the user // Items manually pinned by the user
pinnedItems: [{ pinnedItems: [{
_id: false, _id: false,
path: {type: String}, path: {$type: String},
type: {type: String}, type: {$type: String},
}], }],
// Ordered array of shown pinned items, necessary for sorting because seasonal items are not stored in pinnedItems // Ordered array of shown pinned items, necessary for sorting because seasonal items are not stored in pinnedItems
pinnedItemsOrder: [{type: String}], pinnedItemsOrder: [{$type: String}],
// Items the user manually unpinned from the ones suggested by Habitica // Items the user manually unpinned from the ones suggested by Habitica
unpinnedItems: [{ unpinnedItems: [{
_id: false, _id: false,
path: {type: String}, path: {$type: String},
type: {type: String}, type: {$type: String},
}], }],
}, { }, {
skipVersioning: { notifications: true }, skipVersioning: { notifications: true },
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
typeKey: '$type', // So that we can use fields named `type`
}); });
module.exports = schema; module.exports = schema;

11
website/server/models/userNotification.js
View File

@@ -37,7 +37,7 @@ const Schema = mongoose.Schema;
export let schema = new Schema({ export let schema = new Schema({
id: { id: {
type: String, $type: String,
default: uuid, default: uuid,
validate: [v => validator.isUUID(v), 'Invalid uuid.'], validate: [v => validator.isUUID(v), 'Invalid uuid.'],
// @TODO: Add these back once we figure out the issue with notifications // @TODO: Add these back once we figure out the issue with notifications
@@ -45,25 +45,26 @@ export let schema = new Schema({
// required: true, // required: true,
}, },
type: { type: {
type: String, $type: String,
// @TODO: Add these back once we figure out the issue with notifications // @TODO: Add these back once we figure out the issue with notifications
// See Fix for https://github.com/HabitRPG/habitica/issues/9923 // See Fix for https://github.com/HabitRPG/habitica/issues/9923
// required: true, // required: true,
enum: NOTIFICATION_TYPES, enum: NOTIFICATION_TYPES,
}, },
data: {type: Schema.Types.Mixed, default: () => { data: {$type: Schema.Types.Mixed, default: () => {
return {}; return {};
}}, }},
// A field to mark the notification as seen without deleting it, optional use // A field to mark the notification as seen without deleting it, optional use
seen: { seen: {
type: Boolean, $type: Boolean,
// required: true, // required: true,
default: () => false, default: () => false,
}, },
}, { }, {
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
_id: false, // use id instead of _id _id: false, // use id instead of _id,
typeKey: '$type', // So that we can use fields named `type`
}); });
/** /**

13
website/server/models/webhook.js
View File

@@ -32,13 +32,13 @@ const QUEST_ACTIVITY_DEFAULT_OPTIONS = Object.freeze({
export let schema = new Schema({ export let schema = new Schema({
id: { id: {
type: String, $type: String,
required: true, required: true,
validate: [v => validator.isUUID(v), shared.i18n.t('invalidWebhookId')], validate: [v => validator.isUUID(v), shared.i18n.t('invalidWebhookId')],
default: uuid, default: uuid,
}, },
type: { type: {
type: String, $type: String,
required: true, required: true,
enum: [ enum: [
'globalActivity', // global webhooks send a request for every type of event 'globalActivity', // global webhooks send a request for every type of event
@@ -48,12 +48,12 @@ export let schema = new Schema({
default: 'taskActivity', default: 'taskActivity',
}, },
label: { label: {
type: String, $type: String,
required: false, required: false,
default: '', default: '',
}, },
url: { url: {
type: String, $type: String,
required: true, required: true,
validate: [(v) => { validate: [(v) => {
return validator.isURL(v, { return validator.isURL(v, {
@@ -61,9 +61,9 @@ export let schema = new Schema({
}); });
}, shared.i18n.t('invalidUrl')], }, shared.i18n.t('invalidUrl')],
}, },
enabled: { type: Boolean, required: true, default: true }, enabled: { $type: Boolean, required: true, default: true },
options: { options: {
type: Schema.Types.Mixed, $type: Schema.Types.Mixed,
required: true, required: true,
default () { default () {
return {}; return {};
@@ -73,6 +73,7 @@ export let schema = new Schema({
strict: true, strict: true,
minimize: false, // So empty objects are returned minimize: false, // So empty objects are returned
_id: false, _id: false,
typeKey: '$type', // So that we can use fields named `type`
}); });
schema.plugin(baseModel, { schema.plugin(baseModel, {