org.apache.chemistry.opencmis.commons.definitions.TypeDefinition Java Examples

/**
 * Create dispatch for AtomPub
 * 
 * @param context call context
 * @param properties the properties
 * @param folderId identifier of the parent folder
 * @param contentStream stream of the document to create
 * @param versioningState state of the version
 * @param objectInfos informations
 * 
 * @return the newly created object
 */
public ObjectData create(CallContext context, Properties properties, String folderId, ContentStream contentStream,
		VersioningState versioningState, ObjectInfoHandler objectInfos) {
	debug("create " + folderId);
	validatePermission(folderId, context, Permission.WRITE);

	String typeId = getTypeId(properties);

	TypeDefinition type = types.getType(typeId);
	if (type == null)
		throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");

	String objectId = null;
	if (type.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT) {
		objectId = createDocument(context, properties, folderId, contentStream, versioningState);
		return compileObjectType(context, getDocument(objectId), null, false, false, objectInfos);
	} else if (type.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
		objectId = createFolder(context, properties, folderId);
		return compileObjectType(context, getFolder(objectId), null, false, false, objectInfos);
	} else {
		throw new CmisObjectNotFoundException("Cannot create object of type '" + typeId + "'!");
	}
}
 

/**
 * Gathers the type descendants tree
 * 
 * @param depth depth specifications
 * @param tc the container
 * @param includePropertyDefinitions if the property definitions must be included
 * 
 * @return the definition container
 */
private TypeDefinitionContainer getTypesDescendants(int depth, TypeDefinitionContainer tc,
		boolean includePropertyDefinitions) {
	TypeDefinitionContainerImpl result = new TypeDefinitionContainerImpl();

	TypeDefinition type = copyTypeDefintion(tc.getTypeDefinition());
	if (!includePropertyDefinitions) {
		type.getPropertyDefinitions().clear();
	}

	result.setTypeDefinition(type);

	if (depth != 0) {
		if (tc.getChildren() != null) {
			result.setChildren(new ArrayList<TypeDefinitionContainer>());
			for (TypeDefinitionContainer tdc : tc.getChildren()) {
				result.getChildren()
						.add(getTypesDescendants(depth < 0 ? -1 : depth - 1, tdc, includePropertyDefinitions));
			}
		}
	}

	return result;
}
 

static ObjectDataImpl toObjectData(CmisRepositoryConfiguration config,
		CallContext context,
		TypeDefinition type,
		Object object,
		boolean root,
		Set<String> filter,
		ObjectInfoHandler objectInfos) {

	ObjectDataImpl result = new ObjectDataImpl();
	ObjectInfoImpl objectInfo = new ObjectInfoImpl();

	compileObjectMetadata(objectInfo, type);

	result.setProperties(compileProperties(config, type, object, root, filter, objectInfo));

	result.setAllowableActions(compileAllowableActions(type, object, false, false));

	if (context.isObjectInfoRequired()) {
		objectInfo.setObject(result);
		objectInfos.addObjectInfo(objectInfo);
	}

	return result;
}
 

public CmisServiceBridge(CmisRepositoryConfiguration cmisRepositoryConfiguration) {
	this.cmisRepositoryConfiguration = cmisRepositoryConfiguration;

	for (TypeDefinition typeDef : cmisRepositoryConfiguration.getCmisTypeDefinitionList().getList()) {
		typeMap.put(typeDef.getId(), typeDef);
	}

	DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
	registrar.setDateTimeFormatter(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
	registrar.registerFormatters(conversionService);

	conversionService.addConverter(new Converter<Instant, GregorianCalendar>() {
		@Override
		public GregorianCalendar convert(Instant source) {
			ZonedDateTime zdt = ZonedDateTime.ofInstant(source, ZoneId.systemDefault());
			return GregorianCalendar.from(zdt);
		}
	});
}
 

/**
 * Converts a type list
 * 
 * @param typeList the list to convert
 * 
 * @return the converted definition list
 */
public static TypeDefinitionList convert(CmisTypeDefinitionListType typeList) {
	if (typeList == null) {
		return null;
	}

	TypeDefinitionListImpl result = new TypeDefinitionListImpl();
	List<TypeDefinition> types = new ArrayList<TypeDefinition>();
	for (CmisTypeDefinitionType typeDefinition : typeList.getTypes()) {
		types.add(convert(typeDefinition));
	}

	result.setList(types);
	result.setHasMoreItems(typeList.isHasMoreItems());
	result.setNumItems(typeList.getNumItems());

	// handle extensions
	convertExtension(typeList, result);

	return result;
}
 

/**
 * Converts a type list
 * 
 * @param typeList list of types
 * 
 * @return the CMIS definitions
 */
public static CmisTypeDefinitionListType convert(TypeDefinitionList typeList) {
	if (typeList == null) {
		return null;
	}

	CmisTypeDefinitionListType result = new CmisTypeDefinitionListType();

	if (typeList.getList() != null) {
		for (TypeDefinition tdd : typeList.getList()) {
			result.getTypes().add(convert(tdd));
		}
	}

	result.setHasMoreItems(convertBoolean(typeList.hasMoreItems(), false));
	result.setNumItems(typeList.getNumItems());

	// handle extensions
	convertExtension(typeList, result);

	return result;
}
 

@Override
public TypeDefinition getTypeDefinition(String repositoryId, String typeId, ExtensionsData extension) {

	if(!eventDispatcher.contains(CmisEvent.GET_TYPE_DEFINITION)) {
		return repositoryService.getTypeDefinition(repositoryId, typeId, extension);
	}
	else {
		XmlBuilder cmisXml = new XmlBuilder("cmis");
		cmisXml.addSubElement(buildXml("repositoryId", repositoryId));
		cmisXml.addSubElement(buildXml("typeId", typeId));

		Element cmisResult = eventDispatcher.trigger(CmisEvent.GET_TYPE_DEFINITION, cmisXml.toXML(), callContext);

		Element typesXml = XmlUtils.getFirstChildTag(cmisResult, "typeDefinitions");

		return CmisUtils.xml2TypeDefinition(XmlUtils.getFirstChildTag(typesXml, "typeDefinition"), callContext.getCmisVersion());
	}
}
 

static boolean checkAddProperty(Properties properties, TypeDefinition type, Set<String> filter, String id) {
	if ((properties == null) || (properties.getProperties() == null)) {
		throw new IllegalArgumentException("Properties must not be null!");
	}

	if (id == null) {
		throw new IllegalArgumentException("Id must not be null!");
	}

	if (!type.getPropertyDefinitions().containsKey(id)) {
		throw new IllegalArgumentException("Unknown property: " + id);
	}

	String queryName = type.getPropertyDefinitions().get(id).getQueryName();

	if ((queryName != null) && (filter != null)) {
		if (!filter.contains(queryName)) {
			return false;
		} else {
			filter.remove(queryName);
		}
	}

	return true;
}
 

public TypeDefinition getTypeDefinition(boolean includePropertyDefinitions)
{
    lock.readLock().lock();
    try
    {
        if (includePropertyDefinitions)
        {
            return typeDefInclProperties;
        }
        else
        {
            return typeDef;
        }
    }
    finally
    {
        lock.readLock().unlock();
    }
}
 

/**
 * Gathers the type descendants tree.
 */
private TypeDefinitionContainer getTypesDescendants(int depth, TypeDefinitionContainer tc, boolean includePropertyDefinitions) {
	TypeDefinitionContainerImpl result = new TypeDefinitionContainerImpl();
	TypeDefinition type = copyTypeDefintion(tc.getTypeDefinition());

	if (!includePropertyDefinitions) {
		type.getPropertyDefinitions().clear();
	}

	result.setTypeDefinition(type);

	if (depth != 0) {
		if (tc.getChildren() != null) {
			result.setChildren(new ArrayList<TypeDefinitionContainer>());

			for (TypeDefinitionContainer tdc : tc.getChildren()) {
				result.getChildren().add(getTypesDescendants(depth < 0 ? -1 : depth - 1, tdc, includePropertyDefinitions));
			}
		}
	}

	return result;
}
 

static void addPropertyId(PropertiesImpl props, TypeDefinition type, Set<String> filter, String id, String value) {
	if (!checkAddProperty(props, type, filter, id)) {
		return;
	}

	props.addProperty(new PropertyIdImpl(id, value));
}
 

/**
 * ACE-33
 * 
 * Cmis Item support
 */
@Test
public void testItems()
{

    withCmisService(new CmisServiceCallback<String>() {
        @Override
        public String execute(CmisService cmisService) {
            List<RepositoryInfo> repositories = cmisService.getRepositoryInfos(null);
            assertTrue(repositories.size() > 0);
            RepositoryInfo repo = repositories.get(0);
            String repositoryId = repo.getId();
            
        	TypeDefinition def = cmisService.getTypeDefinition(repositoryId, "cmis:item", null);
        	assertNotNull("the cmis:item type is not defined", def); 
            
        	@SuppressWarnings("unused")
            TypeDefinition p = cmisService.getTypeDefinition(repositoryId, "I:cm:person", null);
        	assertNotNull("the I:cm:person type is not defined", def); 
        	
        	ObjectList result = cmisService.query(repositoryId, "select * from cm:person", Boolean.FALSE, Boolean.TRUE, IncludeRelationships.NONE, "", BigInteger.TEN, BigInteger.ZERO, null);
        	assertTrue("", result.getNumItems().intValue() > 0);
        	return "";
    
        };
    }, CmisVersion.CMIS_1_1);
	
}
 

static void addPropertyDateTime(PropertiesImpl props, TypeDefinition type, Set<String> filter, String id, GregorianCalendar value) {
	if (!checkAddProperty(props, type, filter, id)) {
		return;
	}

	props.addProperty(new PropertyDateTimeImpl(id, value));
}
 

static void addPropertyBoolean(PropertiesImpl props, TypeDefinition type, Set<String> filter, String id, boolean value) {
	if (!checkAddProperty(props, type, filter, id)) {
		return;
	}

	props.addProperty(new PropertyBooleanImpl(id, value));
}
 

static void addPropertyBigInteger(PropertiesImpl props, TypeDefinition type, Set<String> filter, String id, BigInteger value) {
	if (!checkAddProperty(props, type, filter, id)) {
		return;
	}

	props.addProperty(new PropertyIntegerImpl(id, value));
}
 

/**
 * Adds a type to collection with inheriting base type properties
 * 
 * @param type the type
 * 
 * @return if the type has been added
 */
public boolean addType(TypeDefinition type) {
	if (type == null) {
		return false;
	}

	if (type.getBaseTypeId() == null) {
		return false;
	}

	// find base type
	TypeDefinition baseType = null;
	if (type.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT) {
		baseType = copyTypeDefintion(types.get(DOCUMENT_TYPE_ID).getTypeDefinition());
	} else if (type.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
		baseType = copyTypeDefintion(types.get(FOLDER_TYPE_ID).getTypeDefinition());
	} else if (type.getBaseTypeId() == BaseTypeId.CMIS_RELATIONSHIP) {
		baseType = copyTypeDefintion(types.get(RELATIONSHIP_TYPE_ID).getTypeDefinition());
	} else if (type.getBaseTypeId() == BaseTypeId.CMIS_POLICY) {
		baseType = copyTypeDefintion(types.get(POLICY_TYPE_ID).getTypeDefinition());
	} else {
		return false;
	}

	AbstractTypeDefinition newType = (AbstractTypeDefinition) copyTypeDefintion(type);

	// copy property definition
	for (PropertyDefinition<?> propDef : baseType.getPropertyDefinitions().values()) {
		((AbstractPropertyDefinition<?>) propDef).setIsInherited(true);
		newType.addPropertyDefinition(propDef);
	}

	// add it
	addTypeInteral(newType);

	log.info("Added type '" + newType.getId() + "'.");

	return true;
}
 

/**
 * For internal use.
 */
public TypeDefinition getType(String typeId) {
	TypeDefinitionContainer tc = types.get(typeId);

	if (tc == null) {
		return null;
	}

	return tc.getTypeDefinition();
}
 

/**
 * CMIS getTypeDefinition.
 */
public TypeDefinition getTypeDefinition(CallContext context, String typeId) {
	TypeDefinitionContainer tc = types.get(typeId);

	if (tc == null) {
		throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");
	}

	return copyTypeDefintion(tc.getTypeDefinition());
}
 

static void addPropertyString(PropertiesImpl props, TypeDefinition type, Set<String> filter, String id, String value) {
	if (!checkAddProperty(props, type, filter, id)) {
		return;
	}

	props.addProperty(new PropertyStringImpl(id, value));
}
 

@Override
public TypeDefinition getTypeDefinition(String repositoryId, String typeId, ExtensionsData extension) {
    checkRepositoryId(repositoryId);
    checkId("Type Id", typeId);

    try {
        return getWrappedService().getTypeDefinition(repositoryId, typeId, extension);
    } catch (Exception e) {
        throw createCmisException(e);
    }
}
 

@Override
public TypeDefinition getObject() throws Exception {
	CmisDocument cmisDocumentMetadata = entityClass.getAnnotation(CmisDocument.class);
	CmisFolder cmisFolderMetadata = entityClass.getAnnotation(CmisFolder.class);
	if (cmisDocumentMetadata != null) {
		return createDocumentTypeDefinition(entityClass, repoClass, storeClass, cmisDocumentMetadata, CmisVersion.CMIS_1_1, null);
	} else if (cmisFolderMetadata != null) {
		return createFolderTypeDefinition(entityClass, repoClass, cmisFolderMetadata, CmisVersion.CMIS_1_1, null);
	}
	throw new IllegalStateException(format("Unknown type definition: %s", entityClass));
}
 

TypeDefinition getType(Object object) {
	Assert.notNull(object, () -> "object is null");

	if (object.getClass().getAnnotation(CmisFolder.class) != null) {
		return typeMap.get("cmis:folder");
	} else if (object.getClass().getAnnotation(CmisDocument.class) != null) {
		return typeMap.get("cmis:document");
	}

	throw new IllegalStateException(format("invalid type %s", object.getClass()));
}
 

static void compileObjectMetadata(ObjectInfoImpl objectInfo, TypeDefinition type) {

		if (type.getId().equals(BaseTypeId.CMIS_FOLDER.value())) {
			objectInfo.setBaseType(BaseTypeId.CMIS_FOLDER);
			objectInfo.setTypeId(BaseTypeId.CMIS_FOLDER.value());
			objectInfo.setContentType(null);
			objectInfo.setFileName(null);
			objectInfo.setHasAcl(true);
			objectInfo.setHasContent(false);
			objectInfo.setVersionSeriesId(null);
			objectInfo.setIsCurrentVersion(true);
			objectInfo.setRelationshipSourceIds(null);
			objectInfo.setRelationshipTargetIds(null);
			objectInfo.setRenditionInfos(null);
			objectInfo.setSupportsDescendants(true);
			objectInfo.setSupportsFolderTree(true);
			objectInfo.setSupportsPolicies(false);
			objectInfo.setSupportsRelationships(false);
			objectInfo.setWorkingCopyId(null);
			objectInfo.setWorkingCopyOriginalId(null);
		} else {
			objectInfo.setBaseType(BaseTypeId.CMIS_DOCUMENT);
			objectInfo.setTypeId(BaseTypeId.CMIS_DOCUMENT.value());
			objectInfo.setHasAcl(true);
			objectInfo.setHasContent(true);
			objectInfo.setHasParent(true);
			objectInfo.setVersionSeriesId(null);
			objectInfo.setIsCurrentVersion(true);
			objectInfo.setRelationshipSourceIds(null);
			objectInfo.setRelationshipTargetIds(null);
			objectInfo.setRenditionInfos(null);
			objectInfo.setSupportsDescendants(false);
			objectInfo.setSupportsFolderTree(false);
			objectInfo.setSupportsPolicies(false);
			objectInfo.setSupportsRelationships(false);
			objectInfo.setWorkingCopyId(null);
			objectInfo.setWorkingCopyOriginalId(null);
		}
	}
 

@Override
public TypeDefinition createType(String repositoryId, TypeDefinition type, ExtensionsData extension) {
    checkRepositoryId(repositoryId);
    checkTypeDefinition(type);

    try {
        return getWrappedService().createType(repositoryId, type, extension);
    } catch (Exception e) {
        throw createCmisException(e);
    }
}
 

@Override
public TypeDefinition updateType(String repositoryId, TypeDefinition type, ExtensionsData extension) {
    checkRepositoryId(repositoryId);
    checkTypeDefinition(type);

    try {
        return getWrappedService().updateType(repositoryId, type, extension);
    } catch (Exception e) {
        throw createCmisException(e);
    }
}
 

@Override
public TypeDefinition getTypeDefinition(String repositoryId, String typeId, ExtensionsData extension) {

	return bridge.getTypeDefinition(config,
			typeId,
			extension);
}
 

/**
 * For internal use
 * 
 * @param typeId identifier of the type
 * 
 * @return the type definition
 */
public TypeDefinition getType(String typeId) {
	TypeDefinitionContainer tc = types.get(typeId);
	if (tc == null) {
		return null;
	}

	return tc.getTypeDefinition();
}
 

/**
 * CMIS getTypeDefinition
 * 
 * @param context call context
 * @param typeId identifier of the type
 * 
 * @return definition of the type
 */
public TypeDefinition getTypeDefinition(CallContext context, String typeId) {
	TypeDefinitionContainer tc = types.get(typeId);
	if (tc == null) {
		throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");
	}

	return copyTypeDefintion(tc.getTypeDefinition());
}
 

public static List<TypeDefinitionContainer> xml2TypeDescendants(Element typeDefinitionsXml, CmisVersion cmisVersion) {
	List<TypeDefinitionContainer> typeDefinitionList = new ArrayList<TypeDefinitionContainer>();
	Collection<Node> typeDescendantList = XmlUtils.getChildTags(typeDefinitionsXml, "typeDescendant");
	for (Node node : typeDescendantList) {
		Element typeDefinition = XmlUtils.getFirstChildTag((Element) node, "typeDefinition");
		TypeDefinition typeDef = CmisUtils.xml2TypeDefinition(typeDefinition, cmisVersion);
		TypeDefinitionContainerImpl typeDefinitionContainer = new TypeDefinitionContainerImpl(typeDef);

		Element children = XmlUtils.getFirstChildTag((Element) node, "children");
		typeDefinitionContainer.setChildren(xml2TypeDescendants(children, cmisVersion));

		typeDefinitionList.add(typeDefinitionContainer);
	}
	return typeDefinitionList;
}
 

@Override
public TypeDefinition getTypeDefinition(String repositoryId, String typeId, ExtensionsData extension)
{
    checkRepositoryId(repositoryId);

    // find the type
    TypeDefinitionWrapper tdw = connector.getOpenCMISDictionaryService().findType(typeId);
    if (tdw == null)
    {
        throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");
    }

    // return type definition
    return tdw.getTypeDefinition(true);
}