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.io.Serializable;
  21 import java.util.Hashtable;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.UUID;
  26
  27 import javax.ws.rs.WebApplicationException;
  28 import javax.ws.rs.core.MultivaluedMap;
  29
  30 import org.collectionspace.services.client.IQueryManager;
  31 import org.collectionspace.services.client.PoxPayloadIn;
  32 import org.collectionspace.services.client.PoxPayloadOut;
  33 import org.collectionspace.services.client.workflow.WorkflowClient;
  34 import org.collectionspace.services.common.context.ServiceContext;
  35 import org.collectionspace.services.common.query.QueryContext;
  36 import org.collectionspace.services.common.repository.RepositoryClient;
  37 import org.collectionspace.services.common.profile.Profiler;
  38 import org.collectionspace.services.lifecycle.TransitionDef;
  39 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  40
  41 import org.collectionspace.services.common.document.BadRequestException;
  42 import org.collectionspace.services.common.document.DocumentException;
  43 import org.collectionspace.services.common.document.DocumentFilter;
  44 import org.collectionspace.services.common.document.DocumentHandler;
  45 import org.collectionspace.services.common.document.DocumentNotFoundException;
  46 import org.collectionspace.services.common.document.DocumentHandler.Action;
  47 import org.collectionspace.services.common.document.DocumentWrapper;
  48 import org.collectionspace.services.common.document.DocumentWrapperImpl;
  49
  50 import org.nuxeo.common.utils.IdUtils;
  51 import org.nuxeo.ecm.core.api.ClientException;
  52 import org.nuxeo.ecm.core.api.DocumentModel;
  53 import org.nuxeo.ecm.core.api.DocumentModelList;
  54 import org.nuxeo.ecm.core.api.IterableQueryResult;
  55 import org.nuxeo.ecm.core.api.impl.DocumentModelListImpl;
  56 import org.nuxeo.ecm.core.api.DocumentRef;
  57 import org.nuxeo.ecm.core.api.IdRef;
  58 import org.nuxeo.ecm.core.api.PathRef;
  59 import org.nuxeo.ecm.core.api.repository.RepositoryInstance;
  60
  61 //
  62 // CSPACE-5036 - How to make CMISQL queries from Nuxeo
  63 //
  64 import org.apache.chemistry.opencmis.commons.server.CallContext;
  65 import org.apache.chemistry.opencmis.server.impl.CallContextImpl;
  66 import org.nuxeo.ecm.core.opencmis.impl.server.NuxeoCmisService;
  67 import org.nuxeo.ecm.core.opencmis.impl.server.NuxeoRepository;
  68
  69 import org.slf4j.Logger;
  70 import org.slf4j.LoggerFactory;
  71
  72 /**
  73  * RepositoryJavaClient is used to perform CRUD operations on documents in Nuxeo
  74  * repository using Remote Java APIs. It uses @see DocumentHandler as IOHandler
  75  * with the client.
  76  *
  77  * $LastChangedRevision: $ $LastChangedDate: $
  78  */
  79 public class RepositoryJavaClientImpl implements RepositoryClient<PoxPayloadIn, PoxPayloadOut> {
  80
  81     /** The logger. */
  82     private final Logger logger = LoggerFactory.getLogger(RepositoryJavaClientImpl.class);
  83 //    private final Logger profilerLogger = LoggerFactory.getLogger("remperf");
  84 //    private String foo = Profiler.createLogger();
  85
  86     public static final String NUXEO_CORE_TYPE_DOMAIN = "Domain";
  87     public static final String NUXEO_CORE_TYPE_WORKSPACEROOT = "WorkspaceRoot";
  88
  89     /**
  90      * Instantiates a new repository java client impl.
  91      */
  92     public RepositoryJavaClientImpl() {
  93         //Empty constructor
  94
  95     }
  96
  97     public void assertWorkflowState(ServiceContext ctx,
  98                 DocumentModel docModel) throws DocumentNotFoundException, ClientException {
  99         MultivaluedMap<String, String> queryParams = ctx.getQueryParams();
 100         if (queryParams != null) {
 101                 //
 102                 // Look for the workflow "delete" query param and see if we need to assert that the
 103                 // docModel is in a non-deleted workflow state.
 104                 //
 105                 String currentState = docModel.getCurrentLifeCycleState();
 106                 String includeDeletedStr = queryParams.getFirst(WorkflowClient.WORKFLOW_QUERY_NONDELETED);
 107                 boolean includeDeleted = includeDeletedStr == null ? true : Boolean.parseBoolean(includeDeletedStr);
 108                 if (includeDeleted == false) {
 109                         //
 110                         // We don't wanted soft-deleted object, so throw an exception if this one is soft-deleted.
 111                         //
 112                         if (currentState.equalsIgnoreCase(WorkflowClient.WORKFLOWSTATE_DELETED)) {
 113                                 String msg = "The GET assertion that docModel not be in 'deleted' workflow state failed.";
 114                                 logger.debug(msg);
 115                                 throw new DocumentNotFoundException(msg);
 116                         }
 117                 }
 118         }
 119     }
 120
 121     /**
 122      * create document in the Nuxeo repository
 123      *
 124      * @param ctx service context under which this method is invoked
 125      * @param handler
 126      *            should be used by the caller to provide and transform the
 127      *            document
 128      * @return id in repository of the newly created document
 129      * @throws DocumentException
 130      */
 131     @Override
 132     public String create(ServiceContext ctx,
 133             DocumentHandler handler) throws BadRequestException,
 134             DocumentException {
 135
 136         String docType = NuxeoUtils.getTenantQualifiedDocType(ctx); //ctx.getDocumentType();
 137         if (docType == null) {
 138             throw new IllegalArgumentException(
 139                     "RepositoryJavaClient.create: docType is missing");
 140         }
 141
 142         if (handler == null) {
 143             throw new IllegalArgumentException(
 144                     "RepositoryJavaClient.create: handler is missing");
 145         }
 146         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 147         if (nuxeoWspaceId == null) {
 148             throw new DocumentNotFoundException(
 149                     "Unable to find workspace for service " + ctx.getServiceName()
 150                     + " check if the workspace exists in the Nuxeo repository");
 151         }
 152
 153         RepositoryInstance repoSession = null;
 154         try {
 155             handler.prepare(Action.CREATE);
 156             repoSession = getRepositorySession();
 157             DocumentRef nuxeoWspace = new IdRef(nuxeoWspaceId);
 158             DocumentModel wspaceDoc = repoSession.getDocument(nuxeoWspace);
 159             String wspacePath = wspaceDoc.getPathAsString();
 160             //give our own ID so PathRef could be constructed later on
 161             String id = IdUtils.generateId(UUID.randomUUID().toString());
 162             // create document model
 163             DocumentModel doc = repoSession.createDocumentModel(wspacePath, id, docType);
 164             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 165             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 166             handler.handle(Action.CREATE, wrapDoc);
 167             // create document with documentmodel
 168             doc = repoSession.createDocument(doc);
 169             repoSession.save();
 170 // TODO for sub-docs need to call into the handler to let it deal with subitems. Pass in the id,
 171 // and assume the handler has the state it needs (doc fragments).
 172             handler.complete(Action.CREATE, wrapDoc);
 173             return id;
 174         } catch (BadRequestException bre) {
 175             throw bre;
 176         } catch (Exception e) {
 177                 logger.error("Caught exception ", e);
 178             throw new DocumentException(e);
 179         } finally {
 180             if (repoSession != null) {
 181                 releaseRepositorySession(repoSession);
 182             }
 183         }
 184
 185     }
 186
 187     /**
 188      * get document from the Nuxeo repository
 189      * @param ctx service context under which this method is invoked
 190      * @param id
 191      *            of the document to retrieve
 192      * @param handler
 193      *            should be used by the caller to provide and transform the
 194      *            document
 195      * @throws DocumentException
 196      */
 197     @Override
 198     public void get(ServiceContext ctx, String id, DocumentHandler handler)
 199             throws DocumentNotFoundException, DocumentException {
 200
 201         if (handler == null) {
 202             throw new IllegalArgumentException(
 203                     "RepositoryJavaClient.get: handler is missing");
 204         }
 205
 206         RepositoryInstance repoSession = null;
 207         try {
 208             handler.prepare(Action.GET);
 209             repoSession = getRepositorySession();
 210             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 211             DocumentModel docModel = null;
 212             try {
 213                 docModel = repoSession.getDocument(docRef);
 214                 assertWorkflowState(ctx, docModel);
 215             } catch (ClientException ce) {
 216                 String msg = logException(ce, "Could not find document with CSID=" + id);
 217                 throw new DocumentNotFoundException(msg, ce);
 218             }
 219             //
 220             // Set repository session to handle the document
 221             //
 222             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 223             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(docModel);
 224             handler.handle(Action.GET, wrapDoc);
 225             handler.complete(Action.GET, wrapDoc);
 226         } catch (IllegalArgumentException iae) {
 227             throw iae;
 228         } catch (DocumentException de) {
 229             throw de;
 230         } catch (Exception e) {
 231             if (logger.isDebugEnabled()) {
 232                 logger.debug("Caught exception ", e);
 233             }
 234             throw new DocumentException(e);
 235         } finally {
 236             if (repoSession != null) {
 237                 releaseRepositorySession(repoSession);
 238             }
 239         }
 240     }
 241
 242     /**
 243      * get document from the Nuxeo repository, using the docFilter params.
 244      * @param ctx service context under which this method is invoked
 245      * @param handler
 246      *            should be used by the caller to provide and transform the
 247      *            document. Handler must have a docFilter set to return a single item.
 248      * @throws DocumentException
 249      */
 250     @Override
 251     public void get(ServiceContext ctx, DocumentHandler handler)
 252             throws DocumentNotFoundException, DocumentException {
 253         QueryContext queryContext = new QueryContext(ctx, handler);
 254         RepositoryInstance repoSession = null;
 255
 256         try {
 257             handler.prepare(Action.GET);
 258             repoSession = getRepositorySession();
 259
 260             DocumentModelList docList = null;
 261             // force limit to 1, and ignore totalSize
 262             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 263             docList = repoSession.query(query, null, 1, 0, false);
 264             if (docList.size() != 1) {
 265                 throw new DocumentNotFoundException("No document found matching filter params: " + query);
 266             }
 267             DocumentModel doc = docList.get(0);
 268
 269             if (logger.isDebugEnabled()) {
 270                 logger.debug("Executed NXQL query: " + query);
 271             }
 272
 273             //set reposession to handle the document
 274             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 275             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 276             handler.handle(Action.GET, wrapDoc);
 277             handler.complete(Action.GET, wrapDoc);
 278         } catch (IllegalArgumentException iae) {
 279             throw iae;
 280         } catch (DocumentException de) {
 281             throw de;
 282         } catch (Exception e) {
 283             if (logger.isDebugEnabled()) {
 284                 logger.debug("Caught exception ", e);
 285             }
 286             throw new DocumentException(e);
 287         } finally {
 288             if (repoSession != null) {
 289                 releaseRepositorySession(repoSession);
 290             }
 291         }
 292     }
 293
 294     public DocumentWrapper<DocumentModel> getDoc(
 295                 RepositoryInstance repoSession,
 296             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 297             String csid) throws DocumentNotFoundException, DocumentException {
 298         DocumentWrapper<DocumentModel> wrapDoc = null;
 299
 300         try {
 301             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 302             DocumentModel doc = null;
 303             try {
 304                 doc = repoSession.getDocument(docRef);
 305             } catch (ClientException ce) {
 306                 String msg = logException(ce, "Could not find document with CSID=" + csid);
 307                 throw new DocumentNotFoundException(msg, ce);
 308             }
 309             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 310         } catch (IllegalArgumentException iae) {
 311             throw iae;
 312         } catch (DocumentException de) {
 313             throw de;
 314         }
 315
 316         return wrapDoc;
 317     }
 318
 319     /**
 320      * Get wrapped documentModel from the Nuxeo repository.  The search is restricted to the workspace
 321      * of the current context.
 322      *
 323      * @param ctx service context under which this method is invoked
 324      * @param id
 325      *            of the document to retrieve
 326      * @throws DocumentException
 327      */
 328     @Override
 329     public DocumentWrapper<DocumentModel> getDoc(
 330             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 331             String csid) throws DocumentNotFoundException, DocumentException {
 332         RepositoryInstance repoSession = null;
 333         DocumentWrapper<DocumentModel> wrapDoc = null;
 334
 335         try {
 336                 // Open a new repository session
 337             repoSession = getRepositorySession();
 338             wrapDoc = getDoc(repoSession, ctx, csid);
 339         } catch (IllegalArgumentException iae) {
 340             throw iae;
 341         } catch (DocumentException de) {
 342             throw de;
 343         } catch (Exception e) {
 344             if (logger.isDebugEnabled()) {
 345                 logger.debug("Caught exception ", e);
 346             }
 347             throw new DocumentException(e);
 348         } finally {
 349             if (repoSession != null) {
 350                 releaseRepositorySession(repoSession);
 351             }
 352         }
 353
 354         if (logger.isWarnEnabled() == true) {
 355                 logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 356         }
 357         return wrapDoc;
 358     }
 359
 360     public DocumentWrapper<DocumentModel> findDoc(
 361             RepositoryInstance repoSession,
 362             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 363             String whereClause)
 364             throws DocumentNotFoundException, DocumentException {
 365         DocumentWrapper<DocumentModel> wrapDoc = null;
 366
 367         try {
 368             QueryContext queryContext = new QueryContext(ctx, whereClause);
 369             DocumentModelList docList = null;
 370             // force limit to 1, and ignore totalSize
 371             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 372             docList = repoSession.query(query,
 373                     null, //Filter
 374                     1, //limit
 375                     0, //offset
 376                     false); //countTotal
 377             if (docList.size() != 1) {
 378                 if (logger.isDebugEnabled()) {
 379                     logger.debug("findDoc: Query found: " + docList.size() + " items.");
 380                     logger.debug(" Query: " + query);
 381                 }
 382                 throw new DocumentNotFoundException("No document found matching filter params: " + query);
 383             }
 384             DocumentModel doc = docList.get(0);
 385             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 386         } catch (IllegalArgumentException iae) {
 387             throw iae;
 388         } catch (DocumentException de) {
 389             throw de;
 390         } catch (Exception e) {
 391             if (logger.isDebugEnabled()) {
 392                 logger.debug("Caught exception ", e);
 393             }
 394             throw new DocumentException(e);
 395         }
 396
 397         return wrapDoc;
 398     }
 399
 400     /**
 401      * find wrapped documentModel from the Nuxeo repository
 402      * @param ctx service context under which this method is invoked
 403      * @param whereClause where NXQL where clause to get the document
 404      * @throws DocumentException
 405      */
 406     @Override
 407     public DocumentWrapper<DocumentModel> findDoc(
 408             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 409             String whereClause)
 410                         throws DocumentNotFoundException, DocumentException {
 411         RepositoryInstance repoSession = null;
 412         DocumentWrapper<DocumentModel> wrapDoc = null;
 413
 414         try {
 415             repoSession = getRepositorySession();
 416             wrapDoc = findDoc(repoSession, ctx, whereClause);
 417         } catch (Exception e) {
 418                         throw new DocumentException("Unable to create a Nuxeo repository session.", e);
 419                 } finally {
 420             if (repoSession != null) {
 421                 releaseRepositorySession(repoSession);
 422             }
 423         }
 424
 425         if (logger.isWarnEnabled() == true) {
 426                 logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 427         }
 428
 429         return wrapDoc;
 430     }
 431
 432     /**
 433      * find doc and return CSID from the Nuxeo repository
 434      * @param ctx service context under which this method is invoked
 435      * @param whereClause where NXQL where clause to get the document
 436      * @throws DocumentException
 437      */
 438     @Override
 439     public String findDocCSID(RepositoryInstance repoSession,
 440             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx, String whereClause)
 441             throws DocumentNotFoundException, DocumentException {
 442         String csid = null;
 443         boolean releaseSession = false;
 444         try {
 445                 if(repoSession== null) {
 446                         repoSession = this.getRepositorySession();
 447                         releaseSession = true;
 448                 }
 449             DocumentWrapper<DocumentModel> wrapDoc = findDoc(repoSession, ctx, whereClause);
 450             DocumentModel docModel = wrapDoc.getWrappedObject();
 451             csid = NuxeoUtils.getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());
 452         } catch (DocumentNotFoundException dnfe) {
 453             throw dnfe;
 454         } catch (IllegalArgumentException iae) {
 455             throw iae;
 456         } catch (DocumentException de) {
 457             throw de;
 458         } catch (Exception e) {
 459             if (logger.isDebugEnabled()) {
 460                 logger.debug("Caught exception ", e);
 461             }
 462             throw new DocumentException(e);
 463         } finally {
 464                 if(releaseSession && (repoSession != null)) {
 465                         this.releaseRepositorySession(repoSession);
 466                 }
 467         }
 468         return csid;
 469     }
 470
 471     public DocumentWrapper<DocumentModelList> findDocs(
 472             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 473             RepositoryInstance repoSession,
 474             List<String> docTypes,
 475             String whereClause,
 476             int pageSize, int pageNum, boolean computeTotal)
 477                         throws DocumentNotFoundException, DocumentException {
 478         DocumentWrapper<DocumentModelList> wrapDoc = null;
 479
 480         try {
 481             if (docTypes == null || docTypes.size() < 1) {
 482                 throw new DocumentNotFoundException(
 483                         "The findDocs() method must specify at least one DocumentType.");
 484             }
 485             DocumentModelList docList = null;
 486             QueryContext queryContext = new QueryContext(ctx, whereClause);
 487             String query = NuxeoUtils.buildNXQLQuery(docTypes, queryContext);
 488             if (logger.isDebugEnabled()) {
 489                 logger.debug("findDocs() NXQL: "+query);
 490             }
 491             docList = repoSession.query(query, null, pageSize, pageNum, computeTotal);
 492             wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 493         } catch (IllegalArgumentException iae) {
 494             throw iae;
 495         } catch (Exception e) {
 496             if (logger.isDebugEnabled()) {
 497                 logger.debug("Caught exception ", e);
 498             }
 499             throw new DocumentException(e);
 500         }
 501
 502         return wrapDoc;
 503     }
 504
 505     /**
 506      * Find a list of documentModels from the Nuxeo repository
 507      * @param docTypes a list of DocType names to match
 508      * @param  whereClause where the clause to qualify on
 509      * @return
 510      */
 511     @Override
 512     public DocumentWrapper<DocumentModelList> findDocs(
 513             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 514             List<String> docTypes,
 515             String whereClause,
 516             int pageSize, int pageNum, boolean computeTotal)
 517             throws DocumentNotFoundException, DocumentException {
 518         RepositoryInstance repoSession = null;
 519         DocumentWrapper<DocumentModelList> wrapDoc = null;
 520
 521         try {
 522             repoSession = getRepositorySession();
 523             wrapDoc = findDocs(ctx, repoSession, docTypes, whereClause,
 524                         pageSize, pageNum, computeTotal);
 525         } catch (IllegalArgumentException iae) {
 526             throw iae;
 527         } catch (Exception e) {
 528             if (logger.isDebugEnabled()) {
 529                 logger.debug("Caught exception ", e);
 530             }
 531             throw new DocumentException(e);
 532         } finally {
 533             if (repoSession != null) {
 534                 releaseRepositorySession(repoSession);
 535             }
 536         }
 537
 538         if (logger.isWarnEnabled() == true) {
 539                 logger.warn("Returned DocumentModelList instance was created with a repository session that is now closed.");
 540         }
 541
 542         return wrapDoc;
 543     }
 544
 545     /* (non-Javadoc)
 546      * @see org.collectionspace.services.common.storage.StorageClient#get(org.collectionspace.services.common.context.ServiceContext, java.util.List, org.collectionspace.services.common.document.DocumentHandler)
 547      */
 548     @Override
 549     public void get(ServiceContext ctx, List<String> csidList, DocumentHandler handler)
 550             throws DocumentNotFoundException, DocumentException {
 551         if (handler == null) {
 552             throw new IllegalArgumentException(
 553                     "RepositoryJavaClient.getAll: handler is missing");
 554         }
 555
 556         RepositoryInstance repoSession = null;
 557         try {
 558             handler.prepare(Action.GET_ALL);
 559             repoSession = getRepositorySession();
 560             DocumentModelList docModelList = new DocumentModelListImpl();
 561             //FIXME: Should be using NuxeoUtils.createPathRef for security reasons
 562             for (String csid : csidList) {
 563                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 564                 DocumentModel docModel = repoSession.getDocument(docRef);
 565                 docModelList.add(docModel);
 566             }
 567
 568             //set reposession to handle the document
 569             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 570             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docModelList);
 571             handler.handle(Action.GET_ALL, wrapDoc);
 572             handler.complete(Action.GET_ALL, wrapDoc);
 573         } catch (DocumentException de) {
 574             throw de;
 575         } catch (Exception e) {
 576             if (logger.isDebugEnabled()) {
 577                 logger.debug("Caught exception ", e);
 578             }
 579             throw new DocumentException(e);
 580         } finally {
 581             if (repoSession != null) {
 582                 releaseRepositorySession(repoSession);
 583             }
 584         }
 585     }
 586
 587     /**
 588      * getAll get all documents for an entity entity service from the Nuxeo
 589      * repository
 590      *
 591      * @param ctx service context under which this method is invoked
 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 getAll(ServiceContext ctx, DocumentHandler handler)
 599             throws DocumentNotFoundException, DocumentException {
 600         if (handler == null) {
 601             throw new IllegalArgumentException(
 602                     "RepositoryJavaClient.getAll: handler is missing");
 603         }
 604         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 605         if (nuxeoWspaceId == null) {
 606             throw new DocumentNotFoundException(
 607                     "Unable to find workspace for service "
 608                     + ctx.getServiceName()
 609                     + " check if the workspace exists in the Nuxeo repository.");
 610         }
 611
 612         RepositoryInstance repoSession = null;
 613         try {
 614             handler.prepare(Action.GET_ALL);
 615             repoSession = getRepositorySession();
 616             DocumentRef wsDocRef = new IdRef(nuxeoWspaceId);
 617             DocumentModelList docList = repoSession.getChildren(wsDocRef);
 618             //set reposession to handle the document
 619             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 620             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 621             handler.handle(Action.GET_ALL, wrapDoc);
 622             handler.complete(Action.GET_ALL, wrapDoc);
 623         } catch (DocumentException de) {
 624             throw de;
 625         } catch (Exception e) {
 626             if (logger.isDebugEnabled()) {
 627                 logger.debug("Caught exception ", e);
 628             }
 629             throw new DocumentException(e);
 630         } finally {
 631             if (repoSession != null) {
 632                 releaseRepositorySession(repoSession);
 633             }
 634         }
 635     }
 636
 637     private boolean isClauseEmpty(String theString) {
 638         boolean result = true;
 639         if (theString != null && !theString.isEmpty()) {
 640                 result = false;
 641         }
 642         return result;
 643     }
 644
 645     public DocumentWrapper<DocumentModel> getDocFromCsid(
 646                 ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 647                 RepositoryInstance repoSession,
 648                 String csid)
 649             throws Exception {
 650         DocumentWrapper<DocumentModel> result = null;
 651
 652         result = new DocumentWrapperImpl(NuxeoUtils.getDocFromCsid(ctx, repoSession, csid));
 653
 654         return result;
 655     }
 656
 657     /*
 658      * A method to find a CollectionSpace document (of any type) given just a service context and
 659      * its CSID.  A search across *all* service workspaces (within a given tenant context) is performed to find
 660      * the document
 661      *
 662      * This query searches Nuxeo's Hierarchy table where our CSIDs are stored in the "name" column.
 663      */
 664     @Override
 665     public DocumentWrapper<DocumentModel> getDocFromCsid(ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 666                 String csid)
 667             throws Exception {
 668         DocumentWrapper<DocumentModel> result = null;
 669         RepositoryInstance repoSession = null;
 670         try {
 671                 repoSession = getRepositorySession();
 672                 result = getDocFromCsid(ctx, repoSession, csid);
 673         } finally {
 674             if (repoSession != null) {
 675                 releaseRepositorySession(repoSession);
 676             }
 677         }
 678
 679         if (logger.isWarnEnabled() == true) {
 680                 logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 681         }
 682
 683         return result;
 684     }
 685
 686     /**
 687      * find doc and return CSID from the Nuxeo repository
 688      * @param ctx service context under which this method is invoked
 689      * @param whereClause where NXQL where clause to get the document
 690      * @throws DocumentException
 691      */
 692     @Override
 693     public String getDocURI(DocumentWrapper<DocumentModel> wrappedDoc) throws ClientException {
 694         DocumentModel docModel = wrappedDoc.getWrappedObject();
 695         String uri = (String)docModel.getProperty(DocumentModelHandler.COLLECTIONSPACE_CORE_SCHEMA,
 696                                 DocumentModelHandler.COLLECTIONSPACE_CORE_URI);
 697         return uri;
 698     }
 699
 700     /*
 701      * See CSPACE-5036 - How to make CMISQL queries from Nuxeo
 702      */
 703         private IterableQueryResult makeCMISQLQuery(RepositoryInstance repoSession, String query) {
 704                 IterableQueryResult result = null;
 705
 706                 // the NuxeoRepository should be constructed only once, then cached
 707                 // (its construction is expensive)
 708                 try {
 709                         NuxeoRepository repo = new NuxeoRepository(
 710                                         repoSession.getRepositoryName(), repoSession
 711                                                         .getRootDocument().getId());
 712                         logger.debug("Repository ID:" + repo.getId() + " Root folder:"
 713                                         + repo.getRootFolderId());
 714
 715                         CallContextImpl callContext = new CallContextImpl(
 716                                         CallContext.BINDING_LOCAL, repo.getId(), false);
 717                         callContext.put(CallContext.USERNAME, repoSession.getPrincipal()
 718                                         .getName());
 719                         NuxeoCmisService cmisService = new NuxeoCmisService(repo,
 720                                         callContext, repoSession);
 721
 722                         result = repoSession.queryAndFetch(query,
 723                                         "CMISQL", cmisService);
 724                 } catch (ClientException e) {
 725                         // TODO Auto-generated catch block
 726                         logger.error("Encounter trouble making the following CMIS query: " + query, e);
 727                 }
 728
 729                 return result;
 730         }
 731
 732     /**
 733      * getFiltered get all documents for an entity service from the Document repository,
 734      * given filter parameters specified by the handler.
 735      * @param ctx service context under which this method is invoked
 736      * @param handler should be used by the caller to provide and transform the document
 737      * @throws DocumentNotFoundException if workspace not found
 738      * @throws DocumentException
 739      */
 740     @Override
 741     public void getFiltered(ServiceContext ctx, DocumentHandler handler)
 742             throws DocumentNotFoundException, DocumentException {
 743
 744         DocumentFilter filter = handler.getDocumentFilter();
 745         String oldOrderBy = filter.getOrderByClause();
 746         if (isClauseEmpty(oldOrderBy) == true){
 747             filter.setOrderByClause(DocumentFilter.ORDER_BY_LAST_UPDATED);  //per http://issues.collectionspace.org/browse/CSPACE-705 (Doesn't this conflict with what happens with the QueryContext instance that we create below?)
 748         }
 749         QueryContext queryContext = new QueryContext(ctx, handler);
 750
 751         RepositoryInstance repoSession = null;
 752         try {
 753             handler.prepare(Action.GET_ALL);
 754             repoSession = getRepositorySession();
 755
 756             DocumentModelList docList = null;
 757             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 758
 759             if (logger.isDebugEnabled()) {
 760                 logger.debug("Executing NXQL query: " + query.toString());
 761             }
 762
 763             // If we have limit and/or offset, then pass true to get totalSize
 764             // in returned DocumentModelList.
 765                 Profiler profiler = new Profiler(this, 2);
 766                 profiler.log("Executing NXQL query: " + query.toString());
 767                 profiler.start();
 768                 if (handler.isCMISQuery() == true) {
 769                         docList = getFilteredCMIS(repoSession, ctx, handler, queryContext); //FIXME: REM - Need to deal with paging info in CMIS query
 770                 } else if ((queryContext.getDocFilter().getOffset() > 0) || (queryContext.getDocFilter().getPageSize() > 0)) {
 771                 docList = repoSession.query(query, null,
 772                         queryContext.getDocFilter().getPageSize(), queryContext.getDocFilter().getOffset(), true);
 773             } else {
 774                 docList = repoSession.query(query);
 775             }
 776             profiler.stop();
 777
 778             //set repoSession to handle the document
 779             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 780             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 781             handler.handle(Action.GET_ALL, wrapDoc);
 782             handler.complete(Action.GET_ALL, wrapDoc);
 783         } catch (DocumentException de) {
 784             throw de;
 785         } catch (Exception e) {
 786             if (logger.isDebugEnabled()) {
 787                 logger.debug("Caught exception ", e);
 788             }
 789             throw new DocumentException(e);
 790         } finally {
 791             if (repoSession != null) {
 792                 releaseRepositorySession(repoSession);
 793             }
 794         }
 795     }
 796
 797     private DocumentModelList getFilteredCMIS(RepositoryInstance repoSession, ServiceContext ctx, DocumentHandler handler, QueryContext queryContext)
 798             throws DocumentNotFoundException, DocumentException {
 799
 800         DocumentModelList result = new DocumentModelListImpl();
 801         try {
 802             String query = handler.getCMISQuery();
 803
 804             if (logger.isDebugEnabled()) {
 805                 logger.debug("Executing CMIS query: " + query.toString());
 806             }
 807
 808             // If we have limit and/or offset, then pass true to get totalSize
 809             // in returned DocumentModelList.
 810                 Profiler profiler = new Profiler(this, 2);
 811                 profiler.log("Executing CMIS query: " + query.toString());
 812                 profiler.start();
 813                 //
 814                 IterableQueryResult queryResult = makeCMISQLQuery(repoSession, query);
 815                 try {
 816                                 for (Map<String, Serializable> row : queryResult) {
 817                                         logger.debug(
 818                                         // "dc:title is: " + (String)row.get("dc:title")
 819                                         "" + " Hierarchy Table ID is:" + row.get(IQueryManager.CMIS_TARGET_NUXEO_ID)
 820                                                         + " cmis:name is: " + row.get(IQueryManager.CMIS_TARGET_NAME)
 821                                         // + " nuxeo:lifecycleState is: " +
 822                                         // row.get("nuxeo:lifecycleState")
 823                                         );
 824                                         String nuxeoId = (String) row.get(IQueryManager.CMIS_TARGET_NUXEO_ID);
 825                                         DocumentModel docModel = NuxeoUtils.getDocumentModel(repoSession, nuxeoId);
 826                                         result.add(docModel);
 827                                 }
 828                 } finally {
 829                         queryResult.close();
 830                 }
 831                 //
 832             profiler.stop();
 833
 834         } catch (Exception e) {
 835             if (logger.isDebugEnabled()) {
 836                 logger.debug("Caught exception ", e);
 837             }
 838             throw new DocumentException(e);
 839         }
 840
 841         return result;
 842     }
 843
 844     private String logException(Exception e, String msg) {
 845         String result = null;
 846
 847         String exceptionMessage = e.getMessage();
 848         exceptionMessage = exceptionMessage != null ? exceptionMessage : "<No details provided>";
 849         result = msg = msg + ". Caught exception:" + exceptionMessage;
 850
 851         if (logger.isTraceEnabled() == true) {
 852                 logger.error(msg, e);
 853         } else {
 854                 logger.error(msg);
 855         }
 856
 857         return result;
 858     }
 859
 860     /**
 861      * update given document in the Nuxeo repository
 862      *
 863      * @param ctx service context under which this method is invoked
 864      * @param id
 865      *            of the document
 866      * @param handler
 867      *            should be used by the caller to provide and transform the
 868      *            document
 869      * @throws DocumentException
 870      */
 871     @Override
 872     public void update(ServiceContext ctx, String csid, DocumentHandler handler)
 873             throws BadRequestException, DocumentNotFoundException,
 874             DocumentException {
 875         if (handler == null) {
 876             throw new IllegalArgumentException(
 877                     "RepositoryJavaClient.update: document handler is missing.");
 878         }
 879
 880         RepositoryInstance repoSession = null;
 881         try {
 882             handler.prepare(Action.UPDATE);
 883             repoSession = getRepositorySession();
 884             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 885             DocumentModel doc = null;
 886             try {
 887                 doc = repoSession.getDocument(docRef);
 888             } catch (ClientException ce) {
 889                 String msg = logException(ce, "Could not find document to update with CSID=" + csid);
 890                 throw new DocumentNotFoundException(msg, ce);
 891             }
 892             //
 893             // Set reposession to handle the document
 894             //
 895             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 896             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 897             handler.handle(Action.UPDATE, wrapDoc);
 898             repoSession.saveDocument(doc);
 899             repoSession.save();
 900             handler.complete(Action.UPDATE, wrapDoc);
 901         } catch (BadRequestException bre) {
 902             throw bre;
 903         } catch (DocumentException de) {
 904             throw de;
 905         } catch (WebApplicationException wae){
 906             throw wae;
 907         } catch (Exception e) {
 908             if (logger.isDebugEnabled()) {
 909                 logger.debug("Caught exception ", e);
 910             }
 911             throw new DocumentException(e);
 912         } finally {
 913             if (repoSession != null) {
 914                 releaseRepositorySession(repoSession);
 915             }
 916         }
 917     }
 918
 919     /**
 920      * Save a documentModel to the Nuxeo repository.
 921      * @param ctx service context under which this method is invoked
 922      * @param docModel the document to save
 923      * @param fSaveSession if TRUE, will call CoreSession.save() to save accumulated changes.
 924      * @throws DocumentException
 925      */
 926     public void saveDocWithoutHandlerProcessing(
 927             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 928             RepositoryInstance repoSession,
 929             DocumentModel docModel,
 930             boolean fSaveSession)
 931             throws ClientException, DocumentException {
 932
 933         try {
 934             repoSession.saveDocument(docModel);
 935             if (fSaveSession) {
 936                 repoSession.save();
 937             }
 938         } catch (ClientException ce) {
 939             throw ce;
 940         } catch (Exception e) {
 941             if (logger.isDebugEnabled()) {
 942                 logger.debug("Caught exception ", e);
 943             }
 944             throw new DocumentException(e);
 945         }
 946     }
 947
 948
 949     /**
 950      * Save a list of documentModels to the Nuxeo repository.
 951      *
 952      * @param ctx service context under which this method is invoked
 953      * @param docModel the document to save
 954      * @param fSaveSession if TRUE, will call CoreSession.save() to save accumulated changes.
 955      * @throws DocumentException
 956      */
 957     public void saveDocListWithoutHandlerProcessing(
 958             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 959             RepositoryInstance repoSession,
 960             DocumentModelList docList,
 961             boolean fSaveSession)
 962             throws ClientException, DocumentException {
 963         try {
 964             repoSession = getRepositorySession();
 965             DocumentModel[] docModelArray = new DocumentModel[docList.size()];
 966             repoSession.saveDocuments(docList.toArray(docModelArray));
 967             if (fSaveSession) {
 968                 repoSession.save();
 969             }
 970         } catch (ClientException ce) {
 971             throw ce;
 972         } catch (Exception e) {
 973             logger.error("Caught exception ", e);
 974             throw new DocumentException(e);
 975         }
 976     }
 977
 978     /**
 979      * delete a document from the Nuxeo repository
 980      * @param ctx service context under which this method is invoked
 981      * @param id
 982      *            of the document
 983      * @throws DocumentException
 984      */
 985     @Override
 986     public void delete(ServiceContext ctx, String id, DocumentHandler handler) throws DocumentNotFoundException,
 987             DocumentException {
 988         if (ctx == null) {
 989             throw new IllegalArgumentException(
 990                     "delete(ctx, ix, handler): ctx is missing");
 991         }
 992         if (handler == null) {
 993             throw new IllegalArgumentException(
 994                     "delete(ctx, ix, handler): handler is missing");
 995         }
 996         if (logger.isDebugEnabled()) {
 997             logger.debug("Deleting document with CSID=" + id);
 998         }
 999         RepositoryInstance repoSession = null;
1000         try {
1001                 handler.prepare(Action.DELETE);
1002             repoSession = getRepositorySession();
1003             DocumentWrapper<DocumentModel> wrapDoc = null;
1004             try {
1005                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
1006                     wrapDoc = new DocumentWrapperImpl<DocumentModel>(repoSession.getDocument(docRef));
1007                     ((DocumentModelHandler) handler).setRepositorySession(repoSession);
1008                     handler.handle(Action.DELETE, wrapDoc);
1009                 repoSession.removeDocument(docRef);
1010             } catch (ClientException ce) {
1011                 String msg = logException(ce, "Could not find document to delete with CSID=" + id);
1012                 throw new DocumentNotFoundException(msg, ce);
1013             }
1014             repoSession.save();
1015             handler.complete(Action.DELETE, wrapDoc);
1016         } catch (DocumentException de) {
1017             throw de;
1018         } catch (Exception e) {
1019             if (logger.isDebugEnabled()) {
1020                 logger.debug("Caught exception ", e);
1021             }
1022             throw new DocumentException(e);
1023         } finally {
1024             if (repoSession != null) {
1025                 releaseRepositorySession(repoSession);
1026             }
1027         }
1028     }
1029
1030     /* (non-Javadoc)
1031      * @see org.collectionspace.services.common.storage.StorageClient#delete(org.collectionspace.services.common.context.ServiceContext, java.lang.String, org.collectionspace.services.common.document.DocumentHandler)
1032      */
1033     @Override
1034     @Deprecated
1035     public void delete(@SuppressWarnings("rawtypes") ServiceContext ctx, String id)
1036             throws DocumentNotFoundException, DocumentException {
1037         throw new UnsupportedOperationException();
1038         // Use the other delete instead
1039     }
1040
1041     @Override
1042     public Hashtable<String, String> retrieveWorkspaceIds(String domainName) throws Exception {
1043         return NuxeoConnectorEmbedded.getInstance().retrieveWorkspaceIds(domainName);
1044     }
1045
1046     @Override
1047     public String createDomain(String domainName) throws Exception {
1048         RepositoryInstance repoSession = null;
1049         String domainId = null;
1050         try {
1051                 //
1052                 // First create the top-level domain directory
1053                 //
1054             repoSession = getRepositorySession();
1055             DocumentRef parentDocRef = new PathRef("/");
1056             DocumentModel parentDoc = repoSession.getDocument(parentDocRef);
1057             DocumentModel domainDoc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1058                     domainName, NUXEO_CORE_TYPE_DOMAIN);
1059             domainDoc.setPropertyValue("dc:title", domainName);
1060             domainDoc.setPropertyValue("dc:description", "A CollectionSpace domain "
1061                     + domainName);
1062             domainDoc = repoSession.createDocument(domainDoc);
1063             domainId = domainDoc.getId();
1064             repoSession.save();
1065             //
1066             // Next, create a "Workspaces" root directory to contain the workspace folders for the individual service documents
1067             //
1068             DocumentModel workspacesRoot = repoSession.createDocumentModel(domainDoc.getPathAsString(),
1069                         NuxeoUtils.Workspaces, NUXEO_CORE_TYPE_WORKSPACEROOT);
1070             workspacesRoot.setPropertyValue("dc:title", NuxeoUtils.Workspaces);
1071             workspacesRoot.setPropertyValue("dc:description", "A CollectionSpace workspaces directory for "
1072                     + domainDoc.getPathAsString());
1073             workspacesRoot = repoSession.createDocument(workspacesRoot);
1074             String workspacesRootId = workspacesRoot.getId();
1075             repoSession.save();
1076
1077             if (logger.isDebugEnabled()) {
1078                 logger.debug("Created tenant domain name=" + domainName
1079                         + " id=" + domainId + " " +
1080                         NuxeoUtils.Workspaces + " id=" + workspacesRootId);
1081                 logger.debug("Path to Domain: "+domainDoc.getPathAsString());
1082                 logger.debug("Path to Workspaces root: "+workspacesRoot.getPathAsString());
1083             }
1084         } catch (Exception e) {
1085             if (logger.isDebugEnabled()) {
1086                 logger.debug("Could not create tenant domain name=" + domainName + " caught exception ", e);
1087             }
1088             throw e;
1089         } finally {
1090             if (repoSession != null) {
1091                 releaseRepositorySession(repoSession);
1092             }
1093         }
1094
1095         return domainId;
1096     }
1097
1098     @Override
1099     public String getDomainId(String domainName) throws Exception {
1100         String domainId = null;
1101         RepositoryInstance repoSession = null;
1102
1103         if (domainName != null && !domainName.isEmpty()) {
1104                 try {
1105                     repoSession = getRepositorySession();
1106                     DocumentRef docRef = new PathRef(
1107                             "/" + domainName);
1108                     DocumentModel domain = repoSession.getDocument(docRef);
1109                     domainId = domain.getId();
1110                 } catch (Exception e) {
1111                     if (logger.isTraceEnabled()) {
1112                         logger.trace("Caught exception ", e);
1113                     }
1114                     //there is no way to identify if document does not exist due to
1115                     //lack of typed exception for getDocument method
1116                     return null;
1117                 } finally {
1118                     if (repoSession != null) {
1119                         releaseRepositorySession(repoSession);
1120                     }
1121                 }
1122         }
1123
1124         return domainId;
1125     }
1126
1127     /*
1128          * Returns the workspaces root directory for a given domain.
1129          */
1130         private DocumentModel getWorkspacesRoot(RepositoryInstance repoSession,
1131                         String domainName) throws Exception {
1132                 DocumentModel result = null;
1133
1134                 String domainPath = "/" + domainName;
1135                 DocumentRef parentDocRef = new PathRef(domainPath);
1136                 DocumentModelList domainChildrenList = repoSession.getChildren(
1137                                 parentDocRef);
1138                 Iterator<DocumentModel> witer = domainChildrenList.iterator();
1139                 while (witer.hasNext()) {
1140                         DocumentModel childNode = witer.next();
1141                         if (NuxeoUtils.Workspaces.equalsIgnoreCase(childNode.getName())) {
1142                                 result = childNode;
1143                                 logger.trace("Found workspaces directory at: " + result.getPathAsString());
1144                                 break;
1145                         }
1146                 }
1147
1148                 if (result == null) {
1149                         throw new ClientException("Could not find workspace root directory in: "
1150                                         + domainPath);
1151                 }
1152
1153                 return result;
1154         }
1155
1156     /* (non-Javadoc)
1157      * @see org.collectionspace.services.common.repository.RepositoryClient#createWorkspace(java.lang.String, java.lang.String)
1158      */
1159     @Override
1160     public String createWorkspace(String domainName, String workspaceName) throws Exception {
1161         RepositoryInstance repoSession = null;
1162         String workspaceId = null;
1163         try {
1164             repoSession = getRepositorySession();
1165             DocumentModel parentDoc = getWorkspacesRoot(repoSession, domainName);
1166             DocumentModel doc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1167                     workspaceName, NuxeoUtils.WORKSPACE_DOCUMENT_TYPE);
1168             doc.setPropertyValue("dc:title", workspaceName);
1169             doc.setPropertyValue("dc:description", "A CollectionSpace workspace for "
1170                     + workspaceName);
1171             doc = repoSession.createDocument(doc);
1172             workspaceId = doc.getId();
1173             repoSession.save();
1174             if (logger.isDebugEnabled()) {
1175                 logger.debug("Created workspace name=" + workspaceName
1176                         + " id=" + workspaceId);
1177             }
1178         } catch (Exception e) {
1179             if (logger.isDebugEnabled()) {
1180                 logger.debug("createWorkspace caught exception ", e);
1181             }
1182             throw e;
1183         } finally {
1184             if (repoSession != null) {
1185                 releaseRepositorySession(repoSession);
1186             }
1187         }
1188         return workspaceId;
1189     }
1190
1191     /* (non-Javadoc)
1192      * @see org.collectionspace.services.common.repository.RepositoryClient#getWorkspaceId(java.lang.String, java.lang.String)
1193      */
1194     @Override
1195     public String getWorkspaceId(String tenantDomain, String workspaceName) throws Exception {
1196         String workspaceId = null;
1197
1198         RepositoryInstance repoSession = null;
1199         try {
1200             repoSession = getRepositorySession();
1201             DocumentRef docRef = new PathRef(
1202                     "/" + tenantDomain
1203                     + "/" + NuxeoUtils.Workspaces
1204                     + "/" + workspaceName);
1205             DocumentModel workspace = repoSession.getDocument(docRef);
1206             workspaceId = workspace.getId();
1207         } catch (DocumentException de) {
1208             throw de;
1209         } catch (Exception e) {
1210             if (logger.isDebugEnabled()) {
1211                 logger.debug("Caught exception ", e);
1212             }
1213             throw new DocumentException(e);
1214         } finally {
1215             if (repoSession != null) {
1216                 releaseRepositorySession(repoSession);
1217             }
1218         }
1219
1220         return workspaceId;
1221     }
1222
1223
1224     /**
1225      * Gets the repository session. - Package access only.
1226      *
1227      * @return the repository session
1228      * @throws Exception the exception
1229      */
1230     public RepositoryInstance getRepositorySession() throws Exception {
1231         // FIXME: is it possible to reuse repository session?
1232         // Authentication failures happen while trying to reuse the session
1233         Profiler profiler = new Profiler("getRepositorySession():", 2);
1234         profiler.start();
1235
1236         NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1237         RepositoryInstance repoSession = client.openRepository();
1238         if (logger.isTraceEnabled()) {
1239             logger.trace("Testing call to getRepository() repository root: " + repoSession.getRootDocument());
1240         }
1241
1242         profiler.stop();
1243         return repoSession;
1244     }
1245
1246     /**
1247      * Release repository session. - Package access only.
1248      *
1249      * @param repoSession the repo session
1250      */
1251     public void releaseRepositorySession(RepositoryInstance repoSession) {
1252         try {
1253             NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1254             // release session
1255             client.releaseRepository(repoSession);
1256         } catch (Exception e) {
1257             logger.error("Could not close the repository session", e);
1258             // no need to throw this service specific exception
1259         }
1260     }
1261
1262         @Override
1263         public void doWorkflowTransition(ServiceContext ctx, String id,
1264                         DocumentHandler handler, TransitionDef transitionDef)
1265                         throws BadRequestException, DocumentNotFoundException,
1266                         DocumentException {
1267                 // This is a placeholder for when we change the StorageClient interface to treat workflow transitions as 1st class operations like 'get', 'create', 'update, 'delete', etc
1268         }
1269
1270 }