@onehat/data 1.18.13 → 1.19.0

package/cypress/e2e/Property/Property.cy.js

@@ -127,6 +127,94 @@ describe('Property', function() {
 			expect(property.isTempId).to.be.true;
 		});
 
+		it('getModel', function() {
+
+			// fails when name is incorrect
+			let error = null;
+			try {
+				this.property.modelName;
+			} catch(err) {
+				error = err.message;
+			}
+			expect(error).to.eq('this.name is not in the correct format for modelName.');
+	
+			const
+				schema = new Schema({
+					name: 'foo',
+					model: {
+						idProperty: 'model__field',
+						displayProperty: 'model__field',
+						properties: [
+							{ name: 'model__field', },
+						],
+					},
+				}),
+				entity = new Entity(schema);
+				
+			entity.initialize();
+			const property = entity.getProperty('model__field');
+
+			expect(property.modelName).to.be.eq('model');
+		});
+	
+		it('OneBuild properties', function() {
+
+			expect(this.property.isVirtual).to.be.false;
+			expect(this.property.title).to.be.null;
+			expect(this.property.tooltip).to.be.null;
+			expect(this.property.fieldGroup).to.be.null;
+			expect(this.property.isForeignModel).to.be.false;
+			expect(this.property.filterType).to.be.null;
+			expect(this.property.isFilteringDisabled).to.be.false;
+			expect(this.property.editorType).to.be.null;
+			expect(this.property.isEditingDisabled).to.be.false;
+	
+			const
+				filterType = {
+					type: 'Combo',
+					loadAfterRender: false,
+				},
+				editorType = {
+					type: 'Input',
+				},
+				schema = new Schema({
+					name: 'foo',
+					model: {
+						idProperty: 'model__field',
+						displayProperty: 'model__field',
+						properties: [
+							{
+								name: 'model__field',
+								isVirtual: true,
+								title: 'title',
+								tooltip: 'tooltip',
+								fieldGroup: 'fieldGroup',
+								isForeignModel: true,
+								filterType,
+								isFilteringDisabled: true,
+								editorType,
+								isEditingDisabled: true,
+							},
+						],
+					},
+				}),
+				entity = new Entity(schema);
+				
+			entity.initialize();
+			const property = entity.getProperty('model__field');
+			
+			expect(property.isVirtual).to.be.true;
+			expect(property.title).to.be.eq('title');
+			expect(property.tooltip).to.be.eq('tooltip');
+			expect(property.fieldGroup).to.be.eq('fieldGroup');
+			expect(property.isForeignModel).to.be.true;
+			expect(property.filterType).to.be.eql(filterType);
+			expect(property.isFilteringDisabled).to.be.true;
+			expect(property.editorType).to.be.eql(editorType);
+			expect(property.isEditingDisabled).to.be.true;
+		});
+
+
 	});
 
 	describe('setters', function() {

package/cypress/e2e/Repository/OneBuild.cy.js

@@ -63,7 +63,83 @@ describe('OneBuildRepository', function() {
 		expect(p.conditions.key2).to.be.eq('2');
 	});
 
-	it('401', function() {
+	it.only('getTitles, getVirtualdPropertyNames, getIsFilteringDisabledPropertyNames, getIsEditingDisabledPropertyNames, getFieldGroupNames, getFilterTypes', function() {
+		let repository;
+		(async () => {
+			repository = await this.oneHatData.createRepository({
+				schema: {
+					id: 'foo',
+					name: 'foo',
+					model: {
+						idProperty: 'model__field1',
+						displayProperty: 'model__field2',
+						properties: [
+							{
+								name: 'model__field1',
+								isVirtual: true,
+								isFilteringDisabled: false,
+								filterType: {
+									type: 'Combo',
+									loadAfterRender: false,
+								},
+								isEditingDisabled: true,
+								fieldGroup: 'group1',
+							},
+							{
+								name: 'model__field2',
+								isVirtual: true,
+								isFilteringDisabled: true,
+								isEditingDisabled: false,
+								fieldGroup: 'group1',
+							},
+							{
+								name: 'model__field3',
+								isVirtual: false,
+								isFilteringDisabled: true,
+								isEditingDisabled: true,
+								fieldGroup: 'group2',
+							},
+						],
+					},
+					repository: {
+						type: 'onebuild',
+					},
+				},
+			});
+
+			const
+				virtualPropertyNames = [
+					'model__field1',
+					'model__field2',
+				],
+				isFilteringDisabledPropertyNames = [
+					'model__field2',
+					'model__field3',
+				],
+				isEditingDisabledPropertyNames = [
+					'model__field1',
+					'model__field3',
+				],
+				fieldGroupNames = [
+					'group1',
+					'group2',
+				],
+				filterTypes = [
+					{
+						type: 'Combo',
+						loadAfterRender: false,
+					},
+				];
+			expect(repository.getVirtualPropertyNames()).to.be.eql(virtualPropertyNames);
+			expect(repository.getIsFilteringDisabledPropertyNames()).to.be.eql(isFilteringDisabledPropertyNames);
+			expect(repository.getIsEditingDisabledPropertyNames()).to.be.eql(isEditingDisabledPropertyNames);
+			expect(repository.getFieldGroupNames()).to.be.eql(fieldGroupNames);
+			expect(repository.getFilterTypes()).to.be.eql(filterTypes);
+			
+		})();
+	});
+
+	it.skip('401', function() {
 		cy.wrap((async () => {
 
 			let loggedOut = false,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@onehat/data",
-	"version": "1.18.13",
+	"version": "1.19.0",
 	"description": "JS data modeling package with adapters for many storage mediums.",
 	"main": "src/index.js",
 	"type": "module",

package/src/Property/Property.js

@@ -89,45 +89,55 @@ export default class Property extends EventEmitter {
 			 */
 			isTempId: false,
 
+			// ##################################################################
+			// #### These next properties are only for OneBuild repositories ####
+			// ##################################################################
 
+			/**
+			 * @member {boolean} isVirtual - Whether this property represents a virtual field on server
+			 */
+			isVirtual: false,
+			
+			/**
+			 * @member {string} title - The human-readable title for this property
+			 */
+			title: null,
+			
+			/**
+			 * @member {string} tooltip - The human-readable tooltip for this property
+			 */
+			tooltip: null,
+			
+			/**
+			 * @member {string} fieldGroup - The field group for this property
+			 */
+			fieldGroup: null,
+
+			/**
+			 * @member {boolean} isForeignModel - Whether this property belongs to a foreign model
+			 */
+			isForeignModel: false,
+			
+			/**
+			 * @member {object} filterType - The UI filter type of this property
+			 */
+			filterType: null,
+
+			/**
+			 * @member {boolean} isFilteringDisabled - Whether this property is disabled for UI filtering
+			 */
+			isFilteringDisabled: false,
+			
+			/**
+			 * @member {object} editorType - The UI editor type of this property
+			 */
+			editorType: null,
+
+			/**
+			 * @member {boolean} isEditingDisabled - Whether this property is disabled for UI editing
+			 */
+			isEditingDisabled: false,
 
-			// OneBuild META attributes, just bring these over wholesale for now
-			// id: null,
-			// table_id: null,
-			// field_name: null,
-			// client_name: null,
-			// title: null,
-			// is_id_field: null,
-			// is_display_field: null,
-			// is_virtual: null,
-			// pk: null,
-			// fk: null,
-			// exclude: null,
-			// is_editable: null,
-			// date_format: null,
-			// field_group_id: null,
-			// field_type_id: null,
-			// field_data_type_id: null,
-			// sort_order: null,
-			// o_length: null,
-			// o_unsigned: null,
-			// allow_null: true,
-			// o_default: null,
-			// extra: null,
-			// o_zerofill: null,
-			// o_binary: null,
-			// o_encoding: null,
-			// o_collation: null,
-			// comment: null,
-			// xtype: null,
-			// options: null,
-			// tooltip: null,
-			// help_text: null,
-
-
-			// TODO: Room for future development of Property
-			// unique: false, // Boolean
-			// validators: null, // Object[]
 		};
 		
 		_.merge(this, defaults, config);
@@ -318,6 +328,25 @@ export default class Property extends EventEmitter {
 		return entity.getDisplayProperty() === this;
 	}
 
+	/**
+	 * Gets the model name from this property
+	 * NOTE: Only for OneBuild repositories!
+	 * @return {any} submitValue
+	 */
+	get modelName() {
+		if (this.isDestroyed) {
+			throw Error('this.modelName is no longer valid. Property has been destroyed.');
+		}
+		if (!this.name.match(/__/)) {
+			throw Error('this.name is not in the correct format for modelName.');
+		}
+
+		const
+			matches = this.name.match(/^([\w_]+)__/),
+			modelName = matches[1];
+		return modelName;
+	}
+
 
 
 

package/src/Repository/OneBuild.js

@@ -425,6 +425,81 @@ class OneBuildRepository extends AjaxRepository {
 				return response;
 			});
 	}
+	
+	getVirtualPropertyNames = () => {
+		if (this.isDestroyed) {
+			this.throwError('this.getVirtualPropertyNames is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const found = [];
+		_.each(this.schema.model.properties, (property) => {
+			if (property.isVirtual) {
+				found.push(property.name);
+			}
+		});
+		return found;
+	}
+	
+	getIsFilteringDisabledPropertyNames = () => {
+		if (this.isDestroyed) {
+			this.throwError('this.getIsFilteringDisabledPropertyNames is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const found = [];
+		_.each(this.schema.model.properties, (property) => {
+			if (property.isFilteringDisabled) {
+				found.push(property.name);
+			}
+		});
+		return found;
+	}
+	
+	getIsEditingDisabledPropertyNames = () => {
+		if (this.isDestroyed) {
+			this.throwError('this.getIsEditingDisabledPropertyNames is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const found = [];
+		_.each(this.schema.model.properties, (property) => {
+			if (property.isEditingDisabled) {
+				found.push(property.name);
+			}
+		});
+		return found;
+	}
+	
+	getFieldGroupNames = () => {
+		if (this.isDestroyed) {
+			this.throwError('this.getFieldGroupNames is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const found = [];
+		_.each(this.schema.model.properties, (property) => {
+			if (!_.isNil(property.fieldGroup) && !found.includes(property.fieldGroup)) {
+				found.push(property.fieldGroup);
+			}
+		});
+		return found;
+	}
+	
+	getFilterTypes = () => {
+		if (this.isDestroyed) {
+			this.throwError('this.getFilterTypes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const found = [];
+		_.each(this.schema.model.properties, (property) => {
+			if (!_.isNil(property.filterType) && !found.includes(property.filterType)) {
+				found.push(property.filterType);
+			}
+		});
+		return found;
+	}
 
 
 	//   ______