This project has retired. For details please refer to its Attic page.
ObjectService xref 

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.chemistry.opencmis.server.impl.webservices;
20  
21  import static org.apache.chemistry.opencmis.commons.impl.Converter.convert;
22  import static org.apache.chemistry.opencmis.commons.impl.Converter.convertExtensionHolder;
23  import static org.apache.chemistry.opencmis.commons.impl.Converter.convertHolder;
24  import static org.apache.chemistry.opencmis.commons.impl.Converter.setExtensionValues;
25  import static org.apache.chemistry.opencmis.commons.impl.Converter.setHolderValue;
26  
27  import java.math.BigInteger;
28  import java.util.ArrayList;
29  import java.util.List;
30  
31  import javax.annotation.Resource;
32  import javax.jws.WebService;
33  import javax.xml.ws.Holder;
34  import javax.xml.ws.WebServiceContext;
35  import javax.xml.ws.soap.MTOM;
36  
37  import org.apache.chemistry.opencmis.commons.data.ExtensionsData;
38  import org.apache.chemistry.opencmis.commons.data.RenditionData;
39  import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
40  import org.apache.chemistry.opencmis.commons.enums.UnfileObject;
41  import org.apache.chemistry.opencmis.commons.enums.VersioningState;
42  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisAccessControlListType;
43  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisAllowableActionsType;
44  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisContentStreamType;
45  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisException;
46  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisExtensionType;
47  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisObjectType;
48  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisPropertiesType;
49  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisRenditionType;
50  import org.apache.chemistry.opencmis.commons.impl.jaxb.DeleteTreeResponse.FailedToDelete;
51  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumIncludeRelationships;
52  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumUnfileObject;
53  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumVersioningState;
54  import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectServicePort;
55  import org.apache.chemistry.opencmis.commons.server.CmisService;
56  
57  import com.sun.xml.ws.developer.StreamingAttachment;
58  
59  /**
60   * CMIS Object Service.
61   */
62  @MTOM
63  @StreamingAttachment(parseEagerly = true, memoryThreshold = 4 * 1024 * 1204)
64  @WebService(endpointInterface = "org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectServicePort")
65  public class ObjectService extends AbstractService implements ObjectServicePort {
66      @Resource
67      public WebServiceContext wsContext;
68  
69      public void createDocument(String repositoryId, CmisPropertiesType properties, String folderId,
70              CmisContentStreamType contentStream, EnumVersioningState versioningState, List<String> policies,
71              CmisAccessControlListType addAces, CmisAccessControlListType removeAces,
72              Holder<CmisExtensionType> extension, Holder<String> objectId) throws CmisException {
73          CmisService service = null;
74          try {
75              service = getService(wsContext, repositoryId);
76  
77              ExtensionsData extData = convertExtensionHolder(extension);
78  
79              String id = service.createDocument(repositoryId, convert(properties), folderId, convert(contentStream),
80                      convert(VersioningState.class, versioningState), policies, convert(addAces, null),
81                      convert(removeAces, null), extData);
82  
83              if (objectId != null) {
84                  objectId.value = id;
85              }
86  
87              setExtensionValues(extData, extension);
88          } catch (Exception e) {
89              throw convertException(e);
90          } finally {
91              closeService(service);
92          }
93      }
94  
95      public void createDocumentFromSource(String repositoryId, String sourceId, CmisPropertiesType properties,
96              String folderId, EnumVersioningState versioningState, List<String> policies,
97              CmisAccessControlListType addAces, CmisAccessControlListType removeAces,
98              Holder<CmisExtensionType> extension, Holder<String> objectId) throws CmisException {
99          CmisService service = null;
100         try {
101             service = getService(wsContext, repositoryId);
102 
103             ExtensionsData extData = convertExtensionHolder(extension);
104 
105             String id = service.createDocumentFromSource(repositoryId, sourceId, convert(properties), folderId,
106                     convert(VersioningState.class, versioningState), policies, convert(addAces, null),
107                     convert(removeAces, null), extData);
108 
109             if (objectId != null) {
110                 objectId.value = id;
111             }
112 
113             setExtensionValues(extData, extension);
114         } catch (Exception e) {
115             throw convertException(e);
116         } finally {
117             closeService(service);
118         }
119     }
120 
121     public void createFolder(String repositoryId, CmisPropertiesType properties, String folderId,
122             List<String> policies, CmisAccessControlListType addAces, CmisAccessControlListType removeAces,
123             Holder<CmisExtensionType> extension, Holder<String> objectId) throws CmisException {
124         CmisService service = null;
125         try {
126             service = getService(wsContext, repositoryId);
127 
128             ExtensionsData extData = convertExtensionHolder(extension);
129 
130             String id = service.createFolder(repositoryId, convert(properties), folderId, policies,
131                     convert(addAces, null), convert(removeAces, null), extData);
132 
133             if (objectId != null) {
134                 objectId.value = id;
135             }
136 
137             setExtensionValues(extData, extension);
138         } catch (Exception e) {
139             throw convertException(e);
140         } finally {
141             closeService(service);
142         }
143     }
144 
145     public void createPolicy(String repositoryId, CmisPropertiesType properties, String folderId,
146             List<String> policies, CmisAccessControlListType addAces, CmisAccessControlListType removeAces,
147             Holder<CmisExtensionType> extension, Holder<String> objectId) throws CmisException {
148         CmisService service = null;
149         try {
150             service = getService(wsContext, repositoryId);
151 
152             ExtensionsData extData = convertExtensionHolder(extension);
153 
154             String id = service.createPolicy(repositoryId, convert(properties), folderId, policies,
155                     convert(addAces, null), convert(removeAces, null), extData);
156 
157             if (objectId != null) {
158                 objectId.value = id;
159             }
160 
161             setExtensionValues(extData, extension);
162         } catch (Exception e) {
163             throw convertException(e);
164         } finally {
165             closeService(service);
166         }
167     }
168 
169     public void createRelationship(String repositoryId, CmisPropertiesType properties, List<String> policies,
170             CmisAccessControlListType addAces, CmisAccessControlListType removeAces,
171             Holder<CmisExtensionType> extension, Holder<String> objectId) throws CmisException {
172         CmisService service = null;
173         try {
174             service = getService(wsContext, repositoryId);
175 
176             ExtensionsData extData = convertExtensionHolder(extension);
177 
178             String id = service.createRelationship(repositoryId, convert(properties), policies, convert(addAces, null),
179                     convert(removeAces, null), extData);
180 
181             if (objectId != null) {
182                 objectId.value = id;
183             }
184 
185             setExtensionValues(extData, extension);
186         } catch (Exception e) {
187             throw convertException(e);
188         } finally {
189             closeService(service);
190         }
191     }
192 
193     public void deleteContentStream(String repositoryId, Holder<String> objectId, Holder<String> changeToken,
194             Holder<CmisExtensionType> extension) throws CmisException {
195         CmisService service = null;
196         try {
197             service = getService(wsContext, repositoryId);
198 
199             org.apache.chemistry.opencmis.commons.spi.Holder<String> objectIdHolder = convertHolder(objectId);
200             org.apache.chemistry.opencmis.commons.spi.Holder<String> changeTokenHolder = convertHolder(changeToken);
201             ExtensionsData extData = convertExtensionHolder(extension);
202 
203             service.deleteContentStream(repositoryId, objectIdHolder, changeTokenHolder, extData);
204 
205             setHolderValue(objectIdHolder, objectId);
206             setHolderValue(changeTokenHolder, changeToken);
207             setExtensionValues(extData, extension);
208         } catch (Exception e) {
209             throw convertException(e);
210         } finally {
211             closeService(service);
212         }
213     }
214 
215     public void deleteObject(String repositoryId, String objectId, Boolean allVersions,
216             Holder<CmisExtensionType> extension) throws CmisException {
217         CmisService service = null;
218         try {
219             service = getService(wsContext, repositoryId);
220 
221             ExtensionsData extData = convertExtensionHolder(extension);
222 
223             service.deleteObjectOrCancelCheckOut(repositoryId, objectId, allVersions, extData);
224 
225             setExtensionValues(extData, extension);
226         } catch (Exception e) {
227             throw convertException(e);
228         } finally {
229             closeService(service);
230         }
231     }
232 
233     public FailedToDelete deleteTree(String repositoryId, String folderId, Boolean allVersions,
234             EnumUnfileObject unfileObjects, Boolean continueOnFailure, CmisExtensionType extension)
235             throws CmisException {
236         CmisService service = null;
237         try {
238             service = getService(wsContext, repositoryId);
239 
240             return convert(service.deleteTree(repositoryId, folderId, allVersions,
241                     convert(UnfileObject.class, unfileObjects), continueOnFailure, convert(extension)));
242         } catch (Exception e) {
243             throw convertException(e);
244         } finally {
245             closeService(service);
246         }
247     }
248 
249     public CmisAllowableActionsType getAllowableActions(String repositoryId, String objectId,
250             CmisExtensionType extension) throws CmisException {
251         CmisService service = null;
252         try {
253             service = getService(wsContext, repositoryId);
254 
255             return convert(service.getAllowableActions(repositoryId, objectId, convert(extension)));
256         } catch (Exception e) {
257             throw convertException(e);
258         } finally {
259             closeService(service);
260         }
261     }
262 
263     public CmisContentStreamType getContentStream(String repositoryId, String objectId, String streamId,
264             BigInteger offset, BigInteger length, CmisExtensionType extension) throws CmisException {
265         CmisService service = null;
266         try {
267             service = getService(wsContext, repositoryId);
268 
269             return convert(service.getContentStream(repositoryId, objectId, streamId, offset, length,
270                     convert(extension)));
271         } catch (Exception e) {
272             throw convertException(e);
273         } finally {
274             closeService(service);
275         }
276     }
277 
278     public CmisObjectType getObject(String repositoryId, String objectId, String filter,
279             Boolean includeAllowableActions, EnumIncludeRelationships includeRelationships, String renditionFilter,
280             Boolean includePolicyIds, Boolean includeAcl, CmisExtensionType extension) throws CmisException {
281         CmisService service = null;
282         try {
283             service = getService(wsContext, repositoryId);
284 
285             return convert(service.getObject(repositoryId, objectId, filter, includeAllowableActions,
286                     convert(IncludeRelationships.class, includeRelationships), renditionFilter, includePolicyIds,
287                     includeAcl, convert(extension)));
288         } catch (Exception e) {
289             throw convertException(e);
290         } finally {
291             closeService(service);
292         }
293     }
294 
295     public CmisObjectType getObjectByPath(String repositoryId, String path, String filter,
296             Boolean includeAllowableActions, EnumIncludeRelationships includeRelationships, String renditionFilter,
297             Boolean includePolicyIds, Boolean includeAcl, CmisExtensionType extension) throws CmisException {
298         CmisService service = null;
299         try {
300             service = getService(wsContext, repositoryId);
301 
302             return convert(service.getObjectByPath(repositoryId, path, filter, includeAllowableActions,
303                     convert(IncludeRelationships.class, includeRelationships), renditionFilter, includePolicyIds,
304                     includeAcl, convert(extension)));
305         } catch (Exception e) {
306             throw convertException(e);
307         } finally {
308             closeService(service);
309         }
310     }
311 
312     public CmisPropertiesType getProperties(String repositoryId, String objectId, String filter,
313             CmisExtensionType extension) throws CmisException {
314         CmisService service = null;
315         try {
316             service = getService(wsContext, repositoryId);
317 
318             return convert(service.getProperties(repositoryId, objectId, filter, convert(extension)));
319         } catch (Exception e) {
320             throw convertException(e);
321         } finally {
322             closeService(service);
323         }
324     }
325 
326     public List<CmisRenditionType> getRenditions(String repositoryId, String objectId, String renditionFilter,
327             BigInteger maxItems, BigInteger skipCount, CmisExtensionType extension) throws CmisException {
328         CmisService service = null;
329         try {
330             service = getService(wsContext, repositoryId);
331 
332             List<CmisRenditionType> result = new ArrayList<CmisRenditionType>();
333 
334             List<RenditionData> renditionList = service.getRenditions(repositoryId, objectId, renditionFilter,
335                     maxItems, skipCount, convert(extension));
336 
337             if (renditionList != null) {
338                 for (RenditionData rendition : renditionList) {
339                     result.add(convert(rendition));
340                 }
341             }
342 
343             return result;
344         } catch (Exception e) {
345             throw convertException(e);
346         } finally {
347             closeService(service);
348         }
349     }
350 
351     public void moveObject(String repositoryId, Holder<String> objectId, String targetFolderId, String sourceFolderId,
352             Holder<CmisExtensionType> extension) throws CmisException {
353         CmisService service = null;
354         try {
355             service = getService(wsContext, repositoryId);
356 
357             org.apache.chemistry.opencmis.commons.spi.Holder<String> objectIdHolder = convertHolder(objectId);
358             ExtensionsData extData = convertExtensionHolder(extension);
359 
360             service.moveObject(repositoryId, objectIdHolder, targetFolderId, sourceFolderId, extData);
361 
362             setHolderValue(objectIdHolder, objectId);
363             setExtensionValues(extData, extension);
364         } catch (Exception e) {
365             throw convertException(e);
366         } finally {
367             closeService(service);
368         }
369     }
370 
371     public void setContentStream(String repositoryId, Holder<String> objectId, Boolean overwriteFlag,
372             Holder<String> changeToken, CmisContentStreamType contentStream, Holder<CmisExtensionType> extension)
373             throws CmisException {
374         CmisService service = null;
375         try {
376             service = getService(wsContext, repositoryId);
377 
378             org.apache.chemistry.opencmis.commons.spi.Holder<String> objectIdHolder = convertHolder(objectId);
379             org.apache.chemistry.opencmis.commons.spi.Holder<String> changeTokenHolder = convertHolder(changeToken);
380             ExtensionsData extData = convertExtensionHolder(extension);
381 
382             service.setContentStream(repositoryId, objectIdHolder, overwriteFlag, changeTokenHolder,
383                     convert(contentStream), extData);
384 
385             setHolderValue(objectIdHolder, objectId);
386             setHolderValue(changeTokenHolder, changeToken);
387             setExtensionValues(extData, extension);
388         } catch (Exception e) {
389             throw convertException(e);
390         } finally {
391             closeService(service);
392         }
393     }
394 
395     public void updateProperties(String repositoryId, Holder<String> objectId, Holder<String> changeToken,
396             CmisPropertiesType properties, Holder<CmisExtensionType> extension) throws CmisException {
397         CmisService service = null;
398         try {
399             service = getService(wsContext, repositoryId);
400 
401             org.apache.chemistry.opencmis.commons.spi.Holder<String> objectIdHolder = convertHolder(objectId);
402             org.apache.chemistry.opencmis.commons.spi.Holder<String> changeTokenHolder = convertHolder(changeToken);
403             ExtensionsData extData = convertExtensionHolder(extension);
404 
405             service.updateProperties(repositoryId, objectIdHolder, changeTokenHolder, convert(properties), extData);
406 
407             setHolderValue(objectIdHolder, objectId);
408             setHolderValue(changeTokenHolder, changeToken);
409             setExtensionValues(extData, extension);
410         } catch (Exception e) {
411             throw convertException(e);
412         } finally {
413             closeService(service);
414         }
415     }
416 }