/**
 * Overridden to copy property editor registration to the new bean wrapper.
 *
 * <p>This is necessary because spring only copies over the editors when a new bean wrapper is
 * created. The wrapper is then cached and use for subsequent calls. But the get calls Could bring in
 * new custom editors we need to copy.</p>
 *
 * {@inheritDoc}
 */
@Override
protected BeanWrapperImpl getBeanWrapperForPropertyPath(String propertyPath) {
    BeanWrapperImpl beanWrapper = super.getBeanWrapperForPropertyPath(propertyPath);

    PropertyTokenHolder tokens = getPropertyNametokens(propertyPath);
    String canonicalName = tokens.canonicalName;

    int pos = PropertyAccessorUtils.getFirstnestedPropertySeparatorIndex(canonicalName);
    if (pos != -1) {
        canonicalName = canonicalName.substring(0,pos);
    }

    copyCustomEditorsTo(beanWrapper,canonicalName);

    return beanWrapper;
}

/**
 * Set the parent for bi-directional relationships when adding a line to a collection.
 *
 * @param model the view data
 * @param collectionPath the path to the collection being linked
 * @param addedindex the index of the added line
 * @return whether the linked line needs further processing
 */
protected boolean linkAddedLine(Object model,String collectionPath,int addedindex) {
    int lastSepIndex = PropertyAccessorUtils.getLastnestedPropertySeparatorIndex(collectionPath);
    if (lastSepIndex != -1) {
        String collectionParentPath = collectionPath.substring(0,lastSepIndex);
        Object parent = ObjectPropertyUtils.getPropertyValue(model,collectionParentPath);
        if (parent != null && getDataObjectService().supports(parent.getClass())) {
            DataObjectWrapper<?> wrappedParent = getDataObjectService().wrap(parent);
            String collectionName = collectionPath.substring(lastSepIndex + 1);
            wrappedParent.linkChanges(Sets.newHashSet(collectionName + "[" + addedindex + "]"));
        }

        // check if its edit line in dialog line action,and if it is we want to set the collection as
        // the dialog's parent and do not want further processing of the dialog object
        if (collectionParentPath.equalsIgnoreCase(UifPropertyPaths.DIALOG_DATA_OBJECT)) {
            ((UifFormBase) model).setDialogDataObject(parent);
            return false;
        }
    }
    return true;
}

@Override
public Map<String,String> getInquiryParameters(Object dataObject,List<String> keys,String propertyName) {
    Map<String,String> inquiryParameters = new HashMap<String,String>();
    org.kuali.rice.krad.data.Metadata.DataObjectRelationship dataObjectRelationship = null;

    DataObjectMetadata objectMetadata =
            KRADServiceLocator.getDataObjectService().getMetadataRepository().getMetadata(dataObject.getClass());

    if (objectMetadata != null) {
        dataObjectRelationship = objectMetadata.getRelationshipByLastAttributeInRelationship(propertyName);
    }

    for (String keyName : keys) {
        String keyConversion = keyName;
        if (dataObjectRelationship != null) {
            keyConversion = dataObjectRelationship.getParentAttributeNameRelatedtochildAttributeName(keyName);
        } else if (PropertyAccessorUtils.isnestedOrIndexedProperty(propertyName)) {
            String nestedAttributePrefix = KRADUtils.getnestedAttributePrefix(propertyName);
            keyConversion = nestedAttributePrefix + "." + keyName;
        }
        inquiryParameters.put(keyConversion,keyName);
    }
    return inquiryParameters;
}

/**
 * Gets the property type for a property name.
 *
 * @param objectMetadata the Metadata object.
 * @param propertyName the name of the property.
 * @return the property type for a property name.
 */
private Class<?> getPropertyTypeChild(DataObjectMetadata objectMetadata,String propertyName){
    if(PropertyAccessorUtils.isnestedOrIndexedProperty(propertyName)){
        String attributePrefix = StringUtils.substringBefore(propertyName,".");
        String attributeName = StringUtils.substringAfter(propertyName,".");

        if(StringUtils.isNotBlank(attributePrefix) && StringUtils.isNotBlank(attributeName) &&
                objectMetadata!= null){
            Class<?> propertyType = traverseRelationship(objectMetadata,attributePrefix,attributeName);
            if(propertyType != null){
                return propertyType;
            }
        }
    }
    return getPropertyType(propertyName);
}

/**
 * Gets the property type for a property name in a relationship.
 *
 * @param objectMetadata the Metadata object.
 * @param attributePrefix the prefix of the property that indicated it was in a relationship.
 * @param attributeName the name of the property.
 * @return the property type for a property name.
 */
private Class<?> traverseRelationship(DataObjectMetadata objectMetadata,String attributePrefix,String attributeName){
    DataObjectRelationship rd = objectMetadata.getRelationship(attributePrefix);
    if(rd != null){
        DataObjectMetadata relatedobjectMetadata =
                dataObjectService.getMetadataRepository().getMetadata(rd.getRelatedType());
        if(relatedobjectMetadata != null){
            if(PropertyAccessorUtils.isnestedOrIndexedProperty(attributeName)){
                return getPropertyTypeChild(relatedobjectMetadata,attributeName);
            } else{
                if(relatedobjectMetadata.getAttribute(attributeName) == null &&
                        relatedobjectMetadata.getRelationship(attributeName)!=null){
                    DataObjectRelationship relationship = relatedobjectMetadata.getRelationship(attributeName);
                    return relationship.getRelatedType();
                }
                return relatedobjectMetadata.getAttribute(attributeName).getDataType().getType();
            }
        }
    }
    return null;
}

/**
* Gets indexes that have been modified.
*
* <p>
*     Returns a set of indexes which have been modified in the given collection. If the returned set contains
*     {@link java.lang.Integer#MAX_VALUE} then it means that it should be treated as if all items in the collection
*     have been modified.
* </p>
*
* @return indexes which have been modified in the given collection
*/
private Set<Integer> extractModifiedindicies(DataObjectCollection collectionMetadata,Map<String,Set<String>> decomposedpaths) {
    String relationshipName = collectionMetadata.getName();
    Set<Integer> modifiedindicies = Sets.newHashSet();
    // if it contains *exactly* the collection relationship name,then indicate that all items modified
    if (decomposedpaths.containsKey(relationshipName)) {
        modifiedindicies.add(Integer.valueOf(Integer.MAX_VALUE));
    }
    for (String propertyName : decomposedpaths.keySet()) {
        if (relationshipName.equals(PropertyAccessorUtils.getPropertyName(relationshipName))) {
            Integer index = extractIndex(propertyName);
            if (index != null) {
                modifiedindicies.add(index);
            }
        }
    }
    return modifiedindicies;
}

@Override
public Map<String,String>();
    Class<?> objectClass = ObjectUtils.materializeClassForProxiedobject(dataObject);
    org.kuali.rice.krad.bo.DataObjectRelationship relationship =
            dataObjectMetaDataService.getDataObjectRelationship(dataObject,objectClass,propertyName,"",true,false,true);
    for (String keyName : keys) {
        String keyConversion = keyName;
        if (relationship != null) {
            keyConversion = relationship.getParentAttributeForChildAttribute(keyName);
        } else if (PropertyAccessorUtils.isnestedOrIndexedProperty(propertyName)) {
            String nestedAttributePrefix = KRADUtils.getnestedAttributePrefix(propertyName);
            keyConversion = nestedAttributePrefix + "." + keyName;
        }
        inquiryParameters.put(keyConversion,keyName);
    }
    return inquiryParameters;
}

private boolean isPersonProperty(Object bo,String propertyName) {
    try {
        if (PropertyAccessorUtils.isnestedOrIndexedProperty( propertyName ) // is a nested property
                && !StringUtils.contains(propertyName,"add.") ) {// exclude add line properties (due to path parsing problems in PropertyUtils.getPropertyType)
            int lastIndex = PropertyAccessorUtils.getLastnestedPropertySeparatorIndex(propertyName);
            String propertyTypeName = lastIndex != -1 ? StringUtils.substring(propertyName,lastIndex) : StringUtils.EMPTY;
            Class<?> type = PropertyUtils.getPropertyType(bo,propertyTypeName);
            // property type indicates a Person object
            if ( type != null ) {
                return Person.class.isAssignableFrom(type);
            }
            LOG.warn( "Unable to determine type of nested property: " + bo.getClass().getName() + " / " + propertyName );
        }
    } catch (Exception ex) {
        if ( LOG.isDebugEnabled() ) {
            LOG.debug("Unable to determine if property on " + bo.getClass().getName() + " to a person object: " + propertyName,ex );
        }
    }
    return false;
}

/**
 * Overridden to copy property editor registration to the new bean wrapper.
 *
 * <p>This is necessary because spring only copies over the editors when a new bean wrapper is
 * created. The wrapper is then cached and use for subsequent calls. But the get calls Could bring in
 * new custom editors we need to copy.</p>
 *
 * {@inheritDoc}
 */
@Override
protected BeanWrapperImpl getBeanWrapperForPropertyPath(String propertyPath) {
    BeanWrapperImpl beanWrapper = super.getBeanWrapperForPropertyPath(propertyPath);

    PropertyTokenHolder tokens = getPropertyNametokens(propertyPath);
    String canonicalName = tokens.canonicalName;

    int pos = PropertyAccessorUtils.getFirstnestedPropertySeparatorIndex(canonicalName);
    if (pos != -1) {
        canonicalName = canonicalName.substring(0,canonicalName);

    return beanWrapper;
}

/**
 * Set the parent for bi-directional relationships when adding a line to a collection.
 *
 * @param model the view data
 * @param collectionPath the path to the collection being linked
 * @param addedindex the index of the added line
 * @return whether the linked line needs further processing
 */
protected boolean linkAddedLine(Object model,and if it is we want to set the collection as
        // the dialog's parent and do not want further processing of the dialog object
        if (collectionParentPath.equalsIgnoreCase(UifPropertyPaths.DIALOG_DATA_OBJECT)) {
            ((UifFormBase) model).setDialogDataObject(parent);
            return false;
        }
    }
    return true;
}

@Override
public Map<String,keyName);
    }
    return inquiryParameters;
}

/**
 * Gets the property type for a property name.
 *
 * @param objectMetadata the Metadata object.
 * @param propertyName the name of the property.
 * @return the property type for a property name.
 */
private Class<?> getPropertyTypeChild(DataObjectMetadata objectMetadata,attributeName);
            if(propertyType != null){
                return propertyType;
            }
        }
    }
    return getPropertyType(propertyName);
}

/**
 * Gets the property type for a property name in a relationship.
 *
 * @param objectMetadata the Metadata object.
 * @param attributePrefix the prefix of the property that indicated it was in a relationship.
 * @param attributeName the name of the property.
 * @return the property type for a property name.
 */
private Class<?> traverseRelationship(DataObjectMetadata objectMetadata,attributeName);
            } else{
                if(relatedobjectMetadata.getAttribute(attributeName) == null &&
                        relatedobjectMetadata.getRelationship(attributeName)!=null){
                    DataObjectRelationship relationship = relatedobjectMetadata.getRelationship(attributeName);
                    return relationship.getRelatedType();
                }
                return relatedobjectMetadata.getAttribute(attributeName).getDataType().getType();
            }
        }
    }
    return null;
}

/**
* Gets indexes that have been modified.
*
* <p>
*     Returns a set of indexes which have been modified in the given collection. If the returned set contains
*     {@link java.lang.Integer#MAX_VALUE} then it means that it should be treated as if all items in the collection
*     have been modified.
* </p>
*
* @return indexes which have been modified in the given collection
*/
private Set<Integer> extractModifiedindicies(DataObjectCollection collectionMetadata,then indicate that all items modified
    if (decomposedpaths.containsKey(relationshipName)) {
        modifiedindicies.add(Integer.valueOf(Integer.MAX_VALUE));
    }
    for (String propertyName : decomposedpaths.keySet()) {
        if (relationshipName.equals(PropertyAccessorUtils.getPropertyName(relationshipName))) {
            Integer index = extractIndex(propertyName);
            if (index != null) {
                modifiedindicies.add(index);
            }
        }
    }
    return modifiedindicies;
}

@Override
public Map<String,keyName);
    }
    return inquiryParameters;
}

private boolean isPersonProperty(Object bo,ex );
        }
    }
    return false;
}

@Override
protected BeanWrapperImpl getBeanWrapperForPropertyPath(String propertyPath) {
    BeanWrapperImpl beanWrapper = super.getBeanWrapperForPropertyPath(propertyPath);

    PropertyTokenHolder tokens = getPropertyNametokens(propertyPath);
    String canonicalName = tokens.canonicalName;

    int pos = PropertyAccessorUtils.getFirstnestedPropertySeparatorIndex(canonicalName);
    if (pos != -1) {
        canonicalName = canonicalName.substring(0,canonicalName);

    return beanWrapper;
}

/**
 * Check the given property values against the allowed fields,* removing values for fields that are not allowed.
 * @param mpvs the property values to be bound (can be modified)
 * @see #getAllowedFields
 * @see #isAllowed(String)
 */
protected void checkAllowedFields(MutablePropertyValues mpvs) {
    PropertyValue[] pvs = mpvs.getPropertyValues();
    for (PropertyValue pv : pvs) {
        String field = PropertyAccessorUtils.canonicalPropertyName(pv.getName());
        if (!isAllowed(field)) {
            mpvs.removePropertyValue(pv);
            getBindingResult().recordSuppressedField(field);
            if (logger.isDebugEnabled()) {
                logger.debug("Field [" + field + "] has been removed from PropertyValues " +
                        "and will not be bound,because it has not been found in the list of allowed fields");
            }
        }
    }
}

/**
 * Check the given property values against the allowed fields,because it has not been found in the list of allowed fields");
            }
        }
    }
}

/**
 * Check the given property values against the allowed fields,because it has not been found in the list of allowed fields");
            }
        }
    }
}

/**
 * Check the given property values against the allowed fields,because it has not been found in the list of allowed fields");
            }
        }
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void refreshReferences(String referencesToRefresh) {
    Object model = ViewLifecycle.getModel();
    for (String reference : StringUtils.split(referencesToRefresh,KRADConstants.REFERENCES_TO_REFRESH_SEParaTOR)) {
        if (StringUtils.isBlank(reference)) {
            continue;
        }

        //Todo: handle add line

        if (PropertyAccessorUtils.isnestedOrIndexedProperty(reference)) {
            String parentPath = KRADUtils.getnestedAttributePrefix(reference);
            Object parentObject = ObjectPropertyUtils.getPropertyValue(model,parentPath);
            String referenceObjectName = KRADUtils.getnestedAttributePrimitive(reference);

            if (parentObject == null) {
                LOG.warn("Unable to refresh references for " + referencesToRefresh +
                        ". Object not found in model. nothing refreshed.");
                continue;
            }

            refreshReference(parentObject,referenceObjectName);
        } else {
            refreshReference(model,reference);
        }
    }
}

/**
 * @see org.kuali.rice.krad.service.DictionaryValidationService#validateReferenceExistsAndisActive(java.lang.Object
 * dataObject,* String,String,String)
 */
@Override
public boolean validateReferenceExistsAndisActive(Object dataObject,String referenceName,String attributetoHighlightOnFail,String displayFieldName) {

    // if we're dealing with a nested attribute,we need to resolve down to the BO where the primitive attribute is located
    // this is primarily to deal with the case of a defaultExistenceCheck that uses an "extension",i.e referenceName
    // would be extension.attributeName
    if (PropertyAccessorUtils.isnestedOrIndexedProperty(referenceName)) {
        String nestedAttributePrefix = KRADUtils.getnestedAttributePrefix(referenceName);
        String nestedAttributePrimitive = KRADUtils.getnestedAttributePrimitive(referenceName);
        Object nestedobject = KradDataServiceLocator.getDataObjectService().wrap(dataObject)
                .getPropertyValueNullSafe(nestedAttributePrefix);
        return validateReferenceExistsAndisActive(nestedobject,nestedAttributePrimitive,attributetoHighlightOnFail,displayFieldName);
    }

    boolean hasReferences = validateFkFieldsPopulated(dataObject,referenceName);
    boolean referenceExists = hasReferences && validateReferenceExists(dataObject,referenceName);
    boolean canIncludeActiveReference = referenceExists && (!(dataObject instanceof Inactivatable) ||
            ((Inactivatable) dataObject).isActive());
    boolean referenceActive = canIncludeActiveReference && validateReferenceIsActive(dataObject,referenceName);

    if(hasReferences && !referenceExists) {
        GlobalVariables.getMessageMap().putError(attributetoHighlightOnFail,RiceKeyConstants.ERROR_EXISTENCE,displayFieldName);
        return false;
    } else if(canIncludeActiveReference && !referenceActive) {
        GlobalVariables.getMessageMap().putError(attributetoHighlightOnFail,RiceKeyConstants.ERROR_INACTIVE,displayFieldName);
        return false;
    }

    return true;
}

@Override
/**
 * Recursively calls getPropertyTypeChild if nested property to allow it to properly look it up
 */
public Class<?> getPropertyType(Object object,String propertyName) {
    DataObjectWrapper<?> wrappedobject = dataObjectService.wrap(object);
    if (PropertyAccessorUtils.isnestedOrIndexedProperty(propertyName)) {
        return wrappedobject.getPropertyTypeNullSafe(wrappedobject.getWrappedClass(),propertyName);
    }
    return wrappedobject.getPropertyType(propertyName);
}

/**
     * Recursively navigate to return a BeanWrapper for the nested property path.
     *
     * @param propertyPath
     *         property property path,which may be nested
     * @return a BeanWrapper for the target bean
     */
    PropertyDescriptor getPropertyDescriptorForPropertyPath(String propertyPath,Class<?> propertyType) {
        int pos = PropertyAccessorUtils.getFirstnestedPropertySeparatorIndex(propertyPath);
        // Handle nested properties recursively.
        if (pos > -1) {
            String nestedProperty = propertyPath.substring(0,pos);
            String nestedpath = propertyPath.substring(pos + 1);
            PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(propertyType,nestedProperty);
//            BeanWrapperImpl nestedBw = getnestedBeanWrapper(nestedProperty);
            return getPropertyDescriptorForPropertyPath(nestedpath,propertyDescriptor.getPropertyType());
        } else {
            return BeanUtils.getPropertyDescriptor(propertyType,propertyPath);
        }
    }

/**
 * Check the given property values against the allowed fields,because it has not been found in the list of allowed fields");
            }
        }
    }
}

/**
 * Actually set the nested path.
 * Delegated to by setnestedpath and pushnestedpath.
 * <p/>
 * Note: Not yet kNown what to use the path for. Possibly if the Asset has
 * second class Asset contained inside it.
 *
 * @param nestedpath Path
 */
protected void doSetnestedpath(String nestedpath) {
    if (nestedpath == null) {
        nestedpath = "";
    }
    nestedpath = PropertyAccessorUtils.canonicalPropertyName(nestedpath);
    if (nestedpath.length() > 0 && !nestedpath.endsWith(nesTED_PATH_SEParaTOR)) {
        nestedpath += nesTED_PATH_SEParaTOR;
    }
    this.nestedpath = nestedpath;
}

/**
 * Transform the given field into its full path,* regarding the nested path of this instance.
 *
 * @param field a {@link java.lang.String} object.
 * @return  {@link java.lang.String} object.
 */
protected String fixedField(String field) {
    if (StringUtils.hasLength(field)) {
        return getnestedpath() + PropertyAccessorUtils.canonicalPropertyName(field);
    } else {
        String path = getnestedpath();
        return (path.endsWith(org.springframework.validation.Errors.nesTED_PATH_SEParaTOR) ?
                path.substring(0,path.length() - nesTED_PATH_SEParaTOR.length()) : path);
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void refreshReferences(String referencesToRefresh) {
    Object model = ViewLifecycle.getModel();
    for (String reference : StringUtils.split(referencesToRefresh,reference);
        }
    }
}

/**
 * @see org.kuali.rice.krad.service.DictionaryValidationService#validateReferenceExistsAndisActive(java.lang.Object
 * dataObject,displayFieldName);
        return false;
    }

    return true;
}

@Override
/**
 * Recursively calls getPropertyTypeChild if nested property to allow it to properly look it up
 */
public Class<?> getPropertyType(Object object,propertyName);
    }
    return wrappedobject.getPropertyType(propertyName);
}

/**
 * <p>Constructor for PropertyPath.</p>
 *
 * @param nestedpath a {@link java.lang.String} object.
 */
public PropertyPath(String nestedpath) {
    String canonicalPath = PropertyAccessorUtils.canonicalPropertyName(nestedpath);
    int lastIndex = PropertyAccessorUtils.getLastnestedPropertySeparatorIndex(canonicalPath);
    if (lastIndex < 0) {
        propertyName = PropertyAccessorUtils.getPropertyName(canonicalPath);
        key = computeKey(canonicalPath);
    } 
    else {
        parent = new PropertyPath(canonicalPath.substring(0,lastIndex));
        String lastProperty = canonicalPath.substring(lastIndex+1);
        propertyName = PropertyAccessorUtils.getPropertyName(lastProperty);
        key = computeKey(lastProperty);
    }
}

/**
 * <p>Constructor for PropertyPath.</p>
 *
 * @param nestedpath a {@link java.lang.String} object.
 */
public PropertyPath(String nestedpath) {
    String canonicalPath = PropertyAccessorUtils.canonicalPropertyName(nestedpath);
    int lastIndex = PropertyAccessorUtils.getLastnestedPropertySeparatorIndex(canonicalPath);
    if (lastIndex < 0) {
        propertyName = PropertyAccessorUtils.getPropertyName(canonicalPath);
        key = computeKey(canonicalPath);
    } 
    else {
        parent = new PropertyPath(canonicalPath.substring(0,lastIndex));
        String lastProperty = canonicalPath.substring(lastIndex+1);
        propertyName = PropertyAccessorUtils.getPropertyName(lastProperty);
        key = computeKey(lastProperty);
    }
}

/**
 * Returns the canonical property name.
 * @see org.springframework.beans.PropertyAccessorUtils#canonicalPropertyName
 */
@Override
protected String canonicalFieldName(String field) {
    return PropertyAccessorUtils.canonicalPropertyName(field);
}

/**
 * Returns the canonical property name.
 * @see org.springframework.beans.PropertyAccessorUtils#canonicalPropertyName
 */
@Override
protected String canonicalFieldName(String field) {
    return PropertyAccessorUtils.canonicalPropertyName(field);
}

/**
 * Returns the canonical property name.
 * @see org.springframework.beans.PropertyAccessorUtils#canonicalPropertyName
 */
@Override
protected String canonicalFieldName(String field) {
    return PropertyAccessorUtils.canonicalPropertyName(field);
}

/**
 * Returns the canonical property name.
 * @see org.springframework.beans.PropertyAccessorUtils#canonicalPropertyName
 */
@Override
protected String canonicalFieldName(String field) {
    return PropertyAccessorUtils.canonicalPropertyName(field);
}

/**
 * Returns the canonical property name.
 * @see org.springframework.beans.PropertyAccessorUtils#canonicalPropertyName
 */
@Override
protected String canonicalFieldName(String field) {
    return PropertyAccessorUtils.canonicalPropertyName(field);
}

/**
 * Register fields that are required for each binding process.
 * <p>If one of the specified fields is not contained in the list of
 * incoming property values,a corresponding "missing field" error
 * will be created,with error code "required" (by the default
 * binding error processor).
 * @param requiredFields array of field names
 * @see #setBindingErrorProcessor
 * @see DefaultBindingErrorProcessor#MISSING_FIELD_ERROR_CODE
 */
public void setrequiredFields(String... requiredFields) {
    this.requiredFields = PropertyAccessorUtils.canonicalPropertyNames(requiredFields);
    if (logger.isDebugEnabled()) {
        logger.debug("DataBinder requires binding of required fields [" +
                StringUtils.arrayToCommaDelimitedString(requiredFields) + "]");
    }
}

/**
 * Register fields that are required for each binding process.
 * <p>If one of the specified fields is not contained in the list of
 * incoming property values,with error code "required" (by the default
 * binding error processor).
 * @param requiredFields array of field names
 * @see #setBindingErrorProcessor
 * @see DefaultBindingErrorProcessor#MISSING_FIELD_ERROR_CODE
 */
public void setrequiredFields(String... requiredFields) {
    this.requiredFields = PropertyAccessorUtils.canonicalPropertyNames(requiredFields);
    if (logger.isDebugEnabled()) {
        logger.debug("DataBinder requires binding of required fields [" +
                StringUtils.arrayToCommaDelimitedString(requiredFields) + "]");
    }
}

@Override
public void apply(GroovyClassLoader loader,GroovyCompilerConfiguration configuration,GeneratorContext generatorContext,SourceUnit source,ClassNode classNode)
                throws CompilationFailedException {
    if (!AstUtils.hasAtLeastOneAnnotation(classNode,"RunWith")) {
        AnnotationNode runWith = new AnnotationNode(ClassHelper.make("RunWith"));
        runWith.addMember("value",new ClassExpression(ClassHelper.make("springrunner")));
        classNode.addAnnotation(runWith);
    }
}

@Override
public void apply(GroovyClassLoader loader,new ClassExpression(ClassHelper.make("springrunner")));
        classNode.addAnnotation(runWith);
    }
}

@Override
public void apply(GroovyClassLoader loader,"RunWith")) {
        AnnotationNode runwith = new AnnotationNode(ClassHelper.make("RunWith"));
        runwith.addMember("value",new ClassExpression(ClassHelper.make("SpringJUnit4ClassRunner")));
        classNode.addAnnotation(runwith);
    }
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"Test");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableWebSecurity","EnableGlobalMethodSecurity");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableBatchProcessing");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableRabbit")
            || AstUtils.hasAtLeastOneAnnotation(classNode,"EnableRabbitMessaging");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableIntegration")
            || AstUtils.hasAtLeastOneAnnotation(classNode,"MessageEndpoint");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"Twitter");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableGroovyTemplates");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"Controller","RestController","EnableWebMvc");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.subclasses(classNode,"Specification");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"Facebook");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableJms")
            || AstUtils.hasAtLeastOneAnnotation(classNode,"EnableJmsMessaging");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableRetry","Retryable","Recover");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableTransactionManagement");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"LinkedIn");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableAuthorizationServer","EnableResourceServer","Enableoauth2client","EnableOAuth2Sso");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"JdbcTemplate","NamedParameterJdbcTemplate","DataSource");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableReactor")
            || AstUtils.hasAtLeastOneFieldOrMethod(classNode,"EventBus");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableCaching");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"SpringApplicationConfiguration");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableDeviceResolver");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableWebSocket","EnableWebSocketMessagebroker");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"Test");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableGlobalMethodSecurity");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableBatchProcessing");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableRabbitMessaging");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"MessageEndpoint");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"Twitter");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableGroovyTemplates");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableWebMvc");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.subclasses(classNode,"Specification");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"Facebook");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableJmsMessaging");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"Recover");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableTransactionManagement");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"LinkedIn");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneAnnotation(classNode,"EnableOAuth2Sso");
}

@Override
public boolean matches(ClassNode classNode) {
    return AstUtils.hasAtLeastOneFieldOrMethod(classNode,"DataSource");
}

public void generateProject(ProjectGenerationRequest request,boolean force)
        throws IOException {
    ProjectGenerationResponse response = this.initializrService.generate(request);
    String fileName = (request.getoutput() != null ? request.getoutput()
            : response.getFileName());
    if (shouldExtract(request,response)) {
        if (isZipArchive(response)) {
            extractProject(response,request.getoutput(),force);
            return;
        }
        else {
            Log.info("Could not extract '" + response.getContentType() + "'");
            // Use value from the server since we can't extract it
            fileName = response.getFileName();
        }
    }
    if (fileName == null) {
        throw new ReportableException(
                "Could not save the project,the server did not set a preferred "
                        + "file name and no location was set. Specify the output location "
                        + "for the project.");
    }
    writeProject(response,fileName,force);
}

private void extractProject(ProjectGenerationResponse entity,String output,boolean overwrite) throws IOException {
    File outputFolder = (output != null ? new File(output)
            : new File(System.getProperty("user.dir")));
    if (!outputFolder.exists()) {
        outputFolder.mkdirs();
    }
    ZipInputStream zipStream = new ZipInputStream(
            new ByteArrayInputStream(entity.getContent()));
    try {
        extractFromStream(zipStream,overwrite,outputFolder);
        fixExecutableFlag(outputFolder,"mvnw");
        fixExecutableFlag(outputFolder,"gradlew");
        Log.info("Project extracted to '" + outputFolder.getAbsolutePath() + "'");
    }
    finally {
        zipStream.close();
    }
}

private void writeProject(ProjectGenerationResponse entity,boolean overwrite) throws IOException {
    File outputFile = new File(output);
    if (outputFile.exists()) {
        if (!overwrite) {
            throw new ReportableException("File '" + outputFile.getName()
                    + "' already exists. Use --force if you want to "
                    + "overwrite or specify an alternate location.");
        }
        if (!outputFile.delete()) {
            throw new ReportableException(
                    "Failed to delete existing file " + outputFile.getPath());
        }
    }
    FilecopyUtils.copy(entity.getContent(),outputFile);
    Log.info("Content saved to '" + output + "'");
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    try {
        if (options.has(this.allOption)) {
            if (!args.isEmpty()) {
                throw new IllegalArgumentException(
                        "Please use --all without specifying any dependencies");
            }
            new Installer(options,this).uninstallAll();
        }
        if (args.isEmpty()) {
            throw new IllegalArgumentException(
                    "Please specify at least one dependency,in the form group:artifact:version,to uninstall");
        }
        new Installer(options,this).uninstall(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

public void generateProject(ProjectGenerationRequest request,force);
}

private void extractProject(ProjectGenerationResponse entity,"gradlew");
        Log.info("Project extracted to '" + outputFolder.getAbsolutePath() + "'");
    }
    finally {
        zipStream.close();
    }
}

private void writeProject(ProjectGenerationResponse entity,outputFile);
    Log.info("Content saved to '" + output + "'");
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    try {
        if (options.has(this.allOption)) {
            if (!args.isEmpty()) {
                throw new IllegalArgumentException(
                        "Please use --all without specifying any dependencies");
            }
            new Installer(options,this).uninstall(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

public void generateProject(ProjectGenerationRequest request,force);
}

private void extractProject(ProjectGenerationResponse entity,outputFolder);
        Log.info("Project extracted to '" + outputFolder.getAbsolutePath() + "'");
    }
    finally {
        zipStream.close();
    }
}

private void writeProject(ProjectGenerationResponse entity,outputFile);
    Log.info("Content saved to '" + output + "'");
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    try {
        if (options.has(this.allOption)) {
            if (!args.isEmpty()) {
                throw new IllegalArgumentException(
                        "Please use --all without specifying any dependencies");
            }
            new Installer(options,this).uninstall(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

/**
 * Generate a project based on the specified {@link ProjectGenerationRequest}.
 * @param request the generation request
 * @return an entity defining the project
 * @throws IOException if generation fails
 */
public ProjectGenerationResponse generate(ProjectGenerationRequest request)
        throws IOException {
    Log.info("Using service at " + request.getServiceUrl());
    InitializrServiceMetadata Metadata = loadMetadata(request.getServiceUrl());
    URI url = request.generateUrl(Metadata);
    CloseableHttpResponse httpResponse = executeProjectGenerationRequest(url);
    httpentity httpentity = httpResponse.getEntity();
    validateResponse(httpResponse,request.getServiceUrl());
    return createResponse(httpResponse,httpentity);
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    Assert.notEmpty(args,"Please specify at least one "
            + "dependency,to install");
    try {
        new Installer(options,this).install(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

public void install(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    libDirectory.mkdirs();
    Log.info("Installing into: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount == 0) {
            FilecopyUtils.copy(artifactFile,new File(libDirectory,artifactFile.getName()));
        }
        setInstallCount(artifactFile,installCount + 1);
    }
    saveInstallCounts();
}

public void uninstall(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount <= 1) {
            new File(libDirectory,artifactFile.getName()).delete();
        }
        setInstallCount(artifactFile,installCount - 1);
    }
    saveInstallCounts();
}

public void uninstallAll() throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    for (String name : this.installCounts.stringPropertyNames()) {
        new File(libDirectory,name).delete();
    }
    this.installCounts.clear();
    saveInstallCounts();
}

private void showCommandHints(String starting) {
    for (Command command : this.commandRunner) {
        if (isHintMatch(command,starting)) {
            Log.info(command.getName() + " " + command.getDescription());
        }
    }
}

private void showCommandOptionHints(String commandName,List<String> specifiedArguments,String starting) {
    Command command = this.commandRunner.findCommand(commandName);
    if (command != null) {
        for (OptionHelp help : command.getoptionsHelp()) {
            if (!alreadyUsed(help,specifiedArguments)) {
                for (String option : help.getoptions()) {
                    if (option.startsWith(starting)) {
                        Log.info(option + " " + help.getUsageHelp());
                    }
                }
            }
        }
    }
}

@Override
public ExitStatus run(String... args) throws Exception {
    if (args.length == 0) {
        throw new NoHelpCommandArgumentsException();
    }
    String commandName = args[0];
    for (Command command : this.commandRunner) {
        if (command.getName().equals(commandName)) {
            Log.info(this.commandRunner.getName() + command.getName() + " - "
                    + command.getDescription());
            Log.info("");
            if (command.getUsageHelp() != null) {
                Log.info("usage: " + this.commandRunner.getName() + command.getName()
                        + " " + command.getUsageHelp());
                Log.info("");
            }
            if (command.getHelp() != null) {
                Log.info(command.getHelp());
            }
            Collection<HelpExample> examples = command.getExamples();
            if (examples != null) {
                Log.info(examples.size() == 1 ? "example:" : "examples:");
                Log.info("");
                for (HelpExample example : examples) {
                    Log.info("    " + example.getDescription() + ":");
                    Log.info("        $ " + example.getExample());
                    Log.info("");
                }
                Log.info("");
            }
            return ExitStatus.OK;
        }
    }
    throw new NoSuchCommandException(commandName);
}

public MavenSettings readSettings() {
    Settings settings = loadSettings();
    SettingsDecryptionResult decrypted = decryptSettings(settings);
    if (!decrypted.getProblems().isEmpty()) {
        Log.error(
                "Maven settings decryption Failed. Some Maven repositories may be inaccessible");
        // Continue - the encrypted credentials may not be used
    }
    return new MavenSettings(settings,decrypted);
}

/**
 * Generate a project based on the specified {@link ProjectGenerationRequest}.
 * @param request the generation request
 * @return an entity defining the project
 * @throws IOException if generation fails
 */
public ProjectGenerationResponse generate(ProjectGenerationRequest request)
        throws IOException {
    Log.info("Using service at " + request.getServiceUrl());
    InitializrServiceMetadata Metadata = loadMetadata(request.getServiceUrl());
    URI url = request.generateUrl(Metadata);
    CloseableHttpResponse httpResponse = executeProjectGenerationRequest(url);
    httpentity httpentity = httpResponse.getEntity();
    validateResponse(httpResponse,httpentity);
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    Assert.notEmpty(args,this).install(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

public void install(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    libDirectory.mkdirs();
    Log.info("Installing into: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount == 0) {
            FilecopyUtils.copy(artifactFile,installCount + 1);
    }
    saveInstallCounts();
}

public void uninstall(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount <= 1) {
            new File(libDirectory,installCount - 1);
    }
    saveInstallCounts();
}

public void uninstallAll() throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    for (String name : this.installCounts.stringPropertyNames()) {
        new File(libDirectory,name).delete();
    }
    this.installCounts.clear();
    saveInstallCounts();
}

private void showCommandHints(String starting) {
    for (Command command : this.commandRunner) {
        if (isHintMatch(command,starting)) {
            Log.info(command.getName() + " " + command.getDescription());
        }
    }
}

private void showCommandOptionHints(String commandName,specifiedArguments)) {
                for (String option : help.getoptions()) {
                    if (option.startsWith(starting)) {
                        Log.info(option + " " + help.getUsageHelp());
                    }
                }
            }
        }
    }
}

@Override
public ExitStatus run(String... args) throws Exception {
    if (args.length == 0) {
        throw new NoHelpCommandArgumentsException();
    }
    String commandName = args[0];
    for (Command command : this.commandRunner) {
        if (command.getName().equals(commandName)) {
            Log.info(this.commandRunner.getName() + command.getName() + " - "
                    + command.getDescription());
            Log.info("");
            if (command.getUsageHelp() != null) {
                Log.info("usage: " + this.commandRunner.getName() + command.getName()
                        + " " + command.getUsageHelp());
                Log.info("");
            }
            if (command.getHelp() != null) {
                Log.info(command.getHelp());
            }
            Collection<HelpExample> examples = command.getExamples();
            if (examples != null) {
                Log.info(examples.size() == 1 ? "example:" : "examples:");
                Log.info("");
                for (HelpExample example : examples) {
                    Log.info("    " + example.getDescription() + ":");
                    Log.info("        $ " + example.getExample());
                    Log.info("");
                }
                Log.info("");
            }
            return ExitStatus.OK;
        }
    }
    throw new NoSuchCommandException(commandName);
}

public MavenSettings readSettings() {
    Settings settings = loadSettings();
    SettingsDecryptionResult decrypted = decryptSettings(settings);
    if (!decrypted.getProblems().isEmpty()) {
        Log.error(
                "Maven settings decryption Failed. Some Maven repositories may be inaccessible");
        // Continue - the encrypted credentials may not be used
    }
    return new MavenSettings(settings,decrypted);
}

/**
 * Generate a project based on the specified {@link ProjectGenerationRequest}.
 * @param request the generation request
 * @return an entity defining the project
 * @throws IOException if generation fails
 */
public ProjectGenerationResponse generate(ProjectGenerationRequest request)
        throws IOException {
    Log.info("Using service at " + request.getServiceUrl());
    InitializrServiceMetadata Metadata = loadMetadata(request.getServiceUrl());
    URI url = request.generateUrl(Metadata);
    CloseableHttpResponse httpResponse = executeProjectGenerationRequest(url);
    httpentity httpentity = httpResponse.getEntity();
    validateResponse(httpResponse,httpentity);
}

@Override
@SuppressWarnings("unchecked")
protected ExitStatus run(OptionSet options) throws Exception {
    List<String> args = (List<String>) options.nonoptionArguments();
    Assert.notEmpty(args,this).install(args);
    }
    catch (Exception ex) {
        String message = ex.getMessage();
        Log.error(message != null ? message : ex.getClass().toString());
    }
    return ExitStatus.OK;
}

public void install(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    libDirectory.mkdirs();
    Log.info("Installing into: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount == 0) {
            FilecopyUtils.copy(artifactFile,installCount + 1);
    }
    saveInstallCounts();
}

public void uninstall(List<String> artifactIdentifiers) throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    List<File> artifactFiles = this.dependencyResolver.resolve(artifactIdentifiers);
    for (File artifactFile : artifactFiles) {
        int installCount = getInstallCount(artifactFile);
        if (installCount <= 1) {
            new File(libDirectory,installCount - 1);
    }
    saveInstallCounts();
}

public void uninstallAll() throws Exception {
    File libDirectory = getDefaultLibDirectory();
    Log.info("Uninstalling from: " + libDirectory);
    for (String name : this.installCounts.stringPropertyNames()) {
        new File(libDirectory,name).delete();
    }
    this.installCounts.clear();
    saveInstallCounts();
}

private void showCommandHints(String starting) {
    for (Command command : this.commandRunner) {
        if (isHintMatch(command,starting)) {
            Log.info(command.getName() + " " + command.getDescription());
        }
    }
}

private void showCommandOptionHints(String commandName,specifiedArguments)) {
                for (String option : help.getoptions()) {
                    if (option.startsWith(starting)) {
                        Log.info(option + " " + help.getUsageHelp());
                    }
                }
            }
        }
    }
}

@Override
public ExitStatus run(String... args) throws Exception {
    if (args.length == 0) {
        throw new NoHelpCommandArgumentsException();
    }
    String commandName = args[0];
    for (Command command : this.commandRunner) {
        if (command.getName().equals(commandName)) {
            Log.info(this.commandRunner.getName() + command.getName() + " - "
                    + command.getDescription());
            Log.info("");
            if (command.getUsageHelp() != null) {
                Log.info("usage: " + this.commandRunner.getName() + command.getName()
                        + " " + command.getUsageHelp());
                Log.info("");
            }
            if (command.getHelp() != null) {
                Log.info(command.getHelp());
            }
            Collection<HelpExample> examples = command.getExamples();
            if (examples != null) {
                Log.info(examples.size() == 1 ? "example:" : "examples:");
                Log.info("");
                for (HelpExample example : examples) {
                    Log.info("    " + example.getDescription() + ":");
                    Log.info("        $ " + example.getExample());
                    Log.info("");
                }
                Log.info("");
            }
            return ExitStatus.OK;
        }
    }
    throw new NoSuchCommandException(commandName);
}

public MavenSettings readSettings() {
    Settings settings = loadSettings();
    SettingsDecryptionResult decrypted = decryptSettings(settings);
    if (!decrypted.getProblems().isEmpty()) {
        Log.error(
                "Maven settings decryption Failed. Some Maven repositories may be inaccessible");
        // Continue - the encrypted credentials may not be used
    }
    return new MavenSettings(settings,decrypted);
}

public MavenSettings readSettings() {
    Settings settings = loadSettings();
    SettingsDecryptionResult decrypted = decryptSettings(settings);
    if (!decrypted.getProblems().isEmpty()) {
        Log.error(
                "Maven settings decryption Failed. Some Maven repositories may be inaccessible");
        // Continue - the encrypted credentials may not be used
    }
    if(Boolean.getBoolean("mavenSettings.offline")) {
        settings.setoffline(true);
    }
    return new MavenSettings(settings,decrypted);
}