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

   1 /**
   2  * This document is a part of the source code and related artifacts for
   3  * CollectionSpace, an open source collections management system for museums and
   4  * related institutions:
   5  *
   6  * http://www.collectionspace.org http://wiki.collectionspace.org
   7  *
   8  * Copyright 2009 University of California at Berkeley
   9  *
  10  * Licensed under the Educational Community License (ECL), Version 2.0. You may
  11  * not use this file except in compliance with this License.
  12  *
  13  * You may obtain a copy of the ECL 2.0 License at
  14  *
  15  * https://source.collectionspace.org/collection-space/LICENSE.txt
  16  */
  17 package org.collectionspace.services.nuxeo.client.java;
  18
  19 import java.io.Serializable;
  20 import java.sql.Connection;
  21 import java.sql.PreparedStatement;
  22 import java.sql.ResultSet;
  23 import java.sql.SQLException;
  24 import java.sql.Statement;
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.Comparator;
  28 import java.util.HashSet;
  29 import java.util.Hashtable;
  30 import java.util.Iterator;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Set;
  34 import java.util.UUID;
  35 import javax.sql.rowset.CachedRowSet;
  36
  37 import javax.ws.rs.WebApplicationException;
  38 import javax.ws.rs.core.MultivaluedMap;
  39
  40 import org.collectionspace.services.client.CollectionSpaceClient;
  41 import org.collectionspace.services.client.IQueryManager;
  42 import org.collectionspace.services.client.PoxPayloadIn;
  43 import org.collectionspace.services.client.PoxPayloadOut;
  44 import org.collectionspace.services.client.Profiler;
  45 import org.collectionspace.services.client.workflow.WorkflowClient;
  46 import org.collectionspace.services.common.context.ServiceContext;
  47 import org.collectionspace.services.common.query.QueryContext;
  48 import org.collectionspace.services.common.repository.RepositoryClient;
  49 import org.collectionspace.services.common.storage.JDBCTools;
  50 import org.collectionspace.services.common.storage.PreparedStatementSimpleBuilder;
  51 import org.collectionspace.services.lifecycle.TransitionDef;
  52 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  53
  54 import org.collectionspace.services.common.document.BadRequestException;
  55 import org.collectionspace.services.common.document.DocumentException;
  56 import org.collectionspace.services.common.document.DocumentFilter;
  57 import org.collectionspace.services.common.document.DocumentHandler;
  58 import org.collectionspace.services.common.document.DocumentNotFoundException;
  59 import org.collectionspace.services.common.document.DocumentHandler.Action;
  60 import org.collectionspace.services.common.document.DocumentWrapper;
  61 import org.collectionspace.services.common.document.DocumentWrapperImpl;
  62 import org.collectionspace.services.common.document.TransactionException;
  63 import org.collectionspace.services.config.tenant.RepositoryDomainType;
  64
  65 import org.nuxeo.common.utils.IdUtils;
  66 import org.nuxeo.ecm.core.api.ClientException;
  67 import org.nuxeo.ecm.core.api.DocumentModel;
  68 import org.nuxeo.ecm.core.api.DocumentModelList;
  69 import org.nuxeo.ecm.core.api.IterableQueryResult;
  70 import org.nuxeo.ecm.core.api.VersioningOption;
  71 import org.nuxeo.ecm.core.api.impl.DocumentModelListImpl;
  72 import org.nuxeo.ecm.core.api.DocumentRef;
  73 import org.nuxeo.ecm.core.api.IdRef;
  74 import org.nuxeo.ecm.core.api.PathRef;
  75 import org.nuxeo.ecm.core.api.repository.RepositoryInstance;
  76 import org.nuxeo.runtime.transaction.TransactionRuntimeException;
  77
  78 //
  79 // CSPACE-5036 - How to make CMISQL queries from Nuxeo
  80 //
  81 import org.apache.chemistry.opencmis.commons.server.CallContext;
  82 import org.apache.chemistry.opencmis.server.impl.CallContextImpl;
  83 import org.collectionspace.services.common.ServiceMain;
  84 import org.collectionspace.services.common.api.Tools;
  85 import org.collectionspace.services.common.config.ConfigUtils;
  86 import org.collectionspace.services.common.config.TenantBindingConfigReaderImpl;
  87 import org.collectionspace.services.common.config.TenantBindingUtils;
  88 import org.collectionspace.services.common.storage.PreparedStatementBuilder;
  89 import org.collectionspace.services.config.tenant.TenantBindingType;
  90 import org.nuxeo.ecm.core.opencmis.impl.server.NuxeoCmisService;
  91 import org.nuxeo.ecm.core.opencmis.impl.server.NuxeoRepository;
  92
  93 import org.slf4j.Logger;
  94 import org.slf4j.LoggerFactory;
  95
  96 /**
  97  * RepositoryJavaClient is used to perform CRUD operations on documents in Nuxeo
  98  * repository using Remote Java APIs. It uses
  99  *
 100  * @see DocumentHandler as IOHandler with the client.
 101  *
 102  * $LastChangedRevision: $ $LastChangedDate: $
 103  */
 104 public class RepositoryJavaClientImpl implements RepositoryClient<PoxPayloadIn, PoxPayloadOut> {
 105
 106     /**
 107      * The logger.
 108      */
 109     private final Logger logger = LoggerFactory.getLogger(RepositoryJavaClientImpl.class);
 110 //    private final Logger profilerLogger = LoggerFactory.getLogger("remperf");
 111 //    private String foo = Profiler.createLogger();
 112     public static final String NUXEO_CORE_TYPE_DOMAIN = "Domain";
 113     public static final String NUXEO_CORE_TYPE_WORKSPACEROOT = "WorkspaceRoot";
 114
 115     /**
 116      * Instantiates a new repository java client impl.
 117      */
 118     public RepositoryJavaClientImpl() {
 119         //Empty constructor
 120     }
 121
 122     public void assertWorkflowState(ServiceContext ctx,
 123             DocumentModel docModel) throws DocumentNotFoundException, ClientException {
 124         MultivaluedMap<String, String> queryParams = ctx.getQueryParams();
 125         if (queryParams != null) {
 126             //
 127             // Look for the workflow "delete" query param and see if we need to assert that the
 128             // docModel is in a non-deleted workflow state.
 129             //
 130             String currentState = docModel.getCurrentLifeCycleState();
 131             String includeDeletedStr = queryParams.getFirst(WorkflowClient.WORKFLOW_QUERY_NONDELETED);
 132             boolean includeDeleted = includeDeletedStr == null ? true : Boolean.parseBoolean(includeDeletedStr);
 133             if (includeDeleted == false) {
 134                 //
 135                 // We don't wanted soft-deleted object, so throw an exception if this one is soft-deleted.
 136                 //
 137                 if (currentState.equalsIgnoreCase(WorkflowClient.WORKFLOWSTATE_DELETED)) {
 138                     String msg = "The GET assertion that docModel not be in 'deleted' workflow state failed.";
 139                     logger.debug(msg);
 140                     throw new DocumentNotFoundException(msg);
 141                 }
 142             }
 143         }
 144     }
 145
 146     /**
 147      * create document in the Nuxeo repository
 148      *
 149      * @param ctx service context under which this method is invoked
 150      * @param handler should be used by the caller to provide and transform the
 151      * document
 152      * @return id in repository of the newly created document
 153      * @throws BadRequestException
 154      * @throws TransactionException
 155      * @throws DocumentException
 156      */
 157     @Override
 158     public String create(ServiceContext ctx,
 159             DocumentHandler handler) throws BadRequestException,
 160             TransactionException, DocumentException {
 161
 162         String docType = NuxeoUtils.getTenantQualifiedDocType(ctx); //ctx.getDocumentType();
 163         if (docType == null) {
 164             throw new IllegalArgumentException(
 165                     "RepositoryJavaClient.create: docType is missing");
 166         }
 167
 168         if (handler == null) {
 169             throw new IllegalArgumentException(
 170                     "RepositoryJavaClient.create: handler is missing");
 171         }
 172         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 173         if (nuxeoWspaceId == null) {
 174             throw new DocumentNotFoundException(
 175                     "Unable to find workspace for service " + ctx.getServiceName()
 176                     + " check if the workspace exists in the Nuxeo repository");
 177         }
 178
 179         RepositoryInstance repoSession = null;
 180         try {
 181             handler.prepare(Action.CREATE);
 182             repoSession = getRepositorySession(ctx);
 183             DocumentRef nuxeoWspace = new IdRef(nuxeoWspaceId);
 184             DocumentModel wspaceDoc = repoSession.getDocument(nuxeoWspace);
 185             String wspacePath = wspaceDoc.getPathAsString();
 186             //give our own ID so PathRef could be constructed later on
 187             String id = IdUtils.generateId(UUID.randomUUID().toString());
 188             // create document model
 189             DocumentModel doc = repoSession.createDocumentModel(wspacePath, id, docType);
 190             /* Check for a versioned document, and check In and Out before we proceed.
 191              * This does not work as we do not have the uid schema on our docs.
 192              if(((DocumentModelHandler) handler).supportsVersioning()) {
 193              doc.setProperty("uid","major_version",1);
 194              doc.setProperty("uid","minor_version",0);
 195              }
 196              */
 197             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 198             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 199             handler.handle(Action.CREATE, wrapDoc);
 200             // create document with documentmodel
 201             doc = repoSession.createDocument(doc);
 202             repoSession.save();
 203 // TODO for sub-docs need to call into the handler to let it deal with subitems. Pass in the id,
 204 // and assume the handler has the state it needs (doc fragments).
 205             handler.complete(Action.CREATE, wrapDoc);
 206             return id;
 207         } catch (BadRequestException bre) {
 208             throw bre;
 209         } catch (Exception e) {
 210             logger.error("Caught exception ", e);
 211             throw new DocumentException(e);
 212         } finally {
 213             if (repoSession != null) {
 214                 releaseRepositorySession(ctx, repoSession);
 215             }
 216         }
 217
 218     }
 219
 220     /**
 221      * get document from the Nuxeo repository
 222      *
 223      * @param ctx service context under which this method is invoked
 224      * @param id of the document to retrieve
 225      * @param handler should be used by the caller to provide and transform the
 226      * document
 227      * @throws DocumentNotFoundException if the document cannot be found in the
 228      * repository
 229      * @throws TransactionException
 230      * @throws DocumentException
 231      */
 232     @Override
 233     public void get(ServiceContext ctx, String id, DocumentHandler handler)
 234             throws DocumentNotFoundException, TransactionException, DocumentException {
 235
 236         if (handler == null) {
 237             throw new IllegalArgumentException(
 238                     "RepositoryJavaClient.get: handler is missing");
 239         }
 240
 241         RepositoryInstance repoSession = null;
 242         try {
 243             handler.prepare(Action.GET);
 244             repoSession = getRepositorySession(ctx);
 245             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
 246             DocumentModel docModel = null;
 247             try {
 248                 docModel = repoSession.getDocument(docRef);
 249                 assertWorkflowState(ctx, docModel);
 250             } catch (ClientException ce) {
 251                 String msg = logException(ce, "Could not find document with CSID=" + id);
 252                 throw new DocumentNotFoundException(msg, ce);
 253             }
 254             //
 255             // Set repository session to handle the document
 256             //
 257             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 258             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(docModel);
 259             handler.handle(Action.GET, wrapDoc);
 260             handler.complete(Action.GET, wrapDoc);
 261         } catch (IllegalArgumentException iae) {
 262             throw iae;
 263         } catch (DocumentException de) {
 264             throw de;
 265         } catch (Exception e) {
 266             if (logger.isDebugEnabled()) {
 267                 logger.debug("Caught exception ", e);
 268             }
 269             throw new DocumentException(e);
 270         } finally {
 271             if (repoSession != null) {
 272                 releaseRepositorySession(ctx, repoSession);
 273             }
 274         }
 275     }
 276
 277     /**
 278      * get a document from the Nuxeo repository, using the docFilter params.
 279      *
 280      * @param ctx service context under which this method is invoked
 281      * @param handler should be used by the caller to provide and transform the
 282      * document. Handler must have a docFilter set to return a single item.
 283      * @throws DocumentNotFoundException if the document cannot be found in the
 284      * repository
 285      * @throws TransactionException
 286      * @throws DocumentException
 287      */
 288     @Override
 289     public void get(ServiceContext ctx, DocumentHandler handler)
 290             throws DocumentNotFoundException, TransactionException, DocumentException {
 291         QueryContext queryContext = new QueryContext(ctx, handler);
 292         RepositoryInstance repoSession = null;
 293
 294         try {
 295             handler.prepare(Action.GET);
 296             repoSession = getRepositorySession(ctx);
 297
 298             DocumentModelList docList = null;
 299             // force limit to 1, and ignore totalSize
 300             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 301             docList = repoSession.query(query, null, 1, 0, false);
 302             if (docList.size() != 1) {
 303                 throw new DocumentNotFoundException("No document found matching filter params: " + query);
 304             }
 305             DocumentModel doc = docList.get(0);
 306
 307             if (logger.isDebugEnabled()) {
 308                 logger.debug("Executed NXQL query: " + query);
 309             }
 310
 311             //set reposession to handle the document
 312             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 313             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 314             handler.handle(Action.GET, wrapDoc);
 315             handler.complete(Action.GET, wrapDoc);
 316         } catch (IllegalArgumentException iae) {
 317             throw iae;
 318         } catch (DocumentException de) {
 319             throw de;
 320         } catch (Exception e) {
 321             if (logger.isDebugEnabled()) {
 322                 logger.debug("Caught exception ", e);
 323             }
 324             throw new DocumentException(e);
 325         } finally {
 326             if (repoSession != null) {
 327                 releaseRepositorySession(ctx, repoSession);
 328             }
 329         }
 330     }
 331
 332     public DocumentWrapper<DocumentModel> getDoc(
 333             RepositoryInstance repoSession,
 334             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 335             String csid) throws DocumentNotFoundException, DocumentException {
 336         DocumentWrapper<DocumentModel> wrapDoc = null;
 337
 338         try {
 339             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 340             DocumentModel doc = null;
 341             try {
 342                 doc = repoSession.getDocument(docRef);
 343             } catch (ClientException ce) {
 344                 String msg = logException(ce, "Could not find document with CSID=" + csid);
 345                 throw new DocumentNotFoundException(msg, ce);
 346             }
 347             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 348         } catch (IllegalArgumentException iae) {
 349             throw iae;
 350         } catch (DocumentException de) {
 351             throw de;
 352         }
 353
 354         return wrapDoc;
 355     }
 356
 357     /**
 358      * Get wrapped documentModel from the Nuxeo repository. The search is
 359      * restricted to the workspace of the current context.
 360      *
 361      * @param ctx service context under which this method is invoked
 362      * @param csid of the document to retrieve
 363      * @throws DocumentNotFoundException
 364      * @throws TransactionException
 365      * @throws DocumentException
 366      * @return a wrapped documentModel
 367      */
 368     @Override
 369     public DocumentWrapper<DocumentModel> getDoc(
 370             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 371             String csid) throws DocumentNotFoundException, TransactionException, DocumentException {
 372         RepositoryInstance repoSession = null;
 373         DocumentWrapper<DocumentModel> wrapDoc = null;
 374
 375         try {
 376             // Open a new repository session
 377             repoSession = getRepositorySession(ctx);
 378             wrapDoc = getDoc(repoSession, ctx, csid);
 379         } catch (IllegalArgumentException iae) {
 380             throw iae;
 381         } catch (DocumentException de) {
 382             throw de;
 383         } catch (Exception e) {
 384             if (logger.isDebugEnabled()) {
 385                 logger.debug("Caught exception ", e);
 386             }
 387             throw new DocumentException(e);
 388         } finally {
 389             if (repoSession != null) {
 390                 releaseRepositorySession(ctx, repoSession);
 391             }
 392         }
 393
 394         if (logger.isWarnEnabled() == true) {
 395             logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 396         }
 397         return wrapDoc;
 398     }
 399
 400     public DocumentWrapper<DocumentModel> findDoc(
 401             RepositoryInstance repoSession,
 402             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 403             String whereClause)
 404             throws DocumentNotFoundException, DocumentException {
 405         DocumentWrapper<DocumentModel> wrapDoc = null;
 406
 407         try {
 408             QueryContext queryContext = new QueryContext(ctx, whereClause);
 409             DocumentModelList docList = null;
 410             // force limit to 1, and ignore totalSize
 411             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 412             docList = repoSession.query(query,
 413                     null, //Filter
 414                     1, //limit
 415                     0, //offset
 416                     false); //countTotal
 417             if (docList.size() != 1) {
 418                 if (logger.isDebugEnabled()) {
 419                     logger.debug("findDoc: Query found: " + docList.size() + " items.");
 420                     logger.debug(" Query: " + query);
 421                 }
 422                 throw new DocumentNotFoundException("No document found matching filter params: " + query);
 423             }
 424             DocumentModel doc = docList.get(0);
 425             wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
 426         } catch (IllegalArgumentException iae) {
 427             throw iae;
 428         } catch (DocumentException de) {
 429             throw de;
 430         } catch (Exception e) {
 431             if (logger.isDebugEnabled()) {
 432                 logger.debug("Caught exception ", e);
 433             }
 434             throw new DocumentException(e);
 435         }
 436
 437         return wrapDoc;
 438     }
 439
 440     /**
 441      * find wrapped documentModel from the Nuxeo repository
 442      *
 443      * @param ctx service context under which this method is invoked
 444      * @param whereClause where NXQL where clause to get the document
 445      * @throws DocumentNotFoundException
 446      * @throws TransactionException
 447      * @throws DocumentException
 448      * @return a wrapped documentModel retrieved by the repository query
 449      */
 450     @Override
 451     public DocumentWrapper<DocumentModel> findDoc(
 452             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 453             String whereClause)
 454             throws DocumentNotFoundException, TransactionException, DocumentException {
 455         RepositoryInstance repoSession = null;
 456         DocumentWrapper<DocumentModel> wrapDoc = null;
 457
 458         try {
 459             repoSession = getRepositorySession(ctx);
 460             wrapDoc = findDoc(repoSession, ctx, whereClause);
 461         } catch (Exception e) {
 462             throw new DocumentException("Unable to create a Nuxeo repository session.", e);
 463         } finally {
 464             if (repoSession != null) {
 465                 releaseRepositorySession(ctx, repoSession);
 466             }
 467         }
 468
 469         if (logger.isWarnEnabled() == true) {
 470             logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 471         }
 472
 473         return wrapDoc;
 474     }
 475
 476     /**
 477      * find doc and return CSID from the Nuxeo repository
 478      *
 479      * @param repoSession
 480      * @param ctx service context under which this method is invoked
 481      * @param whereClause where NXQL where clause to get the document
 482      * @throws DocumentNotFoundException
 483      * @throws TransactionException
 484      * @throws DocumentException
 485      * @return the CollectionSpace ID (CSID) of the requested document
 486      */
 487     @Override
 488     public String findDocCSID(RepositoryInstance repoSession,
 489             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx, String whereClause)
 490             throws DocumentNotFoundException, TransactionException, DocumentException {
 491         String csid = null;
 492         boolean releaseSession = false;
 493         try {
 494             if (repoSession == null) {
 495                 repoSession = this.getRepositorySession(ctx);
 496                 releaseSession = true;
 497             }
 498             DocumentWrapper<DocumentModel> wrapDoc = findDoc(repoSession, ctx, whereClause);
 499             DocumentModel docModel = wrapDoc.getWrappedObject();
 500             csid = NuxeoUtils.getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());
 501         } catch (DocumentNotFoundException dnfe) {
 502             throw dnfe;
 503         } catch (IllegalArgumentException iae) {
 504             throw iae;
 505         } catch (DocumentException de) {
 506             throw de;
 507         } catch (Exception e) {
 508             if (logger.isDebugEnabled()) {
 509                 logger.debug("Caught exception ", e);
 510             }
 511             throw new DocumentException(e);
 512         } finally {
 513             if (releaseSession && (repoSession != null)) {
 514                 this.releaseRepositorySession(ctx, repoSession);
 515             }
 516         }
 517         return csid;
 518     }
 519
 520     public DocumentWrapper<DocumentModelList> findDocs(
 521             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 522             RepositoryInstance repoSession,
 523             List<String> docTypes,
 524             String whereClause,
 525             String orderByClause,
 526             int pageSize,
 527             int pageNum,
 528             boolean computeTotal)
 529             throws DocumentNotFoundException, DocumentException {
 530         DocumentWrapper<DocumentModelList> wrapDoc = null;
 531
 532         try {
 533             if (docTypes == null || docTypes.size() < 1) {
 534                 throw new DocumentNotFoundException(
 535                         "The findDocs() method must specify at least one DocumentType.");
 536             }
 537             DocumentModelList docList = null;
 538             QueryContext queryContext = new QueryContext(ctx, whereClause, orderByClause);
 539             String query = NuxeoUtils.buildNXQLQuery(docTypes, queryContext);
 540             if (logger.isDebugEnabled()) {
 541                 logger.debug("findDocs() NXQL: " + query);
 542             }
 543             docList = repoSession.query(query, null, pageSize, pageSize * pageNum, computeTotal);
 544             wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 545         } catch (IllegalArgumentException iae) {
 546             throw iae;
 547         } catch (Exception e) {
 548             if (logger.isDebugEnabled()) {
 549                 logger.debug("Caught exception ", e);
 550             }
 551             throw new DocumentException(e);
 552         }
 553
 554         return wrapDoc;
 555     }
 556
 557     protected static String buildInListForDocTypes(List<String> docTypes) {
 558         StringBuilder sb = new StringBuilder();
 559         sb.append("(");
 560         boolean first = true;
 561         for (String docType : docTypes) {
 562             if (first) {
 563                 first = false;
 564             } else {
 565                 sb.append(",");
 566             }
 567             sb.append("'");
 568             sb.append(docType);
 569             sb.append("'");
 570         }
 571         sb.append(")");
 572         return sb.toString();
 573     }
 574
 575     public DocumentWrapper<DocumentModelList> findDocs(
 576             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 577             DocumentHandler handler,
 578             RepositoryInstance repoSession,
 579             List<String> docTypes)
 580             throws DocumentNotFoundException, DocumentException {
 581         DocumentWrapper<DocumentModelList> wrapDoc = null;
 582
 583         DocumentFilter filter = handler.getDocumentFilter();
 584         String oldOrderBy = filter.getOrderByClause();
 585         if (isClauseEmpty(oldOrderBy) == true) {
 586             filter.setOrderByClause(DocumentFilter.ORDER_BY_LAST_UPDATED);
 587         }
 588         QueryContext queryContext = new QueryContext(ctx, handler);
 589
 590         try {
 591             if (docTypes == null || docTypes.size() < 1) {
 592                 throw new DocumentNotFoundException(
 593                         "The findDocs() method must specify at least one DocumentType.");
 594             }
 595             DocumentModelList docList = null;
 596             if (handler.isCMISQuery() == true) {
 597                 String inList = buildInListForDocTypes(docTypes);
 598                 ctx.getQueryParams().add(IQueryManager.SEARCH_RELATED_MATCH_OBJ_DOCTYPES, inList);
 599                 docList = getFilteredCMIS(repoSession, ctx, handler, queryContext);
 600             } else {
 601                 String query = NuxeoUtils.buildNXQLQuery(docTypes, queryContext);
 602                 if (logger.isDebugEnabled()) {
 603                     logger.debug("findDocs() NXQL: " + query);
 604                 }
 605                 docList = repoSession.query(query, null, filter.getPageSize(), filter.getOffset(), true);
 606             }
 607             wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 608         } catch (IllegalArgumentException iae) {
 609             throw iae;
 610         } catch (Exception e) {
 611             if (logger.isDebugEnabled()) {
 612                 logger.debug("Caught exception ", e);
 613             }
 614             throw new DocumentException(e);
 615         }
 616
 617         return wrapDoc;
 618     }
 619
 620     /**
 621      * Find a list of documentModels from the Nuxeo repository
 622      *
 623      * @param docTypes a list of DocType names to match
 624      * @param whereClause where the clause to qualify on
 625      * @throws DocumentNotFoundException
 626      * @throws TransactionException
 627      * @throws DocumentException
 628      * @return a list of documentModels
 629      */
 630     @Override
 631     public DocumentWrapper<DocumentModelList> findDocs(
 632             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 633             List<String> docTypes,
 634             String whereClause,
 635             int pageSize, int pageNum, boolean computeTotal)
 636             throws DocumentNotFoundException, TransactionException, DocumentException {
 637         RepositoryInstance repoSession = null;
 638         DocumentWrapper<DocumentModelList> wrapDoc = null;
 639
 640         try {
 641             repoSession = getRepositorySession(ctx);
 642             wrapDoc = findDocs(ctx, repoSession, docTypes, whereClause, null,
 643                     pageSize, pageNum, computeTotal);
 644         } catch (IllegalArgumentException iae) {
 645             throw iae;
 646         } catch (Exception e) {
 647             if (logger.isDebugEnabled()) {
 648                 logger.debug("Caught exception ", e);
 649             }
 650             throw new DocumentException(e);
 651         } finally {
 652             if (repoSession != null) {
 653                 releaseRepositorySession(ctx, repoSession);
 654             }
 655         }
 656
 657         if (logger.isWarnEnabled() == true) {
 658             logger.warn("Returned DocumentModelList instance was created with a repository session that is now closed.");
 659         }
 660
 661         return wrapDoc;
 662     }
 663
 664     /* (non-Javadoc)
 665      * @see org.collectionspace.services.common.storage.StorageClient#get(org.collectionspace.services.common.context.ServiceContext, java.util.List, org.collectionspace.services.common.document.DocumentHandler)
 666      */
 667     @Override
 668     public void get(ServiceContext ctx, List<String> csidList, DocumentHandler handler)
 669             throws DocumentNotFoundException, TransactionException, DocumentException {
 670         if (handler == null) {
 671             throw new IllegalArgumentException(
 672                     "RepositoryJavaClient.getAll: handler is missing");
 673         }
 674
 675         RepositoryInstance repoSession = null;
 676         try {
 677             handler.prepare(Action.GET_ALL);
 678             repoSession = getRepositorySession(ctx);
 679             DocumentModelList docModelList = new DocumentModelListImpl();
 680             //FIXME: Should be using NuxeoUtils.createPathRef for security reasons
 681             for (String csid : csidList) {
 682                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
 683                 DocumentModel docModel = repoSession.getDocument(docRef);
 684                 docModelList.add(docModel);
 685             }
 686
 687             //set reposession to handle the document
 688             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 689             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docModelList);
 690             handler.handle(Action.GET_ALL, wrapDoc);
 691             handler.complete(Action.GET_ALL, wrapDoc);
 692         } catch (DocumentException de) {
 693             throw de;
 694         } catch (Exception e) {
 695             if (logger.isDebugEnabled()) {
 696                 logger.debug("Caught exception ", e);
 697             }
 698             throw new DocumentException(e);
 699         } finally {
 700             if (repoSession != null) {
 701                 releaseRepositorySession(ctx, repoSession);
 702             }
 703         }
 704     }
 705
 706     /**
 707      * getAll get all documents for an entity entity service from the Nuxeo
 708      * repository
 709      *
 710      * @param ctx service context under which this method is invoked
 711      * @param handler should be used by the caller to provide and transform the
 712      * document
 713      * @throws DocumentNotFoundException
 714      * @throws TransactionException
 715      * @throws DocumentException
 716      */
 717     @Override
 718     public void getAll(ServiceContext ctx, DocumentHandler handler)
 719             throws DocumentNotFoundException, TransactionException, DocumentException {
 720         if (handler == null) {
 721             throw new IllegalArgumentException(
 722                     "RepositoryJavaClient.getAll: handler is missing");
 723         }
 724         String nuxeoWspaceId = ctx.getRepositoryWorkspaceId();
 725         if (nuxeoWspaceId == null) {
 726             throw new DocumentNotFoundException(
 727                     "Unable to find workspace for service "
 728                     + ctx.getServiceName()
 729                     + " check if the workspace exists in the Nuxeo repository.");
 730         }
 731
 732         RepositoryInstance repoSession = null;
 733         try {
 734             handler.prepare(Action.GET_ALL);
 735             repoSession = getRepositorySession(ctx);
 736             DocumentRef wsDocRef = new IdRef(nuxeoWspaceId);
 737             DocumentModelList docList = repoSession.getChildren(wsDocRef);
 738             //set reposession to handle the document
 739             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 740             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 741             handler.handle(Action.GET_ALL, wrapDoc);
 742             handler.complete(Action.GET_ALL, wrapDoc);
 743         } catch (DocumentException de) {
 744             throw de;
 745         } catch (Exception e) {
 746             if (logger.isDebugEnabled()) {
 747                 logger.debug("Caught exception ", e);
 748             }
 749             throw new DocumentException(e);
 750         } finally {
 751             if (repoSession != null) {
 752                 releaseRepositorySession(ctx, repoSession);
 753             }
 754         }
 755     }
 756
 757     private boolean isClauseEmpty(String theString) {
 758         boolean result = true;
 759         if (theString != null && !theString.isEmpty()) {
 760             result = false;
 761         }
 762         return result;
 763     }
 764
 765     public DocumentWrapper<DocumentModel> getDocFromCsid(
 766             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 767             RepositoryInstance repoSession,
 768             String csid)
 769             throws Exception {
 770         DocumentWrapper<DocumentModel> result = null;
 771
 772         result = new DocumentWrapperImpl(NuxeoUtils.getDocFromCsid(ctx, repoSession, csid));
 773
 774         return result;
 775     }
 776
 777     /*
 778      * A method to find a CollectionSpace document (of any type) given just a service context and
 779      * its CSID.  A search across *all* service workspaces (within a given tenant context) is performed to find
 780      * the document
 781      *
 782      * This query searches Nuxeo's Hierarchy table where our CSIDs are stored in the "name" column.
 783      */
 784     @Override
 785     public DocumentWrapper<DocumentModel> getDocFromCsid(ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 786             String csid)
 787             throws Exception {
 788         DocumentWrapper<DocumentModel> result = null;
 789         RepositoryInstance repoSession = null;
 790         try {
 791             repoSession = getRepositorySession(ctx);
 792             result = getDocFromCsid(ctx, repoSession, csid);
 793         } finally {
 794             if (repoSession != null) {
 795                 releaseRepositorySession(ctx, repoSession);
 796             }
 797         }
 798
 799         if (logger.isWarnEnabled() == true) {
 800             logger.warn("Returned DocumentModel instance was created with a repository session that is now closed.");
 801         }
 802
 803         return result;
 804     }
 805
 806     /**
 807      * Returns a URI value for a document in the Nuxeo repository
 808      *
 809      * @param wrappedDoc a wrapped documentModel
 810      * @throws ClientException
 811      * @return a document URI
 812      */
 813     @Override
 814     public String getDocURI(DocumentWrapper<DocumentModel> wrappedDoc) throws ClientException {
 815         DocumentModel docModel = wrappedDoc.getWrappedObject();
 816         String uri = (String) docModel.getProperty(CollectionSpaceClient.COLLECTIONSPACE_CORE_SCHEMA,
 817                 CollectionSpaceClient.COLLECTIONSPACE_CORE_URI);
 818         return uri;
 819     }
 820
 821     /*
 822      * See CSPACE-5036 - How to make CMISQL queries from Nuxeo
 823      */
 824     private IterableQueryResult makeCMISQLQuery(RepositoryInstance repoSession, String query, QueryContext queryContext) {
 825         IterableQueryResult result = null;
 826
 827         // the NuxeoRepository should be constructed only once, then cached
 828         // (its construction is expensive)
 829         try {
 830             NuxeoRepository repo = new NuxeoRepository(
 831                     repoSession.getRepositoryName(), repoSession
 832                     .getRootDocument().getId());
 833             logger.debug("Repository ID:" + repo.getId() + " Root folder:"
 834                     + repo.getRootFolderId());
 835
 836             CallContextImpl callContext = new CallContextImpl(
 837                     CallContext.BINDING_LOCAL, repo.getId(), false);
 838             callContext.put(CallContext.USERNAME, repoSession.getPrincipal()
 839                     .getName());
 840             NuxeoCmisService cmisService = new NuxeoCmisService(repo,
 841                     callContext, repoSession);
 842
 843             result = repoSession.queryAndFetch(query, "CMISQL", cmisService);
 844         } catch (ClientException e) {
 845             // TODO Auto-generated catch block
 846             logger.error("Encounter trouble making the following CMIS query: " + query, e);
 847         }
 848
 849         return result;
 850     }
 851
 852     /**
 853      * getFiltered get all documents for an entity service from the Document
 854      * repository, given filter parameters specified by the handler.
 855      *
 856      * @param ctx service context under which this method is invoked
 857      * @param handler should be used by the caller to provide and transform the
 858      * document
 859      * @throws DocumentNotFoundException if workspace not found
 860      * @throws TransactionException
 861      * @throws DocumentException
 862      */
 863     @Override
 864     public void getFiltered(ServiceContext ctx, DocumentHandler handler)
 865             throws DocumentNotFoundException, TransactionException, DocumentException {
 866
 867         DocumentFilter filter = handler.getDocumentFilter();
 868         String oldOrderBy = filter.getOrderByClause();
 869         if (isClauseEmpty(oldOrderBy) == true) {
 870             filter.setOrderByClause(DocumentFilter.ORDER_BY_LAST_UPDATED);
 871         }
 872         QueryContext queryContext = new QueryContext(ctx, handler);
 873
 874         RepositoryInstance repoSession = null;
 875         try {
 876             handler.prepare(Action.GET_ALL);
 877             repoSession = getRepositorySession(ctx); //Keeps a refcount here for the repository session so you need to release this when finished
 878
 879             DocumentModelList docList = null;
 880             String query = NuxeoUtils.buildNXQLQuery(ctx, queryContext);
 881
 882             if (logger.isDebugEnabled()) {
 883                 logger.debug("Executing NXQL query: " + query.toString());
 884             }
 885
 886             // If we have limit and/or offset, then pass true to get totalSize
 887             // in returned DocumentModelList.
 888             Profiler profiler = new Profiler(this, 2);
 889             profiler.log("Executing NXQL query: " + query.toString());
 890             profiler.start();
 891             if (handler.isJDBCQuery() == true) {
 892                 docList = getFilteredJDBC(repoSession, ctx, handler, queryContext);
 893             } else if (handler.isCMISQuery() == true) {
 894                 docList = getFilteredCMIS(repoSession, ctx, handler, queryContext); //FIXME: REM - Need to deal with paging info in CMIS query
 895             } else if ((queryContext.getDocFilter().getOffset() > 0) || (queryContext.getDocFilter().getPageSize() > 0)) {
 896                 docList = repoSession.query(query, null,
 897                         queryContext.getDocFilter().getPageSize(), queryContext.getDocFilter().getOffset(), true);
 898             } else {
 899                 docList = repoSession.query(query);
 900             }
 901             profiler.stop();
 902
 903             //set repoSession to handle the document
 904             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
 905             DocumentWrapper<DocumentModelList> wrapDoc = new DocumentWrapperImpl<DocumentModelList>(docList);
 906             handler.handle(Action.GET_ALL, wrapDoc);
 907             handler.complete(Action.GET_ALL, wrapDoc);
 908         } catch (DocumentException de) {
 909             throw de;
 910         } catch (Exception e) {
 911             if (logger.isDebugEnabled()) {
 912                 logger.debug("Caught exception ", e);
 913             }
 914             throw new DocumentException(e);
 915         } finally {
 916             if (repoSession != null) {
 917                 releaseRepositorySession(ctx, repoSession);
 918             }
 919         }
 920     }
 921
 922     private DocumentModelList getFilteredJDBC(RepositoryInstance repoSession, ServiceContext ctx,
 923             DocumentHandler handler, QueryContext queryContext) throws Exception {
 924         DocumentModelList result = new DocumentModelListImpl();
 925
 926         // FIXME: Get all of the following values from appropriate external constants.
 927         //
 928         // At present, the two constants below are duplicated in both RepositoryJavaClientImpl
 929         // and in AuthorityItemDocumentModelHandler.
 930         final String TERM_GROUP_LIST_NAME = "TERM_GROUP_LIST_NAME";
 931         final String TERM_GROUP_TABLE_NAME_PARAM = "TERM_GROUP_TABLE_NAME";
 932         final String IN_AUTHORITY_PARAM = "IN_AUTHORITY";
 933         // Get this from a constant in AuthorityResource or equivalent
 934         final String PARENT_WILDCARD = "_ALL_";
 935
 936         // Build two SQL statements, to be executed within a single transaction:
 937         // the first statement to control join order, and the second statement
 938         // representing the actual 'get filtered' query
 939
 940         // Build the join control statement
 941         //
 942         // Per http://www.postgresql.org/docs/9.2/static/runtime-config-query.html#GUC-JOIN-COLLAPSE-LIMIT
 943         // "Setting [this value] to 1 prevents any reordering of explicit JOINs.
 944         // Thus, the explicit join order specified in the query will be the
 945         // actual order in which the relations are joined."
 946         // See CSPACE-5945 for further discussion of why this setting is needed.
 947         String joinControlSql = "SET LOCAL join_collapse_limit TO 1;";
 948
 949         // Build the query statement
 950         //
 951         // Start with the default query
 952         String selectStatement =
 953                 "SELECT DISTINCT commonschema.id"
 954                 + " FROM " + handler.getServiceContext().getCommonPartLabel() + " commonschema";
 955
 956         String joinClauses =
 957                 " INNER JOIN misc"
 958                 + "  ON misc.id = commonschema.id"
 959                 + " INNER JOIN hierarchy hierarchy_termgroup"
 960                 + "  ON hierarchy_termgroup.parentid = misc.id"
 961                 + " INNER JOIN "  + handler.getJDBCQueryParams().get(TERM_GROUP_TABLE_NAME_PARAM) + " termgroup"
 962                 + "  ON termgroup.id = hierarchy_termgroup.id ";
 963
 964         String whereClause;
 965         MultivaluedMap<String, String> queryParams = ctx.getQueryParams();
 966         String partialTerm = queryParams.getFirst(IQueryManager.SEARCH_TYPE_PARTIALTERM);
 967         // If the value of the partial term query parameter is blank ('pt='),
 968         // return all records, subject to restriction by any limit clause
 969         if (Tools.isBlank(partialTerm)) {
 970            whereClause = "";
 971         } else {
 972            // Otherwise, return records that match the supplied partial term
 973            whereClause =
 974                 " WHERE (termgroup.termdisplayname ILIKE ?)";
 975         }
 976
 977         // At present, results are ordered in code, below, rather than in SQL,
 978         // and the orderByClause below is thus intentionally blank.
 979         //
 980         // To implement the orderByClause below in SQL; e.g. via
 981         // 'ORDER BY termgroup.termdisplayname', the relevant column
 982         // must be returned by the SELECT statement.
 983         String orderByClause = "";
 984
 985         String limitClause;
 986         TenantBindingConfigReaderImpl tReader =
 987                 ServiceMain.getInstance().getTenantBindingConfigReader();
 988         TenantBindingType tenantBinding = tReader.getTenantBinding(ctx.getTenantId());
 989         String maxListItemsLimit = TenantBindingUtils.getPropertyValue(tenantBinding,
 990                 IQueryManager.MAX_LIST_ITEMS_RETURNED_LIMIT_ON_JDBC_QUERIES);
 991         limitClause =
 992                 " LIMIT " + getMaxItemsLimitOnJdbcQueries(maxListItemsLimit); // implicit int-to-String conversion
 993
 994         List<String> params = new ArrayList<>();
 995
 996         // Read tenant bindings configuration to determine whether
 997         // to automatically insert leading, as well as trailing, wildcards
 998         // into the term matching string.
 999         String usesStartingWildcard = TenantBindingUtils.getPropertyValue(tenantBinding,
1000                 IQueryManager.TENANT_USES_STARTING_WILDCARD_FOR_PARTIAL_TERM);
1001         // Handle user-provided leading wildcard characters, in the
1002         // configuration where a leading wildcard is not automatically inserted.
1003         // (The user-provided wildcard must be in the first, or "starting"
1004         // character position in the partial term value.)
1005         if (Tools.notBlank(usesStartingWildcard) && usesStartingWildcard.equalsIgnoreCase(Boolean.FALSE.toString())) {
1006             partialTerm = handleProvidedStartingWildcard(partialTerm);
1007             // Otherwise, automatically insert a leading wildcard
1008         } else {
1009             partialTerm = JDBCTools.SQL_WILDCARD + partialTerm;
1010         }
1011         // Automatically insert a trailing wildcard
1012         params.add(partialTerm + JDBCTools.SQL_WILDCARD); // Value for replaceable parameter 1 in the query
1013
1014         // Optionally add restrictions to the default query, based on variables
1015         // in the current request
1016
1017         // Restrict the query to filter out deleted records, if requested
1018         String includeDeleted = queryParams.getFirst(WorkflowClient.WORKFLOW_QUERY_NONDELETED);
1019         if (includeDeleted != null && includeDeleted.equalsIgnoreCase(Boolean.FALSE.toString())) {
1020             whereClause = whereClause
1021                 + "  AND (misc.lifecyclestate <> '" + WorkflowClient.WORKFLOWSTATE_DELETED + "')";
1022         }
1023
1024         // If a particular authority is specified, restrict the query further
1025         // to return only records within that authority
1026         String inAuthorityValue = (String) handler.getJDBCQueryParams().get(IN_AUTHORITY_PARAM);
1027         if (Tools.notBlank(inAuthorityValue)) {
1028             // Handle the '_ALL_' case for inAuthority
1029             if (inAuthorityValue.equals(PARENT_WILDCARD)) {
1030                 // Add nothing to the query here if it should match within all authorities
1031             } else {
1032                 joinClauses = joinClauses
1033                     + " INNER JOIN " + handler.getServiceContext().getCommonPartLabel() + " commonschema"
1034                     + "  ON commonschema.id = hierarchy_termgroup.parentid";
1035                 whereClause = whereClause
1036                     + "  AND (commonschema.inauthority = ?)";
1037                 params.add(inAuthorityValue); // Value for replaceable parameter 2 in the query
1038             }
1039         }
1040
1041         // Restrict the query further to return only records pertaining to
1042         // the current tenant, unless:
1043         // * Data for this service, in this tenant, is stored in its own,
1044         //   separate repository, rather than being intermingled with other
1045         //   tenants' data in the default repository; or
1046         // * Restriction by tenant ID in JDBC queries has been disabled,
1047         //   via configuration for this tenant,
1048         if (restrictJDBCQueryByTenantID(tenantBinding, ctx)) {
1049                 joinClauses = joinClauses
1050                     + " INNER JOIN collectionspace_core core"
1051                     + "  ON core.id = hierarchy_termgroup.parentid";
1052                 whereClause = whereClause
1053                     + "  AND (core.tenantid = ?)";
1054                 params.add(ctx.getTenantId()); // Value for replaceable parameter 3 in the query
1055         }
1056
1057         // Piece together the SQL query from its parts
1058         String querySql = selectStatement + joinClauses + whereClause + orderByClause + limitClause;
1059
1060         // Note: PostgreSQL 9.2 introduced a change that may improve performance
1061         // of certain queries using JDBC PreparedStatements.  See comments on
1062         // CSPACE-5943 for details.
1063         PreparedStatementBuilder joinControlBuilder = new PreparedStatementBuilder(joinControlSql);
1064         PreparedStatementSimpleBuilder queryBuilder = new PreparedStatementSimpleBuilder(querySql, params);
1065         List<PreparedStatementBuilder> builders = new ArrayList<>();
1066         builders.add(joinControlBuilder);
1067         builders.add(queryBuilder);
1068         String dataSourceName = JDBCTools.NUXEO_DATASOURCE_NAME;
1069         String repositoryName = ctx.getRepositoryName();
1070         final Boolean EXECUTE_WITHIN_TRANSACTION = true;
1071         Set<String> docIds = new HashSet<>();
1072         try {
1073             List<CachedRowSet> resultsList = JDBCTools.executePreparedQueries(builders,
1074                 dataSourceName, repositoryName, EXECUTE_WITHIN_TRANSACTION);
1075
1076             // One set of results are expected, from the second prepared statement executed.
1077             // If fewer results are returned, return an empty list of document models
1078             if (resultsList == null || resultsList.size() < 1) {
1079                 return result;
1080             }
1081             // Join control query will not return results, so query results will
1082             // be the first set of results (rowSet) returned in the list
1083             CachedRowSet queryResults = resultsList.get(0);
1084
1085             // If the result from executing the query is null or contains zero rows,
1086             // return an empty list of document models
1087             if (queryResults == null) {
1088                 return result;
1089             }
1090             queryResults.last();
1091             if (queryResults.getRow() == 0) {
1092                 return result; // empty list of document models
1093             }
1094
1095             // Otherwise, get the document IDs from the results of the query
1096             String id;
1097             queryResults.beforeFirst();
1098             while (queryResults.next()) {
1099                 id = queryResults.getString(1);
1100                 if (Tools.notBlank(id)) {
1101                     docIds.add(id);
1102                 }
1103             }
1104         } catch (SQLException sqle) {
1105             logger.warn("Could not obtain document IDs via SQL query '" + querySql + "': " + sqle.getMessage());
1106             return result; // return an empty list of document models
1107         }
1108
1109         // Get a list of document models, using the IDs obtained from the query
1110         DocumentModel docModel;
1111         for (String docId : docIds) {
1112             docModel = NuxeoUtils.getDocumentModel(repoSession, docId);
1113             if (docModel == null) {
1114                 logger.warn("Could not obtain document model for document with ID " + docId);
1115             } else {
1116                 result.add(NuxeoUtils.getDocumentModel(repoSession, docId));
1117             }
1118         }
1119
1120         // Order the results
1121         final String COMMON_PART_SCHEMA = handler.getServiceContext().getCommonPartLabel();
1122         final String DISPLAY_NAME_XPATH =
1123                 "//" + handler.getJDBCQueryParams().get(TERM_GROUP_LIST_NAME) + "/[0]/termDisplayName";
1124         Collections.sort(result, new Comparator<DocumentModel>() {
1125             @Override
1126             public int compare(DocumentModel doc1, DocumentModel doc2) {
1127                 String termDisplayName1 = (String) NuxeoUtils.getXPathValue(doc1, COMMON_PART_SCHEMA, DISPLAY_NAME_XPATH);
1128                 String termDisplayName2 = (String) NuxeoUtils.getXPathValue(doc2, COMMON_PART_SCHEMA, DISPLAY_NAME_XPATH);
1129                 return termDisplayName1.compareTo(termDisplayName2);
1130             }
1131         });
1132
1133         return result;
1134     }
1135
1136
1137     private DocumentModelList getFilteredCMIS(RepositoryInstance repoSession, ServiceContext ctx, DocumentHandler handler, QueryContext queryContext)
1138             throws DocumentNotFoundException, DocumentException {
1139
1140         DocumentModelList result = new DocumentModelListImpl();
1141         try {
1142             String query = handler.getCMISQuery(queryContext);
1143
1144             DocumentFilter docFilter = handler.getDocumentFilter();
1145             int pageSize = docFilter.getPageSize();
1146             int offset = docFilter.getOffset();
1147             if (logger.isDebugEnabled()) {
1148                 logger.debug("Executing CMIS query: " + query.toString()
1149                         + "with pageSize: " + pageSize + " at offset: " + offset);
1150             }
1151
1152             // If we have limit and/or offset, then pass true to get totalSize
1153             // in returned DocumentModelList.
1154             Profiler profiler = new Profiler(this, 2);
1155             profiler.log("Executing CMIS query: " + query.toString());
1156             profiler.start();
1157             //
1158             IterableQueryResult queryResult = makeCMISQLQuery(repoSession, query, queryContext);
1159             try {
1160                 int totalSize = (int) queryResult.size();
1161                 ((DocumentModelListImpl) result).setTotalSize(totalSize);
1162                 // Skip the rows before our offset
1163                 if (offset > 0) {
1164                     queryResult.skipTo(offset);
1165                 }
1166                 int nRows = 0;
1167                 for (Map<String, Serializable> row : queryResult) {
1168                     if (logger.isTraceEnabled()) {
1169                         logger.trace(" Hierarchy Table ID is:" + row.get(IQueryManager.CMIS_TARGET_NUXEO_ID)
1170                                 + " nuxeo:pathSegment is: " + row.get(IQueryManager.CMIS_TARGET_NAME));
1171                     }
1172                     String nuxeoId = (String) row.get(IQueryManager.CMIS_TARGET_NUXEO_ID);
1173                     DocumentModel docModel = NuxeoUtils.getDocumentModel(repoSession, nuxeoId);
1174                     result.add(docModel);
1175                     nRows++;
1176                     if (nRows >= pageSize && pageSize != 0) { // A page size of zero means that they want all of them
1177                         logger.debug("Got page full of items - quitting");
1178                         break;
1179                     }
1180                 }
1181             } finally {
1182                 queryResult.close();
1183             }
1184             //
1185             profiler.stop();
1186
1187         } catch (Exception e) {
1188             if (logger.isDebugEnabled()) {
1189                 logger.debug("Caught exception ", e);
1190             }
1191             throw new DocumentException(e);
1192         }
1193
1194         //
1195         // Since we're not supporting paging yet for CMIS queries, we need to perform
1196         // a workaround for the paging information we return in our list of results
1197         //
1198         /*
1199          if (result != null) {
1200          docFilter.setStartPage(0);
1201          if (totalSize > docFilter.getPageSize()) {
1202          docFilter.setPageSize(totalSize);
1203          ((DocumentModelListImpl)result).setTotalSize(totalSize);
1204          }
1205          }
1206          */
1207
1208         return result;
1209     }
1210
1211     private String logException(Exception e, String msg) {
1212         String result = null;
1213
1214         String exceptionMessage = e.getMessage();
1215         exceptionMessage = exceptionMessage != null ? exceptionMessage : "<No details provided>";
1216         result = msg = msg + ". Caught exception:" + exceptionMessage;
1217
1218         if (logger.isTraceEnabled() == true) {
1219             logger.error(msg, e);
1220         } else {
1221             logger.error(msg);
1222         }
1223
1224         return result;
1225     }
1226
1227     /**
1228      * update given document in the Nuxeo repository
1229      *
1230      * @param ctx service context under which this method is invoked
1231      * @param csid of the document
1232      * @param handler should be used by the caller to provide and transform the
1233      * document
1234      * @throws BadRequestException
1235      * @throws DocumentNotFoundException
1236      * @throws TransactionException if the transaction times out or otherwise
1237      * cannot be successfully completed
1238      * @throws DocumentException
1239      */
1240     @Override
1241     public void update(ServiceContext ctx, String csid, DocumentHandler handler)
1242             throws BadRequestException, DocumentNotFoundException, TransactionException,
1243             DocumentException {
1244         if (handler == null) {
1245             throw new IllegalArgumentException(
1246                     "RepositoryJavaClient.update: document handler is missing.");
1247         }
1248
1249         RepositoryInstance repoSession = null;
1250         try {
1251             handler.prepare(Action.UPDATE);
1252             repoSession = getRepositorySession(ctx);
1253             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
1254             DocumentModel doc = null;
1255             try {
1256                 doc = repoSession.getDocument(docRef);
1257             } catch (ClientException ce) {
1258                 String msg = logException(ce, "Could not find document to update with CSID=" + csid);
1259                 throw new DocumentNotFoundException(msg, ce);
1260             }
1261             // Check for a versioned document, and check In and Out before we proceed.
1262             if (((DocumentModelHandler) handler).supportsVersioning()) {
1263                 /* Once we advance to 5.5 or later, we can add this.
1264                  * See also https://jira.nuxeo.com/browse/NXP-8506
1265                  if(!doc.isVersionable()) {
1266                  throw new DocumentException("Configuration for: "
1267                  +handler.getServiceContextPath()+" supports versioning, but Nuxeo config does not!");
1268                  }
1269                  */
1270                 /* Force a version number - Not working. Apparently we need to configure the uid schema??
1271                  if(doc.getProperty("uid","major_version") == null) {
1272                  doc.setProperty("uid","major_version",1);
1273                  }
1274                  if(doc.getProperty("uid","minor_version") == null) {
1275                  doc.setProperty("uid","minor_version",0);
1276                  }
1277                  */
1278                 doc.checkIn(VersioningOption.MINOR, null);
1279                 doc.checkOut();
1280             }
1281
1282             //
1283             // Set reposession to handle the document
1284             //
1285             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
1286             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
1287             handler.handle(Action.UPDATE, wrapDoc);
1288             repoSession.saveDocument(doc);
1289             repoSession.save();
1290             handler.complete(Action.UPDATE, wrapDoc);
1291         } catch (BadRequestException bre) {
1292             throw bre;
1293         } catch (DocumentException de) {
1294             throw de;
1295         } catch (WebApplicationException wae) {
1296             throw wae;
1297         } catch (Exception e) {
1298             if (logger.isDebugEnabled()) {
1299                 logger.debug("Caught exception ", e);
1300             }
1301             throw new DocumentException(e);
1302         } finally {
1303             if (repoSession != null) {
1304                 releaseRepositorySession(ctx, repoSession);
1305             }
1306         }
1307     }
1308
1309     /**
1310      * Save a documentModel to the Nuxeo repository.
1311      *
1312      * @param ctx service context under which this method is invoked
1313      * @param repoSession
1314      * @param docModel the document to save
1315      * @param fSaveSession if TRUE, will call CoreSession.save() to save
1316      * accumulated changes.
1317      * @throws ClientException
1318      * @throws DocumentException
1319      */
1320     public void saveDocWithoutHandlerProcessing(
1321             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
1322             RepositoryInstance repoSession,
1323             DocumentModel docModel,
1324             boolean fSaveSession)
1325             throws ClientException, DocumentException {
1326
1327         try {
1328             repoSession.saveDocument(docModel);
1329             if (fSaveSession) {
1330                 repoSession.save();
1331             }
1332         } catch (ClientException ce) {
1333             throw ce;
1334         } catch (Exception e) {
1335             if (logger.isDebugEnabled()) {
1336                 logger.debug("Caught exception ", e);
1337             }
1338             throw new DocumentException(e);
1339         }
1340     }
1341
1342     /**
1343      * Save a list of documentModels to the Nuxeo repository.
1344      *
1345      * @param ctx service context under which this method is invoked
1346      * @param repoSession a repository session
1347      * @param docModelList a list of document models
1348      * @param fSaveSession if TRUE, will call CoreSession.save() to save
1349      * accumulated changes.
1350      * @throws ClientException
1351      * @throws DocumentException
1352      */
1353     public void saveDocListWithoutHandlerProcessing(
1354             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
1355             RepositoryInstance repoSession,
1356             DocumentModelList docList,
1357             boolean fSaveSession)
1358             throws ClientException, DocumentException {
1359         try {
1360             DocumentModel[] docModelArray = new DocumentModel[docList.size()];
1361             repoSession.saveDocuments(docList.toArray(docModelArray));
1362             if (fSaveSession) {
1363                 repoSession.save();
1364             }
1365         } catch (ClientException ce) {
1366             throw ce;
1367         } catch (Exception e) {
1368             logger.error("Caught exception ", e);
1369             throw new DocumentException(e);
1370         }
1371     }
1372
1373     /**
1374      * delete a document from the Nuxeo repository
1375      *
1376      * @param ctx service context under which this method is invoked
1377      * @param id of the document
1378      * @throws DocumentException
1379      */
1380     @Override
1381     public void delete(ServiceContext ctx, String id, DocumentHandler handler) throws DocumentNotFoundException,
1382             DocumentException, TransactionException {
1383         if (ctx == null) {
1384             throw new IllegalArgumentException(
1385                     "delete(ctx, ix, handler): ctx is missing");
1386         }
1387         if (handler == null) {
1388             throw new IllegalArgumentException(
1389                     "delete(ctx, ix, handler): handler is missing");
1390         }
1391         if (logger.isDebugEnabled()) {
1392             logger.debug("Deleting document with CSID=" + id);
1393         }
1394         RepositoryInstance repoSession = null;
1395         try {
1396             handler.prepare(Action.DELETE);
1397             repoSession = getRepositorySession(ctx);
1398             DocumentWrapper<DocumentModel> wrapDoc = null;
1399             try {
1400                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
1401                 wrapDoc = new DocumentWrapperImpl<DocumentModel>(repoSession.getDocument(docRef));
1402                 ((DocumentModelHandler) handler).setRepositorySession(repoSession);
1403                 handler.handle(Action.DELETE, wrapDoc);
1404                 repoSession.removeDocument(docRef);
1405             } catch (ClientException ce) {
1406                 String msg = logException(ce, "Could not find document to delete with CSID=" + id);
1407                 throw new DocumentNotFoundException(msg, ce);
1408             }
1409             repoSession.save();
1410             handler.complete(Action.DELETE, wrapDoc);
1411         } catch (DocumentException de) {
1412             throw de;
1413         } catch (Exception e) {
1414             if (logger.isDebugEnabled()) {
1415                 logger.debug("Caught exception ", e);
1416             }
1417             throw new DocumentException(e);
1418         } finally {
1419             if (repoSession != null) {
1420                 releaseRepositorySession(ctx, repoSession);
1421             }
1422         }
1423     }
1424
1425     /* (non-Javadoc)
1426      * @see org.collectionspace.services.common.storage.StorageClient#delete(org.collectionspace.services.common.context.ServiceContext, java.lang.String, org.collectionspace.services.common.document.DocumentHandler)
1427      */
1428     @Override
1429     @Deprecated
1430     public void delete(@SuppressWarnings("rawtypes") ServiceContext ctx, String id)
1431             throws DocumentNotFoundException, DocumentException {
1432         throw new UnsupportedOperationException();
1433         // Use the other delete instead
1434     }
1435
1436     @Override
1437     public Hashtable<String, String> retrieveWorkspaceIds(RepositoryDomainType repoDomain) throws Exception {
1438         return NuxeoConnectorEmbedded.getInstance().retrieveWorkspaceIds(repoDomain);
1439     }
1440
1441     @Override
1442     public String createDomain(RepositoryDomainType repositoryDomain) throws Exception {
1443         RepositoryInstance repoSession = null;
1444         String domainId = null;
1445         try {
1446             //
1447             // Open a connection to the domain's repo/db
1448             //
1449             String repoName = repositoryDomain.getRepositoryName();
1450             repoSession = getRepositorySession(repoName); // domainName=storageName=repoName=databaseName
1451             //
1452             // First create the top-level domain directory
1453             //
1454             String domainName = repositoryDomain.getStorageName();
1455             DocumentRef parentDocRef = new PathRef("/");
1456             DocumentModel parentDoc = repoSession.getDocument(parentDocRef);
1457             DocumentModel domainDoc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1458                     domainName, NUXEO_CORE_TYPE_DOMAIN);
1459             domainDoc.setPropertyValue("dc:title", domainName);
1460             domainDoc.setPropertyValue("dc:description", "A CollectionSpace domain "
1461                     + domainName);
1462             domainDoc = repoSession.createDocument(domainDoc);
1463             domainId = domainDoc.getId();
1464             repoSession.save();
1465             //
1466             // Next, create a "Workspaces" root directory to contain the workspace folders for the individual service documents
1467             //
1468             DocumentModel workspacesRoot = repoSession.createDocumentModel(domainDoc.getPathAsString(),
1469                     NuxeoUtils.Workspaces, NUXEO_CORE_TYPE_WORKSPACEROOT);
1470             workspacesRoot.setPropertyValue("dc:title", NuxeoUtils.Workspaces);
1471             workspacesRoot.setPropertyValue("dc:description", "A CollectionSpace workspaces directory for "
1472                     + domainDoc.getPathAsString());
1473             workspacesRoot = repoSession.createDocument(workspacesRoot);
1474             String workspacesRootId = workspacesRoot.getId();
1475             repoSession.save();
1476
1477             if (logger.isDebugEnabled()) {
1478                 logger.debug("Created tenant domain name=" + domainName
1479                         + " id=" + domainId + " "
1480                         + NuxeoUtils.Workspaces + " id=" + workspacesRootId);
1481                 logger.debug("Path to Domain: " + domainDoc.getPathAsString());
1482                 logger.debug("Path to Workspaces root: " + workspacesRoot.getPathAsString());
1483             }
1484         } catch (Exception e) {
1485             if (logger.isDebugEnabled()) {
1486                 logger.debug("Could not create tenant domain name=" + repositoryDomain.getStorageName() + " caught exception ", e);
1487             }
1488             throw e;
1489         } finally {
1490             if (repoSession != null) {
1491                 releaseRepositorySession(null, repoSession);
1492             }
1493         }
1494
1495         return domainId;
1496     }
1497
1498     @Override
1499     public String getDomainId(RepositoryDomainType repositoryDomain) throws Exception {
1500         String domainId = null;
1501         RepositoryInstance repoSession = null;
1502
1503         String repoName = repositoryDomain.getRepositoryName();
1504         String domainStorageName = repositoryDomain.getStorageName();
1505         if (domainStorageName != null && !domainStorageName.isEmpty()) {
1506             try {
1507                 repoSession = getRepositorySession(repoName);
1508                 DocumentRef docRef = new PathRef("/" + domainStorageName);
1509                 DocumentModel domain = repoSession.getDocument(docRef);
1510                 domainId = domain.getId();
1511             } catch (Exception e) {
1512                 if (logger.isTraceEnabled()) {
1513                     logger.trace("Caught exception ", e);  // The document doesn't exist, this let's us know we need to create it
1514                 }
1515                 //there is no way to identify if document does not exist due to
1516                 //lack of typed exception for getDocument method
1517                 return null;
1518             } finally {
1519                 if (repoSession != null) {
1520                     releaseRepositorySession(null, repoSession);
1521                 }
1522             }
1523         }
1524
1525         return domainId;
1526     }
1527
1528     /*
1529      * Returns the workspaces root directory for a given domain.
1530      */
1531     private DocumentModel getWorkspacesRoot(RepositoryInstance repoSession,
1532             String domainName) throws Exception {
1533         DocumentModel result = null;
1534
1535         String domainPath = "/" + domainName;
1536         DocumentRef parentDocRef = new PathRef(domainPath);
1537         DocumentModelList domainChildrenList = repoSession.getChildren(
1538                 parentDocRef);
1539         Iterator<DocumentModel> witer = domainChildrenList.iterator();
1540         while (witer.hasNext()) {
1541             DocumentModel childNode = witer.next();
1542             if (NuxeoUtils.Workspaces.equalsIgnoreCase(childNode.getName())) {
1543                 result = childNode;
1544                 logger.trace("Found workspaces directory at: " + result.getPathAsString());
1545                 break;
1546             }
1547         }
1548
1549         if (result == null) {
1550             throw new ClientException("Could not find workspace root directory in: "
1551                     + domainPath);
1552         }
1553
1554         return result;
1555     }
1556
1557     /* (non-Javadoc)
1558      * @see org.collectionspace.services.common.repository.RepositoryClient#createWorkspace(java.lang.String, java.lang.String)
1559      */
1560     @Override
1561     public String createWorkspace(RepositoryDomainType repositoryDomain, String workspaceName) throws Exception {
1562         RepositoryInstance repoSession = null;
1563         String workspaceId = null;
1564         try {
1565             String repoName = repositoryDomain.getRepositoryName();
1566             repoSession = getRepositorySession(repoName);
1567
1568             String domainStorageName = repositoryDomain.getStorageName();
1569             DocumentModel parentDoc = getWorkspacesRoot(repoSession, domainStorageName);
1570             if (logger.isTraceEnabled()) {
1571                 for (String facet : parentDoc.getFacets()) {
1572                     logger.trace("Facet: " + facet);
1573                 }
1574             }
1575
1576             DocumentModel doc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1577                     workspaceName, NuxeoUtils.WORKSPACE_DOCUMENT_TYPE);
1578             doc.setPropertyValue("dc:title", workspaceName);
1579             doc.setPropertyValue("dc:description", "A CollectionSpace workspace for "
1580                     + workspaceName);
1581             doc = repoSession.createDocument(doc);
1582             workspaceId = doc.getId();
1583             repoSession.save();
1584             if (logger.isDebugEnabled()) {
1585                 logger.debug("Created workspace name=" + workspaceName
1586                         + " id=" + workspaceId);
1587             }
1588         } catch (Exception e) {
1589             if (logger.isDebugEnabled()) {
1590                 logger.debug("createWorkspace caught exception ", e);
1591             }
1592             throw e;
1593         } finally {
1594             if (repoSession != null) {
1595                 releaseRepositorySession(null, repoSession);
1596             }
1597         }
1598         return workspaceId;
1599     }
1600
1601     /* (non-Javadoc)
1602      * @see org.collectionspace.services.common.repository.RepositoryClient#getWorkspaceId(java.lang.String, java.lang.String)
1603      */
1604     @Override
1605     @Deprecated
1606     public String getWorkspaceId(String tenantDomain, String workspaceName) throws Exception {
1607         String workspaceId = null;
1608
1609         RepositoryInstance repoSession = null;
1610         try {
1611             repoSession = getRepositorySession((ServiceContext) null);
1612             DocumentRef docRef = new PathRef(
1613                     "/" + tenantDomain
1614                     + "/" + NuxeoUtils.Workspaces
1615                     + "/" + workspaceName);
1616             DocumentModel workspace = repoSession.getDocument(docRef);
1617             workspaceId = workspace.getId();
1618         } catch (DocumentException de) {
1619             throw de;
1620         } catch (Exception e) {
1621             if (logger.isDebugEnabled()) {
1622                 logger.debug("Caught exception ", e);
1623             }
1624             throw new DocumentException(e);
1625         } finally {
1626             if (repoSession != null) {
1627                 releaseRepositorySession(null, repoSession);
1628             }
1629         }
1630
1631         return workspaceId;
1632     }
1633
1634     public RepositoryInstance getRepositorySession(ServiceContext ctx) throws Exception {
1635         return getRepositorySession(ctx, ctx.getRepositoryName());
1636     }
1637
1638     public RepositoryInstance getRepositorySession(String repoName) throws Exception {
1639         return getRepositorySession(null, repoName);
1640     }
1641
1642     /**
1643      * Gets the repository session. - Package access only. If the 'ctx' param is
1644      * null then the repo name must be non-mull and vice-versa
1645      *
1646      * @return the repository session
1647      * @throws Exception the exception
1648      */
1649     public RepositoryInstance getRepositorySession(ServiceContext ctx, String repoName) throws Exception {
1650         RepositoryInstance repoSession = null;
1651
1652         Profiler profiler = new Profiler("getRepositorySession():", 2);
1653         profiler.start();
1654         //
1655         // To get a connection to the Nuxeo repo, we need either a valid ServiceContext instance or a repository name
1656         //
1657         if (ctx != null) {
1658             repoName = ctx.getRepositoryName(); // Notice we are overriding the passed in 'repoName' since we have a valid service context passed in to us
1659             repoSession = (RepositoryInstance) ctx.getCurrentRepositorySession(); // Look to see if one exists in the context before creating one
1660         } else if (repoName == null || repoName.trim().isEmpty()) {
1661             String errMsg = String.format("We can't get a connection to the Nuxeo repo because the service context passed in was null and no repository name was passed in either.");
1662             logger.error(errMsg);
1663             throw new Exception(errMsg);
1664         }
1665         //
1666         // If we couldn't find a repoSession from the service context (or the context was null) then we need to create a new one using
1667         // just the repo name
1668         //
1669         if (repoSession == null) {
1670             NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1671             repoSession = client.openRepository(repoName);
1672         } else {
1673             if (logger.isDebugEnabled() == true) {
1674                 logger.warn("Reusing the current context's repository session.");
1675             }
1676         }
1677
1678         if (logger.isTraceEnabled()) {
1679             logger.trace("Testing call to getRepository() repository root: " + repoSession.getRootDocument());
1680         }
1681
1682         profiler.stop();
1683
1684         if (ctx != null) {
1685             ctx.setCurrentRepositorySession(repoSession); // For reusing, save the repository session in the current service context
1686         }
1687
1688         return repoSession;
1689     }
1690
1691     /**
1692      * Release repository session. - Package access only.
1693      *
1694      * @param repoSession the repo session
1695      */
1696     public void releaseRepositorySession(ServiceContext ctx, RepositoryInstance repoSession) throws TransactionException {
1697         try {
1698             NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1699             // release session
1700             if (ctx != null) {
1701                 ctx.clearCurrentRepositorySession(); //clear the current context of the now closed repo session
1702                 if (ctx.getCurrentRepositorySession() == null) {
1703                     client.releaseRepository(repoSession); //release the repo session if the service context's ref count is zeo.
1704                 }
1705             } else {
1706                 client.releaseRepository(repoSession); //repo session was acquired without a service context
1707             }
1708         } catch (TransactionRuntimeException tre) {
1709             TransactionException te = new TransactionException(tre);
1710             logger.error(te.getMessage(), tre); // Log the standard transaction exception message, plus an exception-specific stack trace
1711             throw te;
1712         } catch (Exception e) {
1713             logger.error("Could not close the repository session", e);
1714             // no need to throw this service specific exception
1715         }
1716     }
1717
1718     @Override
1719     public void doWorkflowTransition(ServiceContext ctx, String id,
1720             DocumentHandler handler, TransitionDef transitionDef)
1721             throws BadRequestException, DocumentNotFoundException,
1722             DocumentException {
1723         // 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
1724     }
1725
1726     private String handleProvidedStartingWildcard(String partialTerm) {
1727         if (Tools.notBlank(partialTerm)) {
1728             // FIXME: Get this value from an existing constant, if available
1729             final String USER_SUPPLIED_WILDCARD = "*";
1730             if (partialTerm.substring(0, 1).equals(USER_SUPPLIED_WILDCARD)) {
1731                 StringBuffer buffer = new StringBuffer(partialTerm);
1732                 buffer.setCharAt(0, JDBCTools.SQL_WILDCARD.charAt(0));
1733                 partialTerm = buffer.toString();
1734             }
1735         }
1736         return partialTerm;
1737     }
1738
1739     private int getMaxItemsLimitOnJdbcQueries(String maxListItemsLimit) {
1740         final int DEFAULT_ITEMS_LIMIT = 40;
1741         int itemsLimit;
1742         try {
1743             itemsLimit = Integer.parseInt(maxListItemsLimit);
1744             if (itemsLimit < 1) {
1745                 logger.warn("Value of configuration setting "
1746                         + IQueryManager.MAX_LIST_ITEMS_RETURNED_LIMIT_ON_JDBC_QUERIES
1747                         + " must be a positive integer; current value is " + maxListItemsLimit);
1748                 itemsLimit = DEFAULT_ITEMS_LIMIT;
1749             }
1750         } catch (NumberFormatException nfe) {
1751             logger.warn("Value of configuration setting "
1752                         + IQueryManager.MAX_LIST_ITEMS_RETURNED_LIMIT_ON_JDBC_QUERIES
1753                         + " must be a positive integer; current value is " + maxListItemsLimit);
1754             itemsLimit = DEFAULT_ITEMS_LIMIT;
1755         }
1756         return itemsLimit;
1757     }
1758
1759     /**
1760      * Identifies whether a restriction on tenant ID - to return only records
1761      * pertaining to the current tenant - is required in a JDBC query.
1762      *
1763      * @param tenantBinding a tenant binding configuration.
1764      * @param ctx a service context.
1765      * @return true if a restriction on tenant ID is required in the query;
1766      * false if a restriction is not required.
1767      */
1768     private boolean restrictJDBCQueryByTenantID(TenantBindingType tenantBinding, ServiceContext ctx) {
1769         boolean restrict = true;
1770         // If data for the current service, in the current tenant, is isolated
1771         // within its own separate, per-tenant repository, as contrasted with
1772         // being intermingled with other tenants' data in the default repository,
1773         // no restriction on Tenant ID is required in the query.
1774         String repositoryDomainName = ConfigUtils.getRepositoryName(tenantBinding, ctx.getRepositoryDomainName());
1775         if (!(repositoryDomainName.equals(ConfigUtils.DEFAULT_NUXEO_REPOSITORY_NAME))) {
1776             restrict = false;
1777         }
1778         // If a configuration setting for this tenant identifies that JDBC
1779         // queries should not be restricted by tenant ID (perhaps because
1780         // there is always expected to be only one tenant's data present in
1781         // the system), no restriction on Tenant ID is required in the query.
1782         String queriesRestrictedByTenantId = TenantBindingUtils.getPropertyValue(tenantBinding,
1783                 IQueryManager.JDBC_QUERIES_ARE_TENANT_ID_RESTRICTED);
1784         if (Tools.notBlank(queriesRestrictedByTenantId) &&
1785                 queriesRestrictedByTenantId.equalsIgnoreCase(Boolean.FALSE.toString())) {
1786             restrict = false;
1787         }
1788         return restrict;
1789     }
1790 }