Java tutorial
/******************************************************************************* * Copyright (c) 2013 aegif. * * This file is part of NemakiWare. * * NemakiWare is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * NemakiWare is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with NemakiWare. * If not, see <http://www.gnu.org/licenses/>. * * Contributors: * linzhixing(https://github.com/linzhixing) - initial API and implementation ******************************************************************************/ package jp.aegif.nemaki.cmis.service.impl; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.GregorianCalendar; import java.util.List; import java.util.concurrent.locks.Lock; import jp.aegif.nemaki.businesslogic.ContentService; import jp.aegif.nemaki.cmis.aspect.CompileService; import jp.aegif.nemaki.cmis.aspect.ExceptionService; import jp.aegif.nemaki.cmis.service.VersioningService; import jp.aegif.nemaki.model.Content; import jp.aegif.nemaki.model.Document; import jp.aegif.nemaki.model.VersionSeries; import jp.aegif.nemaki.util.cache.NemakiCachePool; import jp.aegif.nemaki.util.constant.DomainType; import jp.aegif.nemaki.util.lock.ThreadLockService; import org.apache.chemistry.opencmis.commons.data.Acl; import org.apache.chemistry.opencmis.commons.data.ContentStream; import org.apache.chemistry.opencmis.commons.data.ExtensionsData; import org.apache.chemistry.opencmis.commons.data.ObjectData; import org.apache.chemistry.opencmis.commons.data.PermissionMapping; import org.apache.chemistry.opencmis.commons.data.Properties; import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships; import org.apache.chemistry.opencmis.commons.server.CallContext; import org.apache.chemistry.opencmis.commons.spi.Holder; import org.apache.commons.lang.StringUtils; public class VersioningServiceImpl implements VersioningService { private ContentService contentService; private CompileService compileService; private ExceptionService exceptionService; private NemakiCachePool nemakiCachePool; private ThreadLockService threadLockService; @Override /** * Repository only allow the latest version to be checked out */ public void checkOut(CallContext callContext, String repositoryId, Holder<String> objectId, ExtensionsData extension, Holder<Boolean> contentCopied) { exceptionService.invalidArgumentRequiredHolderString("objectId", objectId); String originalId = objectId.getValue(); Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue()); try { lock.lock(); nemakiCachePool.get(repositoryId).removeCmisCache(originalId); // ////////////////// // General Exception // ////////////////// Document document = contentService.getDocument(repositoryId, objectId.getValue()); exceptionService.objectNotFound(DomainType.OBJECT, document, objectId.getValue()); exceptionService.permissionDenied(callContext, repositoryId, PermissionMapping.CAN_CHECKOUT_DOCUMENT, document); // ////////////////// // Specific Exception // ////////////////// // CMIS doesn't define the error type when checkOut is performed // repeatedly exceptionService.constraintAlreadyCheckedOut(repositoryId, document); exceptionService.constraintVersionable(repositoryId, document.getObjectType()); exceptionService.versioning(document); // ////////////////// // Body of the method // ////////////////// Document pwc = contentService.checkOut(callContext, repositoryId, objectId.getValue(), extension); objectId.setValue(pwc.getId()); Holder<Boolean> copied = new Holder<Boolean>(true); contentCopied = copied; } finally { lock.unlock(); } } @Override public void cancelCheckOut(CallContext callContext, String repositoryId, String objectId, ExtensionsData extension) { exceptionService.invalidArgumentRequiredString("objectId", objectId); Lock lock = threadLockService.getWriteLock(repositoryId, objectId); try { lock.lock(); nemakiCachePool.get(repositoryId).removeCmisCache(objectId); // ////////////////// // General Exception // ////////////////// Document document = contentService.getDocument(repositoryId, objectId); exceptionService.objectNotFound(DomainType.OBJECT, document, objectId); exceptionService.permissionDenied(callContext, repositoryId, PermissionMapping.CAN_CHECKIN_DOCUMENT, document); // ////////////////// // Specific Exception // ////////////////// exceptionService.constraintVersionable(repositoryId, document.getObjectType()); // ////////////////// // Body of the method // ////////////////// contentService.cancelCheckOut(callContext, repositoryId, objectId, extension); //remove cache Document latest = contentService.getDocumentOfLatestVersion(repositoryId, document.getVersionSeriesId()); //Latest document does not exit when pwc is created as the first version if (latest != null) { Lock latestLock = threadLockService.getWriteLock(repositoryId, latest.getId()); try { latestLock.lock(); nemakiCachePool.get(repositoryId).removeCmisCache(latest.getId()); } finally { latestLock.unlock(); } } } finally { lock.unlock(); } } @Override public void checkIn(CallContext callContext, String repositoryId, Holder<String> objectId, Boolean major, Properties properties, ContentStream contentStream, String checkinComment, List<String> policies, Acl addAces, Acl removeAces, ExtensionsData extension) { exceptionService.invalidArgumentRequiredHolderString("objectId", objectId); Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue()); try { lock.lock(); // ////////////////// // General Exception // ////////////////// Document pwc = contentService.getDocument(repositoryId, objectId.getValue()); nemakiCachePool.get(repositoryId).removeCmisCache(pwc.getId()); exceptionService.objectNotFound(DomainType.OBJECT, pwc, objectId.getValue()); exceptionService.permissionDenied(callContext, repositoryId, PermissionMapping.CAN_CANCEL_CHECKOUT_DOCUMENT, pwc); // ////////////////// // Specific Exception // ////////////////// exceptionService.constraintVersionable(repositoryId, pwc.getObjectType()); // TODO implement // exceptionService.streamNotSupported(documentTypeDefinition, // contentStream); // ////////////////// // Body of the method // ////////////////// Document checkedIn = contentService.checkIn(callContext, repositoryId, objectId, major, properties, contentStream, checkinComment, policies, addAces, removeAces, extension); objectId.setValue(checkedIn.getId()); //refresh latest version Document latest = contentService.getDocumentOfLatestVersion(repositoryId, pwc.getVersionSeriesId()); if (latest != null) { Lock latestLock = threadLockService.getWriteLock(repositoryId, latest.getId()); try { latestLock.lock(); nemakiCachePool.get(repositoryId).removeCmisCache(latest.getId()); } finally { latestLock.unlock(); } } } finally { lock.unlock(); } } @Override public ObjectData getObjectOfLatestVersion(CallContext context, String repositoryId, String objectId, String versionSeriesId, Boolean major, String filter, Boolean includeAllowableActions, IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds, Boolean includeAcl, ExtensionsData extension) { // ////////////////// // General Exception // ////////////////// // Chemistry Atompub calls this method only with objectId if (versionSeriesId == null) { exceptionService.invalidArgumentRequiredString("objectId", objectId); Document d = contentService.getDocument(repositoryId, objectId); versionSeriesId = d.getVersionSeriesId(); } // Default to false Boolean _major = (major == null) ? false : major; Document document = null; if (_major) { document = contentService.getDocumentOfLatestMajorVersion(repositoryId, versionSeriesId); } else { document = contentService.getDocumentOfLatestVersion(repositoryId, versionSeriesId); } Lock lock = threadLockService.getReadLock(repositoryId, document.getId()); try { lock.lock(); exceptionService.objectNotFound(DomainType.OBJECT, document, versionSeriesId); exceptionService.permissionDenied(context, repositoryId, PermissionMapping.CAN_GET_PROPERTIES_OBJECT, document); // ////////////////// // Body of the method // ////////////////// ObjectData objectData = compileService.compileObjectData(context, repositoryId, document, filter, includeAllowableActions, includeRelationships, renditionFilter, includeAcl); return objectData; } finally { lock.unlock(); } } @Override public List<ObjectData> getAllVersions(CallContext context, String repositoryId, String objectId, String versionSeriesId, String filter, Boolean includeAllowableActions, ExtensionsData extension) { // ////////////////// // General Exception // ////////////////// // CMIS spec needs versionSeries as required, but Chemistry also takes // objectId if (StringUtils.isBlank(versionSeriesId)) { exceptionService.invalidArgumentRequiredString("objectId", objectId); Document d = contentService.getDocument(repositoryId, objectId); versionSeriesId = d.getVersionSeriesId(); } List<Document> allVersions = contentService.getAllVersions(context, repositoryId, versionSeriesId); exceptionService.objectNotFoundVersionSeries(versionSeriesId, allVersions); List<Lock> locks = threadLockService.readLocks(repositoryId, allVersions); try { threadLockService.bulkLock(locks); // Sort by the descending order Collections.sort(allVersions, new VersionComparator()); Document latest = allVersions.get(0); if (latest.isPrivateWorkingCopy()) { VersionSeries vs = contentService.getVersionSeries(repositoryId, latest); if (!context.getUsername().equals(vs.getVersionSeriesCheckedOutBy())) { allVersions.remove(latest); } } // ////////////////// // Body of the method // ////////////////// List<ObjectData> result = new ArrayList<ObjectData>(); for (Content content : allVersions) { ObjectData objectData = compileService.compileObjectData(context, repositoryId, content, filter, includeAllowableActions, IncludeRelationships.NONE, null, true); result.add(objectData); } return result; } finally { threadLockService.bulkUnlock(locks); } } /** * Descending order by cmis:creationDate * * @author linzhixing */ private class VersionComparator implements Comparator<Content> { @Override public int compare(Content content0, Content content1) { // TODO when created time is not set GregorianCalendar created0 = content0.getCreated(); GregorianCalendar created1 = content1.getCreated(); if (created0.before(created1)) { return 1; } else if (created0.after(created1)) { return -1; } else { return 0; } } } public void setContentService(ContentService contentService) { this.contentService = contentService; } public void setCompileService(CompileService compileService) { this.compileService = compileService; } public void setExceptionService(ExceptionService exceptionService) { this.exceptionService = exceptionService; } public void setNemakiCachePool(NemakiCachePool nemakiCachePool) { this.nemakiCachePool = nemakiCachePool; } public void setThreadLockService(ThreadLockService threadLockService) { this.threadLockService = threadLockService; } }