This project has retired. For details please refer to its Attic page.
ObjectServiceImpl 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.client.bindings.spi.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 org.apache.chemistry.opencmis.client.bindings.spi.BindingSession;
32  import org.apache.chemistry.opencmis.commons.data.Acl;
33  import org.apache.chemistry.opencmis.commons.data.AllowableActions;
34  import org.apache.chemistry.opencmis.commons.data.ContentStream;
35  import org.apache.chemistry.opencmis.commons.data.ExtensionsData;
36  import org.apache.chemistry.opencmis.commons.data.FailedToDeleteData;
37  import org.apache.chemistry.opencmis.commons.data.ObjectData;
38  import org.apache.chemistry.opencmis.commons.data.Properties;
39  import org.apache.chemistry.opencmis.commons.data.RenditionData;
40  import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
41  import org.apache.chemistry.opencmis.commons.enums.UnfileObject;
42  import org.apache.chemistry.opencmis.commons.enums.VersioningState;
43  import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
44  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisException;
45  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisExtensionType;
46  import org.apache.chemistry.opencmis.commons.impl.jaxb.CmisRenditionType;
47  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumIncludeRelationships;
48  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumUnfileObject;
49  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumVersioningState;
50  import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectServicePort;
51  import org.apache.chemistry.opencmis.commons.spi.Holder;
52  import org.apache.chemistry.opencmis.commons.spi.ObjectService;
53  
54  /**
55   * Object Service Web Services client.
56   */
57  public class ObjectServiceImpl extends AbstractWebServicesService implements ObjectService {
58  
59      private final AbstractPortProvider portProvider;
60  
61      /**
62       * Constructor.
63       */
64      public ObjectServiceImpl(BindingSession session, AbstractPortProvider portProvider) {
65          setSession(session);
66          this.portProvider = portProvider;
67      }
68  
69      public String createDocument(String repositoryId, Properties properties, String folderId,
70              ContentStream contentStream, VersioningState versioningState, List<String> policies, Acl addACEs,
71              Acl removeACEs, ExtensionsData extension) {
72          ObjectServicePort port = portProvider.getObjectServicePort();
73  
74          try {
75              javax.xml.ws.Holder<String> objectId = new javax.xml.ws.Holder<String>();
76              javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
77  
78              port.createDocument(repositoryId, convert(properties), folderId, convert(contentStream),
79                      convert(EnumVersioningState.class, versioningState), policies, convert(addACEs),
80                      convert(removeACEs), portExtension, objectId);
81  
82              setExtensionValues(portExtension, extension);
83  
84              return objectId.value;
85          } catch (CmisException e) {
86              throw convertException(e);
87          } catch (Exception e) {
88              throw new CmisRuntimeException("Error: " + e.getMessage(), e);
89          } finally {
90              portProvider.endCall(port);
91          }
92      }
93  
94      public String createDocumentFromSource(String repositoryId, String sourceId, Properties properties,
95              String folderId, VersioningState versioningState, List<String> policies, Acl addACEs, Acl removeACEs,
96              ExtensionsData extension) {
97          ObjectServicePort port = portProvider.getObjectServicePort();
98  
99          try {
100             javax.xml.ws.Holder<String> objectId = new javax.xml.ws.Holder<String>();
101             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
102 
103             port.createDocumentFromSource(repositoryId, sourceId, convert(properties), folderId,
104                     convert(EnumVersioningState.class, versioningState), policies, convert(addACEs),
105                     convert(removeACEs), portExtension, objectId);
106 
107             setExtensionValues(portExtension, extension);
108 
109             return objectId.value;
110         } catch (CmisException e) {
111             throw convertException(e);
112         } catch (Exception e) {
113             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
114         } finally {
115             portProvider.endCall(port);
116         }
117     }
118 
119     public String createFolder(String repositoryId, Properties properties, String folderId, List<String> policies,
120             Acl addACEs, Acl removeACEs, ExtensionsData extension) {
121         ObjectServicePort port = portProvider.getObjectServicePort();
122 
123         try {
124             javax.xml.ws.Holder<String> objectId = new javax.xml.ws.Holder<String>();
125             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
126 
127             port.createFolder(repositoryId, convert(properties), folderId, policies, convert(addACEs),
128                     convert(removeACEs), portExtension, objectId);
129 
130             setExtensionValues(portExtension, extension);
131 
132             return objectId.value;
133         } catch (CmisException e) {
134             throw convertException(e);
135         } catch (Exception e) {
136             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
137         } finally {
138             portProvider.endCall(port);
139         }
140     }
141 
142     public String createPolicy(String repositoryId, Properties properties, String folderId, List<String> policies,
143             Acl addACEs, Acl removeACEs, ExtensionsData extension) {
144         ObjectServicePort port = portProvider.getObjectServicePort();
145 
146         try {
147             javax.xml.ws.Holder<String> objectId = new javax.xml.ws.Holder<String>();
148             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
149 
150             port.createPolicy(repositoryId, convert(properties), folderId, policies, convert(addACEs),
151                     convert(removeACEs), portExtension, objectId);
152 
153             setExtensionValues(portExtension, extension);
154 
155             return objectId.value;
156         } catch (CmisException e) {
157             throw convertException(e);
158         } catch (Exception e) {
159             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
160         } finally {
161             portProvider.endCall(port);
162         }
163     }
164 
165     public String createRelationship(String repositoryId, Properties properties, List<String> policies, Acl addACEs,
166             Acl removeACEs, ExtensionsData extension) {
167         ObjectServicePort port = portProvider.getObjectServicePort();
168 
169         try {
170             javax.xml.ws.Holder<String> objectId = new javax.xml.ws.Holder<String>();
171             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
172 
173             port.createRelationship(repositoryId, convert(properties), policies, convert(addACEs), convert(removeACEs),
174                     portExtension, objectId);
175 
176             setExtensionValues(portExtension, extension);
177 
178             return objectId.value;
179         } catch (CmisException e) {
180             throw convertException(e);
181         } catch (Exception e) {
182             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
183         } finally {
184             portProvider.endCall(port);
185         }
186     }
187 
188     public void updateProperties(String repositoryId, Holder<String> objectId, Holder<String> changeToken,
189             Properties properties, ExtensionsData extension) {
190         ObjectServicePort port = portProvider.getObjectServicePort();
191 
192         try {
193             javax.xml.ws.Holder<String> portObjectId = convertHolder(objectId);
194             javax.xml.ws.Holder<String> portChangeToken = convertHolder(changeToken);
195             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
196 
197             port.updateProperties(repositoryId, portObjectId, portChangeToken, convert(properties), portExtension);
198 
199             setHolderValue(portObjectId, objectId);
200             setHolderValue(portChangeToken, changeToken);
201             setExtensionValues(portExtension, extension);
202         } catch (CmisException e) {
203             throw convertException(e);
204         } catch (Exception e) {
205             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
206         } finally {
207             portProvider.endCall(port);
208         }
209     }
210 
211     public void deleteObject(String repositoryId, String objectId, Boolean allVersions, ExtensionsData extension) {
212         ObjectServicePort port = portProvider.getObjectServicePort();
213 
214         try {
215             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
216 
217             port.deleteObject(repositoryId, objectId, allVersions, portExtension);
218 
219             setExtensionValues(portExtension, extension);
220         } catch (CmisException e) {
221             throw convertException(e);
222         } catch (Exception e) {
223             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
224         } finally {
225             portProvider.endCall(port);
226         }
227     }
228 
229     public FailedToDeleteData deleteTree(String repositoryId, String folderId, Boolean allVersions,
230             UnfileObject unfileObjects, Boolean continueOnFailure, ExtensionsData extension) {
231         ObjectServicePort port = portProvider.getObjectServicePort();
232 
233         try {
234             return convert(port.deleteTree(repositoryId, folderId, allVersions,
235                     convert(EnumUnfileObject.class, unfileObjects), continueOnFailure, convert(extension)));
236         } catch (CmisException e) {
237             throw convertException(e);
238         } catch (Exception e) {
239             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
240         } finally {
241             portProvider.endCall(port);
242         }
243     }
244 
245     public AllowableActions getAllowableActions(String repositoryId, String objectId, ExtensionsData extension) {
246         ObjectServicePort port = portProvider.getObjectServicePort();
247 
248         try {
249             return convert(port.getAllowableActions(repositoryId, objectId, convert(extension)));
250         } catch (CmisException e) {
251             throw convertException(e);
252         } catch (Exception e) {
253             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
254         } finally {
255             portProvider.endCall(port);
256         }
257     }
258 
259     public ContentStream getContentStream(String repositoryId, String objectId, String streamId, BigInteger offset,
260             BigInteger length, ExtensionsData extension) {
261         ObjectServicePort port = portProvider.getObjectServicePort();
262 
263         try {
264             return convert(port.getContentStream(repositoryId, objectId, streamId, offset, length, convert(extension)));
265         } catch (CmisException e) {
266             throw convertException(e);
267         } catch (Exception e) {
268             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
269         } finally {
270             portProvider.endCall(port);
271         }
272     }
273 
274     public ObjectData getObject(String repositoryId, String objectId, String filter, Boolean includeAllowableActions,
275             IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds,
276             Boolean includeACL, ExtensionsData extension) {
277         ObjectServicePort port = portProvider.getObjectServicePort();
278 
279         try {
280             return convert(port.getObject(repositoryId, objectId, filter, includeAllowableActions,
281                     convert(EnumIncludeRelationships.class, includeRelationships), renditionFilter, includePolicyIds,
282                     includeACL, convert(extension)));
283         } catch (CmisException e) {
284             throw convertException(e);
285         } catch (Exception e) {
286             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
287         } finally {
288             portProvider.endCall(port);
289         }
290     }
291 
292     public ObjectData getObjectByPath(String repositoryId, String path, String filter, Boolean includeAllowableActions,
293             IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds,
294             Boolean includeACL, ExtensionsData extension) {
295         ObjectServicePort port = portProvider.getObjectServicePort();
296 
297         try {
298             return convert(port.getObjectByPath(repositoryId, path, filter, includeAllowableActions,
299                     convert(EnumIncludeRelationships.class, includeRelationships), renditionFilter, includePolicyIds,
300                     includeACL, convert(extension)));
301         } catch (CmisException e) {
302             throw convertException(e);
303         } catch (Exception e) {
304             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
305         } finally {
306             portProvider.endCall(port);
307         }
308     }
309 
310     public Properties getProperties(String repositoryId, String objectId, String filter, ExtensionsData extension) {
311         ObjectServicePort port = portProvider.getObjectServicePort();
312 
313         try {
314             return convert(port.getProperties(repositoryId, objectId, filter, convert(extension)));
315         } catch (CmisException e) {
316             throw convertException(e);
317         } catch (Exception e) {
318             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
319         } finally {
320             portProvider.endCall(port);
321         }
322     }
323 
324     public List<RenditionData> getRenditions(String repositoryId, String objectId, String renditionFilter,
325             BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) {
326         ObjectServicePort port = portProvider.getObjectServicePort();
327 
328         try {
329             List<CmisRenditionType> renditionList = port.getRenditions(repositoryId, objectId, renditionFilter,
330                     maxItems, skipCount, convert(extension));
331 
332             // no list?
333             if (renditionList == null) {
334                 return null;
335             }
336 
337             // convert list
338             List<RenditionData> result = new ArrayList<RenditionData>();
339             for (CmisRenditionType rendition : renditionList) {
340                 result.add(convert(rendition));
341             }
342 
343             return result;
344         } catch (CmisException e) {
345             throw convertException(e);
346         } catch (Exception e) {
347             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
348         } finally {
349             portProvider.endCall(port);
350         }
351     }
352 
353     public void moveObject(String repositoryId, Holder<String> objectId, String targetFolderId, String sourceFolderId,
354             ExtensionsData extension) {
355         ObjectServicePort port = portProvider.getObjectServicePort();
356 
357         try {
358             javax.xml.ws.Holder<String> portObjectId = convertHolder(objectId);
359             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
360 
361             port.moveObject(repositoryId, portObjectId, targetFolderId, sourceFolderId, portExtension);
362 
363             setHolderValue(portObjectId, objectId);
364             setExtensionValues(portExtension, extension);
365         } catch (CmisException e) {
366             throw convertException(e);
367         } catch (Exception e) {
368             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
369         } finally {
370             portProvider.endCall(port);
371         }
372     }
373 
374     public void setContentStream(String repositoryId, Holder<String> objectId, Boolean overwriteFlag,
375             Holder<String> changeToken, ContentStream contentStream, ExtensionsData extension) {
376         ObjectServicePort port = portProvider.getObjectServicePort();
377 
378         try {
379             javax.xml.ws.Holder<String> portObjectId = convertHolder(objectId);
380             javax.xml.ws.Holder<String> portChangeToken = convertHolder(changeToken);
381             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
382 
383             port.setContentStream(repositoryId, portObjectId, overwriteFlag, portChangeToken, convert(contentStream),
384                     portExtension);
385 
386             setHolderValue(portObjectId, objectId);
387             setHolderValue(portChangeToken, changeToken);
388             setExtensionValues(portExtension, extension);
389         } catch (CmisException e) {
390             throw convertException(e);
391         } catch (Exception e) {
392             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
393         } finally {
394             portProvider.endCall(port);
395         }
396     }
397 
398     public void deleteContentStream(String repositoryId, Holder<String> objectId, Holder<String> changeToken,
399             ExtensionsData extension) {
400         ObjectServicePort port = portProvider.getObjectServicePort();
401 
402         try {
403             javax.xml.ws.Holder<String> portObjectId = convertHolder(objectId);
404             javax.xml.ws.Holder<String> portChangeToken = convertHolder(changeToken);
405             javax.xml.ws.Holder<CmisExtensionType> portExtension = convertExtensionHolder(extension);
406 
407             port.deleteContentStream(repositoryId, portObjectId, portChangeToken, portExtension);
408 
409             setHolderValue(portObjectId, objectId);
410             setHolderValue(portChangeToken, changeToken);
411             setExtensionValues(portExtension, extension);
412         } catch (CmisException e) {
413             throw convertException(e);
414         } catch (Exception e) {
415             throw new CmisRuntimeException("Error: " + e.getMessage(), e);
416         } finally {
417             portProvider.endCall(port);
418         }
419     }
420 }