@Override public boolean containsParameter(String name) { MetaClass metadata = inputEntity.getMetaClass(); return metadata.getFieldByName(name) != null; }
public void setSort(List<String> sortFieldNames, List<Integer> sortOrders, MetaClass metaClass) { this.metaClass = metaClass; this.sortOrders = sortOrders; this.sortFields = new ArrayList<ISearchField>(); for (String fieldName : sortFieldNames) { this.sortFields.add(new SelectionField(this.metaClass.getFieldByName(fieldName), strategy)); } }
private MetaField findMetaField(MetaClass metadata, String fieldName) { MetaField metaField = metadata.getFieldByName(fieldName); if (metaField == null) { throw new QueryParseException(QueryErrCodeEnum.METAFIELD_NOT_FOUND, "Can't find field {" + fieldName + "} in metadata " + metadata.getName()); } return metaField; }
private SearchCriteria buildSearchCritiera(String metaName, MetaClass historyMetaClass, int version, ISearchStrategy strategy) { LogicalSearchCriteria logicCriteria = new LogicalSearchCriteria(LogicOperatorEnum.AND); MetaField entityIdField = historyMetaClass.getFieldByName(HistoryMetaClass.EntityId); SearchCriteria idCriteria = new FieldSearchCriteria(entityIdField, strategy, FieldOperatorEnum.EQ, metaName); logicCriteria.addChild(idCriteria); if (version >= 0) { MetaField entityVersionField = historyMetaClass.getFieldByName(HistoryMetaClass.EntityVersion); SearchCriteria versionCriteria = new FieldSearchCriteria(entityVersionField, strategy, FieldOperatorEnum.EQ, version); logicCriteria.addChild(versionCriteria); } return logicCriteria; }
@Override public boolean hasField(String fieldName){ MetaField metaField = getMetaClass().getFieldByName(fieldName); if (metaField == null) { return false; } String dbName = metaField.getDbName(); return bsonObject.containsField(dbName); }
public void removeFieldProperty(String fieldName, String propertyName) { MetaField metaField = getMetaClass().getFieldByName(fieldName); FieldProperty fp = FieldProperty.fromQueryName(propertyName); CheckConditions.checkArgument(fp != null, MessageFormat.format("field property %s not found!", propertyName)); String propertyValueDbName = metaField.getFlattenPropertyValueDbName(fp); bsonObject.removeField(propertyValueDbName); }
private void removeEmbedEntities(IEntity entity) { MetaClass meta = entity.getMetaClass(); Collection<String> fields = entity.getFieldNames(); for (String fieldName : fields) { MetaField field = meta.getFieldByName(fieldName); if (field instanceof MetaRelationship && (((MetaRelationship) field).getRelationType() == RelationTypeEnum.Embedded)) { entity.removeField(fieldName); } } }
public void setFieldProperty(String fieldName, String propertyName, Object value) { FieldProperty property = FieldProperty.fromQueryName(propertyName); CheckConditions.checkArgument(property != null, MessageFormat.format("field property %s not found!", propertyName)); MetaField metaField = getMetaClass().getFieldByName(fieldName); String propertyDbName = metaField.getDbName() + MetaField.VALUE_KEY_CONNECTOR + property.getDbName(); BasicDBObject fieldBsonObject = bsonObject; // FIXME: check value based on the data type fieldBsonObject.put(propertyDbName, value); }
private void checkFieldArgument(BsonEntity entity, String fieldName) { checkArguments(entity.getBranchId(), entity.getId(), entity.getType()); CheckConditions.checkArgument(fieldName != null && !fieldName.isEmpty(), "fieldName can not be empty!"); MetaField field = entity.getMetaClass().getFieldByName(fieldName); CheckConditions.checkArgument(field != null, MessageFormat.format("Can not find field {0} on meta class!", fieldName)); CheckConditions.checkArgument(!field.isInternal(), MessageFormat.format("Can not update internal field {0}!", fieldName)); CheckConditions.checkArgument(!field.isConstant(), MessageFormat.format("Can not update constant field {0}!", fieldName)); }
private void validateKeyList(MetaClass meta, IndexInfo ii) { for (String key : ii.getKeyList()) { if (meta.getFieldByName(key) == null) { throw new IndexOptionOperationException("MetaClass " + meta.getName() + "'sindex " + ii.getIndexName() + " key list contains non-existing field " + key + " in meta " + meta.getName()); } } }
public Object getFieldProperty(String fieldName, String propertyName) { FieldProperty property = FieldProperty.fromQueryName(propertyName); CheckConditions.checkArgument(property != null, MessageFormat.format("field property %s not found!", propertyName)); MetaField metaField = getMetaClass().getFieldByName(fieldName); BasicDBObject fieldBsonObject = getBsonField(metaField.getDbName()); if (fieldBsonObject != null) { return fieldBsonObject.get(property.getDbName()); } else { return null; } }
@Override protected Object getInternalFieldValue(InternalFieldEnum fieldEnum){ String fieldName = fieldEnum.getName(); MetaField metaField = getMetaClass().getFieldByName(fieldName); DataTypeEnum dataType = metaField.getDataType(); IDataTypeHandler handler = JsonDataTypeHandlerFactory.getHandler(dataType); JsonNode jsonValue = jsonObject.get(fieldName); if (jsonValue == null) { return null; } return handler.read(this, jsonValue, metaField); }
public void setFieldProperty(String fieldName, String propertyName, Object value) { FieldProperty property = FieldProperty.fromQueryName(propertyName); CheckConditions.checkArgument(property != null, MessageFormat.format("field property %s not found!", propertyName)); MetaField metaField = getMetaClass().getFieldByName(fieldName); BasicDBObject fieldBsonObject = getOrNewBsonField(metaField.getDbName()); // FIXME: check value based on the data type fieldBsonObject.put(property.getDbName(), value); bsonObject.put(metaField.getDbName(), fieldBsonObject); }
public void setFieldTimestamp(String fieldName, Date date) { MetaField metaField = getMetaClass().getFieldByName(fieldName); BasicDBObject fieldBsonObject = getOrNewBsonField(metaField.getDbName()); fieldBsonObject.put(FieldProperty.TIMESTAMP.getDbName(), date); bsonObject.put(metaField.getDbName(), fieldBsonObject); }
@Test public void testReferenceGetInvalidValue() { BasicDBObject given = new BasicDBObject(); NewBsonEntity appEntity = new NewBsonEntity(appServiceMetadata, given); MetaField refField = appServiceMetadata.getFieldByName(SERVICES); BasicDBObject dbo = new BasicDBObject(); // invalid value dbo.put(MetaField.VALUE_KEY, null); given.put(refField.getName(), dbo); List<?> services = appEntity.getFieldValues(SERVICES); Assert.assertEquals(0, services.size()); }
@Test public void testBooleanGetInvalidValue() { BasicDBObject given = new BasicDBObject(); BsonEntity bsonEntity = new BsonEntity(serviceInstanceMetadata, given); MetaField field = serviceInstanceMetadata.getFieldByName(HTTPS); BasicDBObject dbo = new BasicDBObject(); // add an invalid value dbo.put(MetaField.VALUE_KEY, "true"); given.put(field.getDbName(), dbo); List<?> invalidValue = bsonEntity.getFieldValues(HTTPS); Assert.assertEquals(0, invalidValue.size()); }
@Test public void testSetFieldValue_asEmpty() { NewBsonEntity newEntity = new NewBsonEntity(serviceInstanceMetadata); String fieldName = "manifestRef"; MetaField field = serviceInstanceMetadata.getFieldByName(fieldName); newEntity.setFieldValues(fieldName, Collections.emptyList()); Assert.assertTrue(newEntity.hasField(fieldName)); Assert.assertEquals(Collections.emptyList(), newEntity.getFieldValues(fieldName)); List<?> value = (List<?>) newEntity.getNode().get(field.getFlattenValueDbName()); Assert.assertNotNull(value); Assert.assertEquals(0, value.size()); }
public void setFieldProperty(String fieldName, String propertyName, Object value) { FieldProperty property = FieldProperty.fromQueryName(propertyName); CheckConditions.checkArgument(property != null, MessageFormat.format("field property %s not found!", propertyName)); MetaField metaField = getMetaClass().getFieldByName(fieldName); BasicDBObject fieldBsonObject = getOrNewBsonField(metaField.getDbName()); // FIXME: check value based on the data type fieldBsonObject.put(property.getDbName(), value); bsonObject.put(metaField.getDbName(), fieldBsonObject); }
@Override protected Object getInternalFieldValue(InternalFieldEnum fieldEnum){ MetaField metaField = getMetaClass().getFieldByName(fieldEnum.getName()); String dbValName = metaField.getDbName(); Object bsonValue = bsonObject.get(dbValName); if (bsonValue == null) return null; DataTypeEnum dataType = metaField.getDataType(); IDataTypeHandler handler = BsonDataTypeHandlerFactory.getHandler(dataType); return handler.read(this, bsonValue, metaField); }
private NewBsonEntity newEmployeeEntity() { MetaClass meta = raptorMetaService.getMetaClass("Employee"); MetaAttribute companyField = (MetaAttribute) meta.getFieldByName(COMPANY); Assert.assertTrue(companyField.isConstant()); NewBsonEntity entity = new NewBsonEntity(meta); entity.setBranchId(BRANCH_TEST); entity.addFieldValue("name", "employee-test"); entity.addFieldValue(COMPANY, "ebay-cloud"); entity.addFieldValue(InternalFieldEnum.CREATOR.getName(), "unitTestUser"); return entity; }