import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
@Override
public String createPolicy(
        String repositoryId, Properties properties, String folderId, List<String> policies,
        Acl addAces, Acl removeAces, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // get the parent folder
    getOrCreateFolderInfo(folderId, "Parent Folder");

    String objectTypeId = connector.getObjectTypeIdProperty(properties);
    connector.getTypeForCreate(objectTypeId, BaseTypeId.CMIS_POLICY);

    // we should never get here - policies are not creatable!
    throw new CmisRuntimeException("Polcies cannot be created!");
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> T copy(T source)
{
    T target = null;
    try
    {
        CopyOutputStream cos = new CopyOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(cos);
        out.writeObject(source);
        out.flush();
        out.close();

        ObjectInputStream in = new ObjectInputStream(cos.getInputStream());
        target = (T) in.readObject();
    } catch (Exception e)
    {
        throw new CmisRuntimeException("Object copy failed!", e);
    }

    return target;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
private void skipBytes() {
    long remainingSkipBytes = offset;

    try {
        while (remainingSkipBytes > 0) {
            long skipped = super.skip(remainingSkipBytes);
            remainingSkipBytes -= skipped;

            if (skipped == 0) {
                // stream might not support skipping
                skipBytesByReading(remainingSkipBytes);
                break;
            }
        }
    } catch (IOException e) {
        throw new CmisRuntimeException("Skipping the stream failed!", e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的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.CmisRuntimeException; //导入依赖的package包/类
/**
 * Get a specific version by name
 * @param name  name of the version to get
 * @return  a {@link RegistryVersion} instance for <code>name</code>
 * @throws CmisObjectNotFoundException  if a version <code>name</code> does not exist
 * @throws CmisRuntimeException
 */
public RegistryVersion getVersion(String name) {
    try {
        Resource node = getNode();
        String[] versions = getRepository().getVersions(node.getPath());
        if(versions == null){
            throw new CmisObjectNotFoundException("No versions exist");
        }
        String gotVersion = null;
        for (String version: versions){
        	if(version.equals(name)){
        		gotVersion = version;
        	}
        }
        if(gotVersion == null){
        	throw new CmisObjectNotFoundException("No version found");
        }
        return new RegistryVersion(getRepository(), node, gotVersion, typeManager, pathManager);
    }
    catch (RegistryException e) {
        String msg = "Unable to get the version for " + name;
        log.error(msg, e);
        throw new CmisRuntimeException(msg, e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的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.CmisRuntimeException; //导入依赖的package包/类
/**
 * Returns the root folder node ref.
 */
public NodeRef getRootNodeRef()
{
    NodeRef rootNodeRef = (NodeRef)singletonCache.get(KEY_CMIS_ROOT_NODEREF);
    if (rootNodeRef == null)
    {
        rootNodeRef = AuthenticationUtil.runAs(new RunAsWork<NodeRef>()
        {
            public NodeRef doWork() throws Exception
            {
                return transactionService.getRetryingTransactionHelper().doInTransaction(
                        new RetryingTransactionCallback<NodeRef>()
                        {
                            public NodeRef execute() throws Exception
                            {
                                NodeRef root = nodeService.getRootNode(storeRef);
                                List<NodeRef> rootNodes = searchService.selectNodes(root, rootPath, null,
                                        namespaceService, false);
                                if (rootNodes.size() != 1)
                                {
                                    throw new CmisRuntimeException("Unable to locate CMIS root path " + rootPath);
                                }
                                return rootNodes.get(0);
                            };
                        }, true);
            }
        }, AuthenticationUtil.getSystemUserName());

        if (rootNodeRef == null)
        {
            throw new CmisObjectNotFoundException("Root folder path '" + rootPath + "' not found!");
        }

        singletonCache.put(KEY_CMIS_ROOT_NODEREF, rootNodeRef);
    }

    return rootNodeRef;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
@Override
public ObjectData getFolderParent(String repositoryId, String folderId, String filter, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // get the node ref
    CMISNodeInfo info = getOrCreateFolderInfo(folderId, "Folder");

    // the root folder has no parent
    if (info.isRootFolder())
    {
        throw new CmisInvalidArgumentException("Root folder has no parent!");
    }

    // get the parent
    List<CMISNodeInfo> parentInfos = info.getParents();
    if (parentInfos.isEmpty())
    {
        throw new CmisRuntimeException("Folder has no parent and is not the root folder?!");
    }

    CMISNodeInfo parentInfo = addNodeInfo(parentInfos.get(0));

    ObjectData result = connector.createCMISObject(
            parentInfo, filter, false, IncludeRelationships.NONE,
            CMISConnector.RENDITION_NONE, false, false);
	boolean isObjectInfoRequired = getContext().isObjectInfoRequired();
    if (isObjectInfoRequired)
    {
        getObjectInfo(
                repositoryId,
                parentInfo.getObjectId(),
                IncludeRelationships.NONE);
    }

    return result;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * ALF-20389 Test Alfresco cmis stream interceptor that checks content stream for mimetype. Only ContentStreamImpl extensions should take palace.
 */
@Test
public void testGetRepositoryInfos()
{
    boolean cmisEx = false;
    List<RepositoryInfo> infoDataList = null;
    try
    {
        infoDataList = withCmisService(new CmisServiceCallback<List<RepositoryInfo>>()
        {
            @Override
            public List<RepositoryInfo> execute(CmisService cmisService)
            {
                ExtensionDataImpl result = new ExtensionDataImpl();
                List<CmisExtensionElement> extensions = new ArrayList<CmisExtensionElement>();
                result.setExtensions(extensions);

                return cmisService.getRepositoryInfos(result);
            }
        });
    }
    catch (CmisRuntimeException e)
    {
        cmisEx = true;
    }

    assertNotNull(cmisEx ? "CmisRuntimeException was thrown. Please, take a look on ALF-20389" : "No CMIS repository information was retrieved", infoDataList);
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * Gets the CMIS Type Id given the Alfresco QName for the type in any
 * Alfresco model
 * 
 * @param scope BaseTypeId
 * @param typeQName QName
 * @return String
 */
public String getCmisTypeId(BaseTypeId scope, QName typeQName)
{
    String typeId = mapAlfrescoQNameToTypeId.get(typeQName);
    if (typeId == null)
    {
        String p = null;
        switch (scope)
        {
        case CMIS_DOCUMENT:
            p = "D";
            break;
        case CMIS_FOLDER:
            p = "F";
            break;
        case CMIS_RELATIONSHIP:
            p = "R";
            break;
        case CMIS_SECONDARY:
            p = "P";
            break;
        case CMIS_POLICY:
            p = "P";
            break;
        case CMIS_ITEM:
            p = "I";
            break;
        default:
            throw new CmisRuntimeException("Invalid base type!");
        }

        return p + ":" + typeQName.toPrefixString(namespaceService);
    } 
    else
    {
        return typeId;
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
@Override
public List<RepositoryInfo> getRepositoryInfos(ExtensionsData extension) {
	log.debug("getRepositoryInfos({})", extension);

	try {
		List<RepositoryInfo> infos = new ArrayList<RepositoryInfo>();
		infos.add(getRepository().getRepositoryInfo(getCallContext()));
		return infos;
	} catch (Exception e) {
		throw new CmisRuntimeException(e.getMessage(), e);
	}
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * Returns the id of a File object or throws an appropriate exception.
 */
private String getId(File file) {
    try {
        return fileToId(file);
    } catch (Exception e) {
        throw new CmisRuntimeException(e.getMessage(), e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
private void skipBytesByReading(long remainingSkipBytes) {
    try {
        final byte[] buffer = new byte[BUFFER_SIZE];
        while (remainingSkipBytes > 0) {
            long skipped = super.read(buffer, 0, (int) Math.min(buffer.length, remainingSkipBytes));
            if (skipped == -1) {
                break;
            }

            remainingSkipBytes -= skipped;
        }
    } catch (IOException e) {
        throw new CmisRuntimeException("Reading the stream failed!", e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
public ContentStream getContentStream(){

    	// compile data
        ContentStreamImpl result = new ContentStreamImpl();
        result.setFileName(getName());
            
        try {
            result.setLength(BigInteger.valueOf(getPropertyLength(getNode(), CMISConstants.GREG_DATA)));
            if(getNode().getContent() != null){
                String mimeType = getNode().getProperty(CMISConstants.GREG_MIMETYPE);
                result.setMimeType(mimeType);
                //result.setMimeType(getNode().getMediaType());
            } else {
                result.setMimeType(null);
            }
            if(getNode().getContent() != null){

                InputStream inputStream = getNode().getContentStream();
                result.setStream(new BufferedInputStream(inputStream));  // stream closed by consumer
            } else {
                result.setStream(null);
            }
        } catch (RegistryException e) {
            throw new CmisRuntimeException(e.getMessage(), e);
        }

        return result;
    }
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * See CMIS 1.0 section 2.2.7.3 checkedIn
 *
 * @throws CmisRuntimeException
 */
public RegistryVersion checkin(Properties properties, ContentStream contentStream, String checkinComment) {
    Resource node = getNode();

    try {
        if (!isCheckedOut(node)) {
            throw new CmisStorageException("Not checked out: " + node.getId());
        }

        if (properties != null && !properties.getPropertyList().isEmpty()) {
            updateProperties(properties);
        }

        if (contentStream != null) {
            setContentStream(contentStream, true);
        }

        // todo handle checkinComment
        Resource resource = checkin();
        String pathOfLatestVersion = getRepository().getVersions(resource.getPath())[0];
        return new RegistryVersion(getRepository(), resource, pathOfLatestVersion, typeManager, pathManager);
    }
    catch (RegistryException e) {
        String msg = "Failed checkin";
        log.error(msg, e);
        throw new CmisRuntimeException(msg, e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * See CMIS 1.0 section 2.2.7.2 cancelCheckout
 *
 * @throws CmisRuntimeException
 */
public void cancelCheckout() {
    Resource node = getNode();
    try {
        //TODO If node is the original copy then the pwc has to be passed!
        cancelCheckout(getRepository(),node);
    }
    catch (RegistryException e) {
        String msg = "Failed cancelling the checkout";
        log.error(msg, e);
        throw new CmisRuntimeException(msg, e);
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * Determine the default property data value for a given property definition.
 * @param propDef
 * @return
 * @throws org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException  if <code>propDef</code> is invalid or unknown.
 */
@SuppressWarnings("unchecked")
public static PropertyData<?> getDefaultValue(PropertyDefinition<?> propDef) {
    if (propDef == null) {
        return null;
    }

    List<?> defaultValue = propDef.getDefaultValue();
    if (defaultValue != null && !defaultValue.isEmpty()) {
        switch (propDef.getPropertyType()) {
            case BOOLEAN:
                return new PropertyBooleanImpl(propDef.getId(), (List<Boolean>) defaultValue);
            case DATETIME:
                return new PropertyDateTimeImpl(propDef.getId(), (List<GregorianCalendar>) defaultValue);
            case DECIMAL:
                return new PropertyDecimalImpl(propDef.getId(), (List<BigDecimal>) defaultValue);
            case HTML:
                return new PropertyHtmlImpl(propDef.getId(), (List<String>) defaultValue);
            case ID:
                return new PropertyIdImpl(propDef.getId(), (List<String>) defaultValue);
            case INTEGER:
                return new PropertyIntegerImpl(propDef.getId(), (List<BigInteger>) defaultValue);
            case STRING:
                return new PropertyStringImpl(propDef.getId(), (List<String>) defaultValue);
            case URI:
                return new PropertyUriImpl(propDef.getId(), (List<String>) defaultValue);
            default:
                throw new CmisRuntimeException("Unknown datatype: " + propDef.getPropertyType());
        }
    }
    return null;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
public final EventResult processEvent(Event event) throws Exception
{
    try
    {
        return processCMISEvent(event);
    }
    catch (CmisRuntimeException e)
    {
        String error = e.getMessage();
        String stack = ExceptionUtils.getStackTrace(e);
        // Grab the CMIS information
        DBObject data = BasicDBObjectBuilder
                .start()
                .append("msg", error)
                .append("stack", stack)
                .push("cmisFault")
                    .append("code", "" + e.getCode())               // BigInteger is not Serializable
                    .append("errorContent", e.getErrorContent())
                .pop()
                .get();
        
        // Build failure result
        return new EventResult(data, false);
    }
    catch(Exception genEx)
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("General exception in CMIS benchmark.", genEx);
        }
        throw genEx;
    }
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
@ExceptionHandler(CmisRuntimeException.class)
public ModelAndView handleCmisRuntimeError(HttpServletRequest req, CmisRuntimeException exc) {
    ModelAndView mav = new ModelAndView();
    mav.addObject("Invalid Page", exc.getMessage());
    mav.addObject("exception", exc);
    mav.addObject("utl",req.getRequestURL());
    mav.setViewName("error");

    return mav;
}
 

import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; //导入依赖的package包/类
/**
 * Returns the query as a {@code String}.
 */
public String getQueryString() {
    StringBuilder sb = new StringBuilder("SELECT");

    // SELECT
    if (selectFragments.isEmpty()) {
        sb.append(" *");
    } else {
        concatenate(sb, selectFragments, ",");
    }

    // FROM
    if (!fromFragments.isEmpty()) {
        sb.append(" FROM");
        concatenate(sb, fromFragments, ",");

        // WHERE
        if (!whereFragments.isEmpty()) {
            sb.append(" WHERE");
            concatenate(sb, whereFragments, " AND");
        }

        // ORDER BY
        if (!orderByFragments.isEmpty()) {
            sb.append(" ORDER BY");
            concatenate(sb, orderByFragments, ",");
        }
    } else {
        throw new CmisRuntimeException("No FROM clauses have been specified!");
    }

    return sb.toString();
}