alchemymvc 1.3.15 → 1.3.17

package/lib/app/helper_datasource/00-nosql_datasource.js

@@ -590,7 +590,7 @@ NoSQL.setStatic(function areComparable(a, b) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.1.0
- * @version  1.3.0
+ * @version  1.3.16
  *
  * @param    {Criteria}   criteria
  * @param    {Group}      group
@@ -711,13 +711,16 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 
 			let field_entry = {},
 			    name = entry.target_path,
-				queries_property = name.indexOf('.') > -1;
+			    queries_property = name.indexOf('.') > -1;
 
 			// Do we need to look into an object itself?
-			// (Like the "timestamp" property of a date field when stored with units)
-			if (entry.db_property && !queries_property) {
-				name += '.' + entry.db_property;
-				queries_property = true;
+			if (entry.db_property) {
+
+				// Make sure the query doesn't already specifically query this property
+				if (name == entry.field.path) {
+					name += '.' + entry.db_property;
+					queries_property = true;
+				}
 			}
 
 			if (entry.association) {
@@ -824,10 +827,15 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 				// (entry.field can be undefined if trying to query a path)
 				if (entry.field && entry.field.is_translatable) {
 
-					let prefix = criteria.options.locale;
+					let prefix = criteria.options.locale,
+					    specific_prefix = !!prefix;
+
+					if (specific_prefix && criteria?.model?.translate === false) {
+						specific_prefix = false;
+					}
 
 					// If a prefix is specified, only query that translation
-					if (prefix) {
+					if (specific_prefix) {
 						prefixed_name = name + '.' + prefix;
 					} else {
 						multiple_fields = [];

package/lib/app/helper_field/schema_field.js

@@ -5,9 +5,19 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.4
+ * @version  1.3.16
  */
 var SchemaField = Function.inherits('Alchemy.Field', function Schema(schema, name, options) {
+
+	if (!options) {
+		options = {};
+	}
+
+	// If the contents are array-like, the field itself can't be
+	if (this.force_array_contents) {
+		options.is_array = false;
+	}
+
 	Schema.super.call(this, schema, name, options);
 
 	if (options.schema == null || typeof options.schema != 'object') {
@@ -50,9 +60,18 @@ SchemaField.setDeprecatedProperty('fieldSchema', 'field_schema');
 SchemaField.setDatatype('object');
 
 /**
- * Get the subschema of this field
+ * Is this schema field always an array?
  *
- * @constructor
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.16
+ * @version  1.3.16
+ *
+ * @return   {Boolean}
+ */
+SchemaField.setProperty('force_array_contents', false);
+
+/**
+ * Get the subschema of this field
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
@@ -160,7 +179,7 @@ SchemaField.setMethod(function getSubschema(record, some_path) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.3.1
+ * @version  1.3.16
  *
  * @param    {Object}      value        Value of field, an object in this case
  * @param    {Object}      data         The data object containing `value`
@@ -170,6 +189,38 @@ SchemaField.setMethod(function getSubschema(record, some_path) {
  */
 SchemaField.setMethod(function _toDatasource(value, holder, datasource, callback) {
 
+	if (!this.force_array_contents) {
+		return this._toDatasourceFromValue(value, holder, datasource, callback);
+	}
+
+	value = Array.cast(value);
+
+	let tasks = [];
+
+	for (let entry of value) {
+		tasks.push(next => {
+			this._toDatasourceFromValue(entry, holder, datasource, next);
+		});
+	}
+
+	Function.parallel(tasks, callback);
+});
+
+/**
+ * Cast all the subschema values using their _toDatasource method
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    0.2.0
+ * @version  1.3.1
+ *
+ * @param    {Object}      value        Value of field, an object in this case
+ * @param    {Object}      data         The data object containing `value`
+ * @param    {Datasource}  datasource   The destination datasource
+ *
+ * @return   {Object}
+ */
+SchemaField.setMethod(function _toDatasourceFromValue(value, holder, datasource, callback) {
+
 	var that = this,
 	    sub_schema,
 	    record,
@@ -241,13 +292,50 @@ SchemaField.setMethod(function _toDatasource(value, holder, datasource, callback
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.4
+ * @version  1.3.16
  *
  * @param    {Mixed}      value
  * @param    {Function}   callback
  */
 SchemaField.setMethod(function _toApp(query, options, value, callback) {
 
+	if (!this.force_array_contents) {
+		return this._toAppFromValue(query, options, value, callback);
+	}
+
+	value = Array.cast(value);
+
+	let tasks = [];
+
+	for (let entry of value) {
+		tasks.push(next => {
+			this._toAppFromValue(query, options, entry, next);
+		});
+	}
+
+	Function.parallel(tasks, (err, result) => {
+
+		if (err) {
+			return callback(err);
+		}
+
+		callback(null, this.cast(result));
+	});
+
+});
+
+/**
+ * Turn datasource data into app data
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    0.2.0
+ * @version  1.3.16
+ *
+ * @param    {Mixed}      value
+ * @param    {Function}   callback
+ */
+SchemaField.setMethod(function _toAppFromValue(query, options, value, callback) {
+
 	var that = this,
 	    recursive,
 	    Dummy,
@@ -364,11 +452,11 @@ SchemaField.setMethod(function _toApp(query, options, value, callback) {
 				return callback(err);
 			}
 
-			callback(null, that.cast(result));
+			callback(null, that.castEntry(result));
 		});
 	}
 
-	callback(null, this.cast(value));
+	callback(null, this.castEntry(value));
 });
 
 /**
@@ -424,6 +512,17 @@ SchemaField.setMethod(function translateRecord(prefixes, record, allow_empty) {
 	}
 });
 
+/**
+ * Cast an entry
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.16
+ * @version  1.3.16
+ */
+SchemaField.setMethod(function castEntry(value, to_datasource) {
+	return value;
+});
+
 /**
  * Cast the value to a document
  *

package/lib/app/helper_model/document.js

@@ -1277,6 +1277,7 @@ Document.setMethod(function hasChanged(name) {
 
 		for (key in this.$attributes.original_record) {
 			if (!Object.alike(this.$attributes.original_record[key], this[key])) {
+				// @TODO: some special fields always end up being different
 				result = true;
 				break;
 			}

package/lib/app/helper_model/field_set.js

@@ -60,6 +60,19 @@ FieldSet.setStatic(function fromArray(fields) {
 	return set;
 });
 
+/**
+ * How many fields have been added to this set?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.16
+ * @version  1.3.16
+ *
+ * @type     {Number}
+ */
+FieldSet.setProperty(function size() {
+	return this.fields.size;
+});
+
 /**
  * Return an object for json-drying this list
  *

package/lib/app/helper_model/model.js

@@ -516,7 +516,7 @@ Model.setMethod(function getDisplayTitleOrNull(item, fallbacks) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.3.14
+ * @version  1.3.16
  *
  * @param    {Object}        item       The record item of this model
  * @param    {String|Array}  fallbacks  Extra fallbacks to use
@@ -532,7 +532,7 @@ Model.setMethod(function getDisplayTitle(item, fallbacks) {
 	let result = this.getDisplayTitleOrNull(item, fallbacks);
 
 	if (result == null) {
-		result = main[this.primary_key] || '';
+		result = item[this.primary_key] || '';
 
 		if (result && typeof result != 'string') {
 			result = '' + result;

package/lib/app/model/alchemy_task_history_model.js

@@ -0,0 +1,109 @@
+/**
+ * The Alchemy Task History model:
+ * keep track of all the tasks that have been run
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.5.0
+ * @version  0.5.0
+ */
+const AlchemyTaskHistory = Function.inherits('Alchemy.Model.App', 'AlchemyTaskHistory');
+
+/**
+ * Constitute the class wide schema
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.5.0
+ * @version  1.3.17
+ */
+AlchemyTaskHistory.constitute(function addTaskFields() {
+
+	this.belongsTo('AlchemyTask', {
+		description : 'The original AlchemyTask document it belonged to',
+	});
+
+	// The timestamp this was scheduled for
+	this.addField('scheduled_at', 'Date', {
+		description : 'The original date this was scheduled for',
+	});
+
+	this.addField('process_id', 'Integer', {
+		description : 'The process ID of the task',
+	});
+
+	// The type of Task that is running
+	this.addField('type', 'Enum', {
+		values: Classes.Alchemy.Task.Task.getLiveDescendantsMap(),
+	});
+
+	// The payload/settings of the task
+	this.addField('settings', 'Schema', {
+		description : 'The settings of the task at the time it ran',
+		schema: 'type'
+	});
+
+	this.addField('had_error', 'Boolean', {
+		description : 'Did this task run into an error?'
+	});
+
+	this.addField('error_message', 'String', {
+		description : 'The main error message'
+	});
+
+	this.addField('error_stack', 'Text', {
+		description : 'The error stack trace'
+	});
+
+	this.addField('is_running', 'Boolean', {
+		description : 'Is this task still running?',
+		default     : false,
+	});
+
+	this.addField('started_at', 'Datetime', {
+		description : 'The datetime this task actually started running',
+	});
+
+	this.addField('ended_at', 'Datetime', {
+		description : 'The datetime this task actually ended',
+	});
+
+	this.addIndex('type');
+	this.addIndex('is_running');
+});
+
+/**
+ * Configure the default chimera fieldsets
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
+ */
+AlchemyTaskHistory.constitute(function chimeraConfig() {
+
+	if (!this.chimera) {
+		return;
+	}
+
+	// Get the list group
+	let list = this.chimera.getActionFields('list');
+
+	list.addField('created');
+	list.addField('type');
+	list.addField('process_id');
+	list.addField('scheduled_at');
+	list.addField('started_at');
+	list.addField('ended_at');
+	list.addField('had_error');
+
+	// Get the edit group
+	let edit = this.chimera.getActionFields('edit');
+
+	edit.addField('type');
+	edit.addField('settings');
+	edit.addField('had_error');
+	edit.addField('error_message');
+	edit.addField('error_stack');
+	edit.addField('started_at');
+	edit.addField('ended_at');
+});

package/lib/app/model/alchemy_task_model.js

@@ -1,34 +1,157 @@
-var all_task_types = alchemy.getClassGroup('task');
-
 /**
- * The Alchemy Task Model class
+ * The Alchemy Task model:
+ * 
  *
  * @constructor
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.5.0
- * @version  0.5.0
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
+ */
+const AlchemyTask = Function.inherits('Alchemy.Model.App', 'AlchemyTask');
+
+/**
+ * Constitute the class wide schema
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
  */
-var AlchemyTask = Function.inherits('Alchemy.Model.App', function AlchemyTask(conduit, options) {
+AlchemyTask.constitute(function addTaskFields() {
+
+	this.addField('title', 'String', {
+		description : 'The title of the task',
+	});
+
+	this.addField('type', 'Enum', {
+		values      : Classes.Alchemy.Task.Task.getLiveDescendantsMap(),
+		description : 'The type of task to run',
+	});
+
+	this.addField('settings', 'Schema', {
+		description : 'The settings to use for running the task',
+		schema: 'type'
+	});
 
-	var that = this;
+	this.addField('enabled', 'Boolean', {
+		description : 'Is this task enabled?',
+		default     : true,
+	});
 
-	AlchemyTask.super.call(this, conduit, options);
+	this.addField('frequency', 'String', {
+		description : 'The frequency this task should run at (CRON syntax)',
+	});
+
+	this.addField('comment', 'Text', {
+		description : 'A comment about this task',
+	});
+
+	this.addField('schedule_type', 'Enum', {
+		values: {
+			user            : 'User',
+			system_forced   : 'System (forced)',
+			system_fallback : 'System (fallback)',
+		},
+		default: 'user',
+	});
+
+	this.addField('forced_schedule_checksum', 'String', {
+		description : 'Checksum of the cron syntax and settings, set only for tasks originating from forced schedules',
+	});
+
+	this.addIndex('forced_schedule_checksum', {
+		unique : true,
+		sparse : true,
+	});
 });
 
 /**
- * Constitute the class wide schema
+ * Configure the default chimera fieldsets
  *
- * @author   Jelle De Loecker <jelle@develry.be>
- * @since    0.5.0
- * @version  0.5.0
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
  */
-AlchemyTask.constitute(function addTaskFields() {
+AlchemyTask.constitute(function chimeraConfig() {
+
+	if (!this.chimera) {
+		return;
+	}
+
+	// Get the list group
+	let list = this.chimera.getActionFields('list');
+
+	list.addField('title');
+	list.addField('type');
+	list.addField('enabled');
+	list.addField('frequency');
+	list.addField('schedule_type');
+
+	// Get the edit group
+	let edit = this.chimera.getActionFields('edit');
+
+	edit.addField('title');
+	edit.addField('frequency')
+	edit.addField('enabled');
+	edit.addField('type');
+	edit.addField('settings');
+	edit.addField('comment');
+});
+
+/**
+ * Do something before saving the record
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
+ *
+ * @param    {Document.AlchemyTask}   doc
+ */
+AlchemyTask.setMethod(function beforeSave(doc) {
+
+	if (!doc.schedule_type) {
+		doc.schedule_type = 'user';
+	}
+
+	if (doc.enabled == null) {
+		doc.enabled = false;
+	}
+
+	if (!doc.title) {
+		let title = '';
+
+		if (doc.schedule_type == 'system_forced') {
+			title += 'System forced: ';
+		}
+
+		if (doc.schedule_type == 'system_fallback') {
+			title += 'System fallback: ';
+		}
+
+		title += doc.type;
+		doc.title = title;
+	}
+});
+
+/**
+ * Update the schedules after saving
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.17
+ * @version  1.3.17
+ *
+ * @param    {Object}   main
+ * @param    {Object}   info
+ */
+AlchemyTask.setMethod(function afterSave(main, info) {
 
-	// The type of Task that is running
-	this.addField('type', 'Enum', {values: all_task_types});
+	if (!main.type) {
+		return;
+	}
 
-	// When the task ended
-	this.addField('ended', 'Datetime');
+	if (!alchemy.task_service.has_loaded) {
+		return;
+	}
 
+	alchemy.task_service.rescheduleTasksOfType(main.type);
 });

package/lib/bootstrap.js

@@ -312,6 +312,9 @@ Alchemy.setMethod(function start(options, callback) {
 	// Make sure Blast has executed everything that's still waiting
 	Blast.doLoaded();
 
+	// Call the `afterStart` method
+	this.ready(() => this.afterStart());
+
 	// Schedule the callback
 	return this.ready(callback);
 });