Creating a type¶Java command-line example using the CMIS 1.1 type mutability feature. package typeMutability.enabled; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Properties; import org.apache.chemistry.opencmis.client.api.ObjectType; import org.apache.chemistry.opencmis.client.api.Repository; import org.apache.chemistry.opencmis.client.api.Session; import org.apache.chemistry.opencmis.client.api.SessionFactory; import org.apache.chemistry.opencmis.client.runtime.SessionFactoryImpl; import org.apache.chemistry.opencmis.commons.SessionParameter; import org.apache.chemistry.opencmis.commons.data.CmisExtensionElement; import org.apache.chemistry.opencmis.commons.data.RepositoryInfo; import org.apache.chemistry.opencmis.commons.definitions.Choice; import org.apache.chemistry.opencmis.commons.definitions.DocumentTypeDefinition; import org.apache.chemistry.opencmis.commons.definitions.PropertyBooleanDefinition; import org.apache.chemistry.opencmis.commons.definitions.PropertyDefinition; import org.apache.chemistry.opencmis.commons.definitions.PropertyIdDefinition; import org.apache.chemistry.opencmis.commons.definitions.PropertyIntegerDefinition; import org.apache.chemistry.opencmis.commons.definitions.PropertyStringDefinition; import org.apache.chemistry.opencmis.commons.definitions.TypeDefinition; import org.apache.chemistry.opencmis.commons.definitions.TypeMutability; import org.apache.chemistry.opencmis.commons.enums.BaseTypeId; import org.apache.chemistry.opencmis.commons.enums.Cardinality; import org.apache.chemistry.opencmis.commons.enums.ContentStreamAllowed; import org.apache.chemistry.opencmis.commons.enums.PropertyType; import org.apache.chemistry.opencmis.commons.enums.Updatability; import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException; import typeMutability.util.TestStringChoice; /* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * * This code is based on the Apache Chemistry OpenCMIS FileShare project * <http://chemistry.apache.org/java/developing/repositories/dev-repositories-fileshare.html>. * * This code is part of a training exercise and not intended for production use! * */ /** * Running this test requires an input file containing the connection * properties for your CMIS server. * * The default/static location is /temp/cmis.properties * and is hard coded in the main() method. * See the loadConnectionProperties() call if you * need to change this location or make it dynamic. * * Example format for a typical cmis.properties file: * You can also refer to the properties section in the * Workbench page here: * http://chemistry.apache.org/java/developing/tools/dev-tools-workbench.html * * ****************************************** * SAMPLE cmis.properties ******************* * ****************************************** * * org.apache.chemistry.opencmis.binding.spi.type=browser * org.apache.chemistry.opencmis * org.apache.chemistry.opencmis.binding.browser.url=http://localhost:8080/openfncmis/browser * org.apache.chemistry.opencmis.user=username_here * org.apache.chemistry.opencmis.password=password_here * org.apache.chemistry.opencmis.binding.compression=true * org.apache.chemistry.opencmis.binding.cookies=true * */ /* * This class serves as a simple example of how to create a new TypeDefinintion * in CMIS using the OpenCMIS client. (all in one self contained file) This code * was tested with the FileNet CMIS 1.1 tech preview but can be modified to work * with any CMIS client that supports type mutability. * * Code will create a new subclass of cmis:document with 4 properties * String, Int, Boolean and Id, and two choice list values on the String prop */ public class CreateTestCommandLine { // Modify these values to conform to your local repository requirements // // property id's and names here private static final String property_stringPropertyId = "StringPropertyDefinition"; private static final String property_intPropertyId = "IntPropertyDefinition"; private static final String property_boolPropertyId = "BoolPropertyDefinition"; private static final String property_idPropertyId = "IdPropertyDefinition"; // // type related // the id of the new type's parent private static final String type_idOfParentType = "cmis:document"; // Id of the new subclass we will be creating private static final String type_idOfNewClass = "cmis_newDocSubclass1"; // other information about type private static final String type_description = "Test document type definition"; private static final String type_displayName = "TestTypeDefinition"; private static final String type_localName = "some test local name"; private static final String type_localNamespace = "some test local name space"; // globals private static Session session = null; public static void main(String[] args) { System.out.println("An example of type creation with CMIS TypeMutability from OpenCMIS."); // Assume /cmis.properties is the name of the input file containing all // of the session parameters (test only) Map<String, String> parameters = loadConnectionProperties("/temp/cmis.properties"); session = getSession(parameters); // Look at repository info - demonstrates a valid connection RepositoryInfo repositoryInfo = session.getRepositoryInfo(); System.out.println("Connected to repository. Supports CMIS version:" + repositoryInfo.getCmisVersionSupported()); // Check here to verify the types we will be creating are permissible // for this repository. Boolean canCreateStringProperty = false; Boolean canCreateIdProperty = false; Boolean canCreateBoolProperty = false; Boolean canCreateIntProperty = false; for (PropertyType propCreatable : repositoryInfo.getCapabilities().getCreatablePropertyTypes().canCreate()) { if (propCreatable.equals(PropertyType.STRING)) { canCreateStringProperty = true; } else if (propCreatable.equals(PropertyType.INTEGER)) { canCreateIntProperty = true; } else if (propCreatable.equals(PropertyType.ID)) { canCreateIdProperty = true; } else if (propCreatable.equals(PropertyType.BOOLEAN)) { canCreateBoolProperty = true; } System.out.println("Repository can create property of : " + propCreatable.toString()); } assert canCreateStringProperty: "String is not one of the createable properties."; assert canCreateIdProperty: "Id is not one of the createable properties."; assert canCreateBoolProperty: "Boolean is not one of the createable properties."; assert canCreateIntProperty: "Integer is not one of the createable properties."; // Create new type with string property // and verify it exists in type collection ObjectType newType = createNewType(); // clean up the type if permitted // TODO - check to see if delete is permitted first... session.deleteType(newType.getId()); // TODO - verify delete here for completeness. System.out.println("Cleanup completed."); } /** * Create the new type with with our 4 test property types. * * @return */ public static ObjectType createNewType() { // assuming the following default (change if your repository // does not support these settings Boolean isCreatable = true; Boolean includedInSupertypeQuery = true; Boolean queryable = true; ContentStreamAllowed contentStreamAllowed = ContentStreamAllowed.ALLOWED; Boolean versionable = false; // build property definitions - string, int, boolean and id Map<String, PropertyDefinition<?>> propertyDefinitions = new LinkedHashMap<String, PropertyDefinition<?>>(); TestStringPropertyDefinition spd = createStringPropertyDefinition(); TestIntegerPropertyDefinition ipd = createIntPropertyDefinition(); TestBooleanPropertyDefinition bpd = createBooleanPropertyDefinition(); TestIdPropertyDefinition idpd = createIDPropertyDefinition(); propertyDefinitions.put(spd.getId(), spd); propertyDefinitions.put(ipd.getId(), ipd); propertyDefinitions.put(bpd.getId(), bpd); propertyDefinitions.put(idpd.getId(), idpd); TestDocumentTypeDefinition typeToCreate = new TestDocumentTypeDefinition(type_idOfNewClass, type_description, type_displayName, type_localName, type_localNamespace, type_idOfParentType, isCreatable, includedInSupertypeQuery, queryable, contentStreamAllowed, versionable, propertyDefinitions); TypeDefinition createdType = null; try { createdType = session.createType(typeToCreate); System.out.println("Type created: " + createdType.toString()); } catch (Exception e) { assert false: "An exception was thrown when trying to create a new type definition. Message: " + e.getMessage(); } ObjectType retrievedType = null; try { retrievedType = session.getTypeDefinition(createdType.getId()); assert retrievedType != null: "Unable to retrieve new type. "; } catch (Exception e) { assert false: "Got exception. Cannot get the type definition from the repository. Message: " + e.getMessage(); } return retrievedType; } public static Session getSession(Map<String, String> parameters) { Session session = null; SessionFactory factory = SessionFactoryImpl.newInstance(); if (parameters.containsKey(SessionParameter.REPOSITORY_ID)) { session = factory.createSession(parameters); } else { // Create session for the first repository. List<Repository> repositories = factory.getRepositories(parameters); session = repositories.get(0).createSession(); } // reset op context to default session.setDefaultContext(session.createOperationContext()); return session; } /* * Load our connection properties from a local file * * Note file should use the same format as the expert settings for Workbench */ public static final Map<String, String> loadConnectionProperties(String configResource) { Properties testConfig = new Properties(); if (configResource == null) { throw new CmisRuntimeException("Filename with connection parameters was not supplied."); } FileInputStream inStream; try { inStream = new FileInputStream(configResource); testConfig.load(inStream); inStream.close(); } catch (FileNotFoundException e1) { throw new CmisRuntimeException("Test properties file '" + configResource + "' was not found at:" + configResource); } catch (IOException e) { throw new CmisRuntimeException("Exception loading test properties file " + configResource, e); } Map<String, String> map = new HashMap<String, String>(); for (Entry<?, ?> entry : testConfig.entrySet()) { System.out.println("Found key: " + entry.getKey() + " Value:" + entry.getValue()); map.put((String) entry.getKey(), ((String) entry.getValue()).trim()); } return map; } /** * Create a single string property definition with a choice list */ private static TestStringPropertyDefinition createStringPropertyDefinition() { Cardinality cardinality = Cardinality.SINGLE; String description = "String property definition"; String displayName = "StringPropertyDefinition"; String localName = "StringPropertyDefinition"; String localNameSpace = "StringPropertyDefinition"; Updatability updatability = Updatability.READWRITE; Boolean orderable = false; Boolean queryable = false; ArrayList<String> defaults = new ArrayList<String>(); defaults.add("test"); List<String> vals1 = new LinkedList<String>(); vals1.add("val1"); List<String> vals2 = new LinkedList<String>(); vals2.add("val2"); TestStringChoice strChoice1 = new TestStringChoice("choice1", vals1, null); TestStringChoice strChoice2 = new TestStringChoice("choice2", vals2, null); List<Choice<String>> choiceList = new LinkedList<Choice<String>>(); choiceList.add (strChoice1); choiceList.add (strChoice2); TestStringPropertyDefinition spd = new TestStringPropertyDefinition(property_stringPropertyId, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaults, choiceList, null); return spd; } private static TestIntegerPropertyDefinition createIntPropertyDefinition() { Cardinality cardinality = Cardinality.MULTI; String description = "Int property definition"; String displayName = "IntPropertyDefinition"; String localName = "IntPropertyDefinition"; String localNameSpace = "IntPropertyDefinition"; Updatability updatability = Updatability.READWRITE; Boolean orderable = false; Boolean queryable = false; ArrayList<BigInteger> defaults = new ArrayList<BigInteger>(); // defaults.add(new BigInteger("101")); BigInteger minVal = new BigInteger("100"); BigInteger maxVal = new BigInteger("1000"); TestIntegerPropertyDefinition ipd = new TestIntegerPropertyDefinition(property_intPropertyId, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaults, minVal, maxVal, null); return ipd; } private static TestBooleanPropertyDefinition createBooleanPropertyDefinition() { Cardinality cardinality = Cardinality.SINGLE; String description = "Boolean property definition"; String displayName = "BooleanPropertyDefinition"; String localName = "BooleanPropertyDefinition"; String localNameSpace = "BooleanPropertyDefinition"; Updatability updatability = Updatability.ONCREATE; Boolean orderable = false; Boolean queryable = false; ArrayList<Boolean> defaults = new ArrayList<Boolean>(); defaults.add(false); TestBooleanPropertyDefinition spd = new TestBooleanPropertyDefinition(property_boolPropertyId, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaults); return spd; } private static TestIdPropertyDefinition createIDPropertyDefinition() { Cardinality cardinality = Cardinality.SINGLE; String description = "ID property definition"; String displayName = "IDPropertyDefinition"; String localName = "IDPropertyDefinition"; String localNameSpace = "IDPropertyDefinition"; Updatability updatability = Updatability.READWRITE; Boolean orderable = false; Boolean queryable = false; TestIdPropertyDefinition idpd = new TestIdPropertyDefinition(property_idPropertyId, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, null); return idpd; } /** * ************************************************************************** * Inner classes follow * ************************************************************************** * * All of the abstract base classes (for properties and types) * that are used in this example are defined here * along with their subclasses for each type that we support in this example. * * These classes can be further extended and reused for additional type * mutability operations. * * These were made inner classes so the entire example would be contained * in a single Java file. (no design reason) * */ private static class TestStringPropertyDefinition extends TestPropertyDefinition<String> implements PropertyStringDefinition { BigInteger maxLength = null; public TestStringPropertyDefinition(String idAndQueryName, Cardinality cardinality, String description, String displayName, String localName, String localNameSpace, Updatability updatability, Boolean orderable, Boolean queryable, List<String> defaultValue, List<Choice<String>> choiceList, BigInteger maxLength) { super(idAndQueryName, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaultValue, choiceList); this.maxLength = maxLength; } @Override public PropertyType getPropertyType() { return PropertyType.STRING; } @Override public BigInteger getMaxLength() { return maxLength; } } private static class TestIntegerPropertyDefinition extends TestPropertyDefinition<BigInteger> implements PropertyIntegerDefinition { private BigInteger minVal = null; private BigInteger maxVal = null; public TestIntegerPropertyDefinition(String idAndQueryName, Cardinality cardinality, String description, String displayName, String localName, String localNameSpace, Updatability updatability, Boolean orderable, Boolean queryable, List<BigInteger> defaultValue, BigInteger minVal, BigInteger maxVal, List<Choice<BigInteger>> choiceList) { super(idAndQueryName, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaultValue, choiceList); this.minVal = minVal; this.maxVal = maxVal; } @Override public PropertyType getPropertyType() { return PropertyType.INTEGER; } @Override public BigInteger getMaxValue() { return this.maxVal; } @Override public BigInteger getMinValue() { return this.minVal; } } private static class TestBooleanPropertyDefinition extends TestPropertyDefinition<Boolean> implements PropertyBooleanDefinition { public TestBooleanPropertyDefinition(String idAndQueryName, Cardinality cardinality, String description, String displayName, String localName, String localNameSpace, Updatability updatability, Boolean orderable, Boolean queryable, List<Boolean> defaultValue) { super(idAndQueryName, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaultValue, null); } @Override public PropertyType getPropertyType() { return PropertyType.BOOLEAN; } } private static class TestIdPropertyDefinition extends TestPropertyDefinition<String> implements PropertyIdDefinition { public TestIdPropertyDefinition(String idAndQueryName, Cardinality cardinality, String description, String displayName, String localName, String localNameSpace, Updatability updatability, Boolean orderable, Boolean queryable, List<String> defaultValue) { super(idAndQueryName, cardinality, description, displayName, localName, localNameSpace, updatability, orderable, queryable, defaultValue, null); } @Override public PropertyType getPropertyType() { return PropertyType.ID; } } /** * Base class for all property definition types * * See TestStringPropertyDefinition for example of how to subclass this. * * @param <T> */ abstract private static class TestPropertyDefinition<T> implements PropertyDefinition<T> { private String idAndQueryName = null; private Cardinality cardinality = null; private String description = null; private String displayName = null; private String localName = null; private String localNameSpace = null; private Updatability updatability = null; private Boolean orderable = null; private Boolean queryable = null; private List<T> defaultValue = null; private List<Choice<T>> choiceList = null; public TestPropertyDefinition(String idAndQueryName, Cardinality cardinality, String description, String displayName, String localName, String localNameSpace, Updatability updatability, Boolean orderable, Boolean queryable, List<T> defaultValue, List<Choice<T>> choiceList) { super(); this.idAndQueryName = idAndQueryName; this.cardinality = cardinality; this.description = description; this.displayName = displayName; this.localName = localName; this.localNameSpace = localNameSpace; this.updatability = updatability; this.orderable = orderable; this.queryable = queryable; this.defaultValue = defaultValue; this.choiceList = choiceList; } @Override public String getId() { return idAndQueryName; } @Override public Cardinality getCardinality() { return cardinality; } @Override public String getDescription() { return description; } @Override public String getDisplayName() { return displayName; } @Override public String getLocalName() { return localName; } @Override public String getLocalNamespace() { return localNameSpace; } @Override abstract public PropertyType getPropertyType(); @Override public String getQueryName() { return idAndQueryName; } @Override public Updatability getUpdatability() { return updatability; } @Override public Boolean isOrderable() { return orderable; } @Override public Boolean isQueryable() { return queryable; } // methods with static content @Override public List<Choice<T>> getChoices() { return this.choiceList; } @Override public List<T> getDefaultValue() { return this.defaultValue; } /** * TODO For these remaining attributes you will want to set them * accordingly. They are all set to static values only * because this is sample code. */ @Override public Boolean isInherited() { return false; } @Override public Boolean isOpenChoice() { return false; } @Override public Boolean isRequired() { return false; } @Override public List<CmisExtensionElement> getExtensions() { return null; } @Override public void setExtensions(List<CmisExtensionElement> arg0) { } } /** * Base class for all typeDefinitions. * See TestDocumentTypeDefinition for an example of how to subclass this for document. * */ private static abstract class TestTypeDefinition implements TypeDefinition { private String description = null; private String displayName = null; private String idAndQueryName = null; private String localName = null; private String localNamespace = null; private String parentTypeId = null; private Boolean isCreatable = null; private Boolean includedInSupertypeQuery = null; private Boolean queryable = null; private Map<String, PropertyDefinition<?>> propertyDefinitions = new HashMap<String, PropertyDefinition<?>>(); public TestTypeDefinition(String idAndQueryName, String description, String displayName, String localName, String localNamespace, String parentTypeId, Boolean isCreatable, Boolean includedInSupertypeQuery, Boolean queryable, Map<String, PropertyDefinition<?>> propertyDefinitions) { this.description = description; this.displayName = displayName; this.idAndQueryName = idAndQueryName; this.localName = localName; this.localNamespace = localNamespace; this.parentTypeId = parentTypeId; this.isCreatable = isCreatable; this.includedInSupertypeQuery = includedInSupertypeQuery; this.queryable = queryable; if (propertyDefinitions != null) { this.propertyDefinitions = propertyDefinitions; } } @Override abstract public BaseTypeId getBaseTypeId(); @Override public String getDescription() { return description; } @Override public String getDisplayName() { return displayName; } @Override public String getId() { return idAndQueryName; } @Override public String getLocalName() { return localName; } @Override public String getLocalNamespace() { return localNamespace; } @Override public String getParentTypeId() { return parentTypeId; } @Override public Map<String, PropertyDefinition<?>> getPropertyDefinitions() { return propertyDefinitions; } @Override public String getQueryName() { return idAndQueryName; } @Override public Boolean isCreatable() { return isCreatable; } @Override public Boolean isIncludedInSupertypeQuery() { return includedInSupertypeQuery; } @Override public Boolean isQueryable() { return queryable; } /** * TODO For these remaining attributes you will want to set them * accordingly. They are all set to static values only * because this is sample code. */ @Override public TypeMutability getTypeMutability() { return new TestTypeMutability(); } @Override public Boolean isControllableAcl() { return true; } @Override public Boolean isControllablePolicy() { return false; } @Override public Boolean isFileable() { return true; } @Override public Boolean isFulltextIndexed() { return false; } @Override public List<CmisExtensionElement> getExtensions() { return null; } @Override public void setExtensions(List<CmisExtensionElement> extension) { } } private static class TestDocumentTypeDefinition extends TestTypeDefinition implements DocumentTypeDefinition { private ContentStreamAllowed contentStreamAllowed = null; private Boolean versionable = null; public TestDocumentTypeDefinition(String idAndQueryName, String description, String displayName, String localName, String localNamespace, String parentTypeId, Boolean isCreatable, Boolean includedInSupertypeQuery, Boolean queryable, ContentStreamAllowed contentStreamAllowed, Boolean versionable, Map<String, PropertyDefinition<?>> propertyDefinitions) { super(idAndQueryName, description, displayName, localName, localNamespace, parentTypeId, isCreatable, includedInSupertypeQuery, queryable, propertyDefinitions); this.contentStreamAllowed = contentStreamAllowed; this.versionable = versionable; } @Override public BaseTypeId getBaseTypeId() { return BaseTypeId.CMIS_DOCUMENT; } @Override public ContentStreamAllowed getContentStreamAllowed() { return contentStreamAllowed; } @Override public Boolean isVersionable() { return versionable; } } public static class TestTypeMutability implements TypeMutability { /** * TODO: * Change these values based on your repository and requirements */ @Override public List<CmisExtensionElement> getExtensions() { return null; } @Override public void setExtensions(List<CmisExtensionElement> arg0) { } @Override public Boolean canCreate() { return true; } @Override public Boolean canDelete() { return true; } @Override public Boolean canUpdate() { return true; } } } |