/*
* Copyright (c) 2006-2011 Nuxeo SA (http://nuxeo.com/) and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bogdan Stefanescu
* Florent Guillaume
*/
package org.eclipse.ecr.core.api.impl;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.ecr.core.api.Blob;
import org.eclipse.ecr.core.api.ClientException;
import org.eclipse.ecr.core.api.ClientRuntimeException;
import org.eclipse.ecr.core.api.CoreInstance;
import org.eclipse.ecr.core.api.CoreSession;
import org.eclipse.ecr.core.api.DataModel;
import org.eclipse.ecr.core.api.DataModelMap;
import org.eclipse.ecr.core.api.DocumentException;
import org.eclipse.ecr.core.api.DocumentModel;
import org.eclipse.ecr.core.api.DocumentRef;
import org.eclipse.ecr.core.api.Lock;
import org.eclipse.ecr.core.api.PathRef;
import org.eclipse.ecr.core.api.VersioningOption;
import org.eclipse.ecr.core.api.adapter.DocumentAdapterDescriptor;
import org.eclipse.ecr.core.api.adapter.DocumentAdapterService;
import org.eclipse.ecr.core.api.model.DocumentPart;
import org.eclipse.ecr.core.api.model.Property;
import org.eclipse.ecr.core.api.model.PropertyException;
import org.eclipse.ecr.core.api.model.PropertyNotFoundException;
import org.eclipse.ecr.core.api.repository.Repository;
import org.eclipse.ecr.core.api.repository.RepositoryManager;
import org.eclipse.ecr.core.api.security.ACP;
import org.eclipse.ecr.core.schema.DocumentType;
import org.eclipse.ecr.core.schema.FacetNames;
import org.eclipse.ecr.core.schema.SchemaManager;
import org.eclipse.ecr.core.schema.SchemaNames;
import org.eclipse.ecr.core.schema.TypeConstants;
import org.eclipse.ecr.core.schema.TypeProvider;
import org.eclipse.ecr.core.schema.TypeRef;
import org.eclipse.ecr.core.schema.types.ComplexType;
import org.eclipse.ecr.core.schema.types.CompositeType;
import org.eclipse.ecr.core.schema.types.Field;
import org.eclipse.ecr.core.schema.types.JavaTypes;
import org.eclipse.ecr.core.schema.types.ListType;
import org.eclipse.ecr.core.schema.types.Schema;
import org.eclipse.ecr.core.schema.types.Type;
import org.eclipse.ecr.runtime.api.Framework;
import org.nuxeo.common.collections.ArrayMap;
import org.nuxeo.common.collections.PrimitiveArrays;
import org.nuxeo.common.collections.ScopeType;
import org.nuxeo.common.collections.ScopedMap;
import org.nuxeo.common.utils.Null;
import org.nuxeo.common.utils.Path;
/**
* Standard implementation of a {@link DocumentModel}.
*/
public class DocumentModelImpl implements DocumentModel, Cloneable {
private static final long serialVersionUID = 1L;
public static final String STRICT_LAZY_LOADING_POLICY_KEY = "org.eclipse.ecr.core.strictlazyloading";
public static final long F_STORED = 1L;
public static final long F_DETACHED = 2L;
// reserved: 4, 8
public static final long F_VERSION = 16L;
public static final long F_PROXY = 32L;
public static final long F_LOCKED = 64L;
public static final long F_DIRTY = 128L;
public static final long F_IMMUTABLE = 256L;
private static final Log log = LogFactory.getLog(DocumentModelImpl.class);
protected String sid;
protected DocumentRef ref;
protected TypeRef<DocumentType> type;
/** Schemas including those from instance facets. */
protected Set<String> schemas;
/** Schemas including those from instance facets when the doc was read */
protected Set<String> schemasOrig;
/** Facets including those on instance. */
protected Set<String> facets;
/** Instance facets. */
public Set<String> instanceFacets;
/** Instance facets when the document was read. */
public Set<String> instanceFacetsOrig;
protected String id;
protected Path path;
protected DataModelMap dataModels;
protected DocumentRef parentRef;
protected static final Lock LOCK_UNKNOWN = new Lock(null, null);
protected Lock lock = LOCK_UNKNOWN;
/** state is lifecycle, version stuff. */
protected boolean isStateLoaded;
// loaded if isStateLoaded
protected String currentLifeCycleState;
// loaded if isStateLoaded
protected String lifeCyclePolicy;
// loaded if isStateLoaded
protected boolean isCheckedOut = true;
// loaded if isStateLoaded
protected String versionSeriesId;
// loaded if isStateLoaded
protected boolean isLatestVersion;
// loaded if isStateLoaded
protected boolean isMajorVersion;
// loaded if isStateLoaded
protected boolean isLatestMajorVersion;
// loaded if isStateLoaded
protected boolean isVersionSeriesCheckedOut;
// loaded if isStateLoaded
protected String checkinComment;
// acp is not send between client/server
// it will be loaded lazy first time it is accessed
// and discarded when object is serialized
protected transient ACP acp;
// whether the acp was cached
protected transient boolean isACPLoaded = false;
// the adapters registered for this document - only valid on client
protected transient ArrayMap<Class<?>, Object> adapters;
// flags : TODO
// bit 0 - IS_STORED (1 if stored in repo, 0 otherwise)
// bit 1 - IS_DETACHED (1 after deserialization, 0 otherwise)
// bit 2 - 3: reserved for future use
// bit 4: IS_VERSION (true if set)
// bit 5: IS_PROXY (true if set)
// bit 6: IS_LOCKED (true if set)
// bit 7: IS_DIRTY (true if set)
protected long flags = 0L;
protected String repositoryName;
protected String sourceId;
private ScopedMap contextData;
protected Map<String, Serializable> prefetch;
protected static Boolean strictSessionManagement;
// ThreadLocal CoreSession used when DocumenModelImpl uses the CoreSession
// from within the DocumentManagerBean
// to avoid reentrant calls to the Stateful Bean
// because there can be several CoreSessions in parallele, we need to use a
// Map where sessionId is used as key
public static final ThreadLocal<HashMap<String, CoreSession>> reentrantCoreSession = new ThreadLocal<HashMap<String, CoreSession>>() {
@Override
protected HashMap<String, CoreSession> initialValue() {
return new HashMap<String, CoreSession>();
}
};
protected DocumentModelImpl() {
}
/**
* Constructor to use a document model client side without referencing a
* document.
* <p>
* It must at least contain the type.
*/
public DocumentModelImpl(String type) {
this.type = new TypeRef<DocumentType>(SchemaNames.DOCTYPES, type);
dataModels = new DataModelMapImpl();
contextData = new ScopedMap();
instanceFacets = new HashSet<String>();
instanceFacetsOrig = new HashSet<String>();
facets = new HashSet<String>();
schemas = new HashSet<String>();
schemasOrig = new HashSet<String>();
}
/**
* Constructor to be used by clients.
* <p>
* A client constructed data model must contain at least the path and the
* type.
*/
public DocumentModelImpl(String parentPath, String name, String type) {
this(type);
String fullPath = parentPath == null ? name : parentPath
+ (parentPath.endsWith("/") ? "" : "/") + name;
path = new Path(fullPath);
ref = new PathRef(fullPath);
instanceFacets = new HashSet<String>();
instanceFacetsOrig = new HashSet<String>();
facets = new HashSet<String>();
schemas = new HashSet<String>();
if (getDocumentType() != null) {
facets.addAll(getDocumentType().getFacets());
}
recomputeSchemas();
schemasOrig = new HashSet<String>(schemas);
}
/**
* Constructor.
* <p>
* The lock parameter is unused since 5.4.2.
*
* @param facets the per-instance facets
*/
public DocumentModelImpl(String sid, String type, String id, Path path,
Lock lock, DocumentRef docRef, DocumentRef parentRef,
String[] schemas, Set<String> facets, String sourceId,
String repositoryName) {
this(type);
this.sid = sid;
this.id = id;
this.path = path;
ref = docRef;
this.parentRef = parentRef;
instanceFacets = facets == null ? new HashSet<String>()
: new HashSet<String>(facets);
instanceFacetsOrig = new HashSet<String>(instanceFacets);
this.facets = new HashSet<String>(instanceFacets);
if (getDocumentType() != null) {
this.facets.addAll(getDocumentType().getFacets());
}
if (schemas == null) {
recomputeSchemas();
} else {
this.schemas = new HashSet<String>(Arrays.asList(schemas));
}
schemasOrig = new HashSet<String>(this.schemas);
this.repositoryName = repositoryName;
this.sourceId = sourceId;
}
/**
* Recompute all schemas from type + instance facets.
*/
protected void recomputeSchemas() {
schemas = new HashSet<String>();
if (getDocumentType() != null) {
schemas.addAll(Arrays.asList(getDocumentType().getSchemaNames()));
}
TypeProvider typeProvider = Framework.getLocalService(SchemaManager.class);
for (String facet : instanceFacets) {
CompositeType facetType = typeProvider.getFacet(facet);
if (facetType != null) { // ignore pseudo-facets like Immutable
schemas.addAll(Arrays.asList(facetType.getSchemaNames()));
}
}
}
/**
* @deprecated unused
*/
@Deprecated
public DocumentModelImpl(String sid, String type) {
this(type);
this.sid = sid;
}
/**
* @deprecated unused
*/
@Deprecated
public DocumentModelImpl(DocumentModel parent, String name, String type) {
this(parent.getPathAsString(), name, type);
}
/**
* @deprecated unused
*/
@Deprecated
public DocumentModelImpl(DocumentModel parent, String name, String type,
DataModelMap data) {
this(parent.getPathAsString(), name, type);
if (data != null) {
dataModels = data;
}
}
/**
* @deprecated unused
*/
@Deprecated
public DocumentModelImpl(String parentPath, String name, String type,
DataModelMap data) {
this(parentPath, name, type);
if (data != null) {
dataModels = data;
}
}
/**
* @deprecated unused
*/
@Deprecated
public DocumentModelImpl(String sid, String type, String id, Path path,
DocumentRef docRef, DocumentRef parentRef, String[] schemas,
Set<String> facets) {
this(sid, type, id, path, null, docRef, parentRef, schemas, facets,
null, null);
}
@Override
public DocumentType getDocumentType() {
return type.get();
}
/**
* Gets the title from the dublincore schema.
*
* @see DocumentModel#getTitle()
*/
@Override
public String getTitle() throws ClientException {
String title = (String) getProperty("dublincore", "title");
if (title != null) {
return title;
}
title = getName();
if (title != null) {
return title;
}
return id;
}
@Override
public String getSessionId() {
return sid;
}
@Override
public DocumentRef getRef() {
return ref;
}
@Override
public DocumentRef getParentRef() {
if (parentRef == null && path != null) {
if (path.isAbsolute()) {
Path parentPath = path.removeLastSegments(1);
parentRef = new PathRef(parentPath.toString());
}
// else keep parentRef null
}
return parentRef;
}
@Override
public CoreSession getCoreSession() {
if (sid == null) {
return null;
}
if (reentrantCoreSession.get().containsKey(sid)) {
return reentrantCoreSession.get().get(sid);
}
return CoreInstance.getInstance().getSession(sid);
}
protected boolean useStrictSessionManagement() {
if (strictSessionManagement == null) {
strictSessionManagement = Boolean.valueOf(Framework.getProperty(
STRICT_LAZY_LOADING_POLICY_KEY, "false"));
}
return strictSessionManagement.booleanValue();
}
protected CoreSession getTempCoreSession() throws ClientException {
if (sid != null) {
// detached docs need a tmp session anyway
if (useStrictSessionManagement()) {
throw new ClientException(
"Document "
+ id
+ " is bound to a closed CoreSession, can not reconnect");
}
}
try {
RepositoryManager mgr = Framework.getService(RepositoryManager.class);
return mgr.getRepository(repositoryName).open();
} catch (ClientException e) {
throw e;
} catch (Exception e) {
throw new ClientException(e);
}
}
protected abstract class RunWithCoreSession<T> {
public CoreSession session;
public abstract T run() throws ClientException;
public T execute() throws ClientException {
session = getCoreSession();
if (session != null) {
return run();
} else {
session = getTempCoreSession();
try {
return run();
} finally {
if (session != null) {
try {
session.save();
} finally {
CoreInstance.getInstance().close(session);
session = null;
}
}
}
}
}
}
/** @deprecated use {@link #getCoreSession} instead. */
@Deprecated
public final CoreSession getClient() throws ClientException {
if (sid == null) {
throw new UnsupportedOperationException(
"Cannot load data models for client defined models");
}
if (reentrantCoreSession.get().containsKey(sid)) {
return reentrantCoreSession.get().get(sid);
}
CoreSession session = CoreInstance.getInstance().getSession(sid);
if (session == null && sid != null && repositoryName != null) {
// session was closed => open a new one
try {
RepositoryManager mgr = Framework.getService(RepositoryManager.class);
Repository repo = mgr.getRepository(repositoryName);
session = repo.open();
// set new session id
sid = session.getSessionId();
} catch (Exception e) {
throw new ClientException(e);
}
}
return session;
}
/**
* Detaches the documentImpl from its existing session, so that it can
* survive beyond the session's closing.
*
* @param loadAll if {@code true}, load all data from the session before
* detaching
*/
public void detach(boolean loadAll) throws ClientException {
if (sid == null) {
return;
}
if (loadAll) {
for (String schema : schemas) {
if (!isSchemaLoaded(schema)) {
loadDataModel(schema);
}
}
}
// fetch ACP too if possible
if (ref != null) {
getACP();
}
sid = null;
}
/**
* Lazily loads the given data model.
*/
protected final DataModel loadDataModel(String schema)
throws ClientException {
if (!schemas.contains(schema)) {
return null;
}
if (!schemasOrig.contains(schema)) {
// not present yet in persistent document
DataModel dataModel = new DataModelImpl(schema);
dataModels.put(schema, dataModel);
return dataModel;
}
if (sid == null) {
// supports non bound docs
DataModel dataModel = new DataModelImpl(schema);
dataModels.put(schema, dataModel);
return dataModel;
}
if (ref == null) {
return null;
}
// load from session
if (getCoreSession() == null && useStrictSessionManagement()) {
log.warn("DocumentModel " + id
+ " is bound to a null or closed session, "
+ "lazy loading is not available");
return null;
}
TypeProvider typeProvider = Framework.getLocalService(SchemaManager.class);
final Schema schemaType = typeProvider.getSchema(schema);
DataModel dataModel = new RunWithCoreSession<DataModel>() {
@Override
public DataModel run() throws ClientException {
return session.getDataModel(ref, schemaType);
}
}.execute();
dataModels.put(schema, dataModel);
return dataModel;
}
@Override
public DataModel getDataModel(String schema) throws ClientException {
DataModel dataModel = dataModels.get(schema);
if (dataModel == null) {
dataModel = loadDataModel(schema);
}
return dataModel;
}
@Override
public Collection<DataModel> getDataModelsCollection() {
return dataModels.values();
}
public void addDataModel(DataModel dataModel) {
dataModels.put(dataModel.getSchema(), dataModel);
}
@Override
public String[] getSchemas() {
return schemas.toArray(new String[schemas.size()]);
}
@Override
@Deprecated
public String[] getDeclaredSchemas() {
return getSchemas();
}
@Override
public boolean hasSchema(String schema) {
return schemas.contains(schema);
}
@Override
public Set<String> getFacets() {
return Collections.unmodifiableSet(facets);
}
@Override
public boolean hasFacet(String facet) {
return facets.contains(facet);
}
@Override
@Deprecated
public Set<String> getDeclaredFacets() {
return getFacets();
}
@Override
public boolean addFacet(String facet) {
if (facet == null) {
throw new ClientRuntimeException("Null facet");
}
if (facets.contains(facet)) {
return false;
}
TypeProvider typeProvider = Framework.getLocalService(SchemaManager.class);
CompositeType facetType = typeProvider.getFacet(facet);
if (facetType == null) {
throw new ClientRuntimeException("No such facet: " + facet);
}
// add it
facets.add(facet);
instanceFacets.add(facet);
schemas.addAll(Arrays.asList(facetType.getSchemaNames()));
return true;
}
@Override
public boolean removeFacet(String facet) {
if (facet == null) {
throw new ClientRuntimeException("Null facet");
}
if (!instanceFacets.contains(facet)) {
return false;
}
// remove it
facets.remove(facet);
instanceFacets.remove(facet);
// find the schemas that were dropped
Set<String> droppedSchemas = new HashSet<String>(schemas);
recomputeSchemas();
droppedSchemas.removeAll(schemas);
// clear these datamodels
for (String s : droppedSchemas) {
dataModels.remove(s);
}
return true;
}
protected static Set<String> inferFacets(Set<String> facets,
DocumentType documentType) {
if (facets == null) {
facets = new HashSet<String>();
if (documentType != null) {
facets.addAll(documentType.getFacets());
}
}
return facets;
}
@Override
public String getId() {
return id;
}
@Override
public String getName() {
if (path != null) {
return path.lastSegment();
}
return null;
}
@Override
public String getPathAsString() {
if (path != null) {
return path.toString();
}
return null;
}
@Override
public Map<String, Object> getProperties(String schemaName)
throws ClientException {
DataModel dm = getDataModel(schemaName);
return dm == null ? null : dm.getMap();
}
/**
* Gets property.
* <p>
* Get property is also consulting the prefetched properties.
*
* @see DocumentModel#getProperty(String, String)
*/
@Override
public Object getProperty(String schemaName, String name)
throws ClientException {
DataModel dm = dataModels.get(schemaName);
if (dm == null) { // no data model loaded
// try prefetched props
if (prefetch != null) {
Object value = prefetch.get(schemaName + '.' + name);
if (value != null) {
return value == Null.VALUE ? null : value;
}
}
if (log.isTraceEnabled()) {
log.trace("Property not in prefetch: " + schemaName + '.'
+ name);
}
dm = getDataModel(schemaName);
}
return dm == null ? null : dm.getData(name);
}
@Override
public void setPathInfo(String parentPath, String name) {
path = new Path(parentPath == null ? name : parentPath + '/' + name);
ref = new PathRef(parentPath, name);
}
protected String oldLockKey(Lock lock) {
if (lock == null) {
return null;
}
// return deprecated format, like "someuser:Nov 29, 2010"
return lock.getOwner()
+ ':'
+ DateFormat.getDateInstance(DateFormat.MEDIUM).format(
new Date(lock.getCreated().getTimeInMillis()));
}
@Override
@Deprecated
public String getLock() {
try {
return oldLockKey(getLockInfo());
} catch (ClientException e) {
throw new ClientRuntimeException(e);
}
}
@Override
public boolean isLocked() {
try {
return getLockInfo() != null;
} catch (ClientException e) {
throw new ClientRuntimeException(e);
}
}
@Override
@Deprecated
public void setLock(String key) throws ClientException {
setLock();
}
@Override
public void unlock() throws ClientException {
removeLock();
}
@Override
public Lock setLock() throws ClientException {
Lock newLock = new RunWithCoreSession<Lock>() {
@Override
public Lock run() throws ClientException {
return session.setLock(ref);
}
}.execute();
lock = newLock;
return lock;
}
@Override
public Lock getLockInfo() throws ClientException {
if (lock != LOCK_UNKNOWN) {
return lock;
}
// no lock if not tied to a session
CoreSession session = getCoreSession();
if (session == null) {
return null;
}
lock = session.getLockInfo(ref);
return lock;
}
@Override
public Lock removeLock() throws ClientException {
Lock oldLock = new RunWithCoreSession<Lock>() {
@Override
public Lock run() throws ClientException {
return session.removeLock(ref);
}
}.execute();
lock = null;
return oldLock;
}
@Override
public boolean isCheckedOut() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return isCheckedOut;
}
@Override
public void checkOut() throws ClientException {
getCoreSession().checkOut(ref);
isStateLoaded = false;
// new version number, refresh content
refresh(REFRESH_CONTENT_IF_LOADED, null);
}
@Override
public DocumentRef checkIn(VersioningOption option, String description)
throws ClientException {
DocumentRef versionRef = getCoreSession().checkIn(ref, option,
description);
isStateLoaded = false;
// new version number, refresh content
refresh(REFRESH_CONTENT_IF_LOADED, null);
return versionRef;
}
@Override
public String getVersionLabel() {
try {
return getCoreSession().getVersionLabel(this);
} catch (ClientException e) {
throw new ClientRuntimeException(e);
}
}
@Override
public String getVersionSeriesId() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return versionSeriesId;
}
@Override
public boolean isLatestVersion() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return isLatestVersion;
}
@Override
public boolean isMajorVersion() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return isMajorVersion;
}
@Override
public boolean isLatestMajorVersion() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return isLatestMajorVersion;
}
@Override
public boolean isVersionSeriesCheckedOut() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return isVersionSeriesCheckedOut;
}
@Override
public String getCheckinComment() throws ClientException {
if (!isStateLoaded) {
refresh(REFRESH_STATE, null);
}
return checkinComment;
}
@Override
public ACP getACP() throws ClientException {
if (!isACPLoaded) { // lazy load
acp = new RunWithCoreSession<ACP>() {
@Override
public ACP run() throws ClientException {
return session.getACP(ref);
}
}.execute();
isACPLoaded = true;
}
return acp;
}
@Override
public void setACP(final ACP acp, final boolean overwrite)
throws ClientException {
new RunWithCoreSession<Object>() {
@Override
public Object run() throws ClientException {
session.setACP(ref, acp, overwrite);
return null;
}
}.execute();
isACPLoaded = false;
}
@Override
public String getType() {
// TODO there are some DOcumentModel impl like DocumentMessageImpl which
// use null types and extend this impl which is wrong - fix this -> type
// must never be null
return type != null ? type.getName() : null;
}
@Override
public void setProperties(String schemaName, Map<String, Object> data)
throws ClientException {
DataModel dm = getDataModel(schemaName);
if (dm != null) {
dm.setMap(data);
}
}
@Override
public void setProperty(String schemaName, String name, Object value)
throws ClientException {
DataModel dm = getDataModel(schemaName);
if (dm != null) {
dm.setData(name, value);
}
}
@Override
public Path getPath() {
return path;
}
@Override
public DataModelMap getDataModels() {
return dataModels;
}
@Override
public boolean isFolder() {
return hasFacet(FacetNames.FOLDERISH);
}
@Override
public boolean isVersionable() {
return hasFacet(FacetNames.VERSIONABLE);
}
@Override
public boolean isDownloadable() throws ClientException {
if (hasFacet(FacetNames.DOWNLOADABLE)) {
// TODO find a better way to check size that does not depend on the
// document schema
Long size = (Long) getProperty("common", "size");
if (size != null) {
return size.longValue() != 0;
}
}
return false;
}
@Override
@SuppressWarnings("unchecked")
public <T> T getAdapter(Class<T> itf) {
T facet = (T) getAdapters().get(itf);
if (facet == null) {
facet = findAdapter(itf);
if (facet != null) {
adapters.put(itf, facet);
}
}
return facet;
}
/**
* Lazy initialization for adapters because they don't survive the
* serialization.
*/
private ArrayMap<Class<?>, Object> getAdapters() {
if (adapters == null) {
adapters = new ArrayMap<Class<?>, Object>();
}
return adapters;
}
@Override
public <T> T getAdapter(Class<T> itf, boolean refreshCache) {
T facet;
if (!refreshCache) {
facet = getAdapter(itf);
} else {
facet = findAdapter(itf);
}
if (facet != null) {
getAdapters().put(itf, facet);
}
return facet;
}
@SuppressWarnings("unchecked")
private <T> T findAdapter(Class<T> itf) {
DocumentAdapterService svc = (DocumentAdapterService) Framework.getRuntime().getComponent(
DocumentAdapterService.NAME);
if (svc != null) {
DocumentAdapterDescriptor dae = svc.getAdapterDescriptor(itf);
if (dae != null) {
String facet = dae.getFacet();
if (facet == null) {
// if no facet is specified, accept the adapter
return (T) dae.getFactory().getAdapter(this, itf);
} else if (hasFacet(facet)) {
return (T) dae.getFactory().getAdapter(this, itf);
} else {
// TODO: throw an exception
log.error("Document model cannot be adapted to " + itf
+ " because it has no facet " + facet);
}
}
} else {
log.warn("DocumentAdapterService not available. Cannot get document model adaptor for "
+ itf);
}
return null;
}
@Override
public boolean followTransition(final String transition)
throws ClientException {
boolean res = new RunWithCoreSession<Boolean>() {
@Override
public Boolean run() throws ClientException {
return Boolean.valueOf(session.followTransition(ref, transition));
}
}.execute().booleanValue();
// Invalidate the prefetched value in this case.
if (res) {
currentLifeCycleState = null;
}
return res;
}
@Override
public Collection<String> getAllowedStateTransitions()
throws ClientException {
return new RunWithCoreSession<Collection<String>>() {
@Override
public Collection<String> run() throws ClientException {
return session.getAllowedStateTransitions(ref);
}
}.execute();
}
@Override
public String getCurrentLifeCycleState() throws ClientException {
if (currentLifeCycleState != null) {
return currentLifeCycleState;
}
// document was just created => not life cycle yet
if (sid == null) {
return null;
}
currentLifeCycleState = new RunWithCoreSession<String>() {
@Override
public String run() throws ClientException {
return session.getCurrentLifeCycleState(ref);
}
}.execute();
return currentLifeCycleState;
}
@Override
public String getLifeCyclePolicy() throws ClientException {
if (lifeCyclePolicy != null) {
return lifeCyclePolicy;
}
// String lifeCyclePolicy = null;
lifeCyclePolicy = new RunWithCoreSession<String>() {
@Override
public String run() throws ClientException {
return session.getLifeCyclePolicy(ref);
}
}.execute();
return lifeCyclePolicy;
}
@Override
public boolean isVersion() {
return (flags & F_VERSION) != 0;
}
@Override
public boolean isProxy() {
return (flags & F_PROXY) != 0;
}
@Override
public boolean isImmutable() {
return (flags & F_IMMUTABLE) != 0;
}
public void setIsVersion(boolean isVersion) {
if (isVersion) {
flags |= F_VERSION;
} else {
flags &= ~F_VERSION;
}
}
public void setIsProxy(boolean isProxy) {
if (isProxy) {
flags |= F_PROXY;
} else {
flags &= ~F_PROXY;
}
}
public void setIsImmutable(boolean isImmutable) {
if (isImmutable) {
flags |= F_IMMUTABLE;
} else {
flags &= ~F_IMMUTABLE;
}
}
@Override
public ScopedMap getContextData() {
return contextData;
}
@Override
public Serializable getContextData(ScopeType scope, String key) {
return contextData.getScopedValue(scope, key);
}
@Override
public void putContextData(ScopeType scope, String key, Serializable value) {
contextData.putScopedValue(scope, key, value);
}
@Override
public Serializable getContextData(String key) {
return contextData.getScopedValue(key);
}
@Override
public void putContextData(String key, Serializable value) {
contextData.putScopedValue(key, value);
}
@Override
public void copyContextData(DocumentModel otherDocument) {
ScopedMap otherMap = otherDocument.getContextData();
if (otherMap != null) {
contextData.putAll(otherMap);
}
}
/** @deprecated unused */
@Deprecated
public void copyContentInto(DocumentModelImpl other) {
other.schemas = schemas;
other.facets = facets;
other.instanceFacets = instanceFacets;
other.instanceFacetsOrig = instanceFacetsOrig;
other.dataModels = dataModels;
}
@Override
public void copyContent(DocumentModel sourceDoc) throws ClientException {
schemas = new HashSet<String>(Arrays.asList(sourceDoc.getSchemas()));
facets = new HashSet<String>(sourceDoc.getFacets());
instanceFacets = new HashSet<String>(
((DocumentModelImpl) sourceDoc).instanceFacets);
instanceFacetsOrig = new HashSet<String>(
((DocumentModelImpl) sourceDoc).instanceFacetsOrig);
DataModelMap newDataModels = new DataModelMapImpl();
for (String key : schemas) {
DataModel oldDM = sourceDoc.getDataModel(key);
DataModel newDM = cloneDataModel(oldDM);
newDataModels.put(key, newDM);
}
dataModels = newDataModels;
}
@SuppressWarnings("unchecked")
public static Object cloneField(Field field, String key, Object value) {
// key is unused
Object clone;
Type type = field.getType();
if (type.isSimpleType()) {
// CLONE TODO
if (value instanceof Calendar) {
Calendar newValue = (Calendar) value;
clone = newValue.clone();
} else {
clone = value;
}
} else if (type.isListType()) {
ListType ltype = (ListType) type;
Field lfield = ltype.getField();
Type ftype = lfield.getType();
List<Object> list;
if (value instanceof Object[]) { // these are stored as arrays
list = Arrays.asList((Object[]) value);
} else {
list = (List<Object>) value;
}
if (ftype.isComplexType()) {
List<Object> clonedList = new ArrayList<Object>(list.size());
for (Object o : list) {
clonedList.add(cloneField(lfield, null, o));
}
clone = clonedList;
} else {
Class<?> klass = JavaTypes.getClass(ftype);
if (klass.isPrimitive()) {
clone = PrimitiveArrays.toPrimitiveArray(list, klass);
} else {
clone = list.toArray((Object[]) Array.newInstance(klass,
list.size()));
}
}
} else {
// complex type
ComplexType ctype = (ComplexType) type;
if (TypeConstants.isContentType(ctype)) { // if a blob
Blob blob = (Blob) value; // TODO
clone = blob;
} else {
// a map, regular complex type
Map<String, Object> map = (Map<String, Object>) value;
Map<String, Object> clonedMap = new HashMap<String, Object>();
for (Map.Entry<String, Object> entry : map.entrySet()) {
Object v = entry.getValue();
String k = entry.getKey();
if (v == null) {
continue;
}
clonedMap.put(k, cloneField(ctype.getField(k), k, v));
}
clone = clonedMap;
}
}
return clone;
}
public static DataModel cloneDataModel(Schema schema, DataModel data) {
DataModel dm = new DataModelImpl(schema.getName());
for (Field field : schema.getFields()) {
String key = field.getName().getLocalName();
Object value;
try {
value = data.getData(key);
} catch (PropertyException e1) {
continue;
}
if (value == null) {
continue;
}
Object clone = cloneField(field, key, value);
try {
dm.setData(key, clone);
} catch (PropertyException e) {
throw new ClientRuntimeException(e);
}
}
return dm;
}
public DataModel cloneDataModel(DataModel data) {
TypeProvider typeProvider = Framework.getLocalService(SchemaManager.class);
return cloneDataModel(typeProvider.getSchema(data.getSchema()), data);
}
@Override
public String getCacheKey() throws ClientException {
// UUID - sessionId
String key = id + '-' + sid + '-' + getPathAsString();
// :FIXME: Assume a dublin core schema => enough for us right now.
Calendar timeStamp = (Calendar) getProperty("dublincore", "modified");
if (timeStamp != null) {
key += '-' + String.valueOf(timeStamp.getTimeInMillis());
}
return key;
}
@Override
public String getRepositoryName() {
return repositoryName;
}
@Override
public String getSourceId() {
return sourceId;
}
public boolean isSchemaLoaded(String name) {
return dataModels.containsKey(name);
}
// TODO: id is schema.field and not prefix:field
@Override
public void prefetchProperty(String id, Object value) {
if (prefetch == null) {
prefetch = new HashMap<String, Serializable>();
}
Serializable sValue = (Serializable) value;
prefetch.put(id, value == null ? Null.VALUE : sValue);
}
@Override
public void prefetchCurrentLifecycleState(String lifecycle) {
currentLifeCycleState = lifecycle;
}
@Override
public void prefetchLifeCyclePolicy(String lifeCyclePolicy) {
this.lifeCyclePolicy = lifeCyclePolicy;
}
public void setFlags(long flags) {
this.flags |= flags;
}
public void clearFlags(long flags) {
this.flags &= ~flags;
}
public void clearFlags() {
flags = 0L;
}
@Override
public long getFlags() {
return flags;
}
public boolean hasFlags(long flags) {
return (this.flags & flags) == flags;
}
@Override
// need this for tree in RCP clients
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof DocumentModelImpl) {
DocumentModel documentModel = (DocumentModel) obj;
String id = documentModel.getId();
if (id != null) {
return id.equals(this.id);
}
}
return false;
}
@Override
public int hashCode() {
return id == null ? 0 : id.hashCode();
}
@Override
public String toString() {
String title;
try {
title = getTitle();
} catch (ClientException e) {
title = "(ERROR: " + e + ')';
}
return getClass().getSimpleName() + '(' + id + ", path=" + path
+ ", title=" + title + ')';
}
@Override
public Map<String, Serializable> getPrefetch() {
return prefetch;
}
@Override
public <T extends Serializable> T getSystemProp(
final String systemProperty, final Class<T> type)
throws ClientException, DocumentException {
return new RunWithCoreSession<T>() {
@Override
public T run() throws ClientException {
try {
return session.getDocumentSystemProp(ref, systemProperty,
type);
} catch (DocumentException e) {
throw new ClientException(e);
}
}
}.execute();
}
@Override
public boolean isLifeCycleLoaded() {
return currentLifeCycleState != null;
}
@Override
public DocumentPart getPart(String schema) throws ClientException {
DataModel dm = getDataModel(schema);
if (dm != null) {
return ((DataModelImpl) dm).getDocumentPart();
}
return null; // TODO thrown an exception?
}
@Override
public DocumentPart[] getParts() throws ClientException {
// DocumentType type = getDocumentType();
// type = Framework.getService(SchemaManager.class).getDocumentType(
// getType());
// Collection<Schema> schemas = type.getSchemas();
// Set<String> allSchemas = getAllSchemas();
DocumentPart[] parts = new DocumentPart[schemas.size()];
int i = 0;
for (String schema : schemas) {
DataModel dm = getDataModel(schema);
parts[i++] = ((DataModelImpl) dm).getDocumentPart();
}
return parts;
}
@Override
public Property getProperty(String xpath) throws ClientException {
Path path = new Path(xpath);
if (path.segmentCount() == 0) {
throw new PropertyNotFoundException(xpath, "Schema not specified");
}
String segment = path.segment(0);
int p = segment.indexOf(':');
if (p == -1) { // support also other schema paths? like schema.property
// allow also unprefixed schemas -> make a search for the first
// matching schema having a property with same name as path segment
// 0
DocumentPart[] parts = getParts();
for (DocumentPart part : parts) {
if (part.getSchema().hasField(segment)) {
return part.resolvePath(path.toString());
}
}
// could not find any matching schema
throw new PropertyNotFoundException(xpath, "Schema not specified");
}
String prefix = segment.substring(0, p);
SchemaManager mgr = Framework.getLocalService(SchemaManager.class);
Schema schema = mgr.getSchemaFromPrefix(prefix);
if (schema == null) {
schema = mgr.getSchema(prefix);
if (schema == null) {
throw new PropertyNotFoundException(xpath,
"Could not find registered schema with prefix: "
+ prefix);
}
}
// workaround for a schema prefix bug -> XPATH lookups in
// DocumentPart must use prefixed
// names for schema with prefixes and non prefixed names for the
// rest o schemas.
// Until then we used the name as the prefix but we must remove it
// since it is not a valid prefix:
// NXP-1913
String[] segments = path.segments();
segments[0] = segments[0].substring(p + 1);
path = Path.createFromSegments(segments);
DocumentPart part = getPart(schema.getName());
if (part == null) {
throw new PropertyNotFoundException(
xpath,
String.format(
"Document '%s' with title '%s' and type '%s' does not have any schema with prefix '%s'",
getRef(), getTitle(), getType(), prefix));
}
return part.resolvePath(path.toString());
}
@Override
public Serializable getPropertyValue(String path) throws PropertyException,
ClientException {
return getProperty(path).getValue();
}
@Override
public void setPropertyValue(String path, Serializable value)
throws PropertyException, ClientException {
getProperty(path).setValue(value);
}
@Override
public DocumentModel clone() throws CloneNotSupportedException {
DocumentModelImpl dm = (DocumentModelImpl) super.clone();
// dm.id =id;
// dm.acp = acp;
// dm.currentLifeCycleState = currentLifeCycleState;
// dm.lifeCyclePolicy = lifeCyclePolicy;
// dm.declaredSchemas = declaredSchemas; // schemas are immutable so we
// don't clone the array
// dm.flags = flags;
// dm.repositoryName = repositoryName;
// dm.ref = ref;
// dm.parentRef = parentRef;
// dm.path = path; // path is immutable
// dm.isACPLoaded = isACPLoaded;
// dm.prefetch = dm.prefetch; // prefetch can be shared
// dm.lock = lock;
// dm.sourceId =sourceId;
// dm.sid = sid;
// dm.type = type;
dm.facets = new HashSet<String>(facets); // facets
// should be
// clones too -
// they are not
// immutable
// context data is keeping contextual info so it is reseted
dm.contextData = new ScopedMap();
// copy parts
dm.dataModels = new DataModelMapImpl();
for (Map.Entry<String, DataModel> entry : dataModels.entrySet()) {
String key = entry.getKey();
DataModel data = entry.getValue();
DataModelImpl newData;
try {
newData = new DataModelImpl(key, data.getMap());
} catch (PropertyException e) {
throw new ClientRuntimeException(e);
}
dm.dataModels.put(key, newData);
}
return dm;
}
@Override
public void reset() {
if (dataModels != null) {
dataModels.clear();
}
if (prefetch != null) {
prefetch.clear();
}
isACPLoaded = false;
acp = null;
currentLifeCycleState = null;
lifeCyclePolicy = null;
}
@Override
public void refresh() throws ClientException {
refresh(REFRESH_DEFAULT, null);
}
@Override
public void refresh(int refreshFlags, String[] schemas)
throws ClientException {
if (id == null) {
// not yet saved
return;
}
if ((refreshFlags & REFRESH_ACP_IF_LOADED) != 0 && isACPLoaded) {
refreshFlags |= REFRESH_ACP;
// we must not clean the REFRESH_ACP_IF_LOADED flag since it is used
// below on the client
}
if ((refreshFlags & REFRESH_CONTENT_IF_LOADED) != 0) {
refreshFlags |= REFRESH_CONTENT;
Collection<String> keys = dataModels.keySet();
schemas = keys.toArray(new String[keys.size()]);
}
DocumentModelRefresh refresh = getCoreSession().refreshDocument(ref,
refreshFlags, schemas);
if ((refreshFlags & REFRESH_PREFETCH) != 0) {
prefetch = refresh.prefetch;
}
if ((refreshFlags & REFRESH_STATE) != 0) {
currentLifeCycleState = refresh.lifeCycleState;
lifeCyclePolicy = refresh.lifeCyclePolicy;
isCheckedOut = refresh.isCheckedOut;
isLatestVersion = refresh.isLatestVersion;
isMajorVersion = refresh.isMajorVersion;
isLatestMajorVersion = refresh.isLatestMajorVersion;
isVersionSeriesCheckedOut = refresh.isVersionSeriesCheckedOut;
versionSeriesId = refresh.versionSeriesId;
checkinComment = refresh.checkinComment;
isStateLoaded = true;
}
acp = null;
isACPLoaded = false;
if ((refreshFlags & REFRESH_ACP) != 0) {
acp = refresh.acp;
isACPLoaded = true;
}
dataModels.clear();
if ((refreshFlags & REFRESH_CONTENT) != 0) {
DocumentPart[] parts = refresh.documentParts;
if (parts != null) {
for (DocumentPart part : parts) {
DataModelImpl dm = new DataModelImpl(part);
dataModels.put(dm.getSchema(), dm);
}
}
}
}
}