ContentDaoServiceImpl.java

/*******************************************************************************
 * 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.dao.impl.couch;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.enums.BaseTypeId;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.ektorp.Attachment;
import org.ektorp.AttachmentInputStream;
import org.ektorp.CouchDbConnector;
import org.ektorp.ViewQuery;
import org.ektorp.ViewResult;
import org.ektorp.ViewResult.Row;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import jp.aegif.nemaki.cmis.factory.info.RepositoryInfoMap;
import jp.aegif.nemaki.dao.ContentDaoService;
import jp.aegif.nemaki.dao.impl.couch.connector.ConnectorPool;
import jp.aegif.nemaki.model.Archive;
import jp.aegif.nemaki.model.AttachmentNode;
import jp.aegif.nemaki.model.Change;
import jp.aegif.nemaki.model.Content;
import jp.aegif.nemaki.model.Document;
import jp.aegif.nemaki.model.Folder;
import jp.aegif.nemaki.model.Item;
import jp.aegif.nemaki.model.NemakiPropertyDefinitionCore;
import jp.aegif.nemaki.model.NemakiPropertyDefinitionDetail;
import jp.aegif.nemaki.model.NemakiTypeDefinition;
import jp.aegif.nemaki.model.NodeBase;
import jp.aegif.nemaki.model.Policy;
import jp.aegif.nemaki.model.Relationship;
import jp.aegif.nemaki.model.Rendition;
import jp.aegif.nemaki.model.VersionSeries;
import jp.aegif.nemaki.model.couch.CouchArchive;
import jp.aegif.nemaki.model.couch.CouchAttachmentNode;
import jp.aegif.nemaki.model.couch.CouchChange;
import jp.aegif.nemaki.model.couch.CouchContent;
import jp.aegif.nemaki.model.couch.CouchDocument;
import jp.aegif.nemaki.model.couch.CouchFolder;
import jp.aegif.nemaki.model.couch.CouchItem;
import jp.aegif.nemaki.model.couch.CouchNodeBase;
import jp.aegif.nemaki.model.couch.CouchPolicy;
import jp.aegif.nemaki.model.couch.CouchPropertyDefinitionCore;
import jp.aegif.nemaki.model.couch.CouchPropertyDefinitionDetail;
import jp.aegif.nemaki.model.couch.CouchRelationship;
import jp.aegif.nemaki.model.couch.CouchRendition;
import jp.aegif.nemaki.model.couch.CouchTypeDefinition;
import jp.aegif.nemaki.model.couch.CouchVersionSeries;
import jp.aegif.nemaki.util.constant.NodeType;

/**
 * Dao Service implementation for CouchDB.
 *
 * @author linzhixing
 *
 */
@Component
public class ContentDaoServiceImpl implements ContentDaoService {

	private RepositoryInfoMap repositoryInfoMap;
	private ConnectorPool connectorPool;
	private static final Log log = LogFactory.getLog(ContentDaoServiceImpl.class);

	private static final String DESIGN_DOCUMENT = "_design/_repo";
	private static final String ATTACHMENT_NAME = "content";

	public ContentDaoServiceImpl() {

	}

	// ///////////////////////////////////////
	// Type & Property definition
	// ///////////////////////////////////////
	@Override
	public List<NemakiTypeDefinition> getTypeDefinitions(String repositoryId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("typeDefinitions");
		List<CouchTypeDefinition> l = connectorPool.get(repositoryId).queryView(query, CouchTypeDefinition.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			List<NemakiTypeDefinition> result = new ArrayList<NemakiTypeDefinition>();
			for (CouchTypeDefinition ct : l) {
				result.add(ct.convert());
			}
			return result;
		}
	}

	@Override
	public NemakiTypeDefinition getTypeDefinition(String repositoryId, String typeId) {
		throw new UnsupportedOperationException(Thread.currentThread().getStackTrace()[0].getMethodName()
				+ ":this method is only for cahced service. No need for implementation.");
	}

	@Override
	public NemakiTypeDefinition createTypeDefinition(String repositoryId, NemakiTypeDefinition typeDefinition) {
		CouchTypeDefinition ct = new CouchTypeDefinition(typeDefinition);
		connectorPool.get(repositoryId).create(ct);
		return ct.convert();
	}

	@Override
	public NemakiTypeDefinition updateTypeDefinition(String repositoryId, NemakiTypeDefinition typeDefinition) {
		CouchTypeDefinition cp = connectorPool.get(repositoryId).get(CouchTypeDefinition.class, typeDefinition.getId());
		CouchTypeDefinition update = new CouchTypeDefinition(typeDefinition);
		update.setRevision(cp.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	@Override
	public void deleteTypeDefinition(String repositoryId, String nodeId) {
		delete(repositoryId, nodeId);
	}

	@Override
	public List<NemakiPropertyDefinitionCore> getPropertyDefinitionCores(String repositoryId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("propertyDefinitionCores");
		List<CouchPropertyDefinitionCore> l = connectorPool.get(repositoryId)
				.queryView(query, CouchPropertyDefinitionCore.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			List<NemakiPropertyDefinitionCore> result = new ArrayList<NemakiPropertyDefinitionCore>();
			for (CouchPropertyDefinitionCore cpdc : l) {
				result.add(cpdc.convert());
			}
			return result;
		}
	}

	@Override
	public NemakiPropertyDefinitionCore getPropertyDefinitionCore(String repositoryId, String nodeId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("propertyDefinitionCores").key(nodeId);
		List<CouchPropertyDefinitionCore> l = connectorPool.get(repositoryId)
				.queryView(query, CouchPropertyDefinitionCore.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			return l.get(0).convert();
		}
	}

	@Override
	public NemakiPropertyDefinitionCore getPropertyDefinitionCoreByPropertyId(String repositoryId, String propertyId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("propertyDefinitionCoresByPropertyId")
				.key(propertyId);
		List<CouchPropertyDefinitionCore> l = connectorPool.get(repositoryId)
				.queryView(query, CouchPropertyDefinitionCore.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			return l.get(0).convert();
		}
	}

	@Override
	public NemakiPropertyDefinitionDetail getPropertyDefinitionDetail(String repositoryId, String nodeId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("propertyDefinitionDetails")
				.key(nodeId);
		List<CouchPropertyDefinitionDetail> l = connectorPool.get(repositoryId)
				.queryView(query, CouchPropertyDefinitionDetail.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			return l.get(0).convert();
		}
	}

	@Override
	public List<NemakiPropertyDefinitionDetail> getPropertyDefinitionDetailByCoreNodeId(String repositoryId,
			String coreNodeId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("propertyDefinitionDetailsByCoreNodeId")
				.key(coreNodeId);
		List<CouchPropertyDefinitionDetail> l = connectorPool.get(repositoryId)
				.queryView(query, CouchPropertyDefinitionDetail.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			List<NemakiPropertyDefinitionDetail> result = new ArrayList<NemakiPropertyDefinitionDetail>();
			for (CouchPropertyDefinitionDetail cpdd : l) {
				result.add(cpdd.convert());
			}
			return result;
		}
	}

	@Override
	public NemakiPropertyDefinitionCore createPropertyDefinitionCore(String repositoryId,
			NemakiPropertyDefinitionCore propertyDefinitionCore) {
		CouchPropertyDefinitionCore cpc = new CouchPropertyDefinitionCore(propertyDefinitionCore);
		connectorPool.get(repositoryId).create(cpc);
		return cpc.convert();
	}

	@Override
	public NemakiPropertyDefinitionDetail createPropertyDefinitionDetail(String repositoryId,
			NemakiPropertyDefinitionDetail propertyDefinitionDetail) {
		CouchPropertyDefinitionDetail cpd = new CouchPropertyDefinitionDetail(propertyDefinitionDetail);
		connectorPool.get(repositoryId).create(cpd);
		return cpd.convert();
	}

	@Override
	public NemakiPropertyDefinitionDetail updatePropertyDefinitionDetail(String repositoryId,
			NemakiPropertyDefinitionDetail propertyDefinitionDetail) {

		CouchPropertyDefinitionDetail cpd = connectorPool.get(repositoryId)
				.get(CouchPropertyDefinitionDetail.class, propertyDefinitionDetail.getId());

		CouchPropertyDefinitionDetail update = new CouchPropertyDefinitionDetail(propertyDefinitionDetail);
		update.setRevision(cpd.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	// ///////////////////////////////////////
	// Content
	// ///////////////////////////////////////
	@Override
	public NodeBase getNodeBase(String repositoryId, String objectId) {
		CouchNodeBase cnb = connectorPool.get(repositoryId).get(CouchNodeBase.class, objectId);
		return cnb.convert();
	}

	@Override
	public Content getContent(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("contentsById").key(objectId);

		ViewResult result = connectorPool.get(repositoryId).queryView(query);
		return convertJsonToEachBaeType(result);
	}

	private Content convertJsonToEachBaeType(ViewResult result) {
		if (result.getRows().isEmpty()) {
			return null;
		} else {
			Iterator<Row> iterator = result.getRows().iterator();
			while (iterator.hasNext()) {
				ObjectMapper mapper = new ObjectMapper();
				JsonNode jn = iterator.next().getValueAsNode();
				String baseType = jn.path("type").textValue();

				if (BaseTypeId.CMIS_DOCUMENT.value().equals(baseType)) {
					CouchDocument cd = mapper.convertValue(jn, CouchDocument.class);
					return cd.convert();
				} else if (BaseTypeId.CMIS_FOLDER.value().equals(baseType)) {
					CouchFolder cf = mapper.convertValue(jn, CouchFolder.class);
					return cf.convert();
				} else if (BaseTypeId.CMIS_POLICY.value().equals(baseType)) {
					CouchPolicy cp = mapper.convertValue(jn, CouchPolicy.class);
					return cp.convert();
				} else if (BaseTypeId.CMIS_RELATIONSHIP.value().equals(baseType)) {
					CouchRelationship cr = mapper.convertValue(jn, CouchRelationship.class);
					return cr.convert();
				} else if (BaseTypeId.CMIS_ITEM.value().equals(baseType)) {
					CouchItem ci = mapper.convertValue(jn, CouchItem.class);
					return ci.convert();
				}
			}
		}

		return null;
	}

	// TODO Use view
	@Override
	public Document getDocument(String repositoryId, String objectId) {
		CouchDocument cd = connectorPool.get(repositoryId).get(CouchDocument.class, objectId);
		Document doc = cd.convert();
		return doc;
	}

	@Override
	public boolean existContent(String repositoryId, String objectTypeId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("countByObjectType").key(objectTypeId);
		ViewResult l = connectorPool.get(repositoryId).queryView(query);
		List<Row> rows = l.getRows();
		if (CollectionUtils.isEmpty(rows)) {
			return false;
		} else {
			for (Row row : rows) {
				if (objectTypeId.equals(row.getKey())) {
					int count = row.getValueAsInt();
					if (count == 0) {
						return false;
					} else {
						return true;
					}
				}
			}
		}
		return false;
	}

	@Override
	public List<Document> getCheckedOutDocuments(String repositoryId, String parentFolderId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("privateWorkingCopies");
		if (parentFolderId != null)
			query.key(parentFolderId);
		List<CouchDocument> l = connectorPool.get(repositoryId).queryView(query, CouchDocument.class);

		if (CollectionUtils.isEmpty(l))
			return null;
		List<Document> results = new ArrayList<Document>();
		for (CouchDocument cd : l) {
			results.add(cd.convert());
		}
		return results;
	}

	@Override
	public VersionSeries getVersionSeries(String repositoryId, String nodeId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("versionSeries").key(nodeId);
		List<CouchVersionSeries> l = connectorPool.get(repositoryId).queryView(query, CouchVersionSeries.class);

		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			return l.get(0).convert();
		}
	}

	@Override
	public List<Document> getAllVersions(String repositoryId, String versionSeriesId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("documentsByVersionSeriesId")
				.key(versionSeriesId);

		List<CouchDocument> cds = connectorPool.get(repositoryId).queryView(query, CouchDocument.class);
		if (CollectionUtils.isEmpty(cds))
			return null;
		List<Document> list = new ArrayList<Document>();
		for (CouchDocument cd : cds) {
			list.add(cd.convert());
		}
		return list;

	}

	@Override
	public Document getDocumentOfLatestVersion(String repositoryId, String versionSeriesId) {
		if (versionSeriesId == null)
			return null;
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("latestVersions").key(versionSeriesId);
		List<CouchDocument> list = connectorPool.get(repositoryId).queryView(query, CouchDocument.class);

		if (list.size() == 1) {
			return list.get(0).convert();
		} else if (list.size() > 1) {
			log.warn("The latest version of [" + versionSeriesId + "] is duplicate.");
			return list.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public Document getDocumentOfLatestMajorVersion(String repositoryId, String versionSeriesId) {
		if (versionSeriesId == null)
			return null;
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("latestMajorVersions")
				.key(versionSeriesId);
		List<CouchDocument> list = connectorPool.get(repositoryId).queryView(query, CouchDocument.class);

		if (list.size() == 1) {
			return list.get(0).convert();
		} else if (list.size() > 1) {
			log.warn("The latest major version of [" + versionSeriesId + "] is duplicate.");
			return list.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public Folder getFolder(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("folders").key(objectId);
		List<CouchFolder> list = connectorPool.get(repositoryId).queryView(query, CouchFolder.class);

		if (CollectionUtils.isEmpty(list)) {
			return null;
		} else {
			return list.get(0).convert();
		}
	}

	@Override
	public Folder getFolderByPath(String repositoryId, String path) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("foldersByPath").key(path);
		List<CouchFolder> l = connectorPool.get(repositoryId).queryView(query, CouchFolder.class);

		if (CollectionUtils.isEmpty(l))
			return null;
		return l.get(0).convert();
	}

	@Override
	public List<Content> getChildren(String repositoryId, String parentId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("children").key(parentId);
		List<CouchContent> list = connectorPool.get(repositoryId).queryView(query, CouchContent.class);

		if (list != null && !list.isEmpty()) {
			List<Content> contents = new ArrayList<Content>();
			for (CouchContent cc : list) {
				contents.add(cc.convert());
			}
			return contents;
		} else {
			return null;
		}
	}

	@Override
	public Content getChildByName(String repositoryId, String parentId, String name) {
		class ViewKey {
			private String parentId;
			private String name;

			public ViewKey(String parentId, String name) {
				this.parentId = parentId;
				this.name = name;
			}

			public String getParentId() {
				return parentId;
			}

			public String getName() {
				return name;
			}

		}

		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("childByName")
				.key(new ViewKey(parentId, name));
		ViewResult result = connectorPool.get(repositoryId).queryView(query);

		return convertJsonToEachBaeType(result);
	}

	public List<String> getChildrenNames(String repositoryId, String parentId){
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("childrenNames")
				.key(parentId);
		ViewResult result = connectorPool.get(repositoryId).queryView(query);
		
		List<String>list =  new ArrayList<String>();
		if(result == null || result.isEmpty()){
			return new ArrayList<String>();
		}else{
			Iterator<Row> itr = result.iterator();
			while(itr.hasNext()){
				list.add(itr.next().getValue());
			}
		}
		
		return list;
	}
	
	@Override
	public Relationship getRelationship(String repositoryId, String objectId) {
		CouchRelationship cr = connectorPool.get(repositoryId).get(CouchRelationship.class, objectId);
		return cr.convert();
	}

	@Override
	public List<Relationship> getRelationshipsBySource(String repositoryId, String sourceId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("relationshipsBySource").key(sourceId);
		List<CouchRelationship> crs = connectorPool.get(repositoryId).queryView(query, CouchRelationship.class);

		List<Relationship> result = new ArrayList<Relationship>();
		if (crs != null && !crs.isEmpty()) {
			for (CouchRelationship cr : crs) {
				result.add(cr.convert());
			}
		}
		return result;
	}

	@Override
	public List<Relationship> getRelationshipsByTarget(String repositoryId, String targetId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("relationshipsByTarget").key(targetId);
		List<CouchRelationship> crs = connectorPool.get(repositoryId).queryView(query, CouchRelationship.class);

		List<Relationship> result = new ArrayList<Relationship>();
		if (crs != null && !crs.isEmpty()) {
			for (CouchRelationship cr : crs) {
				result.add(cr.convert());
			}
		}
		return result;
	}

	@Override
	public Policy getPolicy(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("policies").key(objectId);
		List<CouchPolicy> cps = connectorPool.get(repositoryId).queryView(query, CouchPolicy.class);
		if (!CollectionUtils.isEmpty(cps)) {
			return cps.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public List<Policy> getAppliedPolicies(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("policiesByAppliedObject")
				.key(objectId);
		List<CouchPolicy> cps = connectorPool.get(repositoryId).queryView(query, CouchPolicy.class);
		if (!CollectionUtils.isEmpty(cps)) {
			List<Policy> policies = new ArrayList<Policy>();
			for (CouchPolicy cp : cps) {
				policies.add(cp.convert());
			}
			return policies;
		} else {
			return null;
		}
	}

	@Override
	public Item getItem(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("items").key(objectId);
		List<CouchItem> cpi = connectorPool.get(repositoryId).queryView(query, CouchItem.class);
		if (!CollectionUtils.isEmpty(cpi)) {
			return cpi.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public Document create(String repositoryId, Document document) {
		CouchDocument cd = new CouchDocument(document);
		connectorPool.get(repositoryId).create(cd);
		return cd.convert();
	}

	@Override
	public VersionSeries create(String repositoryId, VersionSeries versionSeries) {
		CouchVersionSeries cvs = new CouchVersionSeries(versionSeries);
		connectorPool.get(repositoryId).create(cvs);
		return cvs.convert();
	}

	@Override
	public Folder create(String repositoryId, Folder folder) {
		CouchFolder cf = new CouchFolder(folder);
		connectorPool.get(repositoryId).create(cf);
		return cf.convert();
	}

	@Override
	public Relationship create(String repositoryId, Relationship relationship) {
		CouchRelationship cr = new CouchRelationship(relationship);
		connectorPool.get(repositoryId).create(cr);
		return cr.convert();
	}

	@Override
	public Policy create(String repositoryId, Policy policy) {
		CouchPolicy cp = new CouchPolicy(policy);
		connectorPool.get(repositoryId).create(cp);
		return cp.convert();
	}

	@Override
	public Item create(String repositoryId, Item item) {
		CouchItem ci = new CouchItem(item);
		connectorPool.get(repositoryId).create(ci);
		return ci.convert();
	}

	@Override
	public Document update(String repositoryId, Document document) {
		CouchDocument cd = connectorPool.get(repositoryId).get(CouchDocument.class, document.getId());

		// Set the latest revision for avoid conflict
		CouchDocument update = new CouchDocument(document);
		update.setRevision(cd.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}
	
	@Override
	public Document move(String repositoryId, Document document, String sourceId){
		return update(repositoryId, document);
	}

	@Override
	public VersionSeries update(String repositoryId, VersionSeries versionSeries) {
		CouchVersionSeries cvs = connectorPool.get(repositoryId).get(CouchVersionSeries.class, versionSeries.getId());

		// Set the latest revision for avoid conflict
		CouchVersionSeries update = new CouchVersionSeries(versionSeries);
		update.setRevision(cvs.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	@Override
	public Folder update(String repositoryId, Folder folder) {
		CouchFolder cf = connectorPool.get(repositoryId).get(CouchFolder.class, folder.getId());
		// Set the latest revision for avoid conflict
		CouchFolder update = new CouchFolder(folder);
		update.setRevision(cf.getRevision());

		connectorPool.get(repositoryId).update(update);

		return update.convert();
	}
	
	@Override
	public Folder move(String repositoryId, Folder folder, String sourceId){
		return update(repositoryId, folder);
	}

	@Override
	public Relationship update(String repositoryId, Relationship relationship) {
		CouchRelationship cp = connectorPool.get(repositoryId).get(CouchRelationship.class, relationship.getId());
		// Set the latest revision for avoid conflict
		CouchRelationship update = new CouchRelationship(relationship);
		update.setRevision(cp.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	@Override
	public Policy update(String repositoryId, Policy policy) {
		CouchPolicy cp = connectorPool.get(repositoryId).get(CouchPolicy.class, policy.getId());
		// Set the latest revision for avoid conflict
		CouchPolicy update = new CouchPolicy(policy);
		update.setRevision(cp.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	@Override
	public Item update(String repositoryId, Item item) {
		CouchItem ci = connectorPool.get(repositoryId).get(CouchItem.class, item.getId());
		// Set the latest revision for avoid conflict
		CouchItem update = new CouchItem(item);
		update.setRevision(ci.getRevision());

		connectorPool.get(repositoryId).update(update);
		return update.convert();
	}

	@Override
	public void delete(String repositoryId, String objectId) {
		CouchNodeBase cnb = connectorPool.get(repositoryId).get(CouchNodeBase.class, objectId);
		connectorPool.get(repositoryId).delete(cnb);
	}

	// ///////////////////////////////////////
	// Attachment
	// ///////////////////////////////////////
	@Override
	public AttachmentNode getAttachment(String repositoryId, String attachmentId) {

		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("attachments").key(attachmentId);
		List<CouchAttachmentNode> list = connectorPool.get(repositoryId).queryView(query, CouchAttachmentNode.class);

		if (CollectionUtils.isEmpty(list)) {
			return null;
		} else {
			CouchAttachmentNode can = list.get(0);

			Attachment a = can.getAttachments().get(ATTACHMENT_NAME);

			AttachmentNode an = new AttachmentNode();
			an.setId(can.getId());
			an.setMimeType(a.getContentType());
			an.setLength(a.getContentLength());

			return an;
		}
	}

	@Override
	public void setStream(String repositoryId, AttachmentNode attachmentNode) {
		AttachmentInputStream ais = connectorPool.get(repositoryId)
				.getAttachment(attachmentNode.getId(), ATTACHMENT_NAME);
		attachmentNode.setInputStream(ais);
	}

	@Override
	public Rendition getRendition(String repositoryId, String objectId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("renditions").key(objectId);
		List<CouchRendition> list = connectorPool.get(repositoryId).queryView(query, CouchRendition.class);

		if (CollectionUtils.isEmpty(list)) {
			return null;
		} else {
			CouchRendition crd = list.get(0);
			Attachment a = crd.getAttachments().get(ATTACHMENT_NAME);

			Rendition rd = new Rendition();
			rd.setId(objectId);
			rd.setTitle(crd.getTitle());
			rd.setKind(crd.getKind());
			rd.setMimetype(a.getContentType());
			rd.setLength(a.getContentLength());
			AttachmentInputStream ais = connectorPool.get(repositoryId).getAttachment(objectId, ATTACHMENT_NAME);
			rd.setInputStream(ais);

			/*
			 * try { BufferedImage bimg = ImageIO.read(ais); if (bimg != null) {
			 * rd.setWidth(bimg.getWidth()); rd.setHeight(bimg.getHeight());
			 * bimg.flush(); } } catch (IOException e) { // TODO logging // do
			 * nothing }
			 */

			return rd;
		}
	}

	@Override
	public String createAttachment(String repositoryId, AttachmentNode attachment, ContentStream contentStream) {
		CouchAttachmentNode ca = new CouchAttachmentNode(attachment);
		connectorPool.get(repositoryId).create(ca);

		AttachmentInputStream ais = new AttachmentInputStream(ATTACHMENT_NAME, contentStream.getStream(), contentStream
				.getMimeType(), contentStream.getLength());
		connectorPool.get(repositoryId).createAttachment(ca.getId(), ca.getRevision(), ais);

		return ca.getId();
	}

	@Override
	public String createRendition(String repositoryId, Rendition rendition, ContentStream contentStream) {
		CouchRendition cr = new CouchRendition(rendition);
		connectorPool.get(repositoryId).create(cr);

		AttachmentInputStream ais = new AttachmentInputStream(ATTACHMENT_NAME, contentStream.getStream(), contentStream
				.getMimeType(), contentStream.getLength());
		connectorPool.get(repositoryId).createAttachment(cr.getId(), cr.getRevision(), ais);

		return cr.getId();
	}

	@Override
	public void updateAttachment(String repositoryId, AttachmentNode attachment, ContentStream contentStream) {
		CouchAttachmentNode ca = connectorPool.get(repositoryId).get(CouchAttachmentNode.class, attachment.getId());
		CouchAttachmentNode update = new CouchAttachmentNode(attachment);
		// Set the latest revision for avoid conflict
		update.setRevision(ca.getRevision());

		String revisionAfterDeleted = connectorPool.get(repositoryId)
				.deleteAttachment(ca.getId(), ca.getRevision(), ATTACHMENT_NAME);

		AttachmentInputStream ais = new AttachmentInputStream(ATTACHMENT_NAME, contentStream.getStream(), contentStream
				.getMimeType());
		connectorPool.get(repositoryId).createAttachment(attachment.getId(), revisionAfterDeleted, ais);
	}

	// ///////////////////////////////////////
	// Change event
	// ///////////////////////////////////////
	@Override
	public Change getChangeEvent(String repositoryId, String changeTokenId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("changesByToken").key(changeTokenId);
		List<CouchChange> l = connectorPool.get(repositoryId).queryView(query, CouchChange.class);

		if (CollectionUtils.isEmpty(l))
			return null;
		return l.get(0).convert();
	}

	@Override
	public Change getLatestChange(String repositoryId) {
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("changesByToken").descending(true)
				.limit(1);
		List<CouchChange> l = connectorPool.get(repositoryId).queryView(query, CouchChange.class);
		if (CollectionUtils.isEmpty(l)) {
			return null;
		} else {
			return l.get(0).convert();
		}
	}

	@Override
	public List<Change> getLatestChanges(String repositoryId, String startToken, int maxItems) {
		List<Change> result = new ArrayList<Change>();
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("changesByToken").descending(false);

		if (StringUtils.isNotBlank(startToken)) {
			CouchDbConnector conn = connectorPool.get(repositoryId);
			try {
				CouchChange startChange = conn.get(CouchChange.class, startToken);
				Long startKey = startChange.getToken();
				query.startKey(startKey);
			} catch (org.ektorp.DocumentNotFoundException ex) {
				return null;
			}
		}
		if (maxItems > 0) {
			query.limit(maxItems);
		}

		List<CouchChange> l = connectorPool.get(repositoryId).queryView(query, CouchChange.class);
		if (CollectionUtils.isEmpty(l))
			return null;

		for (CouchChange cc : l) {
			result.add(cc.convert());
		}
		return result;
	}

	@Override
	public Change create(String repositoryId, Change change) {
		CouchChange cc = new CouchChange(change);
		connectorPool.get(repositoryId).create(cc);
		return cc.convert();
	}

	// ///////////////////////////////////////
	// Archive
	// ///////////////////////////////////////
	@Override
	public Archive getArchive(String repositoryId, String objectId) {
		String archive = repositoryInfoMap.getArchiveId(repositoryId);
		CouchArchive ca = connectorPool.get(archive).get(CouchArchive.class, objectId);
		return ca.convert();
	}

	@Override
	public Archive getArchiveByOriginalId(String repositoryId, String originalId) {
		String archive = repositoryInfoMap.getArchiveId(repositoryId);
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("all").key(originalId);
		List<CouchArchive> list = connectorPool.get(archive).queryView(query, CouchArchive.class);

		if (list != null && !list.isEmpty()) {
			return list.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public Archive getAttachmentArchive(String repositoryId, Archive archive) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		if (!archive.isDocument())
			return null;
		String attachmentId = archive.getAttachmentNodeId();
		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("attachments").key(attachmentId);
		List<CouchArchive> list = connectorPool.get(archiveId).queryView(query, CouchArchive.class);

		if (list != null && !list.isEmpty()) {
			return list.get(0).convert();
		} else {
			return null;
		}
	}

	@Override
	public List<Archive> getChildArchives(String repositoryId, Archive archive) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("children")
				.key(archive.getOriginalId());
		List<CouchArchive> list = connectorPool.get(archiveId).queryView(query, CouchArchive.class);

		if (list != null && !list.isEmpty()) {
			List<Archive> archives = new ArrayList<Archive>();
			for (CouchArchive ca : list) {
				archives.add(ca.convert());
			}
			return archives;
		} else {
			return null;
		}
	}

	@Override
	public List<Archive> getArchivesOfVersionSeries(String repositoryId, String versionSeriesId) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("versionSeries").key(versionSeriesId);
		List<CouchArchive> list = connectorPool.get(archiveId).queryView(query, CouchArchive.class);

		if (list != null && !list.isEmpty()) {
			List<Archive> archives = new ArrayList<Archive>();
			for (CouchArchive ca : list) {
				archives.add(ca.convert());
			}
			return archives;
		} else {
			return null;
		}
	}

	@Override
	public List<Archive> getAllArchives(String repositoryId) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		ViewQuery query = new ViewQuery().designDocId(DESIGN_DOCUMENT).viewName("all");
		List<CouchArchive> list = connectorPool.get(archiveId).queryView(query, CouchArchive.class);

		List<Archive> archives = new ArrayList<Archive>();
		for (CouchArchive ca : list) {
			archives.add(ca.convert());
		}

		return archives;
	}

	@Override
	public Archive createArchive(String repositoryId, Archive archive, Boolean deletedWithParent) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		CouchNodeBase cnb = connectorPool.get(repositoryId).get(CouchNodeBase.class, archive.getOriginalId());
		CouchArchive ca = new CouchArchive(archive);
		ca.setLastRevision(cnb.getRevision());

		// Write to DB
		connectorPool.get(archiveId).create(ca);
		return ca.convert();
	}

	@Override
	public Archive createAttachmentArchive(String repositoryId, Archive archive) {
		String archiveId = repositoryInfoMap.getArchiveId(repositoryId);

		CouchArchive ca = new CouchArchive(archive);
		CouchNodeBase cnb = connectorPool.get(repositoryId).get(CouchNodeBase.class, archive.getOriginalId());
		ca.setLastRevision(cnb.getRevision());

		connectorPool.get(archiveId).create(ca);
		return ca.convert();
	}

	@Override
	// FIXME return archiveId or something when successfully deleted
	public void deleteArchive(String repositoryId, String archiveId) {
		String archive = repositoryInfoMap.getArchiveId(repositoryId);

		try {
			CouchArchive ca = connectorPool.get(archive).get(CouchArchive.class, archiveId);
			connectorPool.get(archive).delete(ca);
		} catch (Exception e) {
			log.warn(buildLogMsg(archiveId, "the archive not found on db"));
			return;
		}
	}

	@SuppressWarnings("deprecation")
	@Override
	public void restoreContent(String repositoryId, Archive archive) {
		if (archive.isDocument()) {
			// Restore a content
			CouchDocument cd = connectorPool.get(repositoryId)
					.get(CouchDocument.class, archive.getOriginalId(), archive.getLastRevision());
			cd.setRevision(null);
			connectorPool.get(repositoryId).update(cd);
		} else if (archive.isFolder()) {
			CouchFolder cf = connectorPool.get(repositoryId)
					.get(CouchFolder.class, archive.getOriginalId(), archive.getLastRevision());
			cf.setRevision(null);
			connectorPool.get(repositoryId).update(cf);
		} else {
			// TODO Do nothing?
		}
	}

	@SuppressWarnings("deprecation")
	@Override
	public void restoreAttachment(String repositoryId, Archive archive) {
		CouchDbConnector connector = connectorPool.get(repositoryId);

		// Restore its attachment
		CouchAttachmentNode can = connector
				.get(CouchAttachmentNode.class, archive.getOriginalId(), archive.getLastRevision());
		can.setRevision(null);
		AttachmentInputStream is = connector.getAttachment(can.getId(), ATTACHMENT_NAME, archive.getLastRevision());
		connector.createAttachment(can.getId(), can.getRevision(), is);
		CouchAttachmentNode restored = connector.get(CouchAttachmentNode.class, can.getId());
		restored.setType(NodeType.ATTACHMENT.value());
		connector.update(restored);
	}

	// ///////////////////////////////////////
	// Other
	// ///////////////////////////////////////
	private String buildLogMsg(String objectId, String msg) {
		return "[objectId:" + objectId + "]" + msg;
	}

	public void setConnectorPool(ConnectorPool connectorPool) {
		this.connectorPool = connectorPool;
	}

	public void setRepositoryInfoMap(RepositoryInfoMap repositoryInfoMap) {
		this.repositoryInfoMap = repositoryInfoMap;
	}

	@Override
	public void refreshCmisObjectData(String repositoryId, String objectId) {
		// this method is for cached service
	}
}