@Override public void processReference(IEntity currentEntity, IEntity existingEntity, MetaRelationship metaRelationship) { isIgnore.set(true); if (metaRelationship.getRelationType() == RelationTypeEnum.Embedded && (operation.get() == Operation.MODIFY || operation.get() == Operation.REPLACE)) { isIgnore.set(false); } }
private List<MetaRelationship> getStrongFromReferences(MetaClass metaCls) { List<MetaRelationship> refFieldList = new LinkedList<MetaRelationship>(); for (MetaRelationship metaRef : metaCls.getFromReference()) { if (metaRef.getRelationType() == RelationTypeEnum.Reference && metaRef.getConsistencyType() == MetaRelationship.ConsistencyTypeEnum.Strong) { refFieldList.add(metaRef); } } return refFieldList; }
@Override public Collection<String> getVisitFields(IEntity currentEntity) { List<String> fieldNames = new LinkedList<String>(); fieldNames.add(InternalFieldEnum.ID.getName()); MetaClass metadata = currentEntity.getMetaClass(); for (MetaField field : metadata.getFields()) { if (field instanceof MetaRelationship) { MetaRelationship ref = (MetaRelationship) field; if (ref.getRelationType() == RelationTypeEnum.Embedded || ref.getRelationType() == RelationTypeEnum.Inner) { fieldNames.add(ref.getName()); } } } return fieldNames; }
public void preFieldOperationCheck(IEntity entity, String fieldName, boolean isModifyField) { MetaField mField = entity.getMetaClass().getFieldByName(fieldName); if (mField instanceof MetaRelationship) { MetaRelationship rel = (MetaRelationship) mField; if (rel.getRelationType() == RelationTypeEnum.Inner) { throw new CmsEntMgrException(EntMgrErrCodeEnum.INNER_RELATIONSHIP_IMMUTABLE, MessageFormat.format( "inner relationship {0} is immutable", fieldName)); } // modify field doesn't allowed on embed relationship // FIXME: should we disallow the "delete field" on embed // relationship? if (rel.getRelationType() == RelationTypeEnum.Embedded && isModifyField) { throw new CmsEntMgrException(EntMgrErrCodeEnum.EMBED_RELATIONSHIP_IMMUTABLE, MessageFormat.format( "embed relationship {0} is immutable", fieldName)); } } }
@Override public void processReference(IEntity currentEntity, IEntity existingEntity, MetaRelationship metaRelationship) { if (metaRelationship.getRelationType() == RelationTypeEnum.Inner) { String fieldName = metaRelationship.getName(); if (currentEntity.hasField(fieldName)) { throw new CmsEntMgrException(EntMgrErrCodeEnum.INNER_RELATIONSHIP_IMMUTABLE, String.format("inner relationship %s is immutable", fieldName)); } } }
@JsonIgnore public List<MetaField> getEmbedWithExprs() { List<MetaField> expressionFields = new ArrayList<MetaField>(); List<MetaRelationship> relations = getToReference(); for (MetaRelationship rel : relations) { if (rel.getRelationType() == RelationTypeEnum.Embedded && rel.getRefMetaClass().hasExpressionFields()) { expressionFields.add(rel); } } return expressionFields; }
@JsonIgnore public List<MetaField> getEmbedWithValidations() { List<MetaField> embedRels = new ArrayList<MetaField>(); List<MetaRelationship> relations = getToReference(); for (MetaRelationship rel : relations) { if (rel.getRelationType() == RelationTypeEnum.Embedded && rel.getRefMetaClass().hasValidationFields()) { embedRels.add(rel); } } return embedRels; }
public void checkNoInnerInMeta(MetaClass meta) { for (MetaRelationship ref : meta.getToReference()) { if (ref.getRelationType() == RelationTypeEnum.Inner) { throw new CmsEntMgrException(EntMgrErrCodeEnum.META_CONTAINS_INNER_RELATIONSHIP, MessageFormat.format( "Meta Class {0} contains inner relationship {1}", meta.getName(), ref.getName())); } else if (ref.getRelationType() == RelationTypeEnum.Embedded) { checkNoInnerInMeta(ref.getRefMetaClass()); } } }
/** * @param metadatas */ private void getMetadata(List<MetaClass> baseMetadatas, List<MetaClass> allMetadatas) { for (MetaClass baseMeta : baseMetadatas) { allMetadatas.add(baseMeta); List<MetaRelationship> baseRelationships = baseMeta.getFromReference(); if (!baseRelationships.isEmpty()) { List<MetaClass> outerMetadatas = new LinkedList<MetaClass>(); for (MetaRelationship baseRelationship : baseRelationships) { if (baseRelationship.getRelationType().equals(RelationTypeEnum.Embedded)) { MetaClass fromMeta = baseRelationship.getSourceMetaClass(); outerMetadatas.add(fromMeta); } } getMetadata(outerMetadatas, allMetadatas); } } }
private MetaRelationship getHostInnerRelation(MetaClass hostMeta, String[] idParts, boolean check) { if (!(idParts.length > 2)) { // never be true for check=true case return null; } String fieldName = idParts[idParts.length - 1]; MetaField field = hostMeta.getFieldByName(fieldName); if (field instanceof MetaRelationship && ((MetaRelationship) field).getRelationType() == RelationTypeEnum.Inner) { return (MetaRelationship) field; } if (check) { throw new CmsEntMgrException(EntMgrErrCodeEnum.INVALID_HOST_ENTITY_PATH, MessageFormat.format( "the relationship {0} is not a valid inner relationship in meta class {1}", fieldName, hostMeta.getName())); } return null; }
@Override public Collection<String> getVisitFields(IEntity currentEntity) { List<String> fieldNames = null; MetaClass metaClass = currentEntity.getMetaClass(); for(MetaField metaField : metaClass.getFields()){ String fieldName = metaField.getName(); if(metaField.getDataType() == DataTypeEnum.RELATIONSHIP){ MetaRelationship metaRelationship = (MetaRelationship)metaField; if(metaRelationship.getRelationType() == RelationTypeEnum.Embedded){ if (fieldNames == null) { fieldNames = new LinkedList<String>(); } fieldNames.add(fieldName); } } } if (fieldNames != null) { fieldNames.add(InternalFieldEnum.VERSION.getName()); } return fieldNames; }
@Override public void processAttribute(IEntity currentEntity, IEntity existingEntity, MetaField metaField) { MetaClass metaCls = currentEntity.getMetaClass(); for (MetaRelationship metaRef : metaCls.getToReference()) { if (metaRef.getRelationType() == RelationTypeEnum.Reference && metaRef.getConsistencyType() == MetaRelationship.ConsistencyTypeEnum.Strong) { checkSingleDanglingReference(currentEntity, metaRef); } } }
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); } } }
@Override @SuppressWarnings("unchecked") public void processReference(IEntity currentEntity, MetaRelationship metaRelationship) { for (IEntityAction action : actions) { action.processReference(currentEntity, existingEntity, metaRelationship); } if (metaRelationship.getRelationType() == RelationTypeEnum.Embedded) { IEntity originEntity = existingEntity; Map<String, IEntity> idEntityMap = getEmbedEntities(existingEntity, metaRelationship); List<IEntity> refList = (List<IEntity>) currentEntity.getFieldValues(metaRelationship.getName()); for (IEntity ref : refList) { existingEntity = idEntityMap.get(ref.getId()); ref.traverse(this); } existingEntity = originEntity; } }
private void validateReverseQuery(ParseContext context) { if (reverseReference) { ParseQueryNode lastQueryNode = context.getQueryNode(); MetaClass lastMetaQuery = lastQueryNode.getMetaClass(); MetaClass refClass = this.metaReference.getRefMetaClass(); if (!refClass.isAssignableFrom(lastMetaQuery)) { throw new QueryParseException(QueryErrCodeEnum.SYNTAX_ERROR, MessageFormat.format( "Reverse reference doesn''t match! Expected {0}, but reverse reference is {1}", lastMetaQuery.getName(), refClass.getName())); } if (metaReference.getRelationType() == RelationTypeEnum.Embedded) { throw new QueryParseException(QueryErrCodeEnum.REVERSE_QUERY_ON_EMBED_NOT_SUPPORT, MessageFormat.format( "Reverse query {0} on embed meta class {1} is not supported", metaReference.getName(), metaReference.getSourceDataType())); } } }
public void addReferenceIndexes() { Collection<MetaField> fields = getClassFields(); for (MetaField field : fields) { if (field.getDataType() == DataTypeEnum.RELATIONSHIP && ((MetaRelationship) field).getRelationType() != RelationTypeEnum.Embedded) { String indexName = IndexInfo.INDEX_PREFIX + field.getName() + IndexInfo.INDEX_POSTFIX; IndexInfo relationshipIndex = new IndexInfo(indexName, true); relationshipIndex.addKeyField(field.getName()); options.addIndex(relationshipIndex); } } }
public SearchAction(QueryContext context, ParseQueryNode parseNode) { super(context, parseNode, QueryActionTypeEnum.SEARCH); this.parseNode = parseNode; this.isSubQuery = queryContext.isSubQuery(); this.searchQuery = new SearchQuery(parseNode.getMetaClass(), parseNode.getCriteria(), parseNode.getProjection(), context.getRegistration().searchStrategy); this.searchCost = QueryCostEnum.FullScan.getValue(); MetaRelationship metaRef = parseNode.getMetaReference(); if (metaRef != null && metaRef.getRelationType() == RelationTypeEnum.Embedded) { this.embedSearch = true; } else { this.embedSearch = false; } initSearchOption(); joinner = new SearchCriteriaJoinner(this, this.parseNode); }
@Override protected void processParentVersion(BsonEntity parentEntity, MetaRelationship refField, BsonEntity currentEntity) { //only set parent version on root entity for new entity //for replace entity, isNew is false, meaning given entity must already has parent version set if(parentEntity == null && !helper.isEmbedEntity(currentEntity.getId())) { if(isNew){ currentEntity.addFieldValue(InternalFieldEnum.PVERSION.getName(), IEntity.NO_VERSION); } else { if (!currentEntity.hasField(InternalFieldEnum.PVERSION.getName())) { throw new CmsDalException(DalErrCodeEnum.MISS_RUNTIME_FIELD, "Miss Parent Version"); } } } else if ((refField != null && refField.getRelationType() == RelationTypeEnum.Embedded) || helper.isEmbedEntity(currentEntity.getId())) { // remove version from embed entity currentEntity.removeField(InternalFieldEnum.PVERSION.getName()); } }
@Override protected void processParentVersion(NewBsonEntity parentEntity, MetaRelationship refField, NewBsonEntity currentEntity) { //only set parent version on root entity for new entity //for replace entity, isNew is false, meaning given entity must already has parent version set if(parentEntity == null && !helper.isEmbedEntity(currentEntity.getId())) { if(isNew){ currentEntity.addFieldValue(InternalFieldEnum.PVERSION.getName(), IEntity.NO_VERSION); } else { if (!currentEntity.hasField(InternalFieldEnum.PVERSION.getName())) { throw new CmsDalException(DalErrCodeEnum.MISS_RUNTIME_FIELD, "Miss Parent Version"); } } } else if ((refField != null && refField.getRelationType() == RelationTypeEnum.Embedded) || helper.isEmbedEntity(currentEntity.getId())) { // remove version from embed entity currentEntity.removeField(InternalFieldEnum.PVERSION.getName()); } }
@Override protected void processParentVersion(BsonEntity parentEntity, MetaRelationship refField, BsonEntity currentEntity) { //only set parent version on root entity for new entity //for replace entity, isNew is false, meaning given entity must already has parent version set if(parentEntity == null && !helper.isEmbedEntity(currentEntity.getId())) { if(isNew){ currentEntity.addFieldValue(InternalFieldEnum.PVERSION.getName(), IEntity.NO_VERSION); } else { if (!currentEntity.hasField(InternalFieldEnum.PVERSION.getName())) { throw new CmsDalException(DalErrCodeEnum.MISS_RUNTIME_FIELD, "Miss Parent Version"); } } } else if ((refField != null && refField.getRelationType() == RelationTypeEnum.Embedded) || helper.isEmbedEntity(currentEntity.getId())) { // remove version from embed entity currentEntity.removeField(InternalFieldEnum.PVERSION.getName()); } }