alchemy-chimera 0.5.4 → 1.0.2

package/controller/chimera_editor_controller.js

@@ -1,714 +1,259 @@
 /**
  * The Chimera Editor Controller class
  *
- * @author        Jelle De Loecker   <jelle@kipdola.be>
+ * @author        Jelle De Loecker   <jelle@elevenways.be>
  * @since         0.2.0
- * @version       0.5.1
+ * @version       1.0.0
  */
-var Editor = Function.inherits('Alchemy.Controller.Chimera', function Editor(conduit, options) {
+const Editor = Function.inherits('Alchemy.Controller.Chimera', 'Editor');
 
-	Editor.super.call(this, conduit, options);
-
-	this.addComponent('paginate');
+/**
+ * Set the title
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.0.1
+ * @version  1.0.1
+ *
+ * @param    {String}    title
+ */
+Editor.setMethod(function setTitle(title) {
 
-	this.addAction('model', 'index', {title: 'Index', icon: '<x-svg data-src="chimera/list"></x-svg>'});
-	this.addAction('model', 'add', {title: 'Add', icon: '<x-svg data-src="chimera/plus"></x-svg>'});
+	let window_title,
+	    page_title;
 
-	this.addAction('model-list', 'add', {title: 'Add', icon: '<x-svg data-src="chimera/plus"></x-svg>', route_name: 'ModelAction'});
+	if (alchemy.plugins.chimera.title) {
+		window_title = alchemy.plugins.chimera.title || '';
 
-	this.addAction('draft', 'save', {title: 'Save', icon: '<x-svg data-src="chimera/floppy"></x-svg>', handleManual: true});
+		if (title && window_title) {
+			window_title += ' | ';
+		}
+	}
 
-	this.addAction('record', 'edit', {title: 'Edit', icon: '<x-svg data-src="chimera/edit"></x-svg>'});
-	this.addAction('record', 'view', {title: 'View', icon: '<x-svg data-src="chimera/eye"></x-svg>'});
-	this.addAction('record', 'remove', {title: 'Remove', icon: '<x-svg data-src="chimera/garbage"></x-svg>'});
+	if (title) {
+		window_title += title;
+	}
 
-	this.addAction('record-edit', 'save', {title: 'Save', icon: '<x-svg data-src="chimera/floppy"></x-svg>', handleManual: true, route_name: 'RecordAction'});
-	this.addAction('record-edit', 'saveClose', {title: 'Save and close', icon: '<x-svg data-src="chimera/floppy"></x-svg>', handleManual: true, route_name: 'RecordAction'});
+	page_title = title;
 
-	this.addAction('record-draft', 'save', {title: 'Save', icon: '<x-svg data-src="chimera/floppy"></x-svg>', handleManual: true, route_name: 'RecordAction'});
-	this.addAction('record-draft', 'saveClose', {title: 'Save and close', icon: '<x-svg data-src="chimera/floppy"></x-svg>', handleManual: true, route_name: 'RecordAction'});
+	this.set('page_title', page_title);
+	this.set('window_title', window_title || page_title);
 });
 
 /**
  * The index action
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.1.0
- * @version  0.1.0
+ * @version  1.0.1
  *
  * @param    {Conduit}   conduit
+ * @param    {String}    model_name
  */
-Editor.setAction(function index(conduit) {
-	return this.doAction('listing', [conduit, 'list', 'index']);
-});
+Editor.setAction(function index(conduit, model_name) {
 
-/**
- * The generic listing method
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.1.0
- * @version  0.5.1
- *
- * @param    {Conduit}   conduit
- * @param    {String}    type
- * @param    {String}    view
- */
-Editor.setAction(function listing(conduit, type, view) {
-
-	var that = this,
-	    model_plural,
-	    model_title,
-	    model_name,
-	    chimera,
-	    model;
+	let model = this.getModel(model_name);
 
-	// Get the name of the model
-	model_name = conduit.routeParam('subject');
-
-	if (!model_name) {
-		return conduit.error(new Error('No model name was given, nothing to list'));
-	}
+	let widget_config = model.chimera.getWidgetConfig('index', conduit);
 
-	// Get the actual model
-	model = this.getModel(model_name);
-
-	// And get the chimera instance
-	chimera = model.constructor.chimera;
-
-	if (chimera == null) {
-		return conduit.error(new Error('Model "' + model_name + '" has no chimera configuration'));
-	}
+	this.setTitle(model_name.titleize());
 
-	// Get the model title
-	model_title = model_name.titleize();
+	this.set('model_name', model_name);
 
-	// And the plural form
-	model_plural = model_title.pluralize();
+	this.set('widget_config', widget_config);
 
-	// Disable translation behaviour of the model
-	model.disableTranslations();
-
-	// Set the page title
-	this.setTitle(model_plural);
-
-	if (view == null) {
-		view = type;
-	}
-
-	let action_fields = chimera.getActionFields(type),
-	    general       = action_fields.getGroup('general'),
-	    sorted        = general.getSorted(false),
-	    fields        = [],
-	    i;
-
-	for (i = 0; i < sorted.length; i++) {
-		fields.push(sorted[i].path);
-	}
-
-
-	let options = {
-		fields    : fields,
-		pageSize  : 10
-	};
-
-	// Hacky way of stopping pagination
-	if (action_fields.options.paginate === false) {
-		options.pageSize = 999;
-	}
-
-	// Find the paginated records
-	that.components.paginate.find(model, options, function gotRecords(err, items) {
-
-		if (err) {
-			return conduit.error(err);
-		}
-
-		that.conduit.set('available_records', items.available || 0);
-
-		action_fields.processRecords('general', model, items, function groupedRecords(err, results) {
-
-			if (err) {
-				return conduit.error(err);
-			}
-
-			that.set('prefixes',           Prefix.getPrefixList());
-			that.set('fields',             general);
-			that.set('records',            results.general);
-			that.set('actions',            that.getActions());
-			that.set('show_index_filters', model.chimera.show_index_filters);
-
-			that.set('model_title',        model_title);
-			that.set('model_name',         model_name);
-			that.internal('model_name',    model_name);
-
-			// Deprecated modelName
-			that.set('modelName',          model_name);
-			that.internal('modelName',     model_name);
-
-			that.render('chimera/editor/' + view);
-		});
-	});
+	this.render('chimera/editor/index');
 });
 
 /**
- * Create a field value
+ * The add action
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.1.0
+ * @version  1.0.2
  *
- * @param   {Conduit}   conduit
+ * @param    {Conduit}   conduit
+ * @param    {String}    model_name
  */
-Editor.setAction(function create_field_value(conduit, controller, subject, action) {
+Editor.setAction(async function add(conduit, model_name) {
 
-	var that = this,
-	    model = this.getModel(subject),
-	    data = {name: conduit.body.text, title: conduit.body.text};
+	let model = this.getModel(model_name);
 
-	model.save(data, function saved(err, doc) {
+	model.translateItems = false;
 
-		if (err) {
-			return conduit.error(err);
-		}
+	if (conduit.method == 'post') {
 
-		conduit.end({_id: doc._id});
-	});
-});
+		let record = model.createDocument();
 
-/**
- * The add action
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(function add(conduit) {
+		record.setDataRecord(conduit.body[model_name]);
 
-	var that = this,
-	    model_plural,
-	    model_title,
-	    model_name,
-	    chimera,
-	    model;
+		try {
+			await record.save();
 
-	// Get the name of the model
-	model_name = conduit.routeParam('subject');
+			let url = alchemy.routeUrl('Chimera.Editor#edit', {
+				model: model_name,
+				pk: record.$pk,
+				message: 'added'
+			});
 
-	if (!model_name) {
-		return conduit.error(new Error('No model name was given, nothing to list'));
+			return conduit.redirect(url);
+		} catch (err) {
+			this.set('context_variables', {
+				form_violations : err,
+				record : record
+			});
+		}
 	}
 
-	// Get the actual model
-	model = this.getModel(model_name);
-
-	// And get the chimera instance
-	chimera = model.constructor.chimera;
+	let widget_config = model.chimera.getWidgetConfig('edit', conduit);
 
-	if (chimera == null) {
-		return conduit.error(new Error('Model "' + model_name + '" has no chimera configuration'));
+	if (!widget_config.class_names) {
+		widget_config.class_names = [];
 	}
 
-	// Get the model title
-	model_title = model_name.titleize();
-
-	// And the plural form
-	model_plural = model_title.pluralize();
-
-	// Disable translation behaviour of the model
-	model.disableTranslations();
-
-	this.setTitle(model_title + ': Add');
-
-	let action_fields = chimera.getActionFields('edit'),
-	    groups        = action_fields.groups.clone(),
-	    item          = model.compose(),
-	    id            = item._id;
-
-	action_fields.processRecords(model, [item], function groupedRecords(err, groups) {
-
-		if (err) {
-			throw err;
-		}
-
-		that.set('editor_action',      'add');
-		that.set('prefixes',           Prefix.getPrefixList());
-		that.set('groups',             groups);
-		that.set('actions',            that.getActions());
+	widget_config.class_names.push('chimera-editor-widgets');
 
-		that.set('model_title',        model_title);
-		that.set('model_name',         model_name);
-		that.internal('model_name',    model_name);
-		that.internal('record_id',     id);
+	this.set('widget_config', widget_config);
+	this.setTitle(model.constructor.title + ' Add');
 
-		// Deprecated variable names
-		that.set('modelName',          model_name);
-		that.internal('modelName',     model_name);
-		that.internal('recordId',      id);
-
-		that.render('chimera/editor/add');
-	});
+	this.render('chimera/widgets');
 });
 
 /**
  * The edit action
  *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(function edit(conduit) {
-
-	var that = this,
-	    modelName = conduit.routeParam('subject'),
-	    model = this.getModel(modelName),
-	    chimera = model.constructor.chimera,
-	    id = conduit.routeParam('id');
-
-	model.disableTranslations();
-
-	var actionFields = chimera.getActionFields('edit'),
-	    groups = actionFields.groups.clone();
-
-	model.find('first', {conditions: {_id: alchemy.castObjectId(id)}}, function(err, item) {
-
-		if (err) {
-			return conduit.error(err);
-		}
-
-		if (!item) {
-			return conduit.notFound();
-		}
-
-		actionFields.processRecords(model, [item], function groupedRecords(err, groups) {
-
-			if (err) {
-				return conduit.error(err);
-			}
-
-			that.set('editor_action', 'edit');
-			that.set('prefixes', Prefix.getPrefixList());
-			that.set('groups', groups);
-			that.set('actions', that.getActions());
-			that.set('modelName', modelName);
-			that.set('display_field_value', item.getDisplayFieldValue({prefer: 'name'}));
-			that.set('pagetitle', modelName.humanize() + ': Edit');
-			that.internal('modelName', modelName);
-			that.internal('recordId', id);
-
-			that.render('chimera/editor/edit');
-		});
-	});
-});
-
-/**
- * The "peek" method
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.1.0
+ * @version  1.0.2
  *
- * @param   {Conduit}   conduit
+ * @param    {Conduit}   conduit
+ * @param    {String}    model_name
+ * @param    {String}    pk_val
  */
-Editor.setAction(function peek(conduit) {
+Editor.setAction(async function edit(conduit, model_name, pk_val) {
 
-	var that = this,
-	    action_fields,
-	    model_name,
-	    chimera,
-	    groups,
-	    model,
-	    id;
+	let model = this.getModel(model_name);
 
-	model_name = conduit.routeParam('subject');
-	model = this.getModel(model_name);
-	chimera = model.constructor.chimera;
-	id = conduit.routeParam('id');
+	model.translateItems = false;
 
-	// Disable translations in the CMS
-	model.disableTranslations();
+	let record = await model.findByPk(pk_val);
+	let message_type = conduit.param('message');
 
-	// Get the "peek" fields
-	action_fields = chimera.getActionFields('peek');
-	groups = action_fields.groups.clone();
+	let context_variables = {
+		record,
+	};
 
-	// Get the wanted record
-	model.find('first', {conditions: {_id: id}}, function gotRecord(err, item) {
+	if (conduit.method == 'post') {
 
-		if (err) {
-			return conduit.error(err);
-		}
+		Object.assign(record, conduit.body[model_name]);
 
-		if (!item) {
-			return conduit.notFound();
+		try {
+			await record.save();
+			message_type = 'saved';
+		} catch (err) {
+			context_variables.form_violations = err;
 		}
-
-		action_fields.processRecords(model, [item], function groupedRecords(err, groups) {
-
-			if (err) {
-				return conduit.error(err);
-			}
-
-			that.set('editor_action', 'peek');
-			that.set('prefixes', Prefix.getPrefixList());
-			that.set('groups', groups);
-			that.set('actions', that.getActions());
-			that.set('modelName', model_name);
-			that.set('display_field_value', item.getDisplayFieldValue({prefer: 'name'}));
-			that.internal('modelName', model_name);
-			that.internal('recordId', id);
-
-			that.render('chimera/editor/peek');
-		});
-	});
-});
-
-
-/**
- * Reorder an array
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.5.1
- * @version  0.5.1
- *
- * @param    {Array}    arr        The array to reorder
- * @param    {Object}   query      The query that should match the entries
- * @param    {Number}   new_index  The new index this should be moved to
- */
-function reorderByQuery(arr, query, new_index, path) {
-
-	let entry = arr.findByPath(query);
-
-	if (!entry) {
-		return;
-	}
-
-	arr.move(entry, new_index);
-
-	let i;
-
-	for (i = 0; i < arr.length; i++) {
-		Object.setPath(arr[i], path, i);
 	}
-};
-
-/**
- * The "reorder" method
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(async function reorder(conduit) {
-
-	var that = this,
-	    model_name,
-	    new_index,
-	    model,
-	    id;
 
-	new_index = Number(conduit.param('new_index'));
-	model_name = conduit.routeParam('subject');
-	model = this.getModel(model_name);
-	id = conduit.routeParam('id');
+	this.set('context_variables', context_variables);
 
-	let record = await model.findById(id);
-	let records = await model.find('all', {fields: ['_id', 'order']});
+	let widget_config = model.chimera.getWidgetConfig('edit', conduit);
 
-	records = Array.cast(records);
-
-	reorderByQuery(records, {_id: String(id)}, new_index, 'order');
-
-	for (let i = 0; i < records.length; i++) {
-		if (!records[i].hasChanged()) {
-			continue;
-		}
-
-		await records[i].save();
+	if (!widget_config.class_names) {
+		widget_config.class_names = [];
 	}
 
-	conduit.end({saved: true});
-});
-
-/**
- * Associated model data
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(async function model_assoc_data(conduit) {
-
-	var model = Model.get(conduit.routeParam('subject')),
-	    options;
-
-	let records  = await model.find('all'),
-	    results  = [],
-	    response = {};
-
-	for (let i = 0; i < records.length; i++) {
-		let record = records[i];
-
-		let entry = {
-			_id : record._id
-		};
-
-		if (record[model.displayField]) {
-			entry[model.displayField] = record[model.displayField];
-		} else {
-			entry.title = record.title;
-			entry.name = record.name;
+	if (message_type) {
+		if (message_type == 'added') {
+			this.set('message', 'Record has been added');
+		} else if (message_type == 'saved') {
+			this.set('message', 'Record has been saved');
 		}
-
-		results.push(entry);
 	}
 
-	conduit.end({
-		items        : results,
-		displayField : model.displayField
-	});
-});
+	widget_config.class_names.push('chimera-editor-widgets');
 
-/**
- * The related_data action for a certain field
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(function related_data(conduit) {
-
-	var that = this,
-	    modelName = conduit.routeParam('subject'),
-	    model = this.getModel(modelName),
-	    chimera = model.constructor.chimera,
-	    options = {},
-	    id = conduit.routeParam('id'),
-	    field;
-
-	if (conduit.param('display_field_only')) {
-		options.display_field_only = true;
-	}
-
-	model.disableTranslations();
-
-	// Some fields (like subschemas) require record info for related data
-	model.find('first', {conditions: {_id: id}, document: false}, function gotResult(err, items) {
-
-		var nested_in = conduit.param('nested_in'),
-		    fieldpath = conduit.param('fieldpath');
-
-		if (nested_in) {
-			fieldpath = nested_in + '.' + fieldpath;
-		}
+	this.set('widget_config', widget_config);
+	this.setTitle(model.constructor.title + ' Edit');
 
-		field = chimera.getField(fieldpath, items[0]);
-
-		if (!field) {
-			conduit.notFound(new Error('Could not find field "' + fieldpath + '"'));
-		} else {
-			field.sendRelatedData(conduit, items[0], options);
-		}
-	});
+	this.render('chimera/widgets');
 });
 
 /**
- * The view action
+ * The records API action
  *
- * @todo: code is mostly alike to edit, merge together
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.0.0
+ * @version  1.0.0
  *
- * @param   {Conduit}   conduit
+ * @param    {Conduit}   conduit
+ * @param    {String}    model_name
  */
-Editor.setAction(async function view(conduit) {
-
-	var that = this,
-	    modelName = conduit.routeParam('subject'),
-	    model = this.getModel(modelName),
-	    chimera = model.constructor.chimera,
-	    id = conduit.routeParam('id');
-
-	model.disableTranslations();
+Editor.setAction(async function records(conduit, model_name) {
 
-	var actionFields = chimera.getActionFields('edit'),
-	    groups = actionFields.groups.clone();
-
-	let item = await model.findById(id);
+	let body = conduit.body,
+	    model = this.getModel(model_name),
+	    crit = model.find();
 
-	if (!item) {
-		return conduit.notFound();
-	}
+	let page_size = body.page_size,
+	    fields = body.fields,
+	    page = body.page;
 
-	actionFields.processRecords(model, [item], function groupedRecords(err, groups) {
+	if (fields) {
 
-		if (err) {
-			return conduit.error(err);
+		// @TODO: fix FieldSet being sent with regular json?
+		if (fields.fields) {
+			fields = fields.fields;
 		}
 
-		that.set('editor_action', 'view');
-		that.set('prefixes', Prefix.getPrefixList());
-		that.set('groups', groups);
-		that.set('actions', that.getActions());
-		that.set('modelName', modelName);
-		that.set('pageTitle', modelName.humanize());
-		that.set('display_field_value', item.getDisplayFieldValue({prefer: 'name'}));
-		that.internal('modelName', modelName);
-		that.internal('recordId', id);
-		that.internal('chimeraReadOnly', true);
-
-		that.render('chimera/editor/view');
-	});
-});
-
-/**
- * The save action
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.1.0
- * @version  0.5.1
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(function save(conduit) {
-	this.save(conduit, false);
-});
-
-/**
- * The save & close action
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.5.1
- * @version  0.5.1
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(function saveClose(conduit) {
-	this.save(conduit, true);
-});
-
-/**
- * Save a record
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    0.5.1
- * @version  0.5.1
- *
- * @param   {Conduit}   conduit
- */
-Editor.setMethod(function save(conduit, go_to_index) {
-
-	var that = this,
-	    actionFields,
-	    modelName,
-	    chimera,
-	    options,
-	    groups,
-	    record,
-	    model,
-	    data,
-	    id;
-
-	if (conduit.method != 'post') {
-		return conduit.error('Use POST method to apply changes');
+		crit.select(fields);
 	}
 
-	modelName = conduit.routeParam('subject');
-	model = this.getModel(modelName);
-	model.disableTranslations();
-
-	chimera = model.constructor.chimera;
-	data = conduit.body.data;
-
-	if (!data) {
-		return conduit.error('Data was not found in POST body');
+	if (page) {
+		crit.page(page, page_size);
 	}
 
-	id = conduit.routeParam('id');
-
-	actionFields = chimera.getActionFields('edit');
-	groups = actionFields.groups.clone();
-
-	record = data[modelName.classify()];
-	record._id = alchemy.castObjectId(id);
-
-	options = {};
-
-	// Force create, even though an _id could be given
-	if (conduit.body.create === true) {
-		options.create = true;
+	if (body.sort && body.sort.field && body.sort.dir) {
+		crit.sort([body.sort.field, body.sort.dir]);
 	}
 
-	model.save(record, options, function afterSave(err, items) {
-
-		if (err != null) {
-			conduit.flash('Could not save record: ' + err, {className: 'chimera-fail'});
-			return conduit.error(err);
-		}
-
-		let result = items[0];
-
-		let route_params = Object.assign({}, conduit.params);
-
-		conduit.flash('Record has been saved', {className: 'chimera-success'});
-
-		if (go_to_index) {
-			route_params.action = 'index';
-
-			return conduit.redirect({
-				headers : conduit.headers,
-				url     : Router.getUrl('ModelAction', route_params)
-			});
-		}
+	if (body.filters) {
+		let key,
+		    val;
 
-		route_params.action = 'edit';
-		route_params.id = result._id;
+		for (key in body.filters) {
+			val = body.filters[key];
 
-		// When creating a new record we need to supply a new url,
-		// because the 'history' will be activated
-		// The redirect does remain internal, though!
-		if (options.create) {
-
-			return conduit.redirect({
-				headers : conduit.headers,
-				url     : Router.getUrl('RecordAction', route_params)
-			});
-		}
-
-		that.doAction('edit', [conduit]);
-	});
-});
-
-/**
- * The remove action
- *
- * @param   {Conduit}   conduit
- */
-Editor.setAction(async function remove(conduit) {
-
-	var that = this,
-	    model_name = conduit.routeParam('subject'),
-	    model = this.getModel(model_name),
-	    id = conduit.routeParam('id');
-
-	model.disableTranslations();
-
-	if (conduit.body.sure === 'yes') {
-		model.remove(id, function onRemoved(err) {
-
-			if (err) {
-				return conduit.error(err);
+			// The value should always be a string,
+			// so anything that is falsy can be ignored
+			if (!val) {
+				continue;
 			}
 
-			conduit.setHeader('x-history-url', '/chimera/editor/' + model_name + '/index');
-			conduit.flash('Record has been removed', {className: 'chimera-success'});
-
-			let route_params = Object.assign({}, conduit.params);
-			route_params.action = 'index';
-			delete route_params.id;
-
-			return conduit.redirect({
-				headers : conduit.headers,
-				url     : Router.getUrl('ModelAction', route_params)
-			});
-		});
-	} else {
-
-		let item = await model.findById(id);
-
-		if (!item) {
-			return conduit.notFound();
+			val = RegExp.interpretWildcard('*' + val + '*');
+			crit.where(key).equals(val);
 		}
+	}
 
-		that.set('editor_action', 'remove');
-		that.set('actions', that.getActions());
-		that.set('modelName', model_name);
-		that.set('pageTitle', model_name.humanize());
-		that.set('item', item);
-		that.set('display_field_value', item.getDisplayFieldValue({prefer: 'name'}));
-		that.internal('modelName', model_name);
-		that.internal('recordId', id);
-
-		that.render('chimera/editor/remove');
+	let records = await model.find('all', crit),
+	    result = [],
+	    record,
+	    main;
+
+	for (record of records) {
+
+		record.$hold.actions = [
+			{
+				name : 'edit',
+				icon : 'edit',
+				url  : alchemy.routeUrl('Chimera.Editor#edit', {
+					model : model_name,
+					pk    : record.$pk,
+				})
+			}
+		];
 	}
 
+	conduit.end({
+		records : records
+	});
 });