@resolveio/server-lib 1.0.10 → 1.0.11-nr

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/managers/method.manager.js +1 -1
  2. package/methods/collections.d.ts +1 -1
  3. package/methods/collections.js +667 -672
  4. package/models/user.model.d.ts +22 -6
  5. package/package.json +1 -1
package/methods/collections.js CHANGED
@@ -7,737 +7,732 @@ var pagination_model_1 = require("../models/pagination.model");
7
7
  var log_collection_1 = require("../collections/log.collection");
8
8
  var index_1 = require("../index");
9
9
  function loadCollectionMethods(methodManager) {
10
- var int = setInterval(function () {
11
- if (index_1.ResolveIOServer && index_1.ResolveIOServer.getMainServer() && index_1.ResolveIOServer.getMainServer().getMethodManager()) {
12
- clearInterval(int);
13
- index_1.ResolveIOServer.getMainServer().getMethodManager().methods({
14
- // Query database for any collection and query
15
- findOne: {
16
- skipQueue: true,
17
- check: new simpl_schema_1.default({
18
- collection: {
19
- type: String
20
- },
21
- query: {
22
- type: Object,
23
- blackbox: true
24
- }
25
- }),
26
- function: function (collection, query) {
27
- return index_1.ResolveIOServer.getMainDB().model(collection).findOne(query).exec();
28
- }
10
+ methodManager.methods({
11
+ // Query database for any collection and query
12
+ findOne: {
13
+ skipQueue: true,
14
+ check: new simpl_schema_1.default({
15
+ collection: {
16
+ type: String
29
17
  },
30
- find: {
31
- skipQueue: true,
32
- check: new simpl_schema_1.default({
33
- collection: {
34
- type: String
35
- },
36
- query: {
37
- type: Object,
38
- blackbox: true
39
- },
40
- sort: {
41
- type: Object,
42
- blackbox: true,
43
- optional: true
44
- }
45
- }),
46
- function: function (collection, query, sortQuery) {
47
- if (sortQuery === void 0) { sortQuery = {}; }
48
- return index_1.ResolveIOServer.getMainDB().model(collection).find(query).sort(sortQuery).exec();
49
- }
18
+ query: {
19
+ type: Object,
20
+ blackbox: true
21
+ }
22
+ }),
23
+ function: function (collection, query) {
24
+ return index_1.ResolveIOServer.getMainDB().model(collection).findOne(query).exec();
25
+ }
26
+ },
27
+ find: {
28
+ skipQueue: true,
29
+ check: new simpl_schema_1.default({
30
+ collection: {
31
+ type: String
32
+ },
33
+ query: {
34
+ type: Object,
35
+ blackbox: true
50
36
  },
51
- findWithOptions: {
52
- skipQueue: true,
53
- check: new simpl_schema_1.default({
54
- collection: {
55
- type: String
56
- },
57
- query: {
58
- type: Object,
59
- blackbox: true
60
- },
61
- options: {
62
- type: pagination_model_1.PaginationOptionsSchema
37
+ sort: {
38
+ type: Object,
39
+ blackbox: true,
40
+ optional: true
41
+ }
42
+ }),
43
+ function: function (collection, query, sortQuery) {
44
+ if (sortQuery === void 0) { sortQuery = {}; }
45
+ return index_1.ResolveIOServer.getMainDB().model(collection).find(query).sort(sortQuery).exec();
46
+ }
47
+ },
48
+ findWithOptions: {
49
+ skipQueue: true,
50
+ check: new simpl_schema_1.default({
51
+ collection: {
52
+ type: String
53
+ },
54
+ query: {
55
+ type: Object,
56
+ blackbox: true
57
+ },
58
+ options: {
59
+ type: pagination_model_1.PaginationOptionsSchema
60
+ }
61
+ }),
62
+ function: function (collection, query, options) {
63
+ return index_1.ResolveIOServer.getMainDB().model(collection).find(query).sort(options.sort).limit(options.limit).skip(options.skip).select(options.fields).exec();
64
+ }
65
+ },
66
+ // Insert 1 document
67
+ // @Inputs: collection, document
68
+ // @Outputs: res = _id of new document, err = not inserted
69
+ insertDocument: {
70
+ check: new simpl_schema_1.default({
71
+ collection: {
72
+ type: String
73
+ },
74
+ document: {
75
+ type: Object,
76
+ blackbox: true
77
+ }
78
+ }),
79
+ function: function (collection, document) {
80
+ var _this = this;
81
+ return new Promise(function (resolve, reject) {
82
+ var schemaErrors = null;
83
+ try {
84
+ index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(document);
85
+ }
86
+ catch (errors) {
87
+ schemaErrors = errors;
88
+ _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on insert - ' + collection, [schemaErrors, document]);
89
+ }
90
+ if (schemaErrors) {
91
+ console.log(schemaErrors);
92
+ reject('Schema Errors');
93
+ }
94
+ else {
95
+ if (common_1.getBinarySize(JSON.stringify(document)) < 200000) {
96
+ log_collection_1.Logs.create({
97
+ _id: mongoose_1.Types.ObjectId().toHexString(),
98
+ date: new Date(),
99
+ type: 'info',
100
+ title: 'Insert Document',
101
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
102
+ payload: document,
103
+ method: 'insertDocument',
104
+ user: _this.user,
105
+ messageId: ''
106
+ });
63
107
  }
64
- }),
65
- function: function (collection, query, options) {
66
- return index_1.ResolveIOServer.getMainDB().model(collection).find(query).sort(options.sort).limit(options.limit).skip(options.skip).select(options.fields).exec();
108
+ else {
109
+ log_collection_1.Logs.create({
110
+ _id: mongoose_1.Types.ObjectId().toHexString(),
111
+ date: new Date(),
112
+ type: 'info',
113
+ title: 'Insert Document',
114
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
115
+ payload: 'Too Big',
116
+ method: 'insertDocument',
117
+ user: _this.user,
118
+ messageId: ''
119
+ });
120
+ }
121
+ var id_1 = mongoose_1.Types.ObjectId().toHexString();
122
+ document['_id'] = id_1;
123
+ document['__v'] = 0;
124
+ index_1.ResolveIOServer.getMainDB().model(collection).create(document).then(function () { return resolve(id_1); }, function (err) { return reject(err); });
67
125
  }
126
+ });
127
+ }
128
+ },
129
+ // Replaces 1 document with new document (from _id)
130
+ // @Inputs: collection, document id
131
+ // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
132
+ // Search for doc, check version, if found then try and update
133
+ updateDocument: {
134
+ check: new simpl_schema_1.default({
135
+ collection: {
136
+ type: String
68
137
  },
69
- // Insert 1 document
70
- // @Inputs: collection, document
71
- // @Outputs: res = _id of new document, err = not inserted
72
- insertDocument: {
73
- check: new simpl_schema_1.default({
74
- collection: {
75
- type: String
76
- },
77
- document: {
78
- type: Object,
79
- blackbox: true
80
- }
81
- }),
82
- function: function (collection, document) {
83
- var _this = this;
84
- return new Promise(function (resolve, reject) {
85
- var schemaErrors = null;
86
- try {
87
- index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(document);
88
- }
89
- catch (errors) {
90
- schemaErrors = errors;
91
- _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on insert - ' + collection, [schemaErrors, document]);
92
- }
93
- if (schemaErrors) {
94
- console.log(schemaErrors);
95
- reject('Schema Errors');
96
- }
97
- else {
98
- if (common_1.getBinarySize(JSON.stringify(document)) < 200000) {
99
- log_collection_1.Logs.create({
100
- _id: mongoose_1.Types.ObjectId().toHexString(),
101
- date: new Date(),
102
- type: 'info',
103
- title: 'Insert Document',
104
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
105
- payload: document,
106
- method: 'insertDocument',
107
- user: _this.user,
108
- messageId: ''
109
- });
138
+ f_document: {
139
+ type: Object,
140
+ blackbox: true
141
+ }
142
+ }),
143
+ function: function (collection, f_document) {
144
+ var _this = this;
145
+ return new Promise(function (resolve, reject) {
146
+ index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: f_document['_id'] }).lean().exec(function (errDoc, currDoc) {
147
+ if (currDoc) {
148
+ if (currDoc.__v === f_document['__v']) {
149
+ var versionDoc = common_1.deepCopy(currDoc);
150
+ versionDoc._id = {
151
+ _id: currDoc._id,
152
+ __v: currDoc.__v
153
+ };
154
+ var schemaErrors = null;
155
+ try {
156
+ index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(f_document);
110
157
  }
111
- else {
112
- log_collection_1.Logs.create({
113
- _id: mongoose_1.Types.ObjectId().toHexString(),
114
- date: new Date(),
115
- type: 'info',
116
- title: 'Insert Document',
117
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
118
- payload: 'Too Big',
119
- method: 'insertDocument',
120
- user: _this.user,
121
- messageId: ''
122
- });
158
+ catch (errors) {
159
+ schemaErrors = errors;
160
+ _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
123
161
  }
124
- var id_1 = mongoose_1.Types.ObjectId().toHexString();
125
- document['_id'] = id_1;
126
- document['__v'] = 0;
127
- index_1.ResolveIOServer.getMainDB().model(collection).create(document).then(function () { return resolve(id_1); }, function (err) { return reject(err); });
128
- }
129
- });
130
- }
131
- },
132
- // Replaces 1 document with new document (from _id)
133
- // @Inputs: collection, document id
134
- // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
135
- // Search for doc, check version, if found then try and update
136
- updateDocument: {
137
- check: new simpl_schema_1.default({
138
- collection: {
139
- type: String
140
- },
141
- f_document: {
142
- type: Object,
143
- blackbox: true
144
- }
145
- }),
146
- function: function (collection, f_document) {
147
- var _this = this;
148
- return new Promise(function (resolve, reject) {
149
- index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: f_document['_id'] }).lean().exec(function (errDoc, currDoc) {
150
- if (currDoc) {
151
- if (currDoc.__v === f_document['__v']) {
152
- var versionDoc = common_1.deepCopy(currDoc);
153
- versionDoc._id = {
154
- _id: currDoc._id,
155
- __v: currDoc.__v
156
- };
157
- var schemaErrors = null;
158
- try {
159
- index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(f_document);
160
- }
161
- catch (errors) {
162
- schemaErrors = errors;
163
- _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
164
- }
165
- if (schemaErrors) {
166
- console.log(schemaErrors);
167
- reject('Schema Errors');
168
- }
169
- else {
170
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
171
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
172
- $and: [
173
- { '_id._id': currDoc._id },
174
- { '_id.__v': { $lte: currDoc.__v - 4 } }
175
- ]
176
- }).exec();
177
- }, function (err) {
178
- console.log(err);
179
- });
180
- var updates = common_1.getMongoUpdates(currDoc, f_document, true);
181
- if (updates) {
182
- index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: f_document['_id'] }, updates, { strict: false }).exec().then(function (res) {
183
- resolve(res.nModified);
184
- }, function (err) { return reject(err); });
185
- }
186
- else {
187
- resolve(1);
188
- }
189
- if (common_1.getBinarySize(JSON.stringify(f_document)) < 200000) {
190
- log_collection_1.Logs.create({
191
- _id: mongoose_1.Types.ObjectId().toHexString(),
192
- date: new Date(),
193
- type: 'info',
194
- title: 'Update Document',
195
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
196
- payload: f_document,
197
- method: 'updateDocument',
198
- user: _this.user,
199
- messageId: ''
200
- });
201
- }
202
- else {
203
- log_collection_1.Logs.create({
204
- _id: mongoose_1.Types.ObjectId().toHexString(),
205
- date: new Date(),
206
- type: 'info',
207
- title: 'Update Document',
208
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
209
- payload: 'Too Big',
210
- method: 'updateDocument',
211
- user: _this.user,
212
- messageId: ''
213
- });
214
- }
215
- }
216
- }
217
- else {
218
- console.log('invalid version - ' + collection, currDoc.__v, f_document['__v']);
219
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).findOne({
162
+ if (schemaErrors) {
163
+ console.log(schemaErrors);
164
+ reject('Schema Errors');
165
+ }
166
+ else {
167
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
168
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
220
169
  $and: [
221
170
  { '_id._id': currDoc._id },
222
- { '_id.__v': f_document['__v'] }
171
+ { '_id.__v': { $lte: currDoc.__v - 4 } }
223
172
  ]
224
- }).lean().exec(function (errOldDoc, oldDoc) {
225
- var newCurrDocId = currDoc._id;
226
- if (oldDoc) {
227
- var versionDoc_1 = common_1.deepCopy(currDoc);
228
- versionDoc_1._id = {
229
- _id: currDoc._id,
230
- __v: currDoc.__v
231
- };
232
- var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, oldDoc);
233
- updatedDoc._id = newCurrDocId;
234
- updatedDoc.__v++;
235
- index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
236
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_1).then(function (doc) {
237
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
238
- $and: [
239
- { '_id._id': versionDoc_1._id._id },
240
- { '_id.__v': { $lte: versionDoc_1._id.__v - 4 } }
241
- ]
242
- }).exec();
243
- resolve(res.nModified);
244
- });
245
- }, function (err) { return reject(err); });
246
- }
247
- else {
248
- reject('Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
249
- }
173
+ }).exec();
174
+ }, function (err) {
175
+ console.log(err);
176
+ });
177
+ var updates = common_1.getMongoUpdates(currDoc, f_document, true);
178
+ if (updates) {
179
+ index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: f_document['_id'] }, updates, { strict: false }).exec().then(function (res) {
180
+ resolve(res.nModified);
181
+ }, function (err) { return reject(err); });
182
+ }
183
+ else {
184
+ resolve(1);
185
+ }
186
+ if (common_1.getBinarySize(JSON.stringify(f_document)) < 200000) {
187
+ log_collection_1.Logs.create({
188
+ _id: mongoose_1.Types.ObjectId().toHexString(),
189
+ date: new Date(),
190
+ type: 'info',
191
+ title: 'Update Document',
192
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
193
+ payload: f_document,
194
+ method: 'updateDocument',
195
+ user: _this.user,
196
+ messageId: ''
197
+ });
198
+ }
199
+ else {
200
+ log_collection_1.Logs.create({
201
+ _id: mongoose_1.Types.ObjectId().toHexString(),
202
+ date: new Date(),
203
+ type: 'info',
204
+ title: 'Update Document',
205
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
206
+ payload: 'Too Big',
207
+ method: 'updateDocument',
208
+ user: _this.user,
209
+ messageId: ''
250
210
  });
251
211
  }
252
212
  }
253
- else {
254
- reject(errDoc);
255
- }
256
- });
257
- });
258
- }
259
- },
260
- // Updates 1 document's props (from _id)
261
- // @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
262
- // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
263
- // Search for doc, check version, if found then try and update props
264
- updateDocumentProps: {
265
- check: new simpl_schema_1.default({
266
- collection: {
267
- type: String
268
- },
269
- doc_id: {
270
- type: String
271
- },
272
- updateParams: {
273
- type: Array
274
- },
275
- 'updateParams.$': {
276
- type: Object,
277
- blackbox: true
278
- },
279
- doc__v: {
280
- type: Number
281
- }
282
- }),
283
- function: function (collection, doc_id, updateParams, doc__v) {
284
- var _this = this;
285
- return new Promise(function (resolve, reject) {
286
- index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: doc_id }).lean().exec(function (errDoc, currDoc) {
287
- if (currDoc) {
288
- var modifiedDoc_1 = common_1.deepCopy(currDoc);
289
- updateParams.forEach(function (data) {
290
- modifiedDoc_1[data.prop] = data.data;
291
- });
292
- if (modifiedDoc_1.__v === doc__v) {
293
- var versionDoc = common_1.deepCopy(currDoc);
294
- versionDoc._id = {
213
+ }
214
+ else {
215
+ console.log('invalid version - ' + collection, currDoc.__v, f_document['__v']);
216
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).findOne({
217
+ $and: [
218
+ { '_id._id': currDoc._id },
219
+ { '_id.__v': f_document['__v'] }
220
+ ]
221
+ }).lean().exec(function (errOldDoc, oldDoc) {
222
+ var newCurrDocId = currDoc._id;
223
+ if (oldDoc) {
224
+ var versionDoc_1 = common_1.deepCopy(currDoc);
225
+ versionDoc_1._id = {
295
226
  _id: currDoc._id,
296
227
  __v: currDoc.__v
297
228
  };
298
- var schemaErrors = null;
299
- try {
300
- index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(modifiedDoc_1);
301
- }
302
- catch (errors) {
303
- schemaErrors = errors;
304
- _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_1]);
305
- }
306
- if (schemaErrors) {
307
- console.log(schemaErrors);
308
- reject('Schema Errors');
309
- }
310
- else {
311
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
229
+ var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, oldDoc);
230
+ updatedDoc._id = newCurrDocId;
231
+ updatedDoc.__v++;
232
+ index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
233
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_1).then(function (doc) {
312
234
  index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
313
235
  $and: [
314
- { '_id._id': currDoc._id },
315
- { '_id.__v': { $lte: currDoc.__v - 4 } }
236
+ { '_id._id': versionDoc_1._id._id },
237
+ { '_id.__v': { $lte: versionDoc_1._id.__v - 4 } }
316
238
  ]
317
239
  }).exec();
318
- }, function (err) {
319
- console.log(err);
240
+ resolve(res.nModified);
320
241
  });
321
- var updates = common_1.getMongoUpdates(currDoc, modifiedDoc_1, true);
322
- if (updates) {
323
- index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: modifiedDoc_1._id }, updates, { strict: false }).exec().then(function (res) {
324
- resolve(res.ok);
325
- }, function (err) { return reject(err); });
326
- }
327
- else {
328
- resolve(1);
329
- }
330
- if (common_1.getBinarySize(JSON.stringify(updateParams)) < 200000) {
331
- log_collection_1.Logs.create({
332
- _id: mongoose_1.Types.ObjectId().toHexString(),
333
- date: new Date(),
334
- type: 'info',
335
- title: 'Update Document Props',
336
- message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
337
- payload: updateParams,
338
- method: 'updateDocumentProps',
339
- user: _this.user,
340
- messageId: ''
341
- });
342
- }
343
- else {
344
- log_collection_1.Logs.create({
345
- _id: mongoose_1.Types.ObjectId().toHexString(),
346
- date: new Date(),
347
- type: 'info',
348
- title: 'Update Document Props',
349
- message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
350
- payload: 'Too Big',
351
- method: 'updateDocumentProps',
352
- user: _this.user,
353
- messageId: ''
354
- });
355
- }
356
- }
242
+ }, function (err) { return reject(err); });
357
243
  }
358
244
  else {
359
- console.log('invalid version - ' + collection, currDoc.__v, doc__v);
360
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).findOne({
245
+ reject('Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
246
+ }
247
+ });
248
+ }
249
+ }
250
+ else {
251
+ reject(errDoc);
252
+ }
253
+ });
254
+ });
255
+ }
256
+ },
257
+ // Updates 1 document's props (from _id)
258
+ // @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
259
+ // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
260
+ // Search for doc, check version, if found then try and update props
261
+ updateDocumentProps: {
262
+ check: new simpl_schema_1.default({
263
+ collection: {
264
+ type: String
265
+ },
266
+ doc_id: {
267
+ type: String
268
+ },
269
+ updateParams: {
270
+ type: Array
271
+ },
272
+ 'updateParams.$': {
273
+ type: Object,
274
+ blackbox: true
275
+ },
276
+ doc__v: {
277
+ type: Number
278
+ }
279
+ }),
280
+ function: function (collection, doc_id, updateParams, doc__v) {
281
+ var _this = this;
282
+ return new Promise(function (resolve, reject) {
283
+ index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: doc_id }).lean().exec(function (errDoc, currDoc) {
284
+ if (currDoc) {
285
+ var modifiedDoc_1 = common_1.deepCopy(currDoc);
286
+ updateParams.forEach(function (data) {
287
+ modifiedDoc_1[data.prop] = data.data;
288
+ });
289
+ if (modifiedDoc_1.__v === doc__v) {
290
+ var versionDoc = common_1.deepCopy(currDoc);
291
+ versionDoc._id = {
292
+ _id: currDoc._id,
293
+ __v: currDoc.__v
294
+ };
295
+ var schemaErrors = null;
296
+ try {
297
+ index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(modifiedDoc_1);
298
+ }
299
+ catch (errors) {
300
+ schemaErrors = errors;
301
+ _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_1]);
302
+ }
303
+ if (schemaErrors) {
304
+ console.log(schemaErrors);
305
+ reject('Schema Errors');
306
+ }
307
+ else {
308
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
309
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
361
310
  $and: [
362
311
  { '_id._id': currDoc._id },
363
- { '_id.__v': doc__v }
312
+ { '_id.__v': { $lte: currDoc.__v - 4 } }
364
313
  ]
365
- }).lean().exec(function (errOldDoc, oldDoc) {
366
- var newCurrDocId = currDoc._id;
367
- if (oldDoc) {
368
- var versionDoc_2 = common_1.deepCopy(currDoc);
369
- versionDoc_2._id = {
370
- _id: currDoc._id,
371
- __v: currDoc.__v
372
- };
373
- var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_1, currDoc, oldDoc);
374
- updatedDoc._id = newCurrDocId;
375
- updatedDoc.__v++;
376
- index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
377
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_2).then(function (doc) {
378
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
379
- $and: [
380
- { '_id._id': versionDoc_2._id._id },
381
- { '_id.__v': { $lte: versionDoc_2._id.__v - 4 } }
382
- ]
383
- }).exec();
384
- }, function (err) {
385
- console.log(err);
386
- });
387
- resolve(res.nModified);
388
- }, function (err) { return reject(err); });
389
- }
390
- else {
391
- reject('Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc_1.__v);
392
- }
314
+ }).exec();
315
+ }, function (err) {
316
+ console.log(err);
317
+ });
318
+ var updates = common_1.getMongoUpdates(currDoc, modifiedDoc_1, true);
319
+ if (updates) {
320
+ index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: modifiedDoc_1._id }, updates, { strict: false }).exec().then(function (res) {
321
+ resolve(res.ok);
322
+ }, function (err) { return reject(err); });
323
+ }
324
+ else {
325
+ resolve(1);
326
+ }
327
+ if (common_1.getBinarySize(JSON.stringify(updateParams)) < 200000) {
328
+ log_collection_1.Logs.create({
329
+ _id: mongoose_1.Types.ObjectId().toHexString(),
330
+ date: new Date(),
331
+ type: 'info',
332
+ title: 'Update Document Props',
333
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
334
+ payload: updateParams,
335
+ method: 'updateDocumentProps',
336
+ user: _this.user,
337
+ messageId: ''
338
+ });
339
+ }
340
+ else {
341
+ log_collection_1.Logs.create({
342
+ _id: mongoose_1.Types.ObjectId().toHexString(),
343
+ date: new Date(),
344
+ type: 'info',
345
+ title: 'Update Document Props',
346
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
347
+ payload: 'Too Big',
348
+ method: 'updateDocumentProps',
349
+ user: _this.user,
350
+ messageId: ''
393
351
  });
394
352
  }
395
353
  }
396
- else {
397
- reject(errDoc);
398
- }
399
- });
400
- });
401
- }
402
- },
403
- updateDocumentOffline: {
404
- check: new simpl_schema_1.default({
405
- collection: {
406
- type: String
407
- },
408
- f_document: {
409
- type: Object,
410
- blackbox: true
411
- },
412
- f_oldDocument: {
413
- type: Object,
414
- blackbox: true
415
- }
416
- }),
417
- function: function (collection, f_document, f_oldDocument) {
418
- var _this = this;
419
- return new Promise(function (resolve, reject) {
420
- index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: f_document['_id'] }).lean().exec(function (errDoc, currDoc) {
421
- if (currDoc) {
422
- if (currDoc.__v === f_document['__v']) {
423
- var versionDoc = common_1.deepCopy(currDoc);
424
- versionDoc._id = {
354
+ }
355
+ else {
356
+ console.log('invalid version - ' + collection, currDoc.__v, doc__v);
357
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).findOne({
358
+ $and: [
359
+ { '_id._id': currDoc._id },
360
+ { '_id.__v': doc__v }
361
+ ]
362
+ }).lean().exec(function (errOldDoc, oldDoc) {
363
+ var newCurrDocId = currDoc._id;
364
+ if (oldDoc) {
365
+ var versionDoc_2 = common_1.deepCopy(currDoc);
366
+ versionDoc_2._id = {
425
367
  _id: currDoc._id,
426
368
  __v: currDoc.__v
427
369
  };
428
- var schemaErrors = null;
429
- try {
430
- index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(f_document);
431
- }
432
- catch (errors) {
433
- schemaErrors = errors;
434
- _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
435
- }
436
- if (schemaErrors) {
437
- console.log(schemaErrors);
438
- reject('Schema Errors');
439
- }
440
- else {
441
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
370
+ var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_1, currDoc, oldDoc);
371
+ updatedDoc._id = newCurrDocId;
372
+ updatedDoc.__v++;
373
+ index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
374
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_2).then(function (doc) {
442
375
  index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
443
376
  $and: [
444
- { '_id._id': currDoc._id },
445
- { '_id.__v': { $lte: currDoc.__v - 4 } }
377
+ { '_id._id': versionDoc_2._id._id },
378
+ { '_id.__v': { $lte: versionDoc_2._id.__v - 4 } }
446
379
  ]
447
380
  }).exec();
448
381
  }, function (err) {
449
382
  console.log(err);
450
383
  });
451
- var updates = common_1.getMongoUpdates(currDoc, f_document, true);
452
- if (updates) {
453
- index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: f_document['_id'] }, updates, { strict: false }).exec().then(function (res) {
454
- resolve(res.nModified);
455
- }, function (err) { return reject(err); });
456
- }
457
- else {
458
- resolve(1);
459
- }
460
- if (common_1.getBinarySize(JSON.stringify(f_document)) < 200000) {
461
- log_collection_1.Logs.create({
462
- _id: mongoose_1.Types.ObjectId().toHexString(),
463
- date: new Date(),
464
- type: 'info',
465
- title: 'Update Document',
466
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
467
- payload: f_document,
468
- method: 'updateDocumentOffline',
469
- user: _this.user,
470
- messageId: ''
471
- });
472
- }
473
- else {
474
- log_collection_1.Logs.create({
475
- _id: mongoose_1.Types.ObjectId().toHexString(),
476
- date: new Date(),
477
- type: 'info',
478
- title: 'Update Document',
479
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
480
- payload: 'Too Big',
481
- method: 'updateDocumentOffline',
482
- user: _this.user,
483
- messageId: ''
484
- });
485
- }
486
- }
384
+ resolve(res.nModified);
385
+ }, function (err) { return reject(err); });
487
386
  }
488
387
  else {
489
- console.log('invalid version - ' + collection, currDoc.__v, f_document['__v']);
490
- var newCurrDocId = currDoc._id;
491
- if (f_oldDocument) {
492
- var versionDoc_3 = common_1.deepCopy(currDoc);
493
- versionDoc_3._id = {
494
- _id: currDoc._id,
495
- __v: currDoc.__v
496
- };
497
- var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, f_oldDocument);
498
- updatedDoc._id = newCurrDocId;
499
- updatedDoc.__v++;
500
- index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
501
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_3).then(function (doc) {
502
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
503
- $and: [
504
- { '_id._id': versionDoc_3._id._id },
505
- { '_id.__v': { $lte: versionDoc_3._id.__v - 4 } }
506
- ]
507
- }).exec();
508
- }, function (err) {
509
- console.log(err);
510
- });
511
- resolve(res.nModified);
512
- }, function (err) { return reject(err); });
513
- }
514
- else {
515
- reject('OFFLINE - Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
516
- }
388
+ reject('Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc_1.__v);
517
389
  }
390
+ });
391
+ }
392
+ }
393
+ else {
394
+ reject(errDoc);
395
+ }
396
+ });
397
+ });
398
+ }
399
+ },
400
+ updateDocumentOffline: {
401
+ check: new simpl_schema_1.default({
402
+ collection: {
403
+ type: String
404
+ },
405
+ f_document: {
406
+ type: Object,
407
+ blackbox: true
408
+ },
409
+ f_oldDocument: {
410
+ type: Object,
411
+ blackbox: true
412
+ }
413
+ }),
414
+ function: function (collection, f_document, f_oldDocument) {
415
+ var _this = this;
416
+ return new Promise(function (resolve, reject) {
417
+ index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: f_document['_id'] }).lean().exec(function (errDoc, currDoc) {
418
+ if (currDoc) {
419
+ if (currDoc.__v === f_document['__v']) {
420
+ var versionDoc = common_1.deepCopy(currDoc);
421
+ versionDoc._id = {
422
+ _id: currDoc._id,
423
+ __v: currDoc.__v
424
+ };
425
+ var schemaErrors = null;
426
+ try {
427
+ index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(f_document);
518
428
  }
519
- else {
520
- reject(errDoc);
429
+ catch (errors) {
430
+ schemaErrors = errors;
431
+ _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
521
432
  }
522
- });
523
- });
524
- }
525
- },
526
- // Updates 1 document's props (from _id)
527
- // @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
528
- // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
529
- // Search for doc, check version, if found then try and update props
530
- updateDocumentPropsOffline: {
531
- check: new simpl_schema_1.default({
532
- collection: {
533
- type: String
534
- },
535
- doc_id: {
536
- type: String
537
- },
538
- updateParams: {
539
- type: Array
540
- },
541
- 'updateParams.$': {
542
- type: Object,
543
- blackbox: true
544
- },
545
- doc__v: {
546
- type: Number
547
- },
548
- f_oldDocument: {
549
- type: Object,
550
- blackbox: true
551
- }
552
- }),
553
- function: function (collection, doc_id, updateParams, doc__v, f_oldDocument) {
554
- var _this = this;
555
- return new Promise(function (resolve, reject) {
556
- index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: doc_id }).lean().exec(function (errDoc, currDoc) {
557
- if (currDoc) {
558
- var modifiedDoc_2 = common_1.deepCopy(currDoc);
559
- updateParams.forEach(function (data) {
560
- modifiedDoc_2[data.prop] = data.data;
433
+ if (schemaErrors) {
434
+ console.log(schemaErrors);
435
+ reject('Schema Errors');
436
+ }
437
+ else {
438
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
439
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
440
+ $and: [
441
+ { '_id._id': currDoc._id },
442
+ { '_id.__v': { $lte: currDoc.__v - 4 } }
443
+ ]
444
+ }).exec();
445
+ }, function (err) {
446
+ console.log(err);
561
447
  });
562
- if (modifiedDoc_2.__v === doc__v) {
563
- var versionDoc = common_1.deepCopy(currDoc);
564
- versionDoc._id = {
565
- _id: currDoc._id,
566
- __v: currDoc.__v
567
- };
568
- var schemaErrors = null;
569
- try {
570
- index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(modifiedDoc_2);
571
- }
572
- catch (errors) {
573
- schemaErrors = errors;
574
- _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_2]);
575
- }
576
- if (schemaErrors) {
577
- console.log(schemaErrors);
578
- reject('Schema Errors');
579
- }
580
- else {
581
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
582
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
583
- $and: [
584
- { '_id._id': currDoc._id },
585
- { '_id.__v': { $lte: currDoc.__v - 4 } }
586
- ]
587
- }).exec();
588
- }, function (err) {
589
- console.log(err);
590
- });
591
- var updates = common_1.getMongoUpdates(currDoc, modifiedDoc_2, true);
592
- if (updates) {
593
- index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: modifiedDoc_2._id }, updates, { strict: false }).exec().then(function (res) {
594
- resolve(res.ok);
595
- }, function (err) { return reject(err); });
596
- }
597
- else {
598
- resolve(1);
599
- }
600
- if (common_1.getBinarySize(JSON.stringify(updateParams)) < 200000) {
601
- log_collection_1.Logs.create({
602
- _id: mongoose_1.Types.ObjectId().toHexString(),
603
- date: new Date(),
604
- type: 'info',
605
- title: 'Update Document Props',
606
- message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
607
- payload: updateParams,
608
- method: 'updateDocumentPropsOffline',
609
- user: _this.user,
610
- messageId: ''
611
- });
612
- }
613
- else {
614
- log_collection_1.Logs.create({
615
- _id: mongoose_1.Types.ObjectId().toHexString(),
616
- date: new Date(),
617
- type: 'info',
618
- title: 'Update Document Props',
619
- message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
620
- payload: 'Too Big',
621
- method: 'updateDocumentPropsOffline',
622
- user: _this.user,
623
- messageId: ''
624
- });
625
- }
626
- }
448
+ var updates = common_1.getMongoUpdates(currDoc, f_document, true);
449
+ if (updates) {
450
+ index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: f_document['_id'] }, updates, { strict: false }).exec().then(function (res) {
451
+ resolve(res.nModified);
452
+ }, function (err) { return reject(err); });
627
453
  }
628
454
  else {
629
- console.log('invalid version - ' + collection, currDoc.__v, doc__v);
630
- var newCurrDocId = currDoc._id;
631
- if (f_oldDocument) {
632
- var versionDoc_4 = common_1.deepCopy(currDoc);
633
- versionDoc_4._id = {
634
- _id: currDoc._id,
635
- __v: currDoc.__v
636
- };
637
- var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_2, currDoc, f_oldDocument);
638
- updatedDoc._id = newCurrDocId;
639
- updatedDoc.__v++;
640
- index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
641
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_4).then(function (doc) {
642
- index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
643
- $and: [
644
- { '_id._id': versionDoc_4._id._id },
645
- { '_id.__v': { $lte: versionDoc_4._id.__v - 4 } }
646
- ]
647
- }).exec();
648
- }, function (err) {
649
- console.log(err);
650
- });
651
- resolve(res.nModified);
652
- }, function (err) { return reject(err); });
653
- }
654
- else {
655
- reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc_2.__v);
656
- }
455
+ resolve(1);
456
+ }
457
+ if (common_1.getBinarySize(JSON.stringify(f_document)) < 200000) {
458
+ log_collection_1.Logs.create({
459
+ _id: mongoose_1.Types.ObjectId().toHexString(),
460
+ date: new Date(),
461
+ type: 'info',
462
+ title: 'Update Document',
463
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
464
+ payload: f_document,
465
+ method: 'updateDocumentOffline',
466
+ user: _this.user,
467
+ messageId: ''
468
+ });
469
+ }
470
+ else {
471
+ log_collection_1.Logs.create({
472
+ _id: mongoose_1.Types.ObjectId().toHexString(),
473
+ date: new Date(),
474
+ type: 'info',
475
+ title: 'Update Document',
476
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
477
+ payload: 'Too Big',
478
+ method: 'updateDocumentOffline',
479
+ user: _this.user,
480
+ messageId: ''
481
+ });
657
482
  }
658
483
  }
484
+ }
485
+ else {
486
+ console.log('invalid version - ' + collection, currDoc.__v, f_document['__v']);
487
+ var newCurrDocId = currDoc._id;
488
+ if (f_oldDocument) {
489
+ var versionDoc_3 = common_1.deepCopy(currDoc);
490
+ versionDoc_3._id = {
491
+ _id: currDoc._id,
492
+ __v: currDoc.__v
493
+ };
494
+ var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, f_oldDocument);
495
+ updatedDoc._id = newCurrDocId;
496
+ updatedDoc.__v++;
497
+ index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
498
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_3).then(function (doc) {
499
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
500
+ $and: [
501
+ { '_id._id': versionDoc_3._id._id },
502
+ { '_id.__v': { $lte: versionDoc_3._id.__v - 4 } }
503
+ ]
504
+ }).exec();
505
+ }, function (err) {
506
+ console.log(err);
507
+ });
508
+ resolve(res.nModified);
509
+ }, function (err) { return reject(err); });
510
+ }
659
511
  else {
660
- reject(errDoc);
512
+ reject('OFFLINE - Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
661
513
  }
662
- });
663
- });
664
- }
665
- },
666
- // Removes 1 document (from _id)
667
- // @Inputs: collection, document id
668
- // @Outputs: res = 1 (deleted), res = 0 (not deleted), err = not deleted
669
- // Search for doc, if found then try and remove
670
- removeDocument: {
671
- check: new simpl_schema_1.default({
672
- collection: {
673
- type: String
674
- },
675
- doc_id: {
676
- type: String
514
+ }
677
515
  }
678
- }),
679
- function: function (collection, doc_id) {
680
- var _this = this;
681
- return new Promise(function (resolve, reject) {
682
- log_collection_1.Logs.create({
683
- _id: mongoose_1.Types.ObjectId().toHexString(),
684
- date: new Date(),
685
- type: 'info',
686
- title: 'Remove Document',
687
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
688
- payload: { _id: doc_id },
689
- method: 'removeDocument',
690
- user: _this.user,
691
- messageId: ''
516
+ else {
517
+ reject(errDoc);
518
+ }
519
+ });
520
+ });
521
+ }
522
+ },
523
+ // Updates 1 document's props (from _id)
524
+ // @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
525
+ // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
526
+ // Search for doc, check version, if found then try and update props
527
+ updateDocumentPropsOffline: {
528
+ check: new simpl_schema_1.default({
529
+ collection: {
530
+ type: String
531
+ },
532
+ doc_id: {
533
+ type: String
534
+ },
535
+ updateParams: {
536
+ type: Array
537
+ },
538
+ 'updateParams.$': {
539
+ type: Object,
540
+ blackbox: true
541
+ },
542
+ doc__v: {
543
+ type: Number
544
+ },
545
+ f_oldDocument: {
546
+ type: Object,
547
+ blackbox: true
548
+ }
549
+ }),
550
+ function: function (collection, doc_id, updateParams, doc__v, f_oldDocument) {
551
+ var _this = this;
552
+ return new Promise(function (resolve, reject) {
553
+ index_1.ResolveIOServer.getMainDB().model(collection).findOne({ _id: doc_id }).lean().exec(function (errDoc, currDoc) {
554
+ if (currDoc) {
555
+ var modifiedDoc_2 = common_1.deepCopy(currDoc);
556
+ updateParams.forEach(function (data) {
557
+ modifiedDoc_2[data.prop] = data.data;
692
558
  });
693
- index_1.ResolveIOServer.getMainDB().model(collection).deleteOne({ _id: doc_id }).exec(function (err, res) {
694
- if (err) {
695
- reject(err);
559
+ if (modifiedDoc_2.__v === doc__v) {
560
+ var versionDoc = common_1.deepCopy(currDoc);
561
+ versionDoc._id = {
562
+ _id: currDoc._id,
563
+ __v: currDoc.__v
564
+ };
565
+ var schemaErrors = null;
566
+ try {
567
+ index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(modifiedDoc_2);
568
+ }
569
+ catch (errors) {
570
+ schemaErrors = errors;
571
+ _this.callMethodInternal.call(_this, 'insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_2]);
572
+ }
573
+ if (schemaErrors) {
574
+ console.log(schemaErrors);
575
+ reject('Schema Errors');
696
576
  }
697
577
  else {
698
- resolve(res.ok);
578
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc).then(function (doc) {
579
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
580
+ $and: [
581
+ { '_id._id': currDoc._id },
582
+ { '_id.__v': { $lte: currDoc.__v - 4 } }
583
+ ]
584
+ }).exec();
585
+ }, function (err) {
586
+ console.log(err);
587
+ });
588
+ var updates = common_1.getMongoUpdates(currDoc, modifiedDoc_2, true);
589
+ if (updates) {
590
+ index_1.ResolveIOServer.getMainDB().model(collection).updateOne({ _id: modifiedDoc_2._id }, updates, { strict: false }).exec().then(function (res) {
591
+ resolve(res.ok);
592
+ }, function (err) { return reject(err); });
593
+ }
594
+ else {
595
+ resolve(1);
596
+ }
597
+ if (common_1.getBinarySize(JSON.stringify(updateParams)) < 200000) {
598
+ log_collection_1.Logs.create({
599
+ _id: mongoose_1.Types.ObjectId().toHexString(),
600
+ date: new Date(),
601
+ type: 'info',
602
+ title: 'Update Document Props',
603
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
604
+ payload: updateParams,
605
+ method: 'updateDocumentPropsOffline',
606
+ user: _this.user,
607
+ messageId: ''
608
+ });
609
+ }
610
+ else {
611
+ log_collection_1.Logs.create({
612
+ _id: mongoose_1.Types.ObjectId().toHexString(),
613
+ date: new Date(),
614
+ type: 'info',
615
+ title: 'Update Document Props',
616
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection + ', Id: ' + doc_id + ', ' + 'Version: ' + doc__v,
617
+ payload: 'Too Big',
618
+ method: 'updateDocumentPropsOffline',
619
+ user: _this.user,
620
+ messageId: ''
621
+ });
622
+ }
699
623
  }
700
- });
701
- });
702
- }
703
- },
704
- removeDocumentWithQuery: {
705
- check: new simpl_schema_1.default({
706
- collection: {
707
- type: String
708
- },
709
- query: {
710
- type: Object,
711
- blackbox: true
712
- }
713
- }),
714
- function: function (collection, query) {
715
- var _this = this;
716
- return new Promise(function (resolve, reject) {
717
- log_collection_1.Logs.create({
718
- _id: mongoose_1.Types.ObjectId().toHexString(),
719
- date: new Date(),
720
- type: 'info',
721
- title: 'Remove Document (Query)',
722
- message: 'User: ' + _this.user + ', Collection Type: ' + collection,
723
- payload: { _id: query },
724
- method: 'removeDocumentWithQuery',
725
- user: _this.user,
726
- messageId: ''
727
- });
728
- index_1.ResolveIOServer.getMainDB().model(collection).deleteOne(query).exec(function (err, res) {
729
- if (err) {
730
- reject(err);
624
+ }
625
+ else {
626
+ console.log('invalid version - ' + collection, currDoc.__v, doc__v);
627
+ var newCurrDocId = currDoc._id;
628
+ if (f_oldDocument) {
629
+ var versionDoc_4 = common_1.deepCopy(currDoc);
630
+ versionDoc_4._id = {
631
+ _id: currDoc._id,
632
+ __v: currDoc.__v
633
+ };
634
+ var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_2, currDoc, f_oldDocument);
635
+ updatedDoc._id = newCurrDocId;
636
+ updatedDoc.__v++;
637
+ index_1.ResolveIOServer.getMainDB().model(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).exec().then(function (res) {
638
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).create(versionDoc_4).then(function (doc) {
639
+ index_1.ResolveIOServer.getMainDB().model(index_1.ResolveIOServer.getMainDB().model(collection)['versionCollection']).deleteMany({
640
+ $and: [
641
+ { '_id._id': versionDoc_4._id._id },
642
+ { '_id.__v': { $lte: versionDoc_4._id.__v - 4 } }
643
+ ]
644
+ }).exec();
645
+ }, function (err) {
646
+ console.log(err);
647
+ });
648
+ resolve(res.nModified);
649
+ }, function (err) { return reject(err); });
731
650
  }
732
651
  else {
733
- resolve(res.ok);
652
+ reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc_2.__v);
734
653
  }
735
- });
736
- });
737
- }
654
+ }
655
+ }
656
+ else {
657
+ reject(errDoc);
658
+ }
659
+ });
660
+ });
661
+ }
662
+ },
663
+ // Removes 1 document (from _id)
664
+ // @Inputs: collection, document id
665
+ // @Outputs: res = 1 (deleted), res = 0 (not deleted), err = not deleted
666
+ // Search for doc, if found then try and remove
667
+ removeDocument: {
668
+ check: new simpl_schema_1.default({
669
+ collection: {
670
+ type: String
671
+ },
672
+ doc_id: {
673
+ type: String
738
674
  }
739
- });
675
+ }),
676
+ function: function (collection, doc_id) {
677
+ var _this = this;
678
+ return new Promise(function (resolve, reject) {
679
+ log_collection_1.Logs.create({
680
+ _id: mongoose_1.Types.ObjectId().toHexString(),
681
+ date: new Date(),
682
+ type: 'info',
683
+ title: 'Remove Document',
684
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
685
+ payload: { _id: doc_id },
686
+ method: 'removeDocument',
687
+ user: _this.user,
688
+ messageId: ''
689
+ });
690
+ index_1.ResolveIOServer.getMainDB().model(collection).deleteOne({ _id: doc_id }).exec(function (err, res) {
691
+ if (err) {
692
+ reject(err);
693
+ }
694
+ else {
695
+ resolve(res.ok);
696
+ }
697
+ });
698
+ });
699
+ }
700
+ },
701
+ removeDocumentWithQuery: {
702
+ check: new simpl_schema_1.default({
703
+ collection: {
704
+ type: String
705
+ },
706
+ query: {
707
+ type: Object,
708
+ blackbox: true
709
+ }
710
+ }),
711
+ function: function (collection, query) {
712
+ var _this = this;
713
+ return new Promise(function (resolve, reject) {
714
+ log_collection_1.Logs.create({
715
+ _id: mongoose_1.Types.ObjectId().toHexString(),
716
+ date: new Date(),
717
+ type: 'info',
718
+ title: 'Remove Document (Query)',
719
+ message: 'User: ' + _this.user + ', Collection Type: ' + collection,
720
+ payload: { _id: query },
721
+ method: 'removeDocumentWithQuery',
722
+ user: _this.user,
723
+ messageId: ''
724
+ });
725
+ index_1.ResolveIOServer.getMainDB().model(collection).deleteOne(query).exec(function (err, res) {
726
+ if (err) {
727
+ reject(err);
728
+ }
729
+ else {
730
+ resolve(res.ok);
731
+ }
732
+ });
733
+ });
734
+ }
740
735
  }
741
- }, 1000);
736
+ });
742
737
  }
743
- exports.default = loadCollectionMethods;
738
+ exports.loadCollectionMethods = loadCollectionMethods;