@onehat/data 1.21.20 → 1.22.1

package/src/Repository/Repository.js

@@ -396,6 +396,12 @@ export default class Repository extends EventEmitter {
 		}
 	}
 
+	getModel() {
+		if (!this.isUnique) {
+			return this.name;
+		}
+		return this.name.match(/^([^-]*)-(.*)/)[1]; // converts 'ModelName-22f9915c-79f5-4e86-a25b-9446c7b85b63' to 'ModelName'
+	}
 
 	//     __                    __
 	//    / /   ____  ____ _____/ /
@@ -2127,95 +2133,6 @@ export default class Repository extends EventEmitter {
 	}
 
 
-	//   ______
-	//  /_  __/_______  ___  _____
-	//   / / / ___/ _ \/ _ \/ ___/
-	//  / / / /  /  __/  __(__  )
-	// /_/ /_/   \___/\___/____/
-	
-
-	/**
-	 * Gets the root TreeNodes
-	 */
-	getRootNodes() {
-		this.ensureTree();
-		if (this.isDestroyed) {
-			this.throwError('this.loadRootNodes is no longer valid. Repository has been destroyed.');
-			return;
-		}
-
-		// Look through all entities and pull out the root nodes.
-		// Subclasses of Repository will override this method to get root nodes from server
-		const entities = _.filter(this.getEntities(), (entity) => {
-			return entity.isRoot;
-		})
-		return entities;
-	}
-
-
-	/**
-	 * Populates the TreeNodes with .parent and .children references
-	 */
-	assembleTreeNodes() {
-		this.ensureTree();
-		if (this.isDestroyed) {
-			this.throwError('this.assembleTreeNodes is no longer valid. Repository has been destroyed.');
-			return;
-		}
-
-		const treeNodes = this.getEntities();
-
-		// Reset all parent/child relationships
-		_.each(treeNodes, (treeNode) => {
-			treeNode.parent = null;
-			treeNode.children = [];
-		});
-
-		// Rebuild all parent/child relationships
-		const oThis = this;
-		_.each(treeNodes, (treeNode) => {
-			const parent = oThis.getById(treeNode.parentId);
-			if (parent) {
-				treeNode.parent = parent;
-				parent.children.push(treeNode);
-			}
-		});
-	}
-
-	/**
-	 * Removes the treeNode and all of its children from repository
-	 * without deleting anything on the server
-	 */
-	removeTreeNode(treeNode) {
-		if (!_.isEmpty(treeNode.children)) {
-			const children = treeNode.children;
-			treeNode.parent = null;
-			treeNode.children = [];
-			
-			const oThis = this;
-			_.each(children, (child) => {
-				oThis.removeTreeNode(child);
-			});
-		}
-
-		this.removeEntity(treeNode);
-	}
-
-	/**
-	 * Helper to make sure this Repository is a tree
-	 * @private
-	 */
-	async ensureTree() {
-		if (!this.isTree) {
-			this.throwError('This Repository is not a tree!');
-			return false;
-		}
-		return true;
-	}
-
-
-
-
 
 	//    __  ____  _ ___ __  _          
 	//   / / / / /_(_) (_) /_(_)__  _____

package/src/Repository/Tree.js

@@ -0,0 +1,445 @@
+/** @module Repository */
+
+import Repository from './Repository.js'; // so we can use static methods
+import OneBuildRepository from './OneBuild.js';
+import _ from 'lodash';
+
+
+/**
+ * This class is used for OneBuild Trees
+ * that contain multiple node types.
+ * 
+ * @extends TreeRepository
+ */
+class TreeRepository extends OneBuildRepository {
+	constructor(config = {}) {
+		super(...arguments);
+
+		const defaults = {
+
+			isTree: true,
+			rootNodeType: this.getModel(), // e.g. 'Fleets'
+
+			api: {
+				getNodes: 'getNodes',
+				moveNode: 'moveNode',
+				searchNodes: 'searchNodes',
+			},
+
+			editableNodeTypes: [
+				this.getModel(),
+			],
+
+		};
+		_.merge(this, defaults, config);
+
+	}
+
+	async initialize() {
+
+		this.registerEvents([
+			'loadRootNodes',
+		]);
+
+		await super.initialize();
+	}
+
+	getModelFromTreeNode(treeNode) {
+		return treeNode.nodeType || this.rootNodeType;
+	}
+
+	/**
+	 * Loads the root nodes of this tree.
+	 */
+	loadRootNodes(depth) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.setRootNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		this.emit('beforeLoad'); // TODO: canceling beforeLoad will cancel the load operation
+		this.markLoading();
+
+		const
+			data = _.merge({ depth }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.getNodes;
+
+		if (this.debugMode) {
+			console.log('loadRootNodes', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for loadRootNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				this._destroyEntities();
+
+				// Set the current entities
+				const oThis = this;
+				this.entities = _.map(root, (data) => {
+					const entity = Repository._createEntity(oThis.schema, data, this, true);
+					oThis._relayEntityEvents(entity);
+					return entity;
+				});
+
+				this.assembleTreeNodes();
+				
+				// Set the total records that pass filter
+				this.total = total;
+				this._setPaginationVars();
+
+				this.areRootNodesLoaded = true;
+
+				
+				// Don't emit events for root nodes...
+				this.rehash();
+				this.emit('loadRootNodes', this);
+				// this.emit('changeData', this.entities);
+
+				return this.getBy((entity) => {
+					return entity.isRoot;
+				});
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Loads (or reloads) the supplied treeNode
+	 */
+	loadNode(treeNode, depth = 1) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.loadNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		// If children already exist, remove them from the repository
+		// This way, we can reload just a portion of the tree
+		if (!_.isEmpty(treeNode.children)) {
+			_.each(treeNode.children, (child) => {
+				treeNode.repository.removeTreeNode(child);
+			});
+			treeNode.children = [];
+		}
+		
+		this.markLoading();
+
+		const
+			data = _.merge({ depth, nodeId: treeNode.id, }, this._baseParams, this._params),
+			url = treeNode.getModel() + '/' + this.api.getNodes;
+
+		if (this.debugMode) {
+			console.log('loadNode', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for loadNode', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+				
+				// Set the current entities
+				const oThis = this;
+				const children = _.map(root, (data) => {
+					const entity = Repository._createEntity(oThis.schema, data, this, true);
+					oThis._relayEntityEvents(entity);
+					return entity;
+				});
+
+				this.entities = this.entities.concat(children);
+
+				this.assembleTreeNodes();
+				
+				this._setPaginationVars();
+
+				this.rehash();
+				// this.emit('changeData', this.entities);
+				this.emit('load', this);
+
+				return children;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * alias for backward compatibility
+	 */ 
+	loadChildNodes(treeNode, depth = 1) {
+		return this.loadNode(treeNode, depth);
+	}
+
+	/**
+	 * Override the AjaxRepository to we can reload a treeNode if needed
+	 */
+	reloadEntity(entity, callback = null) {
+		if (!entity.isTree) {
+			return super.reloadEntity(entity, callback);
+		}
+
+		return this.loadNode(entity, 1);
+	}
+
+	/**
+	 * Searches all nodes for the supplied text.
+	 * This basically takes the search query and returns whatever the server sends
+	 */
+	searchNodes(q) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.searchNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		const
+			data = _.merge({ q, }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.searchNodes;
+
+		if (this.debugMode) {
+			console.log('searchNodes', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for searchNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				return root;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Moves the supplied treeNode to a new position on the tree
+	 * @returns id of common ancestor node 
+	 */
+	moveTreeNode(treeNode, newParentId) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.moveTreeNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		const
+			oldParentId = treeNode.parent?.id,
+			data = _.merge({ nodeId: treeNode.id, parentId: newParentId, }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.moveNode;
+
+		// NOTE: The rootNodeType controller needs to know about all the possible nodeTypes,
+		// so any particular node can move all around the tree.
+		
+		if (this.debugMode) {
+			console.log('moveTreeNode', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for searchNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root: {
+						commonAncestorId,
+						oldParent,
+						newParent,
+						node,
+					},
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				// move it from oldParent.children to newParent.children
+				const
+					oldParentRecord = this.getById(oldParentId),
+					newParentRecord = this.getById(newParentId);
+
+				oldParentRecord?.loadOriginalData(oldParent);
+				newParentRecord.loadOriginalData(newParent);
+				treeNode.loadOriginalData(node);
+
+				this.assembleTreeNodes();
+
+				return commonAncestorId;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Gets the root TreeNodes
+	 */
+	getRootNodes() {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.loadRootNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		// Look through all entities and pull out the root nodes.
+		// Subclasses of Repository will override this method to get root nodes from server
+		const entities = _.filter(this.getEntities(), (entity) => {
+			return entity.isRoot;
+		})
+		return entities;
+	}
+
+	/**
+	 * Populates the TreeNodes with .parent and .children references
+	 */
+	assembleTreeNodes() {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.assembleTreeNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const treeNodes = this.getEntities();
+
+		// Reset all parent/child relationships
+		_.each(treeNodes, (treeNode) => {
+			treeNode.parent = null;
+			treeNode.children = [];
+		});
+
+		// Rebuild all parent/child relationships
+		const oThis = this;
+		_.each(treeNodes, (treeNode) => {
+			const parent = oThis.getById(treeNode.parentId);
+			if (parent) {
+				treeNode.parent = parent;
+				parent.children.push(treeNode);
+			}
+		});
+	}
+
+	/**
+	 * Removes the treeNode and all of its children from repository
+	 * without deleting anything on the server
+	 */
+	removeTreeNode(treeNode) {
+		if (!_.isEmpty(treeNode.children)) {
+			const children = treeNode.children;
+			treeNode.parent = null;
+			treeNode.children = [];
+			
+			const oThis = this;
+			_.each(children, (child) => {
+				oThis.removeTreeNode(child);
+			});
+		}
+	
+		this.removeEntity(treeNode);
+	}
+
+	/**
+	 * Helper to make sure this Repository is a tree
+	 * @private
+	 */
+	async ensureTree() {
+		if (!this.isTree) {
+			this.throwError('This Repository is not a tree!');
+			return false;
+		}
+		return true;
+	}
+
+}
+
+
+TreeRepository.className = 'Tree';
+TreeRepository.type = 'tree';
+
+export default TreeRepository;

package/src/Repository/index.js

@@ -7,6 +7,7 @@ import MemoryRepository from './Memory.js';
 import NullRepository from './Null.js';
 import OneBuildRepository from './OneBuild.js';
 import RestRepository from './Rest.js';
+import TreeRepository from './Tree.js';
 
 const CoreRepositoryTypes = {
 	[AjaxRepository.type]: AjaxRepository,
@@ -16,6 +17,7 @@ const CoreRepositoryTypes = {
 	[NullRepository.type]: NullRepository,
 	[OneBuildRepository.type]: OneBuildRepository,
 	[RestRepository.type]: RestRepository,
+	[TreeRepository.type]: TreeRepository,
 };
 
 export default CoreRepositoryTypes;

package/src/Schema/Schema.js

@@ -89,11 +89,6 @@ export default class Schema extends EventEmitter {
 				 */
 				hasChildrenProperty: null,
 
-				/**
-				 * @member {boolean} isTree - Whether this model has hierarchical tree data
-				 */
-				isTree: false,
-
 				/**
 				 * @member {boolean} isAdjacencyList - Whether this tree is an Adjacency List
 				 */