2017-11-03 02:09:34 +02:00
|
|
|
const { Log } = require('lib/log.js');
|
|
|
|
const { Database } = require('lib/database.js');
|
|
|
|
const { uuid } = require('lib/uuid.js');
|
|
|
|
const { time } = require('lib/time-utils.js');
|
2017-05-10 21:51:43 +02:00
|
|
|
|
2017-05-08 00:20:34 +02:00
|
|
|
class BaseModel {
|
|
|
|
|
2017-07-03 22:38:26 +02:00
|
|
|
static modelType() {
|
|
|
|
throw new Error('Must be overriden');
|
|
|
|
}
|
|
|
|
|
|
|
|
static tableName() {
|
|
|
|
throw new Error('Must be overriden');
|
|
|
|
}
|
|
|
|
|
2017-06-17 20:40:08 +02:00
|
|
|
static addModelMd(model) {
|
|
|
|
if (!model) return model;
|
|
|
|
|
|
|
|
if (Array.isArray(model)) {
|
|
|
|
let output = [];
|
|
|
|
for (let i = 0; i < model.length; i++) {
|
|
|
|
output.push(this.addModelMd(model[i]));
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
} else {
|
|
|
|
model = Object.assign({}, model);
|
2017-07-03 21:50:45 +02:00
|
|
|
model.type_ = this.modelType();
|
2017-06-17 20:40:08 +02:00
|
|
|
return model;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-25 12:41:03 +02:00
|
|
|
static logger() {
|
|
|
|
return this.db().logger();
|
|
|
|
}
|
|
|
|
|
2017-05-12 21:54:06 +02:00
|
|
|
static useUuid() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-05-15 21:10:00 +02:00
|
|
|
static byId(items, id) {
|
|
|
|
for (let i = 0; i < items.length; i++) {
|
|
|
|
if (items[i].id == id) return items[i];
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-05-19 21:32:49 +02:00
|
|
|
static hasField(name) {
|
|
|
|
let fields = this.fieldNames();
|
|
|
|
return fields.indexOf(name) >= 0;
|
|
|
|
}
|
|
|
|
|
2017-07-16 14:53:59 +02:00
|
|
|
static fieldNames(withPrefix = false) {
|
|
|
|
let output = this.db().tableFieldNames(this.tableName());
|
|
|
|
if (!withPrefix) return output;
|
2017-07-19 21:15:55 +02:00
|
|
|
|
|
|
|
let p = withPrefix === true ? this.tableName() : withPrefix;
|
2017-07-16 14:53:59 +02:00
|
|
|
let temp = [];
|
|
|
|
for (let i = 0; i < output.length; i++) {
|
2017-07-19 21:15:55 +02:00
|
|
|
temp.push(p + '.' + output[i]);
|
2017-07-16 14:53:59 +02:00
|
|
|
}
|
2017-07-19 21:15:55 +02:00
|
|
|
|
2017-07-16 14:53:59 +02:00
|
|
|
return temp;
|
2017-05-18 21:58:01 +02:00
|
|
|
}
|
|
|
|
|
2017-12-05 00:58:42 +02:00
|
|
|
static fieldType(name, defaultValue = null) {
|
2017-06-15 20:18:48 +02:00
|
|
|
let fields = this.fields();
|
|
|
|
for (let i = 0; i < fields.length; i++) {
|
|
|
|
if (fields[i].name == name) return fields[i].type;
|
|
|
|
}
|
2017-12-05 00:58:42 +02:00
|
|
|
if (defaultValue !== null) return defaultValue;
|
2017-06-15 20:18:48 +02:00
|
|
|
throw new Error('Unknown field: ' + name);
|
|
|
|
}
|
|
|
|
|
2017-05-20 00:16:50 +02:00
|
|
|
static fields() {
|
|
|
|
return this.db().tableFields(this.tableName());
|
|
|
|
}
|
|
|
|
|
|
|
|
static new() {
|
|
|
|
let fields = this.fields();
|
|
|
|
let output = {};
|
|
|
|
for (let i = 0; i < fields.length; i++) {
|
|
|
|
let f = fields[i];
|
|
|
|
output[f.name] = f.default;
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2017-05-18 22:31:40 +02:00
|
|
|
static modOptions(options) {
|
|
|
|
if (!options) {
|
|
|
|
options = {};
|
|
|
|
} else {
|
|
|
|
options = Object.assign({}, options);
|
|
|
|
}
|
|
|
|
if (!('isNew' in options)) options.isNew = 'auto';
|
2017-06-18 01:49:52 +02:00
|
|
|
if (!('autoTimestamp' in options)) options.autoTimestamp = true;
|
2017-05-18 22:31:40 +02:00
|
|
|
return options;
|
|
|
|
}
|
|
|
|
|
2017-06-24 19:40:03 +02:00
|
|
|
static count() {
|
|
|
|
return this.db().selectOne('SELECT count(*) as total FROM `' + this.tableName() + '`').then((r) => {
|
|
|
|
return r ? r['total'] : 0;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-05-19 21:12:09 +02:00
|
|
|
static load(id) {
|
2017-06-11 23:11:14 +02:00
|
|
|
return this.loadByField('id', id);
|
|
|
|
}
|
|
|
|
|
2017-07-17 20:46:09 +02:00
|
|
|
static shortId(id) {
|
2017-08-21 19:56:40 +02:00
|
|
|
return id.substr(0, 5);
|
2017-07-17 20:46:09 +02:00
|
|
|
}
|
|
|
|
|
2017-10-24 21:40:15 +02:00
|
|
|
// static minimalPartialId(id) {
|
|
|
|
// let length = 2;
|
|
|
|
// while (true) {
|
|
|
|
// const partialId = id.substr(0, length);
|
|
|
|
// const r = await this.db().selectOne('SELECT count(*) as total FROM `' + this.tableName() + '` WHERE `id` LIKE ?', [partialId + '%']);
|
|
|
|
// if (r['total'] <= 1) return partialId;
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
2017-07-10 22:47:01 +02:00
|
|
|
static loadByPartialId(partialId) {
|
2017-09-10 19:32:04 +02:00
|
|
|
return this.modelSelectAll('SELECT * FROM `' + this.tableName() + '` WHERE `id` LIKE ?', [partialId + '%']);
|
2017-07-10 22:47:01 +02:00
|
|
|
}
|
|
|
|
|
2017-06-25 11:00:54 +02:00
|
|
|
static applySqlOptions(options, sql, params = null) {
|
|
|
|
if (!options) options = {};
|
|
|
|
|
2017-07-26 20:36:16 +02:00
|
|
|
if (options.order && options.order.length) {
|
|
|
|
let items = [];
|
|
|
|
for (let i = 0; i < options.order.length; i++) {
|
|
|
|
const o = options.order[i];
|
|
|
|
let item = o.by;
|
|
|
|
if (options.caseInsensitive === true) item += ' COLLATE NOCASE';
|
|
|
|
if (o.dir) item += ' ' + o.dir;
|
|
|
|
items.push(item);
|
|
|
|
}
|
|
|
|
sql += ' ORDER BY ' + items.join(', ');
|
2017-06-25 11:00:54 +02:00
|
|
|
}
|
2017-07-26 20:36:16 +02:00
|
|
|
|
2017-06-25 11:00:54 +02:00
|
|
|
if (options.limit) sql += ' LIMIT ' + options.limit;
|
|
|
|
|
|
|
|
return { sql: sql, params: params };
|
|
|
|
}
|
|
|
|
|
2017-08-20 16:29:18 +02:00
|
|
|
static async allIds(options = null) {
|
|
|
|
let q = this.applySqlOptions(options, 'SELECT id FROM `' + this.tableName() + '`');
|
|
|
|
const rows = await this.db().selectAll(q.sql, q.params);
|
|
|
|
return rows.map((r) => r.id);
|
|
|
|
}
|
|
|
|
|
2017-07-03 20:58:01 +02:00
|
|
|
static async all(options = null) {
|
2017-06-25 11:00:54 +02:00
|
|
|
let q = this.applySqlOptions(options, 'SELECT * FROM `' + this.tableName() + '`');
|
2017-06-25 17:17:40 +02:00
|
|
|
return this.modelSelectAll(q.sql);
|
2017-06-25 11:00:54 +02:00
|
|
|
}
|
|
|
|
|
2017-07-03 20:58:01 +02:00
|
|
|
static async search(options = null) {
|
|
|
|
if (!options) options = {};
|
|
|
|
if (!options.fields) options.fields = '*';
|
|
|
|
|
|
|
|
let conditions = options.conditions ? options.conditions.slice(0) : [];
|
|
|
|
let params = options.conditionsParams ? options.conditionsParams.slice(0) : [];
|
|
|
|
|
|
|
|
if (options.titlePattern) {
|
|
|
|
let pattern = options.titlePattern.replace(/\*/g, '%');
|
|
|
|
conditions.push('title LIKE ?');
|
|
|
|
params.push(pattern);
|
|
|
|
}
|
|
|
|
|
2017-08-20 10:16:31 +02:00
|
|
|
if ('limit' in options && options.limit <= 0) return [];
|
|
|
|
|
2017-07-03 20:58:01 +02:00
|
|
|
let sql = 'SELECT ' + this.db().escapeFields(options.fields) + ' FROM `' + this.tableName() + '`';
|
|
|
|
if (conditions.length) sql += ' WHERE ' + conditions.join(' AND ');
|
|
|
|
|
|
|
|
let query = this.applySqlOptions(options, sql, params);
|
|
|
|
return this.modelSelectAll(query.sql, query.params);
|
|
|
|
}
|
|
|
|
|
2017-06-17 20:12:09 +02:00
|
|
|
static modelSelectOne(sql, params = null) {
|
|
|
|
if (params === null) params = [];
|
2017-06-17 20:40:08 +02:00
|
|
|
return this.db().selectOne(sql, params).then((model) => {
|
2017-06-24 19:40:03 +02:00
|
|
|
return this.filter(this.addModelMd(model));
|
2017-06-17 20:40:08 +02:00
|
|
|
});
|
2017-06-17 20:12:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static modelSelectAll(sql, params = null) {
|
|
|
|
if (params === null) params = [];
|
2017-06-17 20:40:08 +02:00
|
|
|
return this.db().selectAll(sql, params).then((models) => {
|
2017-06-24 19:40:03 +02:00
|
|
|
return this.filterArray(this.addModelMd(models));
|
2017-06-17 20:40:08 +02:00
|
|
|
});
|
2017-06-17 20:12:09 +02:00
|
|
|
}
|
|
|
|
|
2017-06-25 13:39:42 +02:00
|
|
|
static loadByField(fieldName, fieldValue) {
|
2017-06-24 19:40:03 +02:00
|
|
|
return this.modelSelectOne('SELECT * FROM `' + this.tableName() + '` WHERE `' + fieldName + '` = ?', [fieldValue]);
|
2017-05-19 21:12:09 +02:00
|
|
|
}
|
|
|
|
|
2017-07-02 17:46:03 +02:00
|
|
|
static loadByTitle(fieldValue) {
|
|
|
|
return this.modelSelectOne('SELECT * FROM `' + this.tableName() + '` WHERE `title` = ?', [fieldValue]);
|
|
|
|
}
|
|
|
|
|
2017-05-23 22:36:19 +02:00
|
|
|
static diffObjects(oldModel, newModel) {
|
|
|
|
let output = {};
|
2017-06-21 00:16:41 +02:00
|
|
|
let type = null;
|
2017-05-23 22:36:19 +02:00
|
|
|
for (let n in newModel) {
|
2017-12-04 01:06:02 +02:00
|
|
|
if (!newModel.hasOwnProperty(n)) continue;
|
2017-06-21 00:16:41 +02:00
|
|
|
if (n == 'type_') {
|
2017-12-04 01:06:02 +02:00
|
|
|
type = newModel[n];
|
2017-06-21 00:16:41 +02:00
|
|
|
continue;
|
|
|
|
}
|
2017-05-23 22:36:19 +02:00
|
|
|
if (!(n in oldModel) || newModel[n] !== oldModel[n]) {
|
|
|
|
output[n] = newModel[n];
|
|
|
|
}
|
|
|
|
}
|
2017-06-21 00:16:41 +02:00
|
|
|
if (type !== null) output.type_ = type;
|
2017-05-23 22:36:19 +02:00
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2017-12-04 01:06:02 +02:00
|
|
|
static modelsAreSame(oldModel, newModel) {
|
|
|
|
const diff = this.diffObjects(oldModel, newModel);
|
|
|
|
delete diff.type_;
|
|
|
|
return !Object.getOwnPropertyNames(diff).length;
|
|
|
|
}
|
|
|
|
|
2017-06-18 01:49:52 +02:00
|
|
|
static saveQuery(o, options) {
|
2017-05-20 00:16:50 +02:00
|
|
|
let temp = {}
|
|
|
|
let fieldNames = this.fieldNames();
|
|
|
|
for (let i = 0; i < fieldNames.length; i++) {
|
|
|
|
let n = fieldNames[i];
|
|
|
|
if (n in o) temp[n] = o[n];
|
|
|
|
}
|
|
|
|
o = temp;
|
|
|
|
|
2017-06-18 01:49:52 +02:00
|
|
|
let query = {};
|
2017-06-25 01:19:11 +02:00
|
|
|
let modelId = o.id;
|
2017-05-12 21:54:06 +02:00
|
|
|
|
2017-08-20 22:11:32 +02:00
|
|
|
const timeNow = time.unixMs();
|
|
|
|
|
2017-06-18 01:49:52 +02:00
|
|
|
if (options.autoTimestamp && this.hasField('updated_time')) {
|
2017-08-20 22:11:32 +02:00
|
|
|
o.updated_time = timeNow;
|
|
|
|
}
|
|
|
|
|
2017-12-05 00:58:42 +02:00
|
|
|
// The purpose of user_updated_time is to allow the user to manually set the time of a note (in which case
|
|
|
|
// options.autoTimestamp will be `false`). However note that if the item is later changed, this timestamp
|
|
|
|
// will be set again to the current time.
|
2017-08-20 22:11:32 +02:00
|
|
|
if (options.autoTimestamp && this.hasField('user_updated_time')) {
|
|
|
|
o.user_updated_time = timeNow;
|
2017-05-19 21:32:49 +02:00
|
|
|
}
|
|
|
|
|
2017-06-18 01:49:52 +02:00
|
|
|
if (options.isNew) {
|
2017-05-19 21:12:09 +02:00
|
|
|
if (this.useUuid() && !o.id) {
|
2017-06-25 01:19:11 +02:00
|
|
|
modelId = uuid.create();
|
|
|
|
o.id = modelId;
|
2017-05-18 21:58:01 +02:00
|
|
|
}
|
2017-05-19 21:32:49 +02:00
|
|
|
|
|
|
|
if (!o.created_time && this.hasField('created_time')) {
|
2017-08-20 22:11:32 +02:00
|
|
|
o.created_time = timeNow;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!o.user_created_time && this.hasField('user_created_time')) {
|
2017-10-22 19:12:16 +02:00
|
|
|
o.user_created_time = o.created_time ? o.created_time : timeNow;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!o.user_updated_time && this.hasField('user_updated_time')) {
|
|
|
|
o.user_updated_time = o.updated_time ? o.updated_time : timeNow;
|
2017-05-19 21:32:49 +02:00
|
|
|
}
|
|
|
|
|
2017-05-12 21:54:06 +02:00
|
|
|
query = Database.insertQuery(this.tableName(), o);
|
2017-05-11 22:14:01 +02:00
|
|
|
} else {
|
2017-05-12 21:54:06 +02:00
|
|
|
let where = { id: o.id };
|
|
|
|
let temp = Object.assign({}, o);
|
|
|
|
delete temp.id;
|
|
|
|
query = Database.updateQuery(this.tableName(), temp, where);
|
2017-05-11 22:14:01 +02:00
|
|
|
}
|
2017-05-12 21:54:06 +02:00
|
|
|
|
2017-06-25 01:19:11 +02:00
|
|
|
query.id = modelId;
|
2017-07-16 18:06:05 +02:00
|
|
|
query.modObject = o;
|
2017-05-18 21:58:01 +02:00
|
|
|
|
|
|
|
return query;
|
|
|
|
}
|
|
|
|
|
2017-05-18 22:31:40 +02:00
|
|
|
static save(o, options = null) {
|
|
|
|
options = this.modOptions(options);
|
2017-06-29 22:52:52 +02:00
|
|
|
options.isNew = this.isNew(o, options);
|
2017-05-18 21:58:01 +02:00
|
|
|
|
2017-12-05 00:58:42 +02:00
|
|
|
// Diff saving is an optimisation which takes a new version of the item and an old one,
|
|
|
|
// do a diff and save only this diff. IMPORTANT: When using this make sure that both
|
|
|
|
// models have been normalised using ItemClass.filter()
|
|
|
|
const isDiffSaving = options && options.oldItem && !options.isNew;
|
|
|
|
|
|
|
|
if (isDiffSaving) {
|
|
|
|
const newObject = BaseModel.diffObjects(options.oldItem, o);
|
|
|
|
newObject.type_ = o.type_;
|
|
|
|
newObject.id = o.id;
|
|
|
|
o = newObject;
|
|
|
|
}
|
|
|
|
|
2017-06-24 19:40:03 +02:00
|
|
|
o = this.filter(o);
|
|
|
|
|
2017-06-11 23:11:14 +02:00
|
|
|
let queries = [];
|
2017-06-18 01:49:52 +02:00
|
|
|
let saveQuery = this.saveQuery(o, options);
|
2017-06-25 01:19:11 +02:00
|
|
|
let modelId = saveQuery.id;
|
2017-05-18 21:58:01 +02:00
|
|
|
|
2017-06-11 23:11:14 +02:00
|
|
|
queries.push(saveQuery);
|
|
|
|
|
2017-07-16 14:53:59 +02:00
|
|
|
if (options.nextQueries && options.nextQueries.length) {
|
|
|
|
queries = queries.concat(options.nextQueries);
|
|
|
|
}
|
|
|
|
|
2017-06-11 23:11:14 +02:00
|
|
|
return this.db().transactionExecBatch(queries).then(() => {
|
2017-05-18 21:58:01 +02:00
|
|
|
o = Object.assign({}, o);
|
2017-11-28 00:50:46 +02:00
|
|
|
if (modelId) o.id = modelId;
|
2017-07-16 18:06:05 +02:00
|
|
|
if ('updated_time' in saveQuery.modObject) o.updated_time = saveQuery.modObject.updated_time;
|
|
|
|
if ('created_time' in saveQuery.modObject) o.created_time = saveQuery.modObject.created_time;
|
2017-08-20 22:11:32 +02:00
|
|
|
if ('user_updated_time' in saveQuery.modObject) o.user_updated_time = saveQuery.modObject.user_updated_time;
|
|
|
|
if ('user_created_time' in saveQuery.modObject) o.user_created_time = saveQuery.modObject.user_created_time;
|
2017-06-17 20:40:08 +02:00
|
|
|
o = this.addModelMd(o);
|
2017-12-05 00:58:42 +02:00
|
|
|
|
|
|
|
if (isDiffSaving) {
|
|
|
|
for (let n in options.oldItem) {
|
|
|
|
if (!options.oldItem.hasOwnProperty(n)) continue;
|
|
|
|
if (n in o) continue;
|
|
|
|
o[n] = options.oldItem[n];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-24 19:40:03 +02:00
|
|
|
return this.filter(o);
|
2017-05-21 21:55:01 +02:00
|
|
|
}).catch((error) => {
|
|
|
|
Log.error('Cannot save model', error);
|
2017-05-18 21:58:01 +02:00
|
|
|
});
|
2017-05-10 21:51:43 +02:00
|
|
|
}
|
|
|
|
|
2017-06-29 22:52:52 +02:00
|
|
|
static isNew(object, options) {
|
|
|
|
if (options && ('isNew' in options)) {
|
|
|
|
// options.isNew can be "auto" too
|
|
|
|
if (options.isNew === true) return true;
|
|
|
|
if (options.isNew === false) return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !object.id;
|
|
|
|
}
|
|
|
|
|
2017-06-24 19:40:03 +02:00
|
|
|
static filterArray(models) {
|
|
|
|
let output = [];
|
|
|
|
for (let i = 0; i < models.length; i++) {
|
|
|
|
output.push(this.filter(models[i]));
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
|
|
|
static filter(model) {
|
2017-06-27 01:20:01 +02:00
|
|
|
if (!model) return model;
|
|
|
|
|
|
|
|
let output = Object.assign({}, model);
|
|
|
|
for (let n in output) {
|
|
|
|
if (!output.hasOwnProperty(n)) continue;
|
2017-12-05 00:58:42 +02:00
|
|
|
|
2017-06-27 01:20:01 +02:00
|
|
|
// The SQLite database doesn't have booleans so cast everything to int
|
2017-12-05 00:58:42 +02:00
|
|
|
if (output[n] === true) {
|
|
|
|
output[n] = 1;
|
|
|
|
} else if (output[n] === false) {
|
|
|
|
output[n] = 0;
|
|
|
|
} else {
|
|
|
|
const t = this.fieldType(n, Database.TYPE_UNKNOWN);
|
|
|
|
if (t === Database.TYPE_INT) {
|
|
|
|
output[n] = !n ? 0 : parseInt(output[n], 10);
|
|
|
|
}
|
|
|
|
}
|
2017-06-27 01:20:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return output;
|
2017-06-24 19:40:03 +02:00
|
|
|
}
|
|
|
|
|
2017-05-18 22:31:40 +02:00
|
|
|
static delete(id, options = null) {
|
2017-06-25 09:52:25 +02:00
|
|
|
if (!id) throw new Error('Cannot delete object without an ID');
|
2017-11-28 02:22:38 +02:00
|
|
|
options = this.modOptions(options);
|
2017-07-03 21:50:45 +02:00
|
|
|
return this.db().exec('DELETE FROM ' + this.tableName() + ' WHERE id = ?', [id]);
|
2017-05-16 22:25:19 +02:00
|
|
|
}
|
|
|
|
|
2017-07-11 20:17:23 +02:00
|
|
|
static batchDelete(ids, options = null) {
|
2017-11-28 02:22:38 +02:00
|
|
|
if (!ids.length) return;
|
2017-07-11 20:17:23 +02:00
|
|
|
options = this.modOptions(options);
|
|
|
|
return this.db().exec('DELETE FROM ' + this.tableName() + ' WHERE id IN ("' + ids.join('","') + '")');
|
|
|
|
}
|
|
|
|
|
2017-05-10 21:51:43 +02:00
|
|
|
static db() {
|
2017-05-20 00:16:50 +02:00
|
|
|
if (!this.db_) throw new Error('Accessing database before it has been initialised');
|
|
|
|
return this.db_;
|
2017-05-10 21:51:43 +02:00
|
|
|
}
|
|
|
|
|
2017-07-25 20:36:52 +02:00
|
|
|
static isReady() {
|
|
|
|
return !!this.db_;
|
|
|
|
}
|
|
|
|
|
2017-05-08 00:20:34 +02:00
|
|
|
}
|
|
|
|
|
2017-07-03 21:50:45 +02:00
|
|
|
BaseModel.TYPE_NOTE = 1;
|
|
|
|
BaseModel.TYPE_FOLDER = 2;
|
|
|
|
BaseModel.TYPE_SETTING = 3;
|
|
|
|
BaseModel.TYPE_RESOURCE = 4;
|
|
|
|
BaseModel.TYPE_TAG = 5;
|
2017-07-03 22:38:26 +02:00
|
|
|
BaseModel.TYPE_NOTE_TAG = 6;
|
2017-10-23 22:34:04 +02:00
|
|
|
BaseModel.TYPE_SEARCH = 7;
|
2017-11-28 00:50:46 +02:00
|
|
|
BaseModel.TYPE_ALARM = 8;
|
2017-12-12 23:58:57 +02:00
|
|
|
BaseModel.TYPE_MASTER_KEY = 9;
|
2017-07-03 22:38:26 +02:00
|
|
|
|
2017-06-06 22:01:43 +02:00
|
|
|
BaseModel.db_ = null;
|
2017-06-11 23:11:14 +02:00
|
|
|
BaseModel.dispatch = function(o) {};
|
2017-06-06 22:01:43 +02:00
|
|
|
|
2017-11-03 02:13:17 +02:00
|
|
|
module.exports = { BaseModel };
|