@Override
 public FieldProviderResponse addMetadataFromFieldType(
     AddMetadataFromFieldTypeRequest addMetadataFromFieldTypeRequest,
     Map<String, FieldMetadata> metadata) {
   if (!canHandleFieldForTypeMetadata(addMetadataFromFieldTypeRequest, metadata)) {
     return FieldProviderResponse.NOT_HANDLED;
   }
   super.addMetadataFromFieldType(addMetadataFromFieldTypeRequest, metadata);
   // add additional adorned target support
   AdornedTargetCollectionMetadata fieldMetadata =
       (AdornedTargetCollectionMetadata)
           addMetadataFromFieldTypeRequest.getPresentationAttribute();
   if (StringUtils.isEmpty(fieldMetadata.getCollectionCeilingEntity())) {
     fieldMetadata.setCollectionCeilingEntity(
         addMetadataFromFieldTypeRequest.getType().getReturnedClass().getName());
     AdornedTargetList targetList =
         ((AdornedTargetList)
             fieldMetadata
                 .getPersistencePerspective()
                 .getPersistencePerspectiveItems()
                 .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST));
     targetList.setAdornedTargetEntityClassname(fieldMetadata.getCollectionCeilingEntity());
   }
   return FieldProviderResponse.HANDLED;
 }
 @Override
 public FieldProviderResponse overrideViaXml(
     OverrideViaXmlRequest overrideViaXmlRequest, Map<String, FieldMetadata> metadata) {
   Map<String, FieldMetadataOverride> overrides =
       getTargetedOverride(
           overrideViaXmlRequest.getRequestedConfigKey(),
           overrideViaXmlRequest.getRequestedCeilingEntity());
   if (overrides != null) {
     for (String propertyName : overrides.keySet()) {
       final FieldMetadataOverride localMetadata = overrides.get(propertyName);
       for (String key : metadata.keySet()) {
         if (key.equals(propertyName)) {
           try {
             if (metadata.get(key) instanceof AdornedTargetCollectionMetadata) {
               AdornedTargetCollectionMetadata serverMetadata =
                   (AdornedTargetCollectionMetadata) metadata.get(key);
               if (serverMetadata.getTargetClass() != null) {
                 Class<?> targetClass = Class.forName(serverMetadata.getTargetClass());
                 Class<?> parentClass = null;
                 if (serverMetadata.getOwningClass() != null) {
                   parentClass = Class.forName(serverMetadata.getOwningClass());
                 }
                 String fieldName = serverMetadata.getFieldName();
                 Field field =
                     overrideViaXmlRequest
                         .getDynamicEntityDao()
                         .getFieldManager()
                         .getField(targetClass, fieldName);
                 Map<String, FieldMetadata> temp = new HashMap<String, FieldMetadata>(1);
                 temp.put(field.getName(), serverMetadata);
                 FieldInfo info = buildFieldInfo(field);
                 buildAdornedTargetCollectionMetadata(
                     parentClass,
                     targetClass,
                     temp,
                     info,
                     localMetadata,
                     overrideViaXmlRequest.getDynamicEntityDao());
                 serverMetadata = (AdornedTargetCollectionMetadata) temp.get(field.getName());
                 metadata.put(key, serverMetadata);
                 if (overrideViaXmlRequest.getParentExcluded()) {
                   if (LOG.isDebugEnabled()) {
                     LOG.debug(
                         "applyAdornedTargetCollectionMetadataOverrides:Excluding "
                             + key
                             + "because parent is marked as excluded.");
                   }
                   serverMetadata.setExcluded(true);
                 }
               }
             }
           } catch (Exception e) {
             throw new RuntimeException(e);
           }
         }
       }
     }
   }
   return FieldProviderResponse.HANDLED;
 }
  protected void buildAdornedTargetCollectionMetadata(
      Class<?> parentClass,
      Class<?> targetClass,
      Map<String, FieldMetadata> attributes,
      FieldInfo field,
      FieldMetadataOverride adornedTargetCollectionMetadata,
      DynamicEntityDao dynamicEntityDao) {
    AdornedTargetCollectionMetadata serverMetadata =
        (AdornedTargetCollectionMetadata) attributes.get(field.getName());

    Class<?> resolvedClass = parentClass == null ? targetClass : parentClass;
    AdornedTargetCollectionMetadata metadata;
    if (serverMetadata != null) {
      metadata = serverMetadata;
    } else {
      metadata = new AdornedTargetCollectionMetadata();
    }
    metadata.setTargetClass(targetClass.getName());
    metadata.setFieldName(field.getName());

    if (adornedTargetCollectionMetadata.getReadOnly() != null) {
      metadata.setMutable(!adornedTargetCollectionMetadata.getReadOnly());
    }
    if (adornedTargetCollectionMetadata.getShowIfProperty() != null) {
      metadata.setShowIfProperty(adornedTargetCollectionMetadata.getShowIfProperty());
    }

    org.broadleafcommerce.openadmin.dto.OperationTypes dtoOperationTypes =
        new org.broadleafcommerce.openadmin.dto.OperationTypes(
            OperationType.ADORNEDTARGETLIST,
            OperationType.ADORNEDTARGETLIST,
            OperationType.ADORNEDTARGETLIST,
            OperationType.ADORNEDTARGETLIST,
            OperationType.BASIC);
    if (adornedTargetCollectionMetadata.getAddType() != null) {
      dtoOperationTypes.setAddType(adornedTargetCollectionMetadata.getAddType());
    }
    if (adornedTargetCollectionMetadata.getRemoveType() != null) {
      dtoOperationTypes.setRemoveType(adornedTargetCollectionMetadata.getRemoveType());
    }
    if (adornedTargetCollectionMetadata.getFetchType() != null) {
      dtoOperationTypes.setFetchType(adornedTargetCollectionMetadata.getFetchType());
    }
    if (adornedTargetCollectionMetadata.getInspectType() != null) {
      dtoOperationTypes.setInspectType(adornedTargetCollectionMetadata.getInspectType());
    }
    if (adornedTargetCollectionMetadata.getUpdateType() != null) {
      dtoOperationTypes.setUpdateType(adornedTargetCollectionMetadata.getUpdateType());
    }

    // don't allow additional non-persistent properties or additional foreign keys for an advanced
    // collection datasource - they don't make sense in this context
    PersistencePerspective persistencePerspective;
    if (serverMetadata != null) {
      persistencePerspective = metadata.getPersistencePerspective();
      persistencePerspective.setOperationTypes(dtoOperationTypes);
    } else {
      persistencePerspective =
          new PersistencePerspective(dtoOperationTypes, new String[] {}, new ForeignKey[] {});
      metadata.setPersistencePerspective(persistencePerspective);
    }

    String parentObjectProperty = null;
    if (serverMetadata != null) {
      parentObjectProperty =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getLinkedObjectPath();
    }
    if (!StringUtils.isEmpty(adornedTargetCollectionMetadata.getParentObjectProperty())) {
      parentObjectProperty = adornedTargetCollectionMetadata.getParentObjectProperty();
    }
    if (parentObjectProperty == null && !StringUtils.isEmpty(field.getOneToManyMappedBy())) {
      parentObjectProperty = field.getOneToManyMappedBy();
    }
    if (parentObjectProperty == null && !StringUtils.isEmpty(field.getManyToManyMappedBy())) {
      parentObjectProperty = field.getManyToManyMappedBy();
    }
    if (StringUtils.isEmpty(parentObjectProperty)) {
      throw new IllegalArgumentException(
          "Unable to infer a parentObjectProperty for the @AdminPresentationAdornedTargetCollection annotated field("
              + field.getName()
              + "). If not using the mappedBy property of @OneToMany or @ManyToMany, please make sure to explicitly define the parentObjectProperty property");
    }

    String sortProperty = null;
    if (serverMetadata != null) {
      sortProperty =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getSortField();
    }
    if (!StringUtils.isEmpty(adornedTargetCollectionMetadata.getSortProperty())) {
      sortProperty = adornedTargetCollectionMetadata.getSortProperty();
    }

    metadata.setParentObjectClass(resolvedClass.getName());
    if (adornedTargetCollectionMetadata.getMaintainedAdornedTargetFields() != null) {
      metadata.setMaintainedAdornedTargetFields(
          adornedTargetCollectionMetadata.getMaintainedAdornedTargetFields());
    }
    if (adornedTargetCollectionMetadata.getGridVisibleFields() != null) {
      metadata.setGridVisibleFields(adornedTargetCollectionMetadata.getGridVisibleFields());
    }
    String parentObjectIdProperty = null;
    if (serverMetadata != null) {
      parentObjectIdProperty =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getLinkedIdProperty();
    }
    if (adornedTargetCollectionMetadata.getParentObjectIdProperty() != null) {
      parentObjectIdProperty = adornedTargetCollectionMetadata.getParentObjectIdProperty();
    }
    String targetObjectProperty = null;
    if (serverMetadata != null) {
      targetObjectProperty =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getTargetObjectPath();
    }
    if (adornedTargetCollectionMetadata.getTargetObjectProperty() != null) {
      targetObjectProperty = adornedTargetCollectionMetadata.getTargetObjectProperty();
    }

    String joinEntityClass = null;
    if (serverMetadata != null) {
      joinEntityClass =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getJoinEntityClass();
    }
    if (adornedTargetCollectionMetadata.getJoinEntityClass() != null) {
      joinEntityClass = adornedTargetCollectionMetadata.getJoinEntityClass();
    }

    Class<?> collectionTarget = null;
    try {
      checkCeiling:
      {
        try {
          ParameterizedType pt = (ParameterizedType) field.getGenericType();
          java.lang.reflect.Type collectionType = pt.getActualTypeArguments()[0];
          String ceilingEntityName = ((Class<?>) collectionType).getName();
          collectionTarget = entityConfiguration.lookupEntityClass(ceilingEntityName);
          break checkCeiling;
        } catch (NoSuchBeanDefinitionException e) {
          // We weren't successful at looking at entity configuration to find the type of this
          // collection.
          // We will continue and attempt to find it via the Hibernate annotations
        }
        if (!StringUtils.isEmpty(field.getOneToManyTargetEntity())
            && !void.class.getName().equals(field.getOneToManyTargetEntity())) {
          collectionTarget = Class.forName(field.getOneToManyTargetEntity());
          break checkCeiling;
        }
        if (!StringUtils.isEmpty(field.getManyToManyTargetEntity())
            && !void.class.getName().equals(field.getManyToManyTargetEntity())) {
          collectionTarget = Class.forName(field.getManyToManyTargetEntity());
          break checkCeiling;
        }
      }
      if (StringUtils.isNotBlank(joinEntityClass)) {
        collectionTarget = Class.forName(joinEntityClass);
      }
    } catch (ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
    if (collectionTarget == null) {
      throw new IllegalArgumentException(
          "Unable to infer the type of the collection from the targetEntity property of a OneToMany or ManyToMany collection.");
    }
    Field collectionTargetField =
        dynamicEntityDao.getFieldManager().getField(collectionTarget, targetObjectProperty);
    ManyToOne manyToOne = collectionTargetField.getAnnotation(ManyToOne.class);
    String ceiling = null;
    checkCeiling:
    {
      if (manyToOne != null && manyToOne.targetEntity() != void.class) {
        ceiling = manyToOne.targetEntity().getName();
        break checkCeiling;
      }
      ceiling = collectionTargetField.getType().getName();
    }
    if (!StringUtils.isEmpty(ceiling)) {
      metadata.setCollectionCeilingEntity(ceiling);
    }

    String targetObjectIdProperty = null;
    if (serverMetadata != null) {
      targetObjectIdProperty =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getTargetIdProperty();
    }
    if (adornedTargetCollectionMetadata.getTargetObjectIdProperty() != null) {
      targetObjectIdProperty = adornedTargetCollectionMetadata.getTargetObjectIdProperty();
    }
    Boolean isAscending = true;
    if (serverMetadata != null) {
      isAscending =
          ((AdornedTargetList)
                  serverMetadata
                      .getPersistencePerspective()
                      .getPersistencePerspectiveItems()
                      .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST))
              .getSortAscending();
    }
    if (adornedTargetCollectionMetadata.isSortAscending() != null) {
      isAscending = adornedTargetCollectionMetadata.isSortAscending();
    }

    if (serverMetadata != null) {
      AdornedTargetList adornedTargetList =
          (AdornedTargetList)
              serverMetadata
                  .getPersistencePerspective()
                  .getPersistencePerspectiveItems()
                  .get(PersistencePerspectiveItemType.ADORNEDTARGETLIST);
      adornedTargetList.setCollectionFieldName(field.getName());
      adornedTargetList.setLinkedObjectPath(parentObjectProperty);
      adornedTargetList.setLinkedIdProperty(parentObjectIdProperty);
      adornedTargetList.setTargetObjectPath(targetObjectProperty);
      adornedTargetList.setTargetIdProperty(targetObjectIdProperty);
      adornedTargetList.setJoinEntityClass(joinEntityClass);
      adornedTargetList.setAdornedTargetEntityClassname(collectionTarget.getName());
      adornedTargetList.setSortField(sortProperty);
      adornedTargetList.setSortAscending(isAscending);
      adornedTargetList.setMutable(metadata.isMutable());
    } else {
      AdornedTargetList adornedTargetList =
          new AdornedTargetList(
              field.getName(),
              parentObjectProperty,
              parentObjectIdProperty,
              targetObjectProperty,
              targetObjectIdProperty,
              collectionTarget.getName(),
              sortProperty,
              isAscending);
      adornedTargetList.setJoinEntityClass(joinEntityClass);
      adornedTargetList.setMutable(metadata.isMutable());
      persistencePerspective.addPersistencePerspectiveItem(
          PersistencePerspectiveItemType.ADORNEDTARGETLIST, adornedTargetList);
    }

    if (adornedTargetCollectionMetadata.getExcluded() != null) {
      if (LOG.isDebugEnabled()) {
        if (adornedTargetCollectionMetadata.getExcluded()) {
          LOG.debug(
              "buildAdornedTargetCollectionMetadata:Excluding "
                  + field.getName()
                  + " because it was explicitly declared in config");
        } else {
          LOG.debug(
              "buildAdornedTargetCollectionMetadata:Showing "
                  + field.getName()
                  + " because it was explicitly declared in config");
        }
      }
      metadata.setExcluded(adornedTargetCollectionMetadata.getExcluded());
    }
    if (adornedTargetCollectionMetadata.getFriendlyName() != null) {
      metadata.setFriendlyName(adornedTargetCollectionMetadata.getFriendlyName());
    }
    if (adornedTargetCollectionMetadata.getSecurityLevel() != null) {
      metadata.setSecurityLevel(adornedTargetCollectionMetadata.getSecurityLevel());
    }
    if (adornedTargetCollectionMetadata.getOrder() != null) {
      metadata.setOrder(adornedTargetCollectionMetadata.getOrder());
    }

    if (adornedTargetCollectionMetadata.getTab() != null) {
      metadata.setTab(adornedTargetCollectionMetadata.getTab());
    }
    if (adornedTargetCollectionMetadata.getTabOrder() != null) {
      metadata.setTabOrder(adornedTargetCollectionMetadata.getTabOrder());
    }

    if (adornedTargetCollectionMetadata.getCustomCriteria() != null) {
      metadata.setCustomCriteria(adornedTargetCollectionMetadata.getCustomCriteria());
    }

    if (adornedTargetCollectionMetadata.getUseServerSideInspectionCache() != null) {
      persistencePerspective.setUseServerSideInspectionCache(
          adornedTargetCollectionMetadata.getUseServerSideInspectionCache());
    }

    if (adornedTargetCollectionMetadata.isIgnoreAdornedProperties() != null) {
      metadata.setIgnoreAdornedProperties(
          adornedTargetCollectionMetadata.isIgnoreAdornedProperties());
    }
    if (adornedTargetCollectionMetadata.getCurrencyCodeField() != null) {
      metadata.setCurrencyCodeField(adornedTargetCollectionMetadata.getCurrencyCodeField());
    }

    attributes.put(field.getName(), metadata);
  }
 protected void buildAdminPresentationAdornedTargetCollectionOverride(
     String prefix,
     Boolean isParentExcluded,
     Map<String, FieldMetadata> mergedProperties,
     Map<String, AdminPresentationAdornedTargetCollectionOverride>
         presentationAdornedTargetCollectionOverrides,
     String propertyName,
     String key,
     DynamicEntityDao dynamicEntityDao) {
   AdminPresentationAdornedTargetCollectionOverride override =
       presentationAdornedTargetCollectionOverrides.get(propertyName);
   if (override != null) {
     AdminPresentationAdornedTargetCollection annot = override.value();
     if (annot != null) {
       String testKey = prefix + key;
       if ((testKey.startsWith(propertyName + ".") || testKey.equals(propertyName))
           && annot.excluded()) {
         FieldMetadata metadata = mergedProperties.get(key);
         if (LOG.isDebugEnabled()) {
           LOG.debug(
               "buildAdminPresentationAdornedTargetCollectionOverride:Excluding "
                   + key
                   + "because an override annotation declared "
                   + testKey
                   + "to be excluded");
         }
         metadata.setExcluded(true);
         return;
       }
       if ((testKey.startsWith(propertyName + ".") || testKey.equals(propertyName))
           && !annot.excluded()) {
         FieldMetadata metadata = mergedProperties.get(key);
         if (!isParentExcluded) {
           if (LOG.isDebugEnabled()) {
             LOG.debug(
                 "buildAdminPresentationAdornedTargetCollectionOverride:Showing "
                     + key
                     + "because an override annotation declared "
                     + testKey
                     + " to not be excluded");
           }
           metadata.setExcluded(false);
         }
       }
       if (!(mergedProperties.get(key) instanceof AdornedTargetCollectionMetadata)) {
         return;
       }
       AdornedTargetCollectionMetadata serverMetadata =
           (AdornedTargetCollectionMetadata) mergedProperties.get(key);
       if (serverMetadata.getTargetClass() != null) {
         try {
           Class<?> targetClass = Class.forName(serverMetadata.getTargetClass());
           Class<?> parentClass = null;
           if (serverMetadata.getOwningClass() != null) {
             parentClass = Class.forName(serverMetadata.getOwningClass());
           }
           String fieldName = serverMetadata.getFieldName();
           Field field = dynamicEntityDao.getFieldManager().getField(targetClass, fieldName);
           FieldMetadataOverride localMetadata =
               constructAdornedTargetCollectionMetadataOverride(annot);
           // do not include the previous metadata - we want to construct a fresh metadata from the
           // override annotation
           Map<String, FieldMetadata> temp = new HashMap<String, FieldMetadata>(1);
           FieldInfo info = buildFieldInfo(field);
           buildAdornedTargetCollectionMetadata(
               parentClass, targetClass, temp, info, localMetadata, dynamicEntityDao);
           AdornedTargetCollectionMetadata result =
               (AdornedTargetCollectionMetadata) temp.get(field.getName());
           result.setInheritedFromType(serverMetadata.getInheritedFromType());
           result.setAvailableToTypes(serverMetadata.getAvailableToTypes());
           mergedProperties.put(key, result);
           if (isParentExcluded) {
             if (LOG.isDebugEnabled()) {
               LOG.debug(
                   "buildAdminPresentationAdornedTargetCollectionOverride:Excluding "
                       + key
                       + "because the parent was excluded");
             }
             serverMetadata.setExcluded(true);
           }
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     }
   }
 }
  @Override
  public FieldProviderResponse overrideViaAnnotation(
      OverrideViaAnnotationRequest overrideViaAnnotationRequest,
      Map<String, FieldMetadata> metadata) {
    if (!canHandleAnnotationOverride(overrideViaAnnotationRequest, metadata)) {
      return FieldProviderResponse.NOT_HANDLED;
    }
    Map<String, AdminPresentationAdornedTargetCollectionOverride>
        presentationAdornedTargetCollectionOverrides =
            new HashMap<String, AdminPresentationAdornedTargetCollectionOverride>();

    AdminPresentationOverrides myOverrides =
        overrideViaAnnotationRequest
            .getRequestedEntity()
            .getAnnotation(AdminPresentationOverrides.class);
    if (myOverrides != null) {
      for (AdminPresentationAdornedTargetCollectionOverride myOverride :
          myOverrides.adornedTargetCollections()) {
        presentationAdornedTargetCollectionOverrides.put(myOverride.name(), myOverride);
      }
    }

    for (String propertyName : presentationAdornedTargetCollectionOverrides.keySet()) {
      for (String key : metadata.keySet()) {
        if (key.startsWith(propertyName)) {
          buildAdminPresentationAdornedTargetCollectionOverride(
              overrideViaAnnotationRequest.getPrefix(),
              overrideViaAnnotationRequest.getParentExcluded(),
              metadata,
              presentationAdornedTargetCollectionOverrides,
              propertyName,
              key,
              overrideViaAnnotationRequest.getDynamicEntityDao());
        }
      }
    }

    AdminPresentationMergeOverrides myMergeOverrides =
        overrideViaAnnotationRequest
            .getRequestedEntity()
            .getAnnotation(AdminPresentationMergeOverrides.class);
    if (myMergeOverrides != null) {
      for (AdminPresentationMergeOverride override : myMergeOverrides.value()) {
        String propertyName = override.name();
        Map<String, FieldMetadata> loopMap = new HashMap<String, FieldMetadata>();
        loopMap.putAll(metadata);
        for (Map.Entry<String, FieldMetadata> entry : loopMap.entrySet()) {
          if (entry.getKey().startsWith(propertyName) || StringUtils.isEmpty(propertyName)) {
            FieldMetadata targetMetadata = entry.getValue();
            if (targetMetadata instanceof AdornedTargetCollectionMetadata) {
              AdornedTargetCollectionMetadata serverMetadata =
                  (AdornedTargetCollectionMetadata) targetMetadata;
              if (serverMetadata.getTargetClass() != null) {
                try {
                  Class<?> targetClass = Class.forName(serverMetadata.getTargetClass());
                  Class<?> parentClass = null;
                  if (serverMetadata.getOwningClass() != null) {
                    parentClass = Class.forName(serverMetadata.getOwningClass());
                  }
                  String fieldName = serverMetadata.getFieldName();
                  Field field =
                      overrideViaAnnotationRequest
                          .getDynamicEntityDao()
                          .getFieldManager()
                          .getField(targetClass, fieldName);
                  Map<String, FieldMetadata> temp = new HashMap<String, FieldMetadata>(1);
                  temp.put(field.getName(), serverMetadata);
                  FieldInfo info = buildFieldInfo(field);
                  FieldMetadataOverride fieldMetadataOverride =
                      overrideAdornedTargetMergeMetadata(override);
                  if (serverMetadata.getExcluded() != null
                      && serverMetadata.getExcluded()
                      && (fieldMetadataOverride.getExcluded() == null
                          || fieldMetadataOverride.getExcluded())) {
                    continue;
                  }
                  buildAdornedTargetCollectionMetadata(
                      parentClass,
                      targetClass,
                      temp,
                      info,
                      fieldMetadataOverride,
                      overrideViaAnnotationRequest.getDynamicEntityDao());
                  serverMetadata = (AdornedTargetCollectionMetadata) temp.get(field.getName());
                  metadata.put(entry.getKey(), serverMetadata);
                } catch (Exception e) {
                  throw new RuntimeException(e);
                }
              }
            }
          }
        }
      }
    }

    return FieldProviderResponse.HANDLED;
  }