Java tutorial
/* * #%L * BroadleafCommerce Open Admin Platform * %% * Copyright (C) 2009 - 2013 Broadleaf Commerce * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ package org.broadleafcommerce.openadmin.dto; import org.apache.commons.lang.ArrayUtils; import org.broadleafcommerce.common.presentation.client.PersistencePerspectiveItemType; import java.io.Serializable; import java.util.Arrays; import java.util.Comparator; import java.util.HashMap; import java.util.Map; /** * * @author jfischer * */ public class PersistencePerspective implements Serializable { private static final long serialVersionUID = 1L; protected String[] additionalNonPersistentProperties = new String[] {}; protected ForeignKey[] additionalForeignKeys = new ForeignKey[] {}; protected Map<PersistencePerspectiveItemType, PersistencePerspectiveItem> persistencePerspectiveItems = new HashMap<PersistencePerspectiveItemType, PersistencePerspectiveItem>(); protected OperationTypes operationTypes = new OperationTypes(); protected Boolean populateToOneFields = false; protected String[] excludeFields = new String[] {}; protected String[] includeFields = new String[] {}; protected String configurationKey; protected Boolean showArchivedFields = false; protected Boolean useServerSideInspectionCache = true; public PersistencePerspective() { } public PersistencePerspective(OperationTypes operationTypes, String[] additionalNonPersistentProperties, ForeignKey[] additionalForeignKeys) { setAdditionalNonPersistentProperties(additionalNonPersistentProperties); setAdditionalForeignKeys(additionalForeignKeys); this.operationTypes = operationTypes; } public String[] getAdditionalNonPersistentProperties() { return additionalNonPersistentProperties; } public void setAdditionalNonPersistentProperties(String[] additionalNonPersistentProperties) { this.additionalNonPersistentProperties = additionalNonPersistentProperties; if (!ArrayUtils.isEmpty(this.additionalNonPersistentProperties)) { Arrays.sort(this.additionalNonPersistentProperties); } } public ForeignKey[] getAdditionalForeignKeys() { return additionalForeignKeys; } public void setAdditionalForeignKeys(ForeignKey[] additionalForeignKeys) { this.additionalForeignKeys = additionalForeignKeys; if (!ArrayUtils.isEmpty(this.additionalForeignKeys)) { Arrays.sort(this.additionalForeignKeys, new Comparator<ForeignKey>() { public int compare(ForeignKey o1, ForeignKey o2) { return o1.getManyToField().compareTo(o2.getManyToField()); } }); } } public OperationTypes getOperationTypes() { return operationTypes; } public void setOperationTypes(OperationTypes operationTypes) { this.operationTypes = operationTypes; } public void addPersistencePerspectiveItem(PersistencePerspectiveItemType type, PersistencePerspectiveItem item) { persistencePerspectiveItems.put(type, item); } public Map<PersistencePerspectiveItemType, PersistencePerspectiveItem> getPersistencePerspectiveItems() { return persistencePerspectiveItems; } public void setPersistencePerspectiveItems( Map<PersistencePerspectiveItemType, PersistencePerspectiveItem> persistencePerspectiveItems) { this.persistencePerspectiveItems = persistencePerspectiveItems; } /** * Retrieves whether or not ManyToOne and OneToOne field boundaries * will be traversed when retrieving and populating entity fields. * Implementation should use the @AdminPresentationClass annotation * instead. * * @return Whether or not ManyToOne and OneToOne field boundaries will be crossed. */ @Deprecated public Boolean getPopulateToOneFields() { return populateToOneFields; } /** * Sets whether or not ManyToOne and OneToOne field boundaries * will be traversed when retrieving and populating entity fields. * Implementation should use the @AdminPresentationClass annotation * instead. * * @return Whether or not ManyToOne and OneToOne field boundaries will be crossed. */ @Deprecated public void setPopulateToOneFields(Boolean populateToOneFields) { this.populateToOneFields = populateToOneFields; } /** * Retrieve the list of fields to exclude from the admin presentation. * Implementations should use the excluded property of the AdminPresentation * annotation instead, or use an AdminPresentationOverride if re-enabling a * Broadleaf field is desired. If multiple datasources point to the same * entity, but different exclusion behavior is required, a custom persistence * handler may be employed with different inspect method implementations to * account for the variations. * * @return list of fields to exclude from the admin */ @Deprecated public String[] getExcludeFields() { return excludeFields; } /** * Set the list of fields to exclude from the admin presentation. * Implementations should use the excluded property of the AdminPresentation * annotation instead, or use an AdminPresentationOverride if re-enabling a * Broadleaf field is desired. If multiple datasources point to the same * entity, but different exclusion behavior is required, a custom persistence * handler may be employed with different inspect method implementations to * account for the variations. * * @param excludeManyToOneFields */ @Deprecated public void setExcludeFields(String[] excludeManyToOneFields) { this.excludeFields = excludeManyToOneFields; if (!ArrayUtils.isEmpty(this.excludeFields)) { Arrays.sort(this.excludeFields); } } /** * Get the list of fields to include in the admin presentation. * Implementations should use excludeFields instead. * * @return list of fields to include in the admin */ @Deprecated public String[] getIncludeFields() { return includeFields; } /** * Set the list of fields to include in the admin presentation. * Implementations should use excludeFields instead. * * @param includeManyToOneFields */ @Deprecated public void setIncludeFields(String[] includeManyToOneFields) { this.includeFields = includeManyToOneFields; if (!ArrayUtils.isEmpty(this.includeFields)) { Arrays.sort(this.includeFields); } } public String getConfigurationKey() { return configurationKey; } public void setConfigurationKey(String configurationKey) { this.configurationKey = configurationKey; } public Boolean getShowArchivedFields() { return showArchivedFields; } public void setShowArchivedFields(Boolean showArchivedFields) { this.showArchivedFields = showArchivedFields; } public Boolean getUseServerSideInspectionCache() { return useServerSideInspectionCache; } public void setUseServerSideInspectionCache(Boolean useServerSideInspectionCache) { this.useServerSideInspectionCache = useServerSideInspectionCache; } public PersistencePerspective clonePersistencePerspective() { PersistencePerspective persistencePerspective = new PersistencePerspective(); persistencePerspective.operationTypes = operationTypes.cloneOperationTypes(); if (additionalNonPersistentProperties != null) { persistencePerspective.additionalNonPersistentProperties = new String[additionalNonPersistentProperties.length]; System.arraycopy(additionalNonPersistentProperties, 0, persistencePerspective.additionalNonPersistentProperties, 0, additionalNonPersistentProperties.length); } if (additionalForeignKeys != null) { persistencePerspective.additionalForeignKeys = new ForeignKey[additionalForeignKeys.length]; for (int j = 0; j < additionalForeignKeys.length; j++) { persistencePerspective.additionalForeignKeys[j] = additionalForeignKeys[j].cloneForeignKey(); } } if (this.persistencePerspectiveItems != null) { Map<PersistencePerspectiveItemType, PersistencePerspectiveItem> persistencePerspectiveItems = new HashMap<PersistencePerspectiveItemType, PersistencePerspectiveItem>( this.persistencePerspectiveItems.size()); for (Map.Entry<PersistencePerspectiveItemType, PersistencePerspectiveItem> entry : this.persistencePerspectiveItems .entrySet()) { persistencePerspectiveItems.put(entry.getKey(), entry.getValue().clonePersistencePerspectiveItem()); } persistencePerspective.persistencePerspectiveItems = persistencePerspectiveItems; } persistencePerspective.populateToOneFields = populateToOneFields; persistencePerspective.configurationKey = configurationKey; persistencePerspective.showArchivedFields = showArchivedFields; persistencePerspective.useServerSideInspectionCache = useServerSideInspectionCache; if (excludeFields != null) { persistencePerspective.excludeFields = new String[excludeFields.length]; System.arraycopy(excludeFields, 0, persistencePerspective.excludeFields, 0, excludeFields.length); } if (includeFields != null) { persistencePerspective.includeFields = new String[includeFields.length]; System.arraycopy(includeFields, 0, persistencePerspective.includeFields, 0, includeFields.length); } return persistencePerspective; } @Override public String toString() { final StringBuilder sb = new StringBuilder("PersistencePerspective{"); sb.append("persistencePerspectiveItems=").append(persistencePerspectiveItems); sb.append(", configurationKey='").append(configurationKey).append('\''); sb.append('}'); return sb.toString(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null) return false; if (!getClass().isAssignableFrom(o.getClass())) return false; PersistencePerspective that = (PersistencePerspective) o; if (!Arrays.equals(additionalForeignKeys, that.additionalForeignKeys)) return false; if (!Arrays.equals(additionalNonPersistentProperties, that.additionalNonPersistentProperties)) return false; if (configurationKey != null ? !configurationKey.equals(that.configurationKey) : that.configurationKey != null) return false; if (!Arrays.equals(excludeFields, that.excludeFields)) return false; if (!Arrays.equals(includeFields, that.includeFields)) return false; if (operationTypes != null ? !operationTypes.equals(that.operationTypes) : that.operationTypes != null) return false; if (persistencePerspectiveItems != null ? !persistencePerspectiveItems.equals(that.persistencePerspectiveItems) : that.persistencePerspectiveItems != null) return false; if (populateToOneFields != null ? !populateToOneFields.equals(that.populateToOneFields) : that.populateToOneFields != null) return false; if (showArchivedFields != null ? !showArchivedFields.equals(that.showArchivedFields) : that.showArchivedFields != null) return false; if (useServerSideInspectionCache != null ? !useServerSideInspectionCache.equals(that.useServerSideInspectionCache) : that.useServerSideInspectionCache != null) return false; return true; } @Override public int hashCode() { int result = additionalNonPersistentProperties != null ? Arrays.hashCode(additionalNonPersistentProperties) : 0; result = 31 * result + (additionalForeignKeys != null ? Arrays.hashCode(additionalForeignKeys) : 0); result = 31 * result + (persistencePerspectiveItems != null ? persistencePerspectiveItems.hashCode() : 0); result = 31 * result + (operationTypes != null ? operationTypes.hashCode() : 0); result = 31 * result + (populateToOneFields != null ? populateToOneFields.hashCode() : 0); result = 31 * result + (excludeFields != null ? Arrays.hashCode(excludeFields) : 0); result = 31 * result + (includeFields != null ? Arrays.hashCode(includeFields) : 0); result = 31 * result + (configurationKey != null ? configurationKey.hashCode() : 0); result = 31 * result + (showArchivedFields != null ? showArchivedFields.hashCode() : 0); result = 31 * result + (useServerSideInspectionCache != null ? useServerSideInspectionCache.hashCode() : 0); return result; } }