alchemy-chimera 1.3.0-alpha.3 → 1.3.0

package/controller/00-chimera_controller.js

@@ -3,14 +3,14 @@
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.1.0
- * @version  1.0.0
+ * @version  1.3.0
  */
 let ChimeraController = Function.inherits('Alchemy.Controller', 'Alchemy.Controller.Chimera', function Chimera(conduit, options) {
 
 	Chimera.super.call(this, conduit, options);
 
-	// Set the theme
-	if (alchemy.plugins.chimera.theme) {
+	// Set the theme (only for HTTP conduits, not WebSocket connections)
+	if (alchemy.plugins.chimera.theme && !conduit.websocket) {
 		this.view_render.setTheme(alchemy.plugins.chimera.theme);
 	}
 });
@@ -20,15 +20,18 @@ let ChimeraController = Function.inherits('Alchemy.Controller', 'Alchemy.Control
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.4
- * @version  1.2.6
+ * @version  1.3.0
  */
 ChimeraController.setMethod(function beforeAction() {
 
+	// Skip for WebSocket linkup connections - they don't have routes or params
+	if (this.conduit.websocket) {
+		return;
+	}
+
 	const model = this.conduit.params.model,
 	      is_system_route = this.conduit.route.is_system_route;
 
-	this.set('toolbar_manager', this.toolbar_manager);
-	
 	// If this is not a system route and no model is defined in the parameters,
 	// do not queue a model fallback
 	if (is_system_route && !model) {
@@ -60,4 +63,31 @@ ChimeraController.enforceProperty(function toolbar_manager(new_value) {
 	}
 
 	return new_value;
+});
+
+/**
+ * Set the toolbar manager as a template variable.
+ * This must be called at the END of each action, after the document context
+ * has been set up. Calling it too early (like in beforeAction) causes the
+ * manager to be serialized before the document_watcher is set.
+ *
+ * For actions that don't call setContextDocument(), this will clear the
+ * document_watcher to ensure the avatar doesn't persist from previous pages.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Object}   options
+ * @param    {Boolean}  options.has_document   Whether this action has a document context
+ */
+ChimeraController.setMethod(function setToolbarManagerVariable(options) {
+
+	// If no document context was set for this action, clear the document watcher
+	// This ensures the avatar doesn't persist when navigating from edit to list pages
+	if (!options?.has_document) {
+		this.toolbar_manager.setDocument(null);
+	}
+
+	this.set('toolbar_manager', this.toolbar_manager);
 });

package/controller/chimera_editor_controller.js

@@ -51,10 +51,10 @@ Editor.setMethod(function setTitle(title) {
  *
  * @param    {Document}    doc
  */
-Editor.setMethod(function setContextDocument(doc) {
+Editor.setMethod(async function setContextDocument(doc) {
 	let document_watcher = this.toolbar_manager.setDocument(doc);
 	this.toolbar_manager.setModel(doc.$model_name);
-	document_watcher.addWatcher(this.conduit);
+	await document_watcher.addWatcher(this.conduit);
 });
 
 /**
@@ -79,6 +79,7 @@ Editor.setAction(function index(conduit, model_name) {
 
 	this.set('widget_config', widget_config);
 
+	this.setToolbarManagerVariable();
 	this.render('chimera/editor/index');
 });
 
@@ -133,6 +134,7 @@ Editor.setAction(async function add(conduit, model_name) {
 	this.set('widget_config', widget_config);
 	this.setTitle(model.constructor.title + ' Add');
 
+	this.setToolbarManagerVariable();
 	this.render('chimera/editor/add');
 });
 
@@ -201,13 +203,17 @@ Editor.setAction(async function edit(conduit, model_name, pk_val) {
 		this.set('add_preview_button', true);
 	}
 
-	this.setContextDocument(record);
+	await this.setContextDocument(record);
 
 	this.set('record_pk', record.$pk);
 	this.set('model_name', model.model_name);
 	this.set('widget_config', widget_config);
 	this.setTitle(model.constructor.title + ' Edit');
 
+	// Set toolbar_manager AFTER document context is set up
+	// Pass has_document: true since we have a document context
+	this.setToolbarManagerVariable({has_document: true});
+
 	this.render('chimera/editor/edit');
 });
 
@@ -283,15 +289,52 @@ Editor.setAction(async function trash(conduit, model_name, pk_val) {
 
 	this.set('back_url', referer);
 	this.set('record', record);
+	this.setToolbarManagerVariable();
 	this.render('chimera/editor/trash');
 });
 
+/**
+ * The task monitor action - shows live progress of a running task
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Conduit}   conduit
+ * @param    {String}    task_history_id
+ */
+Editor.setAction(async function taskMonitor(conduit, task_history_id) {
+
+	let TaskHistory = this.getModel('System.TaskHistory');
+	let history_doc = await TaskHistory.findByPk(task_history_id);
+
+	if (!history_doc) {
+		return conduit.notFound('Task history record not found');
+	}
+
+	// Get the associated System.Task document if available
+	let system_task = null;
+	if (history_doc.system_task_id) {
+		let SystemTask = this.getModel('System.Task');
+		system_task = await SystemTask.findByPk(history_doc.system_task_id);
+	}
+
+	this.setTitle('Task Monitor: ' + (system_task?.title || history_doc.type));
+
+	this.set('task_history_id', task_history_id);
+	this.set('history_doc', history_doc);
+	this.set('system_task', system_task);
+
+	this.setToolbarManagerVariable();
+	this.render('chimera/editor/task_monitor');
+});
+
 /**
  * The records API action
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.0.0
- * @version  1.2.0
+ * @version  1.3.0
  *
  * @param    {Conduit}   conduit
  * @param    {String}    model_name
@@ -343,15 +386,12 @@ Editor.setAction(async function records(conduit, model_name) {
 				continue;
 			}
 
-			val = RegExp.interpretWildcard('*' + val + '*', 'i');
-			crit.where(key).equals(val);
+			crit.where(key).matchesFilter(val);
 		}
 	}
 
 	let records = await model.find('all', crit),
-	    result = [],
-	    record,
-	    main;
+	    record;
 	
 	records.keepPrivateFields();
 
@@ -377,7 +417,11 @@ Editor.setAction(async function records(conduit, model_name) {
 			})
 		});
 
+		// Get any custom row actions defined on the model
+		let custom_actions = model.chimera.getRowActionsFor(record);
+
 		record.$hold.actions = [
+			...custom_actions,
 			edit_action,
 			trash_action,
 		];

package/controller/chimera_settings_controller.js

@@ -37,5 +37,6 @@ SettingsController.setAction(async function editor(conduit) {
 
 	this.set('settings_config', settings_config);
 
+	this.setToolbarManagerVariable();
 	this.render('chimera/settings/editor');
 });

package/controller/chimera_static_controller.js

@@ -12,15 +12,176 @@ const ChimeraStatic = Function.inherits('Alchemy.Controller.Chimera', 'Static');
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.1.0
- * @version  1.0.0
+ * @version  1.4.0
  *
  * @param    {Conduit}   conduit
  */
-ChimeraStatic.setAction(function dashboard(conduit) {
+ChimeraStatic.setAction(async function dashboard(conduit) {
+
+	const DashboardConfig = this.getModel('Chimera.DashboardConfig');
+
+	let user_id = conduit.session('UserData')?.$pk;
+	let config;
+	let is_user_dashboard = false;
+
+	// First, try to find a user-specific dashboard
+	if (user_id) {
+		config = await DashboardConfig.find('first', {
+			conditions: {
+				user_id: user_id,
+			}
+		});
+
+		if (config) {
+			is_user_dashboard = true;
+		}
+	}
+
+	// Fall back to the default dashboard
+	if (!config) {
+		config = await DashboardConfig.find('first', {
+			conditions: {
+				is_default: true,
+			}
+		});
+	}
+
+	// If no default exists, create one
+	if (!config) {
+		config = DashboardConfig.createDocument({
+			name       : 'Default Dashboard',
+			is_default : true,
+			widgets    : null,
+		});
+
+		await config.save();
+
+		// Re-fetch to ensure we have the full document with _id
+		config = await DashboardConfig.findByPk(config.$pk);
+	}
+
+	// Get the toolbar manager (created by ChimeraController base class)
+	let manager = this.toolbar_manager;
+
+	// Set the document on the manager for editing
+	manager.setDocument(config);
+
+	// Add dashboard-specific info and buttons to the toolbar manager
+	manager.is_user_dashboard = is_user_dashboard;
+	manager.has_user_id = !!user_id;
+
+	// Add dashboard management buttons
+	if (user_id) {
+		if (is_user_dashboard) {
+			// User has a custom dashboard - show reset button
+			manager.addTemplateToRender('buttons', 'chimera/toolbar/reset_dashboard_button');
+		} else {
+			// User is viewing default - show customize button
+			manager.addTemplateToRender('buttons', 'chimera/toolbar/customize_dashboard_button');
+		}
+	}
+
 	this.set('pagetitle', 'Dashboard');
+	this.set('dashboard_config', config);
+	this.set('is_user_dashboard', is_user_dashboard);
+	this.setToolbarManagerVariable();
 	this.render('chimera/dashboard');
 });
 
+/**
+ * Create a personalized dashboard for the current user
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {Conduit}   conduit
+ */
+ChimeraStatic.setAction(async function customizeDashboard(conduit) {
+
+	const DashboardConfig = this.getModel('Chimera.DashboardConfig');
+
+	let user_id = conduit.session('UserData')?.$pk;
+
+	if (!user_id) {
+		return conduit.error(new Error('You must be logged in to customize the dashboard'));
+	}
+
+	// Check if user already has a custom dashboard
+	let existing = await DashboardConfig.find('first', {
+		conditions: {
+			user_id: user_id,
+		}
+	});
+
+	if (existing) {
+		return conduit.end({
+			success: true,
+			message: 'You already have a customized dashboard',
+			pk: existing.$pk,
+		});
+	}
+
+	// Find the default dashboard to copy from
+	let default_config = await DashboardConfig.find('first', {
+		conditions: {
+			is_default: true,
+		}
+	});
+
+	// Create a new dashboard for this user
+	let user_dashboard = DashboardConfig.createDocument({
+		name       : 'My Dashboard',
+		is_default : false,
+		user_id    : user_id,
+		widgets    : default_config?.widgets || null,
+	});
+
+	await user_dashboard.save();
+
+	conduit.end({
+		success: true,
+		message: 'Dashboard customized',
+		pk: user_dashboard.$pk,
+	});
+});
+
+/**
+ * Reset the user's dashboard back to default
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {Conduit}   conduit
+ */
+ChimeraStatic.setAction(async function resetDashboard(conduit) {
+
+	const DashboardConfig = this.getModel('Chimera.DashboardConfig');
+
+	let user_id = conduit.session('UserData')?.$pk;
+
+	if (!user_id) {
+		return conduit.error(new Error('You must be logged in to reset the dashboard'));
+	}
+
+	// Find and remove the user's custom dashboard
+	let user_dashboard = await DashboardConfig.find('first', {
+		conditions: {
+			user_id: user_id,
+		}
+	});
+
+	if (user_dashboard) {
+		await user_dashboard.remove();
+	}
+
+	conduit.end({
+		success: true,
+		message: 'Dashboard reset to default',
+	});
+});
+
 /**
  * The sidebar action
  *

package/controller/system_task_controller.js

@@ -0,0 +1,224 @@
+/**
+ * System Task controller for Chimera
+ *
+ * @constructor
+ * @extends       Alchemy.Controller.Chimera
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+const SystemTask = Function.inherits('Alchemy.Controller.Chimera', 'SystemTask');
+
+/**
+ * Run a task manually
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Conduit}              conduit
+ * @param    {Document.SystemTask}  system_task   The task to run (auto-populated from route)
+ */
+SystemTask.setAction(async function run(conduit, system_task) {
+
+	if (!system_task) {
+		return conduit.error(new Error('Task not found'));
+	}
+
+	if (!system_task.type) {
+		return conduit.error(new Error('Task has no type configured'));
+	}
+
+	if (!system_task.enabled) {
+		return conduit.error(new Error('Task is disabled'));
+	}
+
+	try {
+		let task_instance = await alchemy.task_service.startTaskManually(system_task);
+
+		// Get the task history document ID for live monitoring
+		let task_history_id = task_instance.id;
+
+		conduit.end({
+			success         : true,
+			message         : 'Task started successfully',
+			task_id         : system_task.$pk,
+			task_history_id : task_history_id,
+		});
+	} catch (err) {
+		conduit.error(err);
+	}
+});
+
+/**
+ * Monitor a running task via linkup
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Conduit}   conduit
+ * @param    {Linkup}    linkup
+ * @param    {Object}    config
+ */
+SystemTask.setAction(async function monitor(conduit, linkup, config) {
+
+	const task_history_id = config?.task_history_id;
+
+	if (!task_history_id) {
+		linkup.submit('error', {message: 'No task history ID provided'});
+		linkup.destroy();
+		return;
+	}
+
+	// Get the TaskHistory model and find the record
+	const TaskHistory = Model.get('System.TaskHistory');
+	const history_doc = await TaskHistory.findByPk(task_history_id);
+
+	if (!history_doc) {
+		linkup.submit('error', {message: 'Task history record not found'});
+		linkup.destroy();
+		return;
+	}
+
+	// Find the running task instance
+	const running = alchemy.shared('Task.running', 'Array');
+	let task_instance = running.find(t => t.id === task_history_id);
+
+	// Helper to get current task state
+	// Prefers in-memory task instance values over database values when available,
+	// because the database save may be pending (async)
+	const getTaskState = async () => {
+
+		let is_running,
+		    started_at,
+		    ended_at,
+		    had_error;
+
+		if (task_instance) {
+			// Use in-memory task instance state (more up-to-date than database)
+			is_running = task_instance.has_started && !task_instance.has_stopped;
+			started_at = task_instance.started ? new Date(task_instance.started) : history_doc.started_at;
+			ended_at = task_instance.stopped ? new Date(task_instance.stopped) : history_doc.ended_at;
+			had_error = task_instance.error ? true : history_doc.had_error;
+		} else {
+			// Task instance not in memory - re-fetch from database for latest state
+			let fresh_doc = await TaskHistory.findByPk(task_history_id);
+			is_running = fresh_doc?.is_running ?? false;
+			started_at = fresh_doc?.started_at ?? history_doc.started_at;
+			ended_at = fresh_doc?.ended_at ?? history_doc.ended_at;
+			had_error = fresh_doc?.had_error ?? history_doc.had_error;
+		}
+
+		return {
+			id          : task_history_id,
+			type        : history_doc.type,
+			started_at  : started_at,
+			ended_at    : ended_at,
+			is_running  : is_running,
+			had_error   : had_error,
+			percentage  : task_instance?.percentage ?? null,
+			reports     : task_instance?.reports ?? [],
+			is_paused   : task_instance?.is_paused ?? false,
+			can_stop    : task_instance?.can_be_stopped ?? false,
+			can_pause   : task_instance?.can_be_paused ?? false,
+		};
+	};
+
+	// Send initial state
+	linkup.submit('state', await getTaskState());
+
+	// Check if task is still actively running
+	const is_task_running = task_instance && task_instance.has_started && !task_instance.has_stopped;
+
+	if (is_task_running) {
+		// Task is actively running - subscribe to its events
+
+		// When task completes, send final state and re-fetch the document
+		const check_completion = async () => {
+			// Re-fetch the history document to get final state
+			const updated_doc = await TaskHistory.findByPk(task_history_id);
+
+			if (updated_doc && !updated_doc.is_running) {
+				linkup.submit('complete', {
+					ended_at     : updated_doc.ended_at,
+					had_error    : updated_doc.had_error,
+					error_message: updated_doc.error_message,
+				});
+			}
+		};
+
+		// Listen for report events
+		const on_report = async (report) => {
+			linkup.submit('report', report);
+			linkup.submit('progress', {
+				percentage: task_instance.percentage,
+				is_paused: task_instance.is_paused,
+			});
+
+			// When the task is done, send the completion state and clean up listener
+			if (report.done) {
+				task_instance.off('report', on_report);
+				await check_completion();
+			}
+		};
+
+		task_instance.on('report', on_report);
+
+		// Handle stop command from client
+		linkup.on('stop', async () => {
+			if (task_instance && task_instance.can_be_stopped) {
+				await task_instance.stop();
+				linkup.submit('stopped');
+			}
+		});
+
+		// Handle pause command from client
+		linkup.on('pause', () => {
+			if (task_instance && task_instance.can_be_paused && !task_instance.is_paused) {
+				task_instance.pause();
+				linkup.submit('paused');
+			}
+		});
+
+		// Handle resume command from client
+		linkup.on('resume', () => {
+			if (task_instance && task_instance.is_paused) {
+				task_instance.resume();
+				linkup.submit('resumed');
+			}
+		});
+
+		// Clean up when linkup is destroyed
+		linkup.on('destroyed', () => {
+			if (task_instance) {
+				task_instance.off('report', on_report);
+			}
+		});
+
+	} else {
+		// Task is not running (either completed or never started)
+		// Send completed state using the most up-to-date values
+		let ended_at, had_error, error_message;
+
+		if (task_instance && task_instance.has_stopped) {
+			// Task instance exists but has stopped - use in-memory values
+			ended_at = task_instance.stopped ? new Date(task_instance.stopped) : null;
+			had_error = task_instance.error ? true : false;
+			error_message = task_instance.error?.message || null;
+		} else {
+			// No task instance - re-fetch from database for latest state
+			let fresh_doc = await TaskHistory.findByPk(task_history_id);
+			ended_at = fresh_doc?.ended_at;
+			had_error = fresh_doc?.had_error;
+			error_message = fresh_doc?.error_message;
+		}
+
+		linkup.submit('complete', {
+			ended_at     : ended_at,
+			had_error    : had_error,
+			error_message: error_message,
+		});
+	}
+});

package/element/chimera_dashboard_button.js

@@ -0,0 +1,100 @@
+/**
+ * The chimera-dashboard-button element
+ * A button that handles "customize" and "reset" dashboard actions
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+const DashboardButton = Function.inherits('Alchemy.Element.Form.Button', 'Alchemy.Element.Chimera', 'DashboardButton');
+
+/**
+ * Set the custom element prefix to 'chimera'
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+DashboardButton.setStatic('custom_element_prefix', 'chimera');
+
+/**
+ * The action to perform: 'customize' or 'reset'
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+DashboardButton.setAttribute('action');
+
+/**
+ * The element has been added to the dom for the first time
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+DashboardButton.setMethod(function introduced() {
+
+	// Call parent introduced first (sets up click/keyup listeners)
+	introduced.super.call(this);
+
+	// Listen to the activate event (emitted by parent Button class on click)
+	this.addEventListener('activate', async e => {
+		await this.handleAction();
+	});
+});
+
+/**
+ * Handle the dashboard action
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+DashboardButton.setMethod(async function handleAction() {
+
+	let action = this.action;
+
+	if (!action || (action !== 'customize' && action !== 'reset')) {
+		console.error('Invalid dashboard button action:', action);
+		return;
+	}
+
+	this.setState('busy');
+
+	let route_name = action === 'customize'
+		? 'Chimera.Static#customizeDashboard'
+		: 'Chimera.Static#resetDashboard';
+
+	try {
+		await this.hawkejs_helpers.Alchemy.getResource({
+			name   : route_name,
+			method : 'post',
+		});
+
+		this.setState('done');
+
+		// After a short delay, replace this button with the opposite action button
+		setTimeout(() => {
+			let template = action === 'customize'
+				? 'chimera/toolbar/reset_dashboard_button'
+				: 'chimera/toolbar/customize_dashboard_button';
+
+			hawkejs.renderToElements(template, {}, (err, elements) => {
+
+				if (err) {
+					console.error('Failed to render replacement button:', err);
+					return;
+				}
+
+				if (elements && elements.length > 0) {
+					this.replaceWith(elements[0]);
+				}
+			});
+		}, 500);
+
+	} catch (err) {
+		console.error('Failed to execute dashboard action:', err);
+		this.setState('error', 3000, 'default');
+	}
+});