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 (Exception e) {
 413             if (logger.isDebugEnabled()) {
 414                 logger.debug("Caught exception ", e);
 415             }
 416             throw new DocumentException(e);
 417         } finally {
 418             if (repoSession != null) {
 419                 releaseRepositorySession(repoSession);
 420             }
 421         }
 422         return wrapDoc;
 423     }
 424
 425
 426     @Override
 427     public void get(ServiceContext ctx, List<String> csidList, DocumentHandler handler)
 428                 throws DocumentNotFoundException, DocumentException {
 429         if (handler == null) {
 430             throw new IllegalArgumentException(
 431                     "RepositoryJavaClient.getAll: handler is missing");
 432         }
 433
 434         RepositoryInstance repoSession = null;
 435
 436         try {
 437             handler.prepare(Action.GET_ALL);
 438             repoSession = getRepositorySession();
 439             DocumentModelList docModelList = new DocumentModelListImpl();
 440             //FIXME: Should be using NuxeoUtils.createPathRef for security reasons
 441             for (String csid : csidList) {
 442                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 443                 DocumentModel docModel = repoSession.getDocument(docRef);
 444                 docModelList.add(docModel);
 445             }
 446
 447             //set reposession to handle the document
 448             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 449             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docModelList);
 450             handler.handle(Action.GET_ALL, wrapDoc);
 451             handler.complete(Action.GET_ALL, wrapDoc);
 452         } catch (DocumentException de) {
 453             throw de;
 454         } catch (Exception e) {
 455             if (logger.isDebugEnabled()) {
 456                 logger.debug("Caught exception ", e);
 457             }
 458             throw new DocumentException(e);
 459         } finally {
 460             if (repoSession != null) {
 461                 releaseRepositorySession(repoSession);
 462             }
 463         }
 464     }
 465
 466     /**
 467      * getAll get all documents for an entity entity service from the Nuxeo
 468      * repository
 469      *
 470      * @param ctx service context under which this method is invoked
 471      * @param handler
 472      *            should be used by the caller to provide and transform the
 473      *            document
 474      * @throws DocumentException
 475      */
 476     @Override
 477     public void getAll(ServiceContext ctx, DocumentHandler handler)
 478             throws DocumentNotFoundException, DocumentException {
 479         if (handler == null) {
 480             throw new IllegalArgumentException(
 481                     "RepositoryJavaClient.getAll: handler is missing");
 482         }
 483         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 484         if (nuxeoWspaceId == null) {
 485             throw new DocumentNotFoundException(
 486                     "Unable to find workspace for service "
 487                     + ctx.getServiceName()
 488                     + " check if the workspace exists in the Nuxeo repository");
 489         }
 490         RepositoryInstance repoSession = null;
 491
 492         try {
 493             handler.prepare(Action.GET_ALL);
 494             repoSession = getRepositorySession();
 495             DocumentRef wsDocRef = new IdRef(nuxeoWspaceId);
 496             DocumentModelList docList = repoSession.getChildren(wsDocRef);
 497             //set reposession to handle the document
 498             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 499             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 500             handler.handle(Action.GET_ALL, wrapDoc);
 501             handler.complete(Action.GET_ALL, wrapDoc);
 502         } catch (DocumentException de) {
 503             throw de;
 504         } catch (Exception e) {
 505             if (logger.isDebugEnabled()) {
 506                 logger.debug("Caught exception ", e);
 507             }
 508             throw new DocumentException(e);
 509         } finally {
 510             if (repoSession != null) {
 511                 releaseRepositorySession(repoSession);
 512             }
 513         }
 514     }
 515
 516     /**
 517      * getFiltered get all documents for an entity service from the Document repository,
 518      * given filter parameters specified by the handler.
 519      * @param ctx service context under which this method is invoked
 520      * @param handler should be used by the caller to provide and transform the document
 521      * @throws DocumentNotFoundException if workspace not found
 522      * @throws DocumentException
 523      */
 524     public void getFiltered(ServiceContext ctx, DocumentHandler handler)
 525             throws DocumentNotFoundException, DocumentException {
 526         if (handler == null) {
 527             throw new IllegalArgumentException(
 528                     "RepositoryJavaClient.getFiltered: handler is missing");
 529         }
 530         DocumentFilter docFilter = handler.getDocumentFilter();
 531         if (docFilter == null) {
 532             throw new IllegalArgumentException(
 533                     "RepositoryJavaClient.getFiltered: handler has no Filter specified");
 534         }
 535         String docType = ctx.getDocumentType();
 536         if (docType == null) {
 537             throw new DocumentNotFoundException(
 538                     "Unable to find DocumentType for service " + ctx.getServiceName());
 539         }
 540         String domain = ctx.getRepositoryDomainName();
 541         if (domain == null) {
 542             throw new DocumentNotFoundException(
 543                     "Unable to find Domain for service " + ctx.getServiceName());
 544         }
 545         RepositoryInstance repoSession = null;
 546         try {
 547             handler.prepare(Action.GET_ALL);
 548             repoSession = getRepositorySession();
 549             DocumentModelList docList = null;
 550             String query = buildNXQLQuery(docType, docFilter.getWhereClause(), domain );
 551
 552             // If we have limit and/or offset, then pass true to get totalSize
 553             // in returned DocumentModelList.
 554             if ((docFilter.getOffset() > 0) || (docFilter.getPageSize() > 0)) {
 555                 docList = repoSession.query(query, null,
 556                         docFilter.getPageSize(), docFilter.getOffset(), true);
 557             } else {
 558                 docList = repoSession.query(query);
 559             }
 560
 561             if (logger.isDebugEnabled()) {
 562                 logger.debug("Executed NXQL query: " + query.toString());
 563             }
 564
 565             //set repoSession to handle the document
 566             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 567             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 568             handler.handle(Action.GET_ALL, wrapDoc);
 569             handler.complete(Action.GET_ALL, wrapDoc);
 570         } catch (DocumentException de) {
 571             throw de;
 572         } catch (Exception e) {
 573             if (logger.isDebugEnabled()) {
 574                 logger.debug("Caught exception ", e);
 575             }
 576             throw new DocumentException(e);
 577         } finally {
 578             if (repoSession != null) {
 579                 releaseRepositorySession(repoSession);
 580             }
 581         }
 582     }
 583
 584     /**
 585      * update given document in the Nuxeo repository
 586      *
 587      * @param ctx service context under which this method is invoked
 588      * @param id
 589      *            of the document
 590      * @param handler
 591      *            should be used by the caller to provide and transform the
 592      *            document
 593      * @throws DocumentException
 594      */
 595     @Override
 596     public void update(ServiceContext ctx, String id, DocumentHandler handler)
 597             throws BadRequestException, DocumentNotFoundException,
 598             DocumentException {
 599         if (handler == null) {
 600             throw new IllegalArgumentException(
 601                     "RepositoryJavaClient.update: handler is missing");
 602         }
 603         RepositoryInstance repoSession = null;
 604         try {
 605             handler.prepare(Action.UPDATE);
 606             repoSession = getRepositorySession();
 607             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 608             DocumentModel doc = null;
 609             try {
 610                 doc = repoSession.getDocument(docRef);
 611             } catch (ClientException ce) {
 612                 String msg = "Could not find document to update with id=" + id;
 613                 logger.error(msg, ce);
 614                 throw new DocumentNotFoundException(msg, ce);
 615             }
 616             //set reposession to handle the document
 617             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 618             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 619             handler.handle(Action.UPDATE, wrapDoc);
 620             repoSession.saveDocument(doc);
 621             repoSession.save();
 622             handler.complete(Action.UPDATE, wrapDoc);
 623         } catch (BadRequestException bre) {
 624             throw bre;
 625         } catch (DocumentException de) {
 626             throw de;
 627         } catch (Exception e) {
 628             if (logger.isDebugEnabled()) {
 629                 logger.debug("Caught exception ", e);
 630             }
 631             throw new DocumentException(e);
 632         } finally {
 633             if (repoSession != null) {
 634                 releaseRepositorySession(repoSession);
 635             }
 636         }
 637     }
 638
 639     /**
 640      * delete a document from the Nuxeo repository
 641      * @param ctx service context under which this method is invoked
 642      * @param id
 643      *            of the document
 644      * @throws DocumentException
 645      */
 646     @Override
 647     public void delete(ServiceContext ctx, String id) throws DocumentNotFoundException,
 648             DocumentException {
 649
 650         if (logger.isDebugEnabled()) {
 651             logger.debug("deleting document with id=" + id);
 652         }
 653         RepositoryInstance repoSession = null;
 654         try {
 655             repoSession = getRepositorySession();
 656             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 657             try {
 658                 repoSession.removeDocument(docRef);
 659             } catch (ClientException ce) {
 660                 String msg = "could not find document to delete with id=" + id;
 661                 logger.error(msg, ce);
 662                 throw new DocumentNotFoundException(msg, ce);
 663             }
 664             repoSession.save();
 665         } catch (DocumentException de) {
 666             throw de;
 667         } catch (Exception e) {
 668             if (logger.isDebugEnabled()) {
 669                 logger.debug("Caught exception ", e);
 670             }
 671             throw new DocumentException(e);
 672         } finally {
 673             if (repoSession != null) {
 674                 releaseRepositorySession(repoSession);
 675             }
 676         }
 677     }
 678
 679     @Override
 680     public String createWorkspace(String tenantDomain, String workspaceName) throws Exception {
 681         RepositoryInstance repoSession = null;
 682         String workspaceId = null;
 683         try {
 684             repoSession = getRepositorySession();
 685             DocumentRef docRef = new PathRef(
 686                     "/" + tenantDomain
 687                     + "/" + "workspaces");
 688             DocumentModel parent = repoSession.getDocument(docRef);
 689             DocumentModel doc = repoSession.createDocumentModel(parent.getPathAsString(),
 690                     workspaceName, "Workspace");
 691             doc.setPropertyValue("dc:title", workspaceName);
 692             doc.setPropertyValue("dc:description", "A CollectionSpace workspace for "
 693                     + workspaceName);
 694             doc = repoSession.createDocument(doc);
 695             workspaceId = doc.getId();
 696             repoSession.save();
 697             if (logger.isDebugEnabled()) {
 698                 logger.debug("created workspace name=" + workspaceName
 699                         + " id=" + workspaceId);
 700             }
 701         } catch (Exception e) {
 702             if (logger.isDebugEnabled()) {
 703                 logger.debug("createWorkspace caught exception ", e);
 704             }
 705             throw e;
 706         } finally {
 707             if (repoSession != null) {
 708                 releaseRepositorySession(repoSession);
 709             }
 710         }
 711         return workspaceId;
 712     }
 713
 714     @Override
 715     public String getWorkspaceId(String tenantDomain, String workspaceName) throws Exception {
 716         String workspaceId = null;
 717         RepositoryInstance repoSession = null;
 718         try {
 719             repoSession = getRepositorySession();
 720             DocumentRef docRef = new PathRef(
 721                     "/" + tenantDomain
 722                     + "/" + "workspaces"
 723                     + "/" + workspaceName);
 724             DocumentModel workspace = repoSession.getDocument(docRef);
 725             workspaceId = workspace.getId();
 726         } catch (DocumentException de) {
 727             throw de;
 728         } catch (Exception e) {
 729             if (logger.isDebugEnabled()) {
 730                 logger.debug("Caught exception ", e);
 731             }
 732             throw new DocumentException(e);
 733         } finally {
 734             if (repoSession != null) {
 735                 releaseRepositorySession(repoSession);
 736             }
 737         }
 738         return workspaceId;
 739     }
 740
 741     private final void appendNXQLWhere(StringBuilder query, String where, String domain ) {
 742         // TODO This is a slow method for tenant-filter
 743         // We should make this a property that is indexed.
 744         query.append(" WHERE ecm:path STARTSWITH '/" + domain + "'");
 745         if ((null != where) && (where.length() > 0)) {
 746                 // Due to an apparent bug/issue in how Nuxeo translates the NXQL query string
 747                 // into SQL, we need to parenthesize our 'where' clause
 748             query.append(" AND " + "(" + where +")");
 749         }
 750         query.append(" AND ecm:isProxy = 0");
 751     }
 752
 753     private final String buildNXQLQuery(String docType, String where, String domain ) {
 754         StringBuilder query = new StringBuilder("SELECT * FROM ");
 755         query.append(docType);
 756         appendNXQLWhere(query, where, domain );
 757         return query.toString();
 758     }
 759
 760     private final String buildNXQLQuery(List<String> docTypes, String where, String domain ) {
 761         StringBuilder query = new StringBuilder("SELECT * FROM ");
 762         boolean fFirst = true;
 763         for(String docType:docTypes) {
 764                 if(fFirst) {
 765                 fFirst = false;
 766                 } else {
 767                         query.append(",");
 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 }