git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**
   2  *  This document is a part of the source code and related artifacts
   3  *  for CollectionSpace, an open source collections management system
   4  *  for museums and related institutions:
   5
   6  *  http://www.collectionspace.org
   7  *  http://wiki.collectionspace.org
   8
   9  *  Copyright 2009 University of California at Berkeley
  10
  11  *  Licensed under the Educational Community License (ECL), Version 2.0.
  12  *  You may not use this file except in compliance with this License.
  13
  14  *  You may obtain a copy of the ECL 2.0 License at
  15
  16  *  https://source.collectionspace.org/collection-space/LICENSE.txt
  17  */
  18 package org.collectionspace.services.nuxeo.client.java;
  19
  20 import java.util.UUID;
  21 import java.util.List;
  22
  23 import org.collectionspace.services.common.context.ServiceContext;
  24 import org.collectionspace.services.common.document.BadRequestException;
  25 import org.collectionspace.services.common.document.DocumentException;
  26 import org.collectionspace.services.common.document.DocumentFilter;
  27 import org.collectionspace.services.common.document.DocumentHandler;
  28 import org.collectionspace.services.common.document.DocumentNotFoundException;
  29 import org.collectionspace.services.common.repository.RepositoryClient;
  30 import org.collectionspace.services.common.document.DocumentHandler.Action;
  31 import org.collectionspace.services.common.document.DocumentWrapper;
  32 import org.collectionspace.services.common.document.DocumentWrapperImpl;
  33 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  34 import org.nuxeo.common.utils.IdUtils;
  35 import org.nuxeo.ecm.core.api.ClientException;
  36 import org.nuxeo.ecm.core.api.DocumentModel;
  37 import org.nuxeo.ecm.core.api.DocumentModelList;
  38 import org.nuxeo.ecm.core.api.impl.DocumentModelListImpl;
  39 import org.nuxeo.ecm.core.api.DocumentRef;
  40 import org.nuxeo.ecm.core.api.IdRef;
  41 import org.nuxeo.ecm.core.api.PathRef;
  42 import org.nuxeo.ecm.core.api.repository.RepositoryInstance;
  43 import org.nuxeo.ecm.core.client.NuxeoClient;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 /**
  48  * RepositoryJavaClient is used to perform CRUD operations on documents in Nuxeo
  49  * repository using Remote Java APIs. It uses @see DocumentHandler as IOHandler
  50  * with the client.
  51  *
  52  * $LastChangedRevision: $ $LastChangedDate: $
  53  */
  54 public class RepositoryJavaClientImpl implements RepositoryClient {
  55
  56     private final Logger logger = LoggerFactory.getLogger(RepositoryJavaClientImpl.class);
  57
  58     public RepositoryJavaClientImpl() {
  59     }
  60
  61     /**
  62      * create document in the Nuxeo repository
  63      *
  64      * @param ctx service context under which this method is invoked
  65      * @param docType
  66      *            of the document created
  67      * @param handler
  68      *            should be used by the caller to provide and transform the
  69      *            document
  70      * @return id in repository of the newly created document
  71      * @throws DocumentException
  72      */
  73     @Override
  74     public String create(ServiceContext ctx,
  75             DocumentHandler handler) throws BadRequestException,
  76             DocumentException {
  77
  78         if (ctx.getDocumentType() == null) {
  79             throw new IllegalArgumentException(
  80                     "RepositoryJavaClient.create: docType is missing");
  81         }
  82         if (handler == null) {
  83             throw new IllegalArgumentException(
  84                     "RepositoryJavaClient.create: handler is missing");
  85         }
  86         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
  87         if (nuxeoWspaceId == null) {
  88             throw new DocumentNotFoundException(
  89                     "Unable to find workspace for service " + ctx.getServiceName()
  90                     + " check if the workspace exists in the Nuxeo repository");
  91         }
  92         RepositoryInstance repoSession = null;
  93         try {
  94             handler.prepare(Action.CREATE);
  95             repoSession = getRepositorySession();
  96             DocumentRef nuxeoWspace = new IdRef(nuxeoWspaceId);
  97             DocumentModel wspaceDoc = repoSession.getDocument(nuxeoWspace);
  98             String wspacePath = wspaceDoc.getPathAsString();
  99             //give our own ID so PathRef could be constructed later on
 100             String id = IdUtils.generateId(UUID.randomUUID().toString());
 101             // create document model
 102             DocumentModel doc = repoSession.createDocumentModel(wspacePath, id,
 103                     ctx.getDocumentType());
 104             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 105             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 106             handler.handle(Action.CREATE, wrapDoc);
 107             // create document with documentmodel
 108             doc = repoSession.createDocument(doc);
 109             repoSession.save();
 110             handler.complete(Action.CREATE, wrapDoc);
 111             return id;
 112         } catch (BadRequestException bre) {
 113             throw bre;
 114         } catch (Exception e) {
 115             if (logger.isDebugEnabled()) {
 116                 logger.debug("Caught exception ", e);
 117             }
 118             throw new DocumentException(e);
 119         } finally {
 120             if (repoSession != null) {
 121                 releaseRepositorySession(repoSession);
 122             }
 123         }
 124
 125     }
 126
 127     /**
 128      * get document from the Nuxeo repository
 129      * @param ctx service context under which this method is invoked
 130      * @param id
 131      *            of the document to retrieve
 132      * @param handler
 133      *            should be used by the caller to provide and transform the
 134      *            document
 135      * @throws DocumentException
 136      */
 137     @Override
 138     public void get(ServiceContext ctx, String id, DocumentHandler handler)
 139             throws DocumentNotFoundException, DocumentException {
 140
 141         if (handler == null) {
 142             throw new IllegalArgumentException(
 143                     "RepositoryJavaClient.get: handler is missing");
 144         }
 145         RepositoryInstance repoSession = null;
 146
 147         try {
 148             handler.prepare(Action.GET);
 149             repoSession = getRepositorySession();
 150             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 151             DocumentModel doc = null;
 152             try {
 153                 doc = repoSession.getDocument(docRef);
 154             } catch (ClientException ce) {
 155                 String msg = "could not find document with id=" + id;
 156                 logger.error(msg, ce);
 157                 throw new DocumentNotFoundException(msg, ce);
 158             }
 159             //set reposession to handle the document
 160             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 161             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 162             handler.handle(Action.GET, wrapDoc);
 163             handler.complete(Action.GET, wrapDoc);
 164         } catch (IllegalArgumentException iae) {
 165             throw iae;
 166         } catch (DocumentException de) {
 167             throw de;
 168         } catch (Exception e) {
 169             if (logger.isDebugEnabled()) {
 170                 logger.debug("Caught exception ", e);
 171             }
 172             throw new DocumentException(e);
 173         } finally {
 174             if (repoSession != null) {
 175                 releaseRepositorySession(repoSession);
 176             }
 177         }
 178     }
 179
 180     /**
 181      * get document from the Nuxeo repository, using the docFilter params.
 182      * @param ctx service context under which this method is invoked
 183      * @param handler
 184      *            should be used by the caller to provide and transform the
 185      *            document. Handler must have a docFilter set to return a single item.
 186      * @throws DocumentException
 187      */
 188     @Override
 189     public void get(ServiceContext ctx, DocumentHandler handler)
 190             throws DocumentNotFoundException, DocumentException {
 191
 192         if (handler == null) {
 193             throw new IllegalArgumentException(
 194                     "RepositoryJavaClient.get: handler is missing");
 195         }
 196         DocumentFilter docFilter = handler.getDocumentFilter();
 197         if (docFilter == null) {
 198             throw new IllegalArgumentException(
 199                    "RepositoryJavaClient.get: handler has no Filter specified");
 200         }
 201         if(docFilter.getPageSize()!= 1) {
 202             logger.warn("RepositoryJavaClient.get: forcing docFilter pagesize to 1.");
 203         }
 204         String docType = ctx.getDocumentType();
 205         if (docType == null) {
 206             throw new DocumentNotFoundException(
 207                    "Unable to find DocumentType for service " + ctx.getServiceName());
 208         }
 209         String domain = ctx.getRepositoryDomainName();
 210         if (domain == null) {
 211             throw new DocumentNotFoundException(
 212                     "Unable to find Domain for service " + ctx.getServiceName());
 213         }
 214         RepositoryInstance repoSession = null;
 215
 216         try {
 217             handler.prepare(Action.GET);
 218             repoSession = getRepositorySession();
 219
 220             DocumentModelList docList = null;
 221             // force limit to 1, and ignore totalSize
 222             String query = buildNXQLQuery(docType, docFilter.getWhereClause(), domain );
 223             docList = repoSession.query( query, null, 1, 0, false);
 224             if(docList.size()!=1) {
 225                 throw new DocumentNotFoundException("No document found matching filter params.");
 226             }
 227             DocumentModel doc = docList.get(0);
 228
 229             if (logger.isDebugEnabled()) {
 230                 logger.debug("Executed NXQL query: " + query);
 231             }
 232
 233             //set reposession to handle the document
 234             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 235             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 236             handler.handle(Action.GET, wrapDoc);
 237             handler.complete(Action.GET, wrapDoc);
 238         } catch (IllegalArgumentException iae) {
 239             throw iae;
 240         } catch (DocumentException de) {
 241             throw de;
 242         } catch (Exception e) {
 243             if (logger.isDebugEnabled()) {
 244                 logger.debug("Caught exception ", e);
 245             }
 246             throw new DocumentException(e);
 247         } finally {
 248             if (repoSession != null) {
 249                 releaseRepositorySession(repoSession);
 250             }
 251         }
 252     }
 253
 254     /**
 255      * get wrapped documentModel from the Nuxeo repository
 256      * @param ctx service context under which this method is invoked
 257      * @param id
 258      *            of the document to retrieve
 259      * @throws DocumentException
 260      */
 261     @Override
 262     public DocumentWrapper<DocumentModel> getDoc(
 263                 ServiceContext ctx, String id)
 264             throws DocumentNotFoundException, DocumentException {
 265         RepositoryInstance repoSession = null;
 266         DocumentWrapper<DocumentModel> wrapDoc = null;
 267
 268         try {
 269             repoSession = getRepositorySession();
 270             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 271             DocumentModel doc = null;
 272             try {
 273                 doc = repoSession.getDocument(docRef);
 274             } catch (ClientException ce) {
 275                 String msg = "could not find document with id=" + id;
 276                 logger.error(msg, ce);
 277                 throw new DocumentNotFoundException(msg, ce);
 278             }
 279             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 280         } catch (IllegalArgumentException iae) {
 281             throw iae;
 282         } catch (DocumentException de) {
 283             throw de;
 284         } catch (Exception e) {
 285             if (logger.isDebugEnabled()) {
 286                 logger.debug("Caught exception ", e);
 287             }
 288             throw new DocumentException(e);
 289         } finally {
 290             if (repoSession != null) {
 291                 releaseRepositorySession(repoSession);
 292             }
 293         }
 294         return wrapDoc;
 295     }
 296
 297     /**
 298      * find wrapped documentModel from the Nuxeo repository
 299      * @param ctx service context under which this method is invoked
 300      * @param where NXQL where clause to get the document
 301      * @throws DocumentException
 302      */
 303     @Override
 304     public DocumentWrapper<DocumentModel> findDoc(
 305                 ServiceContext ctx, String where)
 306             throws DocumentNotFoundException, DocumentException {
 307         RepositoryInstance repoSession = null;
 308         DocumentWrapper<DocumentModel> wrapDoc = null;
 309
 310         try {
 311                 String docType = ctx.getDocumentType();
 312             if (docType == null) {
 313                 throw new DocumentNotFoundException(
 314                        "Unable to find DocumentType for service " + ctx.getServiceName());
 315             }
 316             String domain = ctx.getRepositoryDomainName();
 317             if (domain == null) {
 318                 throw new DocumentNotFoundException(
 319                         "Unable to find Domain for service " + ctx.getServiceName());
 320             }
 321             repoSession = getRepositorySession();
 322             DocumentModelList docList = null;
 323             // force limit to 1, and ignore totalSize
 324             String query = buildNXQLQuery(docType, where, domain );
 325             docList = repoSession.query( query, null, 1, 0, false);
 326             if(docList.size()!=1) {
 327                 if (logger.isDebugEnabled()) {
 328                     logger.debug("findDoc: Query found: "+docList.size()+" items.");
 329                     logger.debug(" Query: " + query);
 330                 }
 331                 throw new DocumentNotFoundException("No document found matching filter params.");
 332             }
 333             DocumentModel doc = docList.get(0);
 334             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 335         } catch (IllegalArgumentException iae) {
 336             throw iae;
 337         } catch (DocumentException de) {
 338             throw de;
 339         } catch (Exception e) {
 340             if (logger.isDebugEnabled()) {
 341                 logger.debug("Caught exception ", e);
 342             }
 343             throw new DocumentException(e);
 344         } finally {
 345             if (repoSession != null) {
 346                 releaseRepositorySession(repoSession);
 347             }
 348         }
 349         return wrapDoc;
 350     }
 351
 352     /**
 353      * find doc and return CSID from the Nuxeo repository
 354      * @param ctx service context under which this method is invoked
 355      * @param where NXQL where clause to get the document
 356      * @throws DocumentException
 357      */
 358     public String findDocCSID(
 359                 ServiceContext ctx, String where)
 360             throws DocumentNotFoundException, DocumentException {
 361         String csid = null;
 362         try {
 363                 DocumentWrapper<DocumentModel> wrapDoc = findDoc(ctx, where);
 364                 DocumentModel docModel = wrapDoc.getWrappedObject();
 365             csid = NuxeoUtils.extractId(docModel.getPathAsString());
 366                 } catch (DocumentNotFoundException dnfe) {
 367             throw dnfe;
 368         } catch (IllegalArgumentException iae) {
 369             throw iae;
 370         } catch (DocumentException de) {
 371             throw de;
 372                 } catch (Exception e) {
 373             if (logger.isDebugEnabled()) {
 374                 logger.debug("Caught exception ", e);
 375             }
 376             throw new DocumentException(e);
 377         }
 378                 return csid;
 379     }
 380
 381     /**
 382      * Find a list of documentModels from the Nuxeo repository
 383      * @param docTypes a list of DocType names to match
 384      * @param where the clause to qualify on
 385      * @param domain the domain for the associated services
 386      * @return
 387      */
 388     @Override
 389     public DocumentWrapper<DocumentModelList> findDocs(
 390                 List<String> docTypes, String where, String domain,
 391                 int pageSize, int pageNum, boolean computeTotal )
 392             throws DocumentNotFoundException, DocumentException {
 393         RepositoryInstance repoSession = null;
 394         DocumentWrapper<DocumentModelList> wrapDoc = null;
 395
 396         try {
 397             if (docTypes == null || docTypes.size()<1) {
 398                 throw new DocumentNotFoundException(
 399                        "findDocs must specify at least one DocumentType.");
 400             }
 401             if (domain == null) {
 402                 throw new DocumentNotFoundException("findDocs must specify Domain.");
 403             }
 404             repoSession = getRepositorySession();
 405             DocumentModelList docList = null;
 406             // force limit to 1, and ignore totalSize
 407             String query = buildNXQLQuery(docTypes, where, domain );
 408             docList = repoSession.query( query, null, pageSize, pageNum, computeTotal);
 409             wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 410         } catch (IllegalArgumentException iae) {
 411             throw iae;
 412         } catch (DocumentException de) {
 413             throw de;
 414         } catch (Exception e) {
 415             if (logger.isDebugEnabled()) {
 416                 logger.debug("Caught exception ", e);
 417             }
 418             throw new DocumentException(e);
 419         } finally {
 420             if (repoSession != null) {
 421                 releaseRepositorySession(repoSession);
 422             }
 423         }
 424         return wrapDoc;
 425     }
 426
 427
 428     @Override
 429     public void get(ServiceContext ctx, List<String> csidList, DocumentHandler handler)
 430                 throws DocumentNotFoundException, DocumentException {
 431         if (handler == null) {
 432             throw new IllegalArgumentException(
 433                     "RepositoryJavaClient.getAll: handler is missing");
 434         }
 435
 436         RepositoryInstance repoSession = null;
 437
 438         try {
 439             handler.prepare(Action.GET_ALL);
 440             repoSession = getRepositorySession();
 441             DocumentModelList docModelList = new DocumentModelListImpl();
 442             //FIXME: Should be using NuxeoUtils.createPathRef for security reasons
 443             for (String csid : csidList) {
 444                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 445                 DocumentModel docModel = repoSession.getDocument(docRef);
 446                 docModelList.add(docModel);
 447             }
 448
 449             //set reposession to handle the document
 450             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 451             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docModelList);
 452             handler.handle(Action.GET_ALL, wrapDoc);
 453             handler.complete(Action.GET_ALL, wrapDoc);
 454         } catch (DocumentException de) {
 455             throw de;
 456         } catch (Exception e) {
 457             if (logger.isDebugEnabled()) {
 458                 logger.debug("Caught exception ", e);
 459             }
 460             throw new DocumentException(e);
 461         } finally {
 462             if (repoSession != null) {
 463                 releaseRepositorySession(repoSession);
 464             }
 465         }
 466     }
 467
 468     /**
 469      * getAll get all documents for an entity entity service from the Nuxeo
 470      * repository
 471      *
 472      * @param ctx service context under which this method is invoked
 473      * @param handler
 474      *            should be used by the caller to provide and transform the
 475      *            document
 476      * @throws DocumentException
 477      */
 478     @Override
 479     public void getAll(ServiceContext ctx, DocumentHandler handler)
 480             throws DocumentNotFoundException, DocumentException {
 481         if (handler == null) {
 482             throw new IllegalArgumentException(
 483                     "RepositoryJavaClient.getAll: handler is missing");
 484         }
 485         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 486         if (nuxeoWspaceId == null) {
 487             throw new DocumentNotFoundException(
 488                     "Unable to find workspace for service "
 489                     + ctx.getServiceName()
 490                     + " check if the workspace exists in the Nuxeo repository");
 491         }
 492         RepositoryInstance repoSession = null;
 493
 494         try {
 495             handler.prepare(Action.GET_ALL);
 496             repoSession = getRepositorySession();
 497             DocumentRef wsDocRef = new IdRef(nuxeoWspaceId);
 498             DocumentModelList docList = repoSession.getChildren(wsDocRef);
 499             //set reposession to handle the document
 500             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 501             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 502             handler.handle(Action.GET_ALL, wrapDoc);
 503             handler.complete(Action.GET_ALL, wrapDoc);
 504         } catch (DocumentException de) {
 505             throw de;
 506         } catch (Exception e) {
 507             if (logger.isDebugEnabled()) {
 508                 logger.debug("Caught exception ", e);
 509             }
 510             throw new DocumentException(e);
 511         } finally {
 512             if (repoSession != null) {
 513                 releaseRepositorySession(repoSession);
 514             }
 515         }
 516     }
 517
 518     /**
 519      * getFiltered get all documents for an entity service from the Document repository,
 520      * given filter parameters specified by the handler.
 521      * @param ctx service context under which this method is invoked
 522      * @param handler should be used by the caller to provide and transform the document
 523      * @throws DocumentNotFoundException if workspace not found
 524      * @throws DocumentException
 525      */
 526     public void getFiltered(ServiceContext ctx, DocumentHandler handler)
 527             throws DocumentNotFoundException, DocumentException {
 528         if (handler == null) {
 529             throw new IllegalArgumentException(
 530                     "RepositoryJavaClient.getFiltered: handler is missing");
 531         }
 532         DocumentFilter docFilter = handler.getDocumentFilter();
 533         if (docFilter == null) {
 534             throw new IllegalArgumentException(
 535                     "RepositoryJavaClient.getFiltered: handler has no Filter specified");
 536         }
 537         String docType = ctx.getDocumentType();
 538         if (docType == null) {
 539             throw new DocumentNotFoundException(
 540                     "Unable to find DocumentType for service " + ctx.getServiceName());
 541         }
 542         String domain = ctx.getRepositoryDomainName();
 543         if (domain == null) {
 544             throw new DocumentNotFoundException(
 545                     "Unable to find Domain for service " + ctx.getServiceName());
 546         }
 547         RepositoryInstance repoSession = null;
 548         try {
 549             handler.prepare(Action.GET_ALL);
 550             repoSession = getRepositorySession();
 551             DocumentModelList docList = null;
 552             String query = buildNXQLQuery(docType, docFilter.getWhereClause(), domain );
 553
 554             // If we have limit and/or offset, then pass true to get totalSize
 555             // in returned DocumentModelList.
 556             if ((docFilter.getOffset() > 0) || (docFilter.getPageSize() > 0)) {
 557                 docList = repoSession.query(query, null,
 558                         docFilter.getPageSize(), docFilter.getOffset(), true);
 559             } else {
 560                 docList = repoSession.query(query);
 561             }
 562
 563             if (logger.isDebugEnabled()) {
 564                 logger.debug("Executed NXQL query: " + query.toString());
 565             }
 566
 567             //set repoSession to handle the document
 568             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 569             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 570             handler.handle(Action.GET_ALL, wrapDoc);
 571             handler.complete(Action.GET_ALL, wrapDoc);
 572         } catch (DocumentException de) {
 573             throw de;
 574         } catch (Exception e) {
 575             if (logger.isDebugEnabled()) {
 576                 logger.debug("Caught exception ", e);
 577             }
 578             throw new DocumentException(e);
 579         } finally {
 580             if (repoSession != null) {
 581                 releaseRepositorySession(repoSession);
 582             }
 583         }
 584     }
 585
 586     /**
 587      * update given document in the Nuxeo repository
 588      *
 589      * @param ctx service context under which this method is invoked
 590      * @param id
 591      *            of the document
 592      * @param handler
 593      *            should be used by the caller to provide and transform the
 594      *            document
 595      * @throws DocumentException
 596      */
 597     @Override
 598     public void update(ServiceContext ctx, String id, DocumentHandler handler)
 599             throws BadRequestException, DocumentNotFoundException,
 600             DocumentException {
 601         if (handler == null) {
 602             throw new IllegalArgumentException(
 603                     "RepositoryJavaClient.update: handler is missing");
 604         }
 605         RepositoryInstance repoSession = null;
 606         try {
 607             handler.prepare(Action.UPDATE);
 608             repoSession = getRepositorySession();
 609             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 610             DocumentModel doc = null;
 611             try {
 612                 doc = repoSession.getDocument(docRef);
 613             } catch (ClientException ce) {
 614                 String msg = "Could not find document to update with id=" + id;
 615                 logger.error(msg, ce);
 616                 throw new DocumentNotFoundException(msg, ce);
 617             }
 618             //set reposession to handle the document
 619             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 620             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 621             handler.handle(Action.UPDATE, wrapDoc);
 622             repoSession.saveDocument(doc);
 623             repoSession.save();
 624             handler.complete(Action.UPDATE, wrapDoc);
 625         } catch (BadRequestException bre) {
 626             throw bre;
 627         } catch (DocumentException de) {
 628             throw de;
 629         } catch (Exception e) {
 630             if (logger.isDebugEnabled()) {
 631                 logger.debug("Caught exception ", e);
 632             }
 633             throw new DocumentException(e);
 634         } finally {
 635             if (repoSession != null) {
 636                 releaseRepositorySession(repoSession);
 637             }
 638         }
 639     }
 640
 641     /**
 642      * delete a document from the Nuxeo repository
 643      * @param ctx service context under which this method is invoked
 644      * @param id
 645      *            of the document
 646      * @throws DocumentException
 647      */
 648     @Override
 649     public void delete(ServiceContext ctx, String id) throws DocumentNotFoundException,
 650             DocumentException {
 651
 652         if (logger.isDebugEnabled()) {
 653             logger.debug("deleting document with id=" + id);
 654         }
 655         RepositoryInstance repoSession = null;
 656         try {
 657             repoSession = getRepositorySession();
 658             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 659             try {
 660                 repoSession.removeDocument(docRef);
 661             } catch (ClientException ce) {
 662                 String msg = "could not find document to delete with id=" + id;
 663                 logger.error(msg, ce);
 664                 throw new DocumentNotFoundException(msg, ce);
 665             }
 666             repoSession.save();
 667         } catch (DocumentException de) {
 668             throw de;
 669         } catch (Exception e) {
 670             if (logger.isDebugEnabled()) {
 671                 logger.debug("Caught exception ", e);
 672             }
 673             throw new DocumentException(e);
 674         } finally {
 675             if (repoSession != null) {
 676                 releaseRepositorySession(repoSession);
 677             }
 678         }
 679     }
 680
 681     @Override
 682     public String createWorkspace(String tenantDomain, String workspaceName) throws Exception {
 683         RepositoryInstance repoSession = null;
 684         String workspaceId = null;
 685         try {
 686             repoSession = getRepositorySession();
 687             DocumentRef docRef = new PathRef(
 688                     "/" + tenantDomain
 689                     + "/" + "workspaces");
 690             DocumentModel parent = repoSession.getDocument(docRef);
 691             DocumentModel doc = repoSession.createDocumentModel(parent.getPathAsString(),
 692                     workspaceName, "Workspace");
 693             doc.setPropertyValue("dc:title", workspaceName);
 694             doc.setPropertyValue("dc:description", "A CollectionSpace workspace for "
 695                     + workspaceName);
 696             doc = repoSession.createDocument(doc);
 697             workspaceId = doc.getId();
 698             repoSession.save();
 699             if (logger.isDebugEnabled()) {
 700                 logger.debug("created workspace name=" + workspaceName
 701                         + " id=" + workspaceId);
 702             }
 703         } catch (Exception e) {
 704             if (logger.isDebugEnabled()) {
 705                 logger.debug("createWorkspace caught exception ", e);
 706             }
 707             throw e;
 708         } finally {
 709             if (repoSession != null) {
 710                 releaseRepositorySession(repoSession);
 711             }
 712         }
 713         return workspaceId;
 714     }
 715
 716     @Override
 717     public String getWorkspaceId(String tenantDomain, String workspaceName) throws Exception {
 718         String workspaceId = null;
 719         RepositoryInstance repoSession = null;
 720         try {
 721             repoSession = getRepositorySession();
 722             DocumentRef docRef = new PathRef(
 723                     "/" + tenantDomain
 724                     + "/" + "workspaces"
 725                     + "/" + workspaceName);
 726             DocumentModel workspace = repoSession.getDocument(docRef);
 727             workspaceId = workspace.getId();
 728         } catch (DocumentException de) {
 729             throw de;
 730         } catch (Exception e) {
 731             if (logger.isDebugEnabled()) {
 732                 logger.debug("Caught exception ", e);
 733             }
 734             throw new DocumentException(e);
 735         } finally {
 736             if (repoSession != null) {
 737                 releaseRepositorySession(repoSession);
 738             }
 739         }
 740         return workspaceId;
 741     }
 742
 743     private final void appendNXQLWhere(StringBuilder query, String where, String domain ) {
 744         // TODO This is a slow method for tenant-filter
 745         // We should make this a property that is indexed.
 746         query.append(" WHERE ecm:path STARTSWITH '/" + domain + "'");
 747         if ((null != where) && (where.length() > 0)) {
 748                 // Due to an apparent bug/issue in how Nuxeo translates the NXQL query string
 749                 // into SQL, we need to parenthesize our 'where' clause
 750             query.append(" AND " + "(" + where +")" + "AND ecm:isProxy = 0");
 751         }
 752     }
 753
 754     private final String buildNXQLQuery(String docType, String where, String domain ) {
 755         StringBuilder query = new StringBuilder("SELECT * FROM ");
 756         query.append(docType);
 757         appendNXQLWhere(query, where, domain );
 758         return query.toString();
 759     }
 760
 761     private final String buildNXQLQuery(List<String> docTypes, String where, String domain ) {
 762         StringBuilder query = new StringBuilder("SELECT * FROM ");
 763         boolean fFirst = true;
 764         for(String docType:docTypes) {
 765                 if(fFirst) {
 766                 query.append(",");
 767                 fFirst = false;
 768                 }
 769             query.append(docType);
 770         }
 771         appendNXQLWhere(query, where, domain );
 772         return query.toString();
 773     }
 774
 775     private RepositoryInstance getRepositorySession() throws Exception {
 776         // FIXME: is it possible to reuse repository session?
 777         // Authentication failures happen while trying to reuse the session
 778         NuxeoClient client = NuxeoConnector.getInstance().getClient();
 779         RepositoryInstance repoSession = client.openRepository();
 780         if (logger.isDebugEnabled()) {
 781             logger.debug("getRepository() repository root: " + repoSession.getRootDocument());
 782         }
 783         return repoSession;
 784     }
 785
 786     private void releaseRepositorySession(RepositoryInstance repoSession) {
 787         try {
 788             NuxeoClient client = NuxeoConnector.getInstance().getClient();
 789             // release session
 790             client.releaseRepository(repoSession);
 791         } catch (Exception e) {
 792             logger.error("Could not close the repository session", e);
 793             // no need to throw this service specific exception
 794         }
 795     }
 796 }