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                 whereClause = whereClause
1033                     + "  AND (commonschema.inauthority = ?)";
1034                 params.add(inAuthorityValue); // Value for replaceable parameter 2 in the query
1035             }
1036         }
1037
1038         // Restrict the query further to return only records pertaining to
1039         // the current tenant, unless:
1040         // * Data for this service, in this tenant, is stored in its own,
1041         //   separate repository, rather than being intermingled with other
1042         //   tenants' data in the default repository; or
1043         // * Restriction by tenant ID in JDBC queries has been disabled,
1044         //   via configuration for this tenant,
1045         if (restrictJDBCQueryByTenantID(tenantBinding, ctx)) {
1046                 joinClauses = joinClauses
1047                     + " INNER JOIN collectionspace_core core"
1048                     + "  ON core.id = hierarchy_termgroup.parentid";
1049                 whereClause = whereClause
1050                     + "  AND (core.tenantid = ?)";
1051                 params.add(ctx.getTenantId()); // Value for replaceable parameter 3 in the query
1052         }
1053
1054         // Piece together the SQL query from its parts
1055         String querySql = selectStatement + joinClauses + whereClause + orderByClause + limitClause;
1056
1057         // Note: PostgreSQL 9.2 introduced a change that may improve performance
1058         // of certain queries using JDBC PreparedStatements.  See comments on
1059         // CSPACE-5943 for details.
1060         PreparedStatementBuilder joinControlBuilder = new PreparedStatementBuilder(joinControlSql);
1061         PreparedStatementSimpleBuilder queryBuilder = new PreparedStatementSimpleBuilder(querySql, params);
1062         List<PreparedStatementBuilder> builders = new ArrayList<>();
1063         builders.add(joinControlBuilder);
1064         builders.add(queryBuilder);
1065         String dataSourceName = JDBCTools.NUXEO_DATASOURCE_NAME;
1066         String repositoryName = ctx.getRepositoryName();
1067         final Boolean EXECUTE_WITHIN_TRANSACTION = true;
1068         Set<String> docIds = new HashSet<>();
1069         try {
1070             List<CachedRowSet> resultsList = JDBCTools.executePreparedQueries(builders,
1071                 dataSourceName, repositoryName, EXECUTE_WITHIN_TRANSACTION);
1072
1073             // One set of results are expected, from the second prepared statement executed.
1074             // If fewer results are returned, return an empty list of document models
1075             if (resultsList == null || resultsList.size() < 1) {
1076                 return result;
1077             }
1078             // Join control query will not return results, so query results will
1079             // be the first set of results (rowSet) returned in the list
1080             CachedRowSet queryResults = resultsList.get(0);
1081
1082             // If the result from executing the query is null or contains zero rows,
1083             // return an empty list of document models
1084             if (queryResults == null) {
1085                 return result;
1086             }
1087             queryResults.last();
1088             if (queryResults.getRow() == 0) {
1089                 return result; // empty list of document models
1090             }
1091
1092             // Otherwise, get the document IDs from the results of the query
1093             String id;
1094             queryResults.beforeFirst();
1095             while (queryResults.next()) {
1096                 id = queryResults.getString(1);
1097                 if (Tools.notBlank(id)) {
1098                     docIds.add(id);
1099                 }
1100             }
1101         } catch (SQLException sqle) {
1102             logger.warn("Could not obtain document IDs via SQL query '" + querySql + "': " + sqle.getMessage());
1103             return result; // return an empty list of document models
1104         }
1105
1106         // Get a list of document models, using the IDs obtained from the query
1107         DocumentModel docModel;
1108         for (String docId : docIds) {
1109             docModel = NuxeoUtils.getDocumentModel(repoSession, docId);
1110             if (docModel == null) {
1111                 logger.warn("Could not obtain document model for document with ID " + docId);
1112             } else {
1113                 result.add(NuxeoUtils.getDocumentModel(repoSession, docId));
1114             }
1115         }
1116
1117         // Order the results
1118         final String COMMON_PART_SCHEMA = handler.getServiceContext().getCommonPartLabel();
1119         final String DISPLAY_NAME_XPATH =
1120                 "//" + handler.getJDBCQueryParams().get(TERM_GROUP_LIST_NAME) + "/[0]/termDisplayName";
1121         Collections.sort(result, new Comparator<DocumentModel>() {
1122             @Override
1123             public int compare(DocumentModel doc1, DocumentModel doc2) {
1124                 String termDisplayName1 = (String) NuxeoUtils.getXPathValue(doc1, COMMON_PART_SCHEMA, DISPLAY_NAME_XPATH);
1125                 String termDisplayName2 = (String) NuxeoUtils.getXPathValue(doc2, COMMON_PART_SCHEMA, DISPLAY_NAME_XPATH);
1126                 return termDisplayName1.compareTo(termDisplayName2);
1127             }
1128         });
1129
1130         return result;
1131     }
1132
1133
1134     private DocumentModelList getFilteredCMIS(RepositoryInstance repoSession, ServiceContext ctx, DocumentHandler handler, QueryContext queryContext)
1135             throws DocumentNotFoundException, DocumentException {
1136
1137         DocumentModelList result = new DocumentModelListImpl();
1138         try {
1139             String query = handler.getCMISQuery(queryContext);
1140
1141             DocumentFilter docFilter = handler.getDocumentFilter();
1142             int pageSize = docFilter.getPageSize();
1143             int offset = docFilter.getOffset();
1144             if (logger.isDebugEnabled()) {
1145                 logger.debug("Executing CMIS query: " + query.toString()
1146                         + "with pageSize: " + pageSize + " at offset: " + offset);
1147             }
1148
1149             // If we have limit and/or offset, then pass true to get totalSize
1150             // in returned DocumentModelList.
1151             Profiler profiler = new Profiler(this, 2);
1152             profiler.log("Executing CMIS query: " + query.toString());
1153             profiler.start();
1154             //
1155             IterableQueryResult queryResult = makeCMISQLQuery(repoSession, query, queryContext);
1156             try {
1157                 int totalSize = (int) queryResult.size();
1158                 ((DocumentModelListImpl) result).setTotalSize(totalSize);
1159                 // Skip the rows before our offset
1160                 if (offset > 0) {
1161                     queryResult.skipTo(offset);
1162                 }
1163                 int nRows = 0;
1164                 for (Map<String, Serializable> row : queryResult) {
1165                     if (logger.isTraceEnabled()) {
1166                         logger.trace(" Hierarchy Table ID is:" + row.get(IQueryManager.CMIS_TARGET_NUXEO_ID)
1167                                 + " nuxeo:pathSegment is: " + row.get(IQueryManager.CMIS_TARGET_NAME));
1168                     }
1169                     String nuxeoId = (String) row.get(IQueryManager.CMIS_TARGET_NUXEO_ID);
1170                     DocumentModel docModel = NuxeoUtils.getDocumentModel(repoSession, nuxeoId);
1171                     result.add(docModel);
1172                     nRows++;
1173                     if (nRows >= pageSize && pageSize != 0) { // A page size of zero means that they want all of them
1174                         logger.debug("Got page full of items - quitting");
1175                         break;
1176                     }
1177                 }
1178             } finally {
1179                 queryResult.close();
1180             }
1181             //
1182             profiler.stop();
1183
1184         } catch (Exception e) {
1185             if (logger.isDebugEnabled()) {
1186                 logger.debug("Caught exception ", e);
1187             }
1188             throw new DocumentException(e);
1189         }
1190
1191         //
1192         // Since we're not supporting paging yet for CMIS queries, we need to perform
1193         // a workaround for the paging information we return in our list of results
1194         //
1195         /*
1196          if (result != null) {
1197          docFilter.setStartPage(0);
1198          if (totalSize > docFilter.getPageSize()) {
1199          docFilter.setPageSize(totalSize);
1200          ((DocumentModelListImpl)result).setTotalSize(totalSize);
1201          }
1202          }
1203          */
1204
1205         return result;
1206     }
1207
1208     private String logException(Exception e, String msg) {
1209         String result = null;
1210
1211         String exceptionMessage = e.getMessage();
1212         exceptionMessage = exceptionMessage != null ? exceptionMessage : "<No details provided>";
1213         result = msg = msg + ". Caught exception:" + exceptionMessage;
1214
1215         if (logger.isTraceEnabled() == true) {
1216             logger.error(msg, e);
1217         } else {
1218             logger.error(msg);
1219         }
1220
1221         return result;
1222     }
1223
1224     /**
1225      * update given document in the Nuxeo repository
1226      *
1227      * @param ctx service context under which this method is invoked
1228      * @param csid of the document
1229      * @param handler should be used by the caller to provide and transform the
1230      * document
1231      * @throws BadRequestException
1232      * @throws DocumentNotFoundException
1233      * @throws TransactionException if the transaction times out or otherwise
1234      * cannot be successfully completed
1235      * @throws DocumentException
1236      */
1237     @Override
1238     public void update(ServiceContext ctx, String csid, DocumentHandler handler)
1239             throws BadRequestException, DocumentNotFoundException, TransactionException,
1240             DocumentException {
1241         if (handler == null) {
1242             throw new IllegalArgumentException(
1243                     "RepositoryJavaClient.update: document handler is missing.");
1244         }
1245
1246         RepositoryInstance repoSession = null;
1247         try {
1248             handler.prepare(Action.UPDATE);
1249             repoSession = getRepositorySession(ctx);
1250             DocumentRef docRef = NuxeoUtils.createPathRef(ctx, csid);
1251             DocumentModel doc = null;
1252             try {
1253                 doc = repoSession.getDocument(docRef);
1254             } catch (ClientException ce) {
1255                 String msg = logException(ce, "Could not find document to update with CSID=" + csid);
1256                 throw new DocumentNotFoundException(msg, ce);
1257             }
1258             // Check for a versioned document, and check In and Out before we proceed.
1259             if (((DocumentModelHandler) handler).supportsVersioning()) {
1260                 /* Once we advance to 5.5 or later, we can add this.
1261                  * See also https://jira.nuxeo.com/browse/NXP-8506
1262                  if(!doc.isVersionable()) {
1263                  throw new DocumentException("Configuration for: "
1264                  +handler.getServiceContextPath()+" supports versioning, but Nuxeo config does not!");
1265                  }
1266                  */
1267                 /* Force a version number - Not working. Apparently we need to configure the uid schema??
1268                  if(doc.getProperty("uid","major_version") == null) {
1269                  doc.setProperty("uid","major_version",1);
1270                  }
1271                  if(doc.getProperty("uid","minor_version") == null) {
1272                  doc.setProperty("uid","minor_version",0);
1273                  }
1274                  */
1275                 doc.checkIn(VersioningOption.MINOR, null);
1276                 doc.checkOut();
1277             }
1278
1279             //
1280             // Set reposession to handle the document
1281             //
1282             ((DocumentModelHandler) handler).setRepositorySession(repoSession);
1283             DocumentWrapper<DocumentModel> wrapDoc = new DocumentWrapperImpl<DocumentModel>(doc);
1284             handler.handle(Action.UPDATE, wrapDoc);
1285             repoSession.saveDocument(doc);
1286             repoSession.save();
1287             handler.complete(Action.UPDATE, wrapDoc);
1288         } catch (BadRequestException bre) {
1289             throw bre;
1290         } catch (DocumentException de) {
1291             throw de;
1292         } catch (WebApplicationException wae) {
1293             throw wae;
1294         } catch (Exception e) {
1295             if (logger.isDebugEnabled()) {
1296                 logger.debug("Caught exception ", e);
1297             }
1298             throw new DocumentException(e);
1299         } finally {
1300             if (repoSession != null) {
1301                 releaseRepositorySession(ctx, repoSession);
1302             }
1303         }
1304     }
1305
1306     /**
1307      * Save a documentModel to the Nuxeo repository.
1308      *
1309      * @param ctx service context under which this method is invoked
1310      * @param repoSession
1311      * @param docModel the document to save
1312      * @param fSaveSession if TRUE, will call CoreSession.save() to save
1313      * accumulated changes.
1314      * @throws ClientException
1315      * @throws DocumentException
1316      */
1317     public void saveDocWithoutHandlerProcessing(
1318             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
1319             RepositoryInstance repoSession,
1320             DocumentModel docModel,
1321             boolean fSaveSession)
1322             throws ClientException, DocumentException {
1323
1324         try {
1325             repoSession.saveDocument(docModel);
1326             if (fSaveSession) {
1327                 repoSession.save();
1328             }
1329         } catch (ClientException ce) {
1330             throw ce;
1331         } catch (Exception e) {
1332             if (logger.isDebugEnabled()) {
1333                 logger.debug("Caught exception ", e);
1334             }
1335             throw new DocumentException(e);
1336         }
1337     }
1338
1339     /**
1340      * Save a list of documentModels to the Nuxeo repository.
1341      *
1342      * @param ctx service context under which this method is invoked
1343      * @param repoSession a repository session
1344      * @param docModelList a list of document models
1345      * @param fSaveSession if TRUE, will call CoreSession.save() to save
1346      * accumulated changes.
1347      * @throws ClientException
1348      * @throws DocumentException
1349      */
1350     public void saveDocListWithoutHandlerProcessing(
1351             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
1352             RepositoryInstance repoSession,
1353             DocumentModelList docList,
1354             boolean fSaveSession)
1355             throws ClientException, DocumentException {
1356         try {
1357             DocumentModel[] docModelArray = new DocumentModel[docList.size()];
1358             repoSession.saveDocuments(docList.toArray(docModelArray));
1359             if (fSaveSession) {
1360                 repoSession.save();
1361             }
1362         } catch (ClientException ce) {
1363             throw ce;
1364         } catch (Exception e) {
1365             logger.error("Caught exception ", e);
1366             throw new DocumentException(e);
1367         }
1368     }
1369
1370     /**
1371      * delete a document from the Nuxeo repository
1372      *
1373      * @param ctx service context under which this method is invoked
1374      * @param id of the document
1375      * @throws DocumentException
1376      */
1377     @Override
1378     public void delete(ServiceContext ctx, String id, DocumentHandler handler) throws DocumentNotFoundException,
1379             DocumentException, TransactionException {
1380         if (ctx == null) {
1381             throw new IllegalArgumentException(
1382                     "delete(ctx, ix, handler): ctx is missing");
1383         }
1384         if (handler == null) {
1385             throw new IllegalArgumentException(
1386                     "delete(ctx, ix, handler): handler is missing");
1387         }
1388         if (logger.isDebugEnabled()) {
1389             logger.debug("Deleting document with CSID=" + id);
1390         }
1391         RepositoryInstance repoSession = null;
1392         try {
1393             handler.prepare(Action.DELETE);
1394             repoSession = getRepositorySession(ctx);
1395             DocumentWrapper<DocumentModel> wrapDoc = null;
1396             try {
1397                 DocumentRef docRef = NuxeoUtils.createPathRef(ctx, id);
1398                 wrapDoc = new DocumentWrapperImpl<DocumentModel>(repoSession.getDocument(docRef));
1399                 ((DocumentModelHandler) handler).setRepositorySession(repoSession);
1400                 handler.handle(Action.DELETE, wrapDoc);
1401                 repoSession.removeDocument(docRef);
1402             } catch (ClientException ce) {
1403                 String msg = logException(ce, "Could not find document to delete with CSID=" + id);
1404                 throw new DocumentNotFoundException(msg, ce);
1405             }
1406             repoSession.save();
1407             handler.complete(Action.DELETE, wrapDoc);
1408         } catch (DocumentException de) {
1409             throw de;
1410         } catch (Exception e) {
1411             if (logger.isDebugEnabled()) {
1412                 logger.debug("Caught exception ", e);
1413             }
1414             throw new DocumentException(e);
1415         } finally {
1416             if (repoSession != null) {
1417                 releaseRepositorySession(ctx, repoSession);
1418             }
1419         }
1420     }
1421
1422     /* (non-Javadoc)
1423      * @see org.collectionspace.services.common.storage.StorageClient#delete(org.collectionspace.services.common.context.ServiceContext, java.lang.String, org.collectionspace.services.common.document.DocumentHandler)
1424      */
1425     @Override
1426     @Deprecated
1427     public void delete(@SuppressWarnings("rawtypes") ServiceContext ctx, String id)
1428             throws DocumentNotFoundException, DocumentException {
1429         throw new UnsupportedOperationException();
1430         // Use the other delete instead
1431     }
1432
1433     @Override
1434     public Hashtable<String, String> retrieveWorkspaceIds(RepositoryDomainType repoDomain) throws Exception {
1435         return NuxeoConnectorEmbedded.getInstance().retrieveWorkspaceIds(repoDomain);
1436     }
1437
1438     @Override
1439     public String createDomain(RepositoryDomainType repositoryDomain) throws Exception {
1440         RepositoryInstance repoSession = null;
1441         String domainId = null;
1442         try {
1443             //
1444             // Open a connection to the domain's repo/db
1445             //
1446             String repoName = repositoryDomain.getRepositoryName();
1447             repoSession = getRepositorySession(repoName); // domainName=storageName=repoName=databaseName
1448             //
1449             // First create the top-level domain directory
1450             //
1451             String domainName = repositoryDomain.getStorageName();
1452             DocumentRef parentDocRef = new PathRef("/");
1453             DocumentModel parentDoc = repoSession.getDocument(parentDocRef);
1454             DocumentModel domainDoc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1455                     domainName, NUXEO_CORE_TYPE_DOMAIN);
1456             domainDoc.setPropertyValue("dc:title", domainName);
1457             domainDoc.setPropertyValue("dc:description", "A CollectionSpace domain "
1458                     + domainName);
1459             domainDoc = repoSession.createDocument(domainDoc);
1460             domainId = domainDoc.getId();
1461             repoSession.save();
1462             //
1463             // Next, create a "Workspaces" root directory to contain the workspace folders for the individual service documents
1464             //
1465             DocumentModel workspacesRoot = repoSession.createDocumentModel(domainDoc.getPathAsString(),
1466                     NuxeoUtils.Workspaces, NUXEO_CORE_TYPE_WORKSPACEROOT);
1467             workspacesRoot.setPropertyValue("dc:title", NuxeoUtils.Workspaces);
1468             workspacesRoot.setPropertyValue("dc:description", "A CollectionSpace workspaces directory for "
1469                     + domainDoc.getPathAsString());
1470             workspacesRoot = repoSession.createDocument(workspacesRoot);
1471             String workspacesRootId = workspacesRoot.getId();
1472             repoSession.save();
1473
1474             if (logger.isDebugEnabled()) {
1475                 logger.debug("Created tenant domain name=" + domainName
1476                         + " id=" + domainId + " "
1477                         + NuxeoUtils.Workspaces + " id=" + workspacesRootId);
1478                 logger.debug("Path to Domain: " + domainDoc.getPathAsString());
1479                 logger.debug("Path to Workspaces root: " + workspacesRoot.getPathAsString());
1480             }
1481         } catch (Exception e) {
1482             if (logger.isDebugEnabled()) {
1483                 logger.debug("Could not create tenant domain name=" + repositoryDomain.getStorageName() + " caught exception ", e);
1484             }
1485             throw e;
1486         } finally {
1487             if (repoSession != null) {
1488                 releaseRepositorySession(null, repoSession);
1489             }
1490         }
1491
1492         return domainId;
1493     }
1494
1495     @Override
1496     public String getDomainId(RepositoryDomainType repositoryDomain) throws Exception {
1497         String domainId = null;
1498         RepositoryInstance repoSession = null;
1499
1500         String repoName = repositoryDomain.getRepositoryName();
1501         String domainStorageName = repositoryDomain.getStorageName();
1502         if (domainStorageName != null && !domainStorageName.isEmpty()) {
1503             try {
1504                 repoSession = getRepositorySession(repoName);
1505                 DocumentRef docRef = new PathRef("/" + domainStorageName);
1506                 DocumentModel domain = repoSession.getDocument(docRef);
1507                 domainId = domain.getId();
1508             } catch (Exception e) {
1509                 if (logger.isTraceEnabled()) {
1510                     logger.trace("Caught exception ", e);  // The document doesn't exist, this let's us know we need to create it
1511                 }
1512                 //there is no way to identify if document does not exist due to
1513                 //lack of typed exception for getDocument method
1514                 return null;
1515             } finally {
1516                 if (repoSession != null) {
1517                     releaseRepositorySession(null, repoSession);
1518                 }
1519             }
1520         }
1521
1522         return domainId;
1523     }
1524
1525     /*
1526      * Returns the workspaces root directory for a given domain.
1527      */
1528     private DocumentModel getWorkspacesRoot(RepositoryInstance repoSession,
1529             String domainName) throws Exception {
1530         DocumentModel result = null;
1531
1532         String domainPath = "/" + domainName;
1533         DocumentRef parentDocRef = new PathRef(domainPath);
1534         DocumentModelList domainChildrenList = repoSession.getChildren(
1535                 parentDocRef);
1536         Iterator<DocumentModel> witer = domainChildrenList.iterator();
1537         while (witer.hasNext()) {
1538             DocumentModel childNode = witer.next();
1539             if (NuxeoUtils.Workspaces.equalsIgnoreCase(childNode.getName())) {
1540                 result = childNode;
1541                 logger.trace("Found workspaces directory at: " + result.getPathAsString());
1542                 break;
1543             }
1544         }
1545
1546         if (result == null) {
1547             throw new ClientException("Could not find workspace root directory in: "
1548                     + domainPath);
1549         }
1550
1551         return result;
1552     }
1553
1554     /* (non-Javadoc)
1555      * @see org.collectionspace.services.common.repository.RepositoryClient#createWorkspace(java.lang.String, java.lang.String)
1556      */
1557     @Override
1558     public String createWorkspace(RepositoryDomainType repositoryDomain, String workspaceName) throws Exception {
1559         RepositoryInstance repoSession = null;
1560         String workspaceId = null;
1561         try {
1562             String repoName = repositoryDomain.getRepositoryName();
1563             repoSession = getRepositorySession(repoName);
1564
1565             String domainStorageName = repositoryDomain.getStorageName();
1566             DocumentModel parentDoc = getWorkspacesRoot(repoSession, domainStorageName);
1567             if (logger.isTraceEnabled()) {
1568                 for (String facet : parentDoc.getFacets()) {
1569                     logger.trace("Facet: " + facet);
1570                 }
1571             }
1572
1573             DocumentModel doc = repoSession.createDocumentModel(parentDoc.getPathAsString(),
1574                     workspaceName, NuxeoUtils.WORKSPACE_DOCUMENT_TYPE);
1575             doc.setPropertyValue("dc:title", workspaceName);
1576             doc.setPropertyValue("dc:description", "A CollectionSpace workspace for "
1577                     + workspaceName);
1578             doc = repoSession.createDocument(doc);
1579             workspaceId = doc.getId();
1580             repoSession.save();
1581             if (logger.isDebugEnabled()) {
1582                 logger.debug("Created workspace name=" + workspaceName
1583                         + " id=" + workspaceId);
1584             }
1585         } catch (Exception e) {
1586             if (logger.isDebugEnabled()) {
1587                 logger.debug("createWorkspace caught exception ", e);
1588             }
1589             throw e;
1590         } finally {
1591             if (repoSession != null) {
1592                 releaseRepositorySession(null, repoSession);
1593             }
1594         }
1595         return workspaceId;
1596     }
1597
1598     /* (non-Javadoc)
1599      * @see org.collectionspace.services.common.repository.RepositoryClient#getWorkspaceId(java.lang.String, java.lang.String)
1600      */
1601     @Override
1602     @Deprecated
1603     public String getWorkspaceId(String tenantDomain, String workspaceName) throws Exception {
1604         String workspaceId = null;
1605
1606         RepositoryInstance repoSession = null;
1607         try {
1608             repoSession = getRepositorySession((ServiceContext) null);
1609             DocumentRef docRef = new PathRef(
1610                     "/" + tenantDomain
1611                     + "/" + NuxeoUtils.Workspaces
1612                     + "/" + workspaceName);
1613             DocumentModel workspace = repoSession.getDocument(docRef);
1614             workspaceId = workspace.getId();
1615         } catch (DocumentException de) {
1616             throw de;
1617         } catch (Exception e) {
1618             if (logger.isDebugEnabled()) {
1619                 logger.debug("Caught exception ", e);
1620             }
1621             throw new DocumentException(e);
1622         } finally {
1623             if (repoSession != null) {
1624                 releaseRepositorySession(null, repoSession);
1625             }
1626         }
1627
1628         return workspaceId;
1629     }
1630
1631     public RepositoryInstance getRepositorySession(ServiceContext ctx) throws Exception {
1632         return getRepositorySession(ctx, ctx.getRepositoryName());
1633     }
1634
1635     public RepositoryInstance getRepositorySession(String repoName) throws Exception {
1636         return getRepositorySession(null, repoName);
1637     }
1638
1639     /**
1640      * Gets the repository session. - Package access only. If the 'ctx' param is
1641      * null then the repo name must be non-mull and vice-versa
1642      *
1643      * @return the repository session
1644      * @throws Exception the exception
1645      */
1646     public RepositoryInstance getRepositorySession(ServiceContext ctx, String repoName) throws Exception {
1647         RepositoryInstance repoSession = null;
1648
1649         Profiler profiler = new Profiler("getRepositorySession():", 2);
1650         profiler.start();
1651         //
1652         // To get a connection to the Nuxeo repo, we need either a valid ServiceContext instance or a repository name
1653         //
1654         if (ctx != null) {
1655             repoName = ctx.getRepositoryName(); // Notice we are overriding the passed in 'repoName' since we have a valid service context passed in to us
1656             repoSession = (RepositoryInstance) ctx.getCurrentRepositorySession(); // Look to see if one exists in the context before creating one
1657         } else if (repoName == null || repoName.trim().isEmpty()) {
1658             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.");
1659             logger.error(errMsg);
1660             throw new Exception(errMsg);
1661         }
1662         //
1663         // 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
1664         // just the repo name
1665         //
1666         if (repoSession == null) {
1667             NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1668             repoSession = client.openRepository(repoName);
1669         } else {
1670             if (logger.isDebugEnabled() == true) {
1671                 logger.warn("Reusing the current context's repository session.");
1672             }
1673         }
1674
1675         if (logger.isTraceEnabled()) {
1676             logger.trace("Testing call to getRepository() repository root: " + repoSession.getRootDocument());
1677         }
1678
1679         profiler.stop();
1680
1681         if (ctx != null) {
1682             ctx.setCurrentRepositorySession(repoSession); // For reusing, save the repository session in the current service context
1683         }
1684
1685         return repoSession;
1686     }
1687
1688     /**
1689      * Release repository session. - Package access only.
1690      *
1691      * @param repoSession the repo session
1692      */
1693     public void releaseRepositorySession(ServiceContext ctx, RepositoryInstance repoSession) throws TransactionException {
1694         try {
1695             NuxeoClientEmbedded client = NuxeoConnectorEmbedded.getInstance().getClient();
1696             // release session
1697             if (ctx != null) {
1698                 ctx.clearCurrentRepositorySession(); //clear the current context of the now closed repo session
1699                 if (ctx.getCurrentRepositorySession() == null) {
1700                     client.releaseRepository(repoSession); //release the repo session if the service context's ref count is zeo.
1701                 }
1702             } else {
1703                 client.releaseRepository(repoSession); //repo session was acquired without a service context
1704             }
1705         } catch (TransactionRuntimeException tre) {
1706             TransactionException te = new TransactionException(tre);
1707             logger.error(te.getMessage(), tre); // Log the standard transaction exception message, plus an exception-specific stack trace
1708             throw te;
1709         } catch (Exception e) {
1710             logger.error("Could not close the repository session", e);
1711             // no need to throw this service specific exception
1712         }
1713     }
1714
1715     @Override
1716     public void doWorkflowTransition(ServiceContext ctx, String id,
1717             DocumentHandler handler, TransitionDef transitionDef)
1718             throws BadRequestException, DocumentNotFoundException,
1719             DocumentException {
1720         // 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
1721     }
1722
1723     private String handleProvidedStartingWildcard(String partialTerm) {
1724         if (Tools.notBlank(partialTerm)) {
1725             // FIXME: Get this value from an existing constant, if available
1726             final String USER_SUPPLIED_WILDCARD = "*";
1727             if (partialTerm.substring(0, 1).equals(USER_SUPPLIED_WILDCARD)) {
1728                 StringBuffer buffer = new StringBuffer(partialTerm);
1729                 buffer.setCharAt(0, JDBCTools.SQL_WILDCARD.charAt(0));
1730                 partialTerm = buffer.toString();
1731             }
1732         }
1733         return partialTerm;
1734     }
1735
1736     private int getMaxItemsLimitOnJdbcQueries(String maxListItemsLimit) {
1737         final int DEFAULT_ITEMS_LIMIT = 40;
1738         int itemsLimit;
1739         try {
1740             itemsLimit = Integer.parseInt(maxListItemsLimit);
1741             if (itemsLimit < 1) {
1742                 logger.warn("Value of configuration setting "
1743                         + IQueryManager.MAX_LIST_ITEMS_RETURNED_LIMIT_ON_JDBC_QUERIES
1744                         + " must be a positive integer; current value is " + maxListItemsLimit);
1745                 itemsLimit = DEFAULT_ITEMS_LIMIT;
1746             }
1747         } catch (NumberFormatException nfe) {
1748             logger.warn("Value of configuration setting "
1749                         + IQueryManager.MAX_LIST_ITEMS_RETURNED_LIMIT_ON_JDBC_QUERIES
1750                         + " must be a positive integer; current value is " + maxListItemsLimit);
1751             itemsLimit = DEFAULT_ITEMS_LIMIT;
1752         }
1753         return itemsLimit;
1754     }
1755
1756     /**
1757      * Identifies whether a restriction on tenant ID - to return only records
1758      * pertaining to the current tenant - is required in a JDBC query.
1759      *
1760      * @param tenantBinding a tenant binding configuration.
1761      * @param ctx a service context.
1762      * @return true if a restriction on tenant ID is required in the query;
1763      * false if a restriction is not required.
1764      */
1765     private boolean restrictJDBCQueryByTenantID(TenantBindingType tenantBinding, ServiceContext ctx) {
1766         boolean restrict = true;
1767         // If data for the current service, in the current tenant, is isolated
1768         // within its own separate, per-tenant repository, as contrasted with
1769         // being intermingled with other tenants' data in the default repository,
1770         // no restriction on Tenant ID is required in the query.
1771         String repositoryDomainName = ConfigUtils.getRepositoryName(tenantBinding, ctx.getRepositoryDomainName());
1772         if (!(repositoryDomainName.equals(ConfigUtils.DEFAULT_NUXEO_REPOSITORY_NAME))) {
1773             restrict = false;
1774         }
1775         // If a configuration setting for this tenant identifies that JDBC
1776         // queries should not be restricted by tenant ID (perhaps because
1777         // there is always expected to be only one tenant's data present in
1778         // the system), no restriction on Tenant ID is required in the query.
1779         String queriesRestrictedByTenantId = TenantBindingUtils.getPropertyValue(tenantBinding,
1780                 IQueryManager.JDBC_QUERIES_ARE_TENANT_ID_RESTRICTED);
1781         if (Tools.notBlank(queriesRestrictedByTenantId) &&
1782                 queriesRestrictedByTenantId.equalsIgnoreCase(Boolean.FALSE.toString())) {
1783             restrict = false;
1784         }
1785         return restrict;
1786     }
1787 }