import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * Checks if a child of a given type can be added to a given folder.
 */
@SuppressWarnings("unchecked")
public void checkChildObjectType(CMISNodeInfo folderInfo, String childType)
{
    TypeDefinitionWrapper targetType = folderInfo.getType();
    PropertyDefinitionWrapper allowableChildObjectTypeProperty = targetType
            .getPropertyById(PropertyIds.ALLOWED_CHILD_OBJECT_TYPE_IDS);
    List<String> childTypes = (List<String>) allowableChildObjectTypeProperty.getPropertyAccessor().getValue(
            folderInfo);

    if ((childTypes == null) || childTypes.isEmpty())
    {
        return;
    }

    if (!childTypes.contains(childType))
    {
        throw new CmisConstraintException("Objects of type '" + childType + "' cannot be added to this folder!");
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@Override
public void removePolicy(String repositoryId, String policyId, String objectId, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // what kind of object is it?
    CMISNodeInfo info = getOrCreateNodeInfo(objectId, "Object");

    TypeDefinitionWrapper type = info.getType();
    if (type == null)
    {
        throw new CmisObjectNotFoundException("No corresponding type found! Not a CMIS object?");
    }

    throw new CmisConstraintException("Object is not policy controllable!");
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@Override
public Acl applyAcl(
        String repositoryId, String objectId, final Acl addAces, final Acl removeAces,
        AclPropagation aclPropagation, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // We are spec compliant if we just let it through and the tck will not fail

    CMISNodeInfo info = getOrCreateNodeInfo(objectId, "Object");

    // relationships don't have ACLs
    if (info.isVariant(CMISObjectVariant.ASSOC))
    {
        throw new CmisConstraintException("Relationships are not ACL controllable!");
    }

    final NodeRef nodeRef = info.getCurrentNodeNodeRef();
    final TypeDefinitionWrapper type = info.getType();

    connector.applyACL(nodeRef, type, addAces, removeAces);

    return connector.getACL(nodeRef, false);
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * Checks if a child of a given type can be added to a given folder.
 */
@SuppressWarnings("unchecked")
public void checkChildObjectType(CMISNodeInfo folderInfo, String childType)
{
    TypeDefinitionWrapper targetType = folderInfo.getType();
    PropertyDefinitionWrapper allowableChildObjectTypeProperty = targetType
            .getPropertyById(PropertyIds.ALLOWED_CHILD_OBJECT_TYPE_IDS);
    List<String> childTypes = (List<String>) allowableChildObjectTypeProperty.getPropertyAccessor().getValue(
            folderInfo);

    if ((childTypes == null) || childTypes.isEmpty())
    {
        return;
    }
    
    if (!childTypes.contains(childType))
    {
        throw new CmisConstraintException("Objects of type '" + childType + "' cannot be added to this folder!");
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * CMIS deleteObject.
 */
public void deleteObject(CallContext context, String objectId) {
    checkUser(context, true);

    // get the file or folder
    File file = getFile(objectId);
    if (!file.exists()) {
        throw new CmisObjectNotFoundException("Object not found!");
    }

    // check if it is a folder and if it is empty
    if (!isFolderEmpty(file)) {
        throw new CmisConstraintException("Folder is not empty!");
    }

    // delete file
    if (!file.delete()) {
        throw new CmisStorageException("Deletion failed!");
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * CMIS deleteTree.
 */
public FailedToDeleteData deleteTree(CallContext context, String folderId, Boolean continueOnFailure) {
    checkUser(context, true);

    boolean cof = FileBridgeUtils.getBooleanParameter(continueOnFailure, false);

    // get the file or folder
    File file = getFile(folderId);

    FailedToDeleteDataImpl result = new FailedToDeleteDataImpl();
    result.setIds(new ArrayList<String>());

    // if it is a folder, remove it recursively
    if (file.isDirectory()) {
        deleteFolder(file, cof, result);
    } else {
        throw new CmisConstraintException("Object is not a folder!");
    }

    return result;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * See CMIS 1.0 section 2.2.7.1 checkOut
 *
 * @throws CmisRuntimeException
 */
public RegistryPrivateWorkingCopy checkout() {
    Resource node = getNode();
    try {
        if (isCheckedOut(node)) {
            throw new CmisConstraintException("Document is already checked out " + node.getId());
        }

        return getPwc(checkout(getRepository(), node));
    }
    catch (RegistryException e) {
        String msg = "Failed checkout the node with path " + node.getPath();
        log.error(msg, e);
        throw new CmisRuntimeException(msg, e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * See CMIS 1.0 section 2.2.4.14 deleteObject
 *
 * @throws CmisRuntimeException
 */
@Override
public void delete(boolean allVersions, boolean isPwc) {
    try {
        if (getNode().getChildCount()>0) {
            throw new CmisConstraintException("Folder is not empty!");
        } else {
            super.delete(allVersions, isPwc);
        }
    }
    catch (RegistryException e) {
        String msg = "Failed to delete the object " + getNode().getPath();
        log.error(msg, e);
        throw new CmisRuntimeException(msg, e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * CMIS deleteObject.
 */
public void deleteObject(CallContext context, String objectId) {
	checkUser(context, true);

	// get the file or folder
	File file = getFile(objectId);
	if (!file.exists()) {
		throw new CmisObjectNotFoundException("Object not found!");
	}

	// check if it is a folder and if it is empty
	if (!isFolderEmpty(file)) {
		throw new CmisConstraintException("Folder is not empty!");
	}

	// delete file
	if (!file.delete()) {
		throw new CmisStorageException("Deletion failed!");
	}
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * CMIS deleteTree.
 */
public FailedToDeleteData deleteTree(CallContext context, String folderId,
		Boolean continueOnFailure) {
	checkUser(context, true);

	boolean cof = FileBridgeUtils.getBooleanParameter(continueOnFailure,
			false);

	// get the file or folder
	File file = getFile(folderId);

	FailedToDeleteDataImpl result = new FailedToDeleteDataImpl();
	result.setIds(new ArrayList<String>());

	// if it is a folder, remove it recursively
	if (file.isDirectory()) {
		deleteFolder(file, cof, result);
	} else {
		throw new CmisConstraintException("Object is not a folder!");
	}

	return result;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * Returns the definition after it has checked if the type can be used for
 * object creation.
 */
public TypeDefinitionWrapper getTypeForCreate(String cmisTypeId, BaseTypeId baseTypeId)
{
    TypeDefinitionWrapper type = getType(cmisTypeId);
    if ((type == null) || (type.getBaseTypeId() != baseTypeId))
    {
        switch (baseTypeId)
        {
        case CMIS_DOCUMENT:
            throw new CmisConstraintException("Type is not a document type!");
        case CMIS_FOLDER:
            throw new CmisConstraintException("Type is not a folder type!");
        case CMIS_RELATIONSHIP:
            throw new CmisConstraintException("Type is not a relationship type!");
        case CMIS_POLICY:
            throw new CmisConstraintException("Type is not a policy type!");
        case CMIS_ITEM:
            throw new CmisConstraintException("Type is not an item type!");
        }
    }

    if (!type.getTypeDefinition(false).isCreatable())
    {
        throw new CmisConstraintException("Type is not creatable!");
    }

    return type;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
private void checkDocumentTypeForContent(TypeDefinitionWrapper type)
{
    if (type == null)
    {
        throw new CmisObjectNotFoundException("No corresponding type found! Not a CMIS object?");
    }
    if (!(type instanceof DocumentTypeDefinitionWrapper))
    {
        throw new CmisStreamNotSupportedException("Object is not a document!");
    }
    if (((DocumentTypeDefinition) type.getTypeDefinition(false)).getContentStreamAllowed() == ContentStreamAllowed.NOTALLOWED)
    {
        throw new CmisConstraintException("Document cannot have content!");
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * Sets the given ACL.
 */
public void applyACL(NodeRef nodeRef, TypeDefinitionWrapper type, Acl aces)
{
    boolean hasAces = (aces != null) && (aces.getAces() != null) && !aces.getAces().isEmpty();

    if (!hasAces && !permissionService.getInheritParentPermissions(nodeRef))
    {
        return;
    }

    if (!type.getTypeDefinition(false).isControllableAcl())
    {
        throw new CmisConstraintException("Object is not ACL controllable!");
    }

    // remove all permissions
    permissionService.deletePermissions(nodeRef);

    // set new permissions
    for (Ace ace : aces.getAces())
    {
        String principalId = ace.getPrincipalId();
        if (CMIS_USER.equals(principalId))
        {
            principalId = AuthenticationUtil.getFullyAuthenticatedUser();
        }

        List<String> permissions = translatePermissionsFromCMIS(ace.getPermissions());
        for (String permission : permissions)
        {
            permissionService.setPermission(nodeRef, principalId, permission, true);
        }
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
public void applyPolicies(NodeRef nodeRef, TypeDefinitionWrapper type, List<String> policies)
{
    if ((policies == null) || (policies.isEmpty()))
    {
        return;
    }

    if (!type.getTypeDefinition(false).isControllablePolicy())
    {
        throw new CmisConstraintException("Object is not policy controllable!");
    }

    // nothing else to do...
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@Override
public void checkOut(
        String repositoryId, final Holder<String> objectId, ExtensionsData extension,
        final Holder<Boolean> contentCopied)
{
    checkRepositoryId(repositoryId);

    CMISNodeInfo info = getOrCreateNodeInfo(objectId.getValue(), "Object");

    // Check for current version
    if (info.isVariant(CMISObjectVariant.CURRENT_VERSION))
    {
        // Good
    }
    else if (info.isVariant(CMISObjectVariant.VERSION))
    {
        throw new CmisInvalidArgumentException("Can't check out an old version of a document");
    }
    else {   
        throw new CmisInvalidArgumentException("Only documents can be checked out! Object was a " + info.getObjectVariant().toString());
    }

    // get object
    final NodeRef nodeRef = info.getNodeRef();

    if (!((DocumentTypeDefinition) info.getType().getTypeDefinition(false)).isVersionable())
    {
        throw new CmisConstraintException("Document is not versionable!");
    }
    
    // check out
    NodeRef pwcNodeRef = connector.getCheckOutCheckInService().checkout(nodeRef);
    CMISNodeInfo pwcNodeInfo = createNodeInfo(pwcNodeRef);
    objectId.setValue(pwcNodeInfo.getObjectId());

    if (contentCopied != null)
    {
        contentCopied.setValue(connector.getFileFolderService().getReader(pwcNodeRef) != null);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@Override
public void removeObjectFromFolder(String repositoryId, String objectId, String folderId, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // get node ref
    CMISNodeInfo info = getOrCreateNodeInfo(objectId, "Object");

    if (!info.isDocument())
    {
        throw new CmisInvalidArgumentException("Object is not a document!");
    }

    final NodeRef nodeRef = info.getNodeRef();

    // get the folder node ref
    final NodeRef folderNodeRef = getOrCreateFolderInfo(folderId, "Folder").getNodeRef();

    // check primary parent
    if (connector.getNodeService().getPrimaryParent(nodeRef).getParentRef().equals(folderNodeRef))
    {
        throw new CmisConstraintException(
                "Unfiling from primary parent folder is not supported! Use deleteObject() instead.");
    }

    connector.getNodeService().removeChild(folderNodeRef, nodeRef);
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@Test
public void testIntegrityException() throws Throwable
{
    Exception e = new IntegrityException(null);
    Class<?> toCatch = CmisConstraintException.class;
    
    doMockCall(e, toCatch);
    doMockCall(new RuntimeException(new RuntimeException(e)), toCatch);
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
private void setProperiesToObject(CmisService cmisService, String repositoryId, String objectIdStr, String propertyStr, BigInteger bigIntValue) throws CmisConstraintException{
    Properties properties = cmisService.getProperties(repositoryId, objectIdStr, null, null);
    PropertyIntegerImpl pd = (PropertyIntegerImpl)properties.getProperties().get(propertyStr);
    pd.setValue(bigIntValue);
    
    Collection<PropertyData<?>> propsList = new ArrayList<PropertyData<?>>();
    propsList.add(pd);
    
    Properties newProps = new PropertiesImpl(propsList);
    
    cmisService.updateProperties(repositoryId, new Holder<String>(objectIdStr), null, newProps, null);
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
@POST
@Consumes(MediaType.APPLICATION_JSON + ";charset=utf-8")
public Response insert(RelationBean pRelationBean, @Context
	    HttpServletRequest pRequest) {
	Session lSession = Util.getUserAlfrescoSession(httpRequest);

	Relationship lRelationship = null;
	try{
		lRelationship =
				AlfrescoHelper.createRelation(lSession, pRelationBean.getTypeId(), pRelationBean.getSourceId(), pRelationBean.getTargetId());
	} catch (Exception e) {
		if(e instanceof CmisConstraintException ){
			//Prendo il resourceBundle per le label degli errori
			final Locale lLocale = LocaleUtil.getLocale(pRequest.getSession());
			ResourceBundle lResourceBundle = null;
           	if(lLocale != null){
           		lResourceBundle = ResourceBundle.getBundle("ApplicationResources",lLocale);
           	} else {
           		lResourceBundle = ResourceBundle.getBundle("ApplicationResources");
           	}
			
			return Response.status(422).entity(new MessageBean(lResourceBundle.getString("js.error.integrity"))).build(); 
		} else {
			throw e;
		}
	}
	

	return Response.ok(lRelationship).build();
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisConstraintException; //导入依赖的package包/类
/**
 * Returns the definition after it has checked if the type can be used for
 * object creation.
 */
public TypeDefinitionWrapper getTypeForCreate(String cmisTypeId, BaseTypeId baseTypeId)
{
    TypeDefinitionWrapper type = getType(cmisTypeId);
    if ((type == null) || (type.getBaseTypeId() != baseTypeId))
    {
        switch (baseTypeId)
        {
        case CMIS_DOCUMENT:
            throw new CmisConstraintException("Type is not a document type!");
        case CMIS_FOLDER:
            throw new CmisConstraintException("Type is not a folder type!");
        case CMIS_RELATIONSHIP:
            throw new CmisConstraintException("Type is not a relationship type!");
        case CMIS_POLICY:
            throw new CmisConstraintException("Type is not a policy type!");
        case CMIS_ITEM:
            throw new CmisConstraintException("Type is not an item type!");    
        }
    }

    if (!type.getTypeDefinition(false).isCreatable())
    {
        throw new CmisConstraintException("Type is not creatable!");
    }

    return type;
}