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

port task model to es6 and implement discriminators

Browse Source
This commit is contained in:
Matteo Pagliazzi
2015-11-27 19:06:26 +01:00
parent 9adfd6311f
commit 7d53a4fd54
3 changed files with 112 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tasks/gulp-eslint.js
View File

@@ -4,6 +4,7 @@ import eslint from 'gulp-eslint';
const SERVER_FILES = [
'./website/src/**/api-v3/**/*.js',
'./website/src/models/user.js',
'./website/src/models/task.js',
'./website/src/models/emailUnsubscription.js',
'./website/src/server.js',
];

189
website/src/models/task.js
View File

@@ -1,108 +1,99 @@
// User.js
// =======
// Defines the user data model (schema) for use via the API.
import mongoose from 'mongoose';
import shared from '../../../common';
import moment from 'moment';
import baseModel from '../libs/api-v3/baseModel';
import _ from 'lodash';
// Dependencies
// ------------
var mongoose = require("mongoose");
var Schema = mongoose.Schema;
var shared = require('../../../common');
var _ = require('lodash');
var moment = require('moment');
// Task Schema
// -----------
var TaskSchema = {
//_id:{type: String,'default': helpers.uuid},
id: {type: String,'default': shared.uuid},
dateCreated: {type:Date, 'default':Date.now},
text: String,
notes: {type: String, 'default': ''},
tags: {type: Schema.Types.Mixed, 'default': {}}, //{ "4ddf03d9-54bd-41a3-b011-ca1f1d2e9371" : true },
value: {type: Number, 'default': 0}, // redness
priority: {type: Number, 'default': '1'},
attribute: {type: String, 'default': "str", enum: ['str','con','int','per']},
challenge: {
id: {type: 'String', ref:'Challenge'},
broken: String, // CHALLENGE_DELETED, TASK_DELETED, UNSUBSCRIBED, CHALLENGE_CLOSED
winner: String // user.profile.name
// group: {type: 'Strign', ref: 'Group'} // if we restore this, rename `id` above to `challenge`
}
let Schema = mongoose.Schema;
let discriminatorOptions = () => {
return {discriminatorKey: 'type'}; // the key that distinguishes task types
};
var HabitSchema = new Schema(
_.defaults({
type: {type:String, 'default': 'habit'},
history: Array, // [{date:Date, value:Number}], // this causes major performance problems
up: {type: Boolean, 'default': true},
down: {type: Boolean, 'default': true}
}, TaskSchema)
, { _id: false, minimize:false }
);
// TODO make sure a task can only update the fields belonging to its type
// We could use discriminators but it looks like when loading from the parent
// Task model the subclasses are not applied - check twice
var collapseChecklist = {type:Boolean, 'default':false};
var checklist = [{
completed:{type:Boolean,'default':false},
export let TaskSchema = new Schema({
type: {type: String, enum: ['habit', 'todo', 'daily', 'reward'], required: true, default: 'habit'},
text: String,
_id:false,
id: {type:String,'default':shared.uuid}
}];
notes: {type: String, default: ''},
tags: {type: Schema.Types.Mixed, default: {}}, // TODO dictionary? { "4ddf03d9-54bd-41a3-b011-ca1f1d2e9371" : true },
value: {type: Number, default: 0}, // redness
priority: {type: Number, default: 1},
attribute: {type: String, default: 'str', enum: ['str', 'con', 'int', 'per']},
userId: {type: String, ref: 'User'}, // When null it belongs to a challenge
var DailySchema = new Schema(
_.defaults({
type: {type: String, 'default': 'daily'},
frequency: {type: String, 'default': 'weekly', enum: ['daily', 'weekly']},
everyX: {type: Number, 'default': 1}, // e.g. once every X weeks
startDate: {type: Date, 'default': moment().startOf('day').toDate()},
history: Array,
completed: {type: Boolean, 'default': false},
repeat: { // used only for 'weekly' frequency,
m: {type: Boolean, 'default': true},
t: {type: Boolean, 'default': true},
w: {type: Boolean, 'default': true},
th: {type: Boolean, 'default': true},
f: {type: Boolean, 'default': true},
s: {type: Boolean, 'default': true},
su: {type: Boolean, 'default': true}
challenge: {
id: {type: String, ref: 'Challenge'},
taskId: {type: String, ref: 'Task'}, // When null but challenge.id defined it's the original task
broken: String, // CHALLENGE_DELETED, TASK_DELETED, UNSUBSCRIBED, CHALLENGE_CLOSED TODO enum
winner: String, // user.profile.name TODO necessary?
},
}, _.default({
minimize: true, // So empty objects are returned
strict: true,
}, discriminatorOptions()));
TaskSchema.plugin(baseModel, {
noSet: [],
private: [],
timestamps: true,
});
export let Task = mongoose.model('Task', TaskSchema);
// TODO discriminators: it's very important to check that the options and plugins of the parent schema are used in the sub-schemas too
// habits and dailies shared fields
let habitDailySchema = () => {
return {history: Array}; // [{date:Date, value:Number}], // this causes major performance problems TODO revisit
};
// dailys and todos shared fields
let dailyTodoSchema = () => {
return {
completed: {type: Boolean, default: false},
// Checklist fields (dailies and todos)
collapseChecklist: {type: Boolean, default: false},
checklist: [{
completed: {type: Boolean, default: false},
text: String,
_id: {type: String, default: shared.uuid},
}],
};
};
export let Habit = Task.discriminator('Habit', new Schema(_.defaults({
up: {type: Boolean, default: true},
down: {type: Boolean, default: true},
}, habitDailySchema())), discriminatorOptions());
export let Daily = Task.discriminator('Daily', new Schema(_.defaults({
frequency: {type: String, default: 'weekly', enum: ['daily', 'weekly']},
everyX: {type: Number, default: 1}, // e.g. once every X weeks
startDate: {
type: Date,
default () {
return moment().startOf('day').toDate();
},
collapseChecklist:collapseChecklist,
checklist:checklist,
streak: {type: Number, 'default': 0}
}, TaskSchema)
, { _id: false, minimize:false }
)
},
repeat: { // used only for 'weekly' frequency,
m: {type: Boolean, default: true},
t: {type: Boolean, default: true},
w: {type: Boolean, default: true},
th: {type: Boolean, default: true},
f: {type: Boolean, default: true},
s: {type: Boolean, default: true},
su: {type: Boolean, default: true},
},
streak: {type: Number, default: 0},
}, habitDailySchema(), dailyTodoSchema())), discriminatorOptions());
var TodoSchema = new Schema(
_.defaults({
type: {type:String, 'default': 'todo'},
completed: {type: Boolean, 'default': false},
dateCompleted: Date,
date: String, // due date for todos // FIXME we're getting parse errors, people have stored as "today" and "3/13". Need to run a migration & put this back to type: Date
collapseChecklist:collapseChecklist,
checklist:checklist
}, TaskSchema)
, { _id: false, minimize:false }
);
export let Todo = Task.discriminator('Todo', new Schema(_.defaults({
dateCompleted: Date,
// FIXME we're getting parse errors, people have stored as "today" and "3/13". Need to run a migration & put this back to type: Date
// TODO change field name
date: String, // due date for todos
}, dailyTodoSchema())), discriminatorOptions());
var RewardSchema = new Schema(
_.defaults({
type: {type:String, 'default': 'reward'}
}, TaskSchema)
, { _id: false, minimize:false }
);
/**
* Workaround for bug when _id & id were out of sync, we can remove this after challenges has been running for a while
*/
//_.each([HabitSchema, DailySchema, TodoSchema, RewardSchema], function(schema){
// schema.post('init', function(doc){
// if (!doc.id && doc._id) doc.id = doc._id;
// })
//})
module.exports.TaskSchema = TaskSchema;
module.exports.HabitSchema = HabitSchema;
module.exports.DailySchema = DailySchema;
module.exports.TodoSchema = TodoSchema;
module.exports.RewardSchema = RewardSchema;
export let Reward = Task.discriminator('Reward', new Schema({}), discriminatorOptions());

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

@@ -1,10 +1,9 @@
// User schema and model
import mongoose from 'mongoose';
import shared from '../../../common';
import _ from 'lodash';
import validator from 'validator';
import moment from 'moment';
import TaskSchemas from './task';
import { model as Task } from './task';
import baseModel from '../libs/api-v3/baseModel';
// import {model as Challenge} from './challenge';
@@ -41,11 +40,9 @@ export let schema = new Schema({
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
// have been updated (http://goo.gl/gQLz41), but we want *every* update
_v: { type: Number, default: 0 },
achievements: {
originalUser: Boolean,
habitSurveys: Number,
@@ -455,14 +452,14 @@ export let schema = new Schema({
messages: {type: Schema.Types.Mixed, default: {}},
optOut: {type: Boolean, default: false},
},
habits: {type: [TaskSchemas.HabitSchema]},
dailys: {type: [TaskSchemas.DailySchema]},
todos: {type: [TaskSchemas.TodoSchema]},
rewards: {type: [TaskSchemas.RewardSchema]},
tasksOrder: {
habits: [{type: String, ref: 'Task'}],
dailys: [{type: String, ref: 'Task'}],
todos: [{type: String, ref: 'Task'}],
completedTodos: [{type: String, ref: 'Task'}],
rewards: [{type: String, ref: 'Task'}],
},
extra: Schema.Types.Mixed,
pushDevices: {
type: [{
regId: {type: String},
@@ -476,10 +473,10 @@ export let schema = new Schema({
});
schema.plugin(baseModel, {
noSet: ['_id', 'apikey', 'auth.blocked', 'auth.timestamps', 'lastCron', 'auth.local.hashed_password', 'auth.local.salt'],
noSet: ['_id', 'apikey', 'auth.blocked', 'auth.timestamps', 'lastCron', 'auth.local.hashed_password', 'auth.local.salt', 'tasksOrder'],
private: ['auth.local.hashed_password', 'auth.local.salt'],
toJSONTransform: function toJSON (doc) {
doc.id = doc._id;
doc.id = doc._id; // TODO remove?
// FIXME? Is this a reference to `doc.filters` or just disabled code? Remove?
doc.filters = {};
@@ -489,31 +486,25 @@ schema.plugin(baseModel, {
},
});
schema.methods.deleteTask = function deleteTask (tid) {
this.ops.deleteTask({params: {id: tid}}, () => {}); // TODO remove this whole method, since it just proxies, and change all references to this method
};
// schema.virtual('tasks').get(function () {
// var tasks = this.habits.concat(this.dailys).concat(this.todos).concat(this.rewards);
// var tasks = _.object(_.pluck(tasks,'id'), tasks);
// return tasks;
// });
schema.post('init', function postInitUser (doc) {
shared.wrap(doc);
});
function _populateDefaultTasks (user, taskTypes) {
_.each(taskTypes, (taskType) => {
user[taskType] = _.map(shared.content.userDefaults[taskType], (task) => {
let newTask = _.cloneDeep(task);
// TODO save in own documents
user[taskType] = _.map(shared.content.userDefaults[taskType], (taskDefaults) => {
let newTask;
// Render task's text and notes in user's language
if (taskType === 'tags') {
newTask = _.cloneDeep(taskDefaults);
// 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 = new Task(taskDefaults);
newTask.userId = user._id;
newTask.text = newTask.text(user.preferences.language);
if (newTask.notes) {
newTask.notes = newTask.notes(user.preferences.language);
@@ -534,27 +525,12 @@ function _populateDefaultTasks (user, taskTypes) {
function _populateDefaultsForNewUser (user) {
let taskTypes;
let iterableFlags = user.toObject().flags;
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',
'inviteParty',
];
_.each(tutorialCommonSections, (section) => {
_.each(iterableFlags.tutorial.common, (section) => {
user.flags.tutorial.common[section] = true;
});
} else {
@@ -562,23 +538,7 @@ function _populateDefaultsForNewUser (user) {
user.flags.showTour = false;
let tourSections = [
'showTour',
'intro',
'classes',
'stats',
'tavern',
'party',
'guilds',
'challenges',
'market',
'pets',
'mounts',
'hall',
'equipment',
];
_.each(tourSections, (section) => {
_.each(iterableFlags.tour, (section) => {
user.flags.tour[section] = -2;
});
}
@@ -668,7 +628,7 @@ schema.methods.unlink = function unlink (options, cb) {
if (keep === 'keep') {
self.tasks[tid].challenge = {};
} else if (keep === 'remove') {
self.deleteTask(tid);
self.ops.deleteTask({params: {id: tid}}, () => {});
} else if (keep === 'keep-all') {
_.each(self.tasks, (t) => {
if (t.challenge && t.challenge.id === cid) {
@@ -678,7 +638,7 @@ schema.methods.unlink = function unlink (options, cb) {
} else if (keep === 'remove-all') {
_.each(self.tasks, (t) => {
if (t.challenge && t.challenge.id === cid) {
self.deleteTask(t.id);
this.ops.deleteTask({params: {id: tid}}, () => {});
}
});
}