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

   1 /**
   2  *  This document is a part of the source code and related artifacts
   3  *  for CollectionSpace, an open source collections management system
   4  *  for museums and related institutions:
   5
   6  *  http://www.collectionspace.org
   7  *  http://wiki.collectionspace.org
   8
   9  *  Copyright 2009 University of California at Berkeley
  10
  11  *  Licensed under the Educational Community License (ECL), Version 2.0.
  12  *  You may not use this file except in compliance with this License.
  13
  14  *  You may obtain a copy of the ECL 2.0 License at
  15
  16  *  https://source.collectionspace.org/collection-space/LICENSE.txt
  17
  18  *  Unless required by applicable law or agreed to in writing, software
  19  *  distributed under the License is distributed on an "AS IS" BASIS,
  20  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21  *  See the License for the specific language governing permissions and
  22  *  limitations under the License.
  23  */
  24 package org.collectionspace.services.common.vocabulary.nuxeo;
  25
  26 import org.collectionspace.services.client.AuthorityClient;
  27 import org.collectionspace.services.client.IQueryManager;
  28 import org.collectionspace.services.client.PoxPayloadIn;
  29 import org.collectionspace.services.client.PoxPayloadOut;
  30
  31 import org.collectionspace.services.common.UriTemplateRegistry;
  32 import org.collectionspace.services.common.api.RefName;
  33 import org.collectionspace.services.common.api.Tools;
  34 import org.collectionspace.services.common.authorityref.AuthorityRefDocList;
  35 import org.collectionspace.services.common.context.MultipartServiceContext;
  36 import org.collectionspace.services.common.context.ServiceContext;
  37 import org.collectionspace.services.common.document.DocumentException;
  38 import org.collectionspace.services.common.document.DocumentFilter;
  39 import org.collectionspace.services.common.document.DocumentWrapper;
  40 import org.collectionspace.services.common.repository.RepositoryClient;
  41 import org.collectionspace.services.common.vocabulary.AuthorityJAXBSchema;
  42 import org.collectionspace.services.common.vocabulary.AuthorityItemJAXBSchema;
  43 import org.collectionspace.services.common.vocabulary.AuthorityResource;
  44 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils;
  45
  46 import org.collectionspace.services.config.service.ListResultField;
  47 import org.collectionspace.services.config.service.ObjectPartType;
  48
  49 import org.collectionspace.services.nuxeo.client.java.DocHandlerBase;
  50 import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClientImpl;
  51 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  52
  53 import org.collectionspace.services.relation.RelationsCommonList;
  54 import org.collectionspace.services.relation.RelationsDocListItem;
  55
  56 import org.collectionspace.services.vocabulary.VocabularyItemJAXBSchema;
  57
  58 import org.nuxeo.ecm.core.api.ClientException;
  59 import org.nuxeo.ecm.core.api.DocumentModel;
  60 import org.nuxeo.ecm.core.api.model.PropertyException;
  61 import org.nuxeo.ecm.core.api.repository.RepositoryInstance;
  62
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66 import javax.ws.rs.core.MultivaluedMap;
  67
  68 import java.util.ArrayList;
  69 import java.util.HashMap;
  70 import java.util.List;
  71 import java.util.Map;
  72 import java.util.regex.Matcher;
  73 import java.util.regex.Pattern;
  74
  75 //import org.collectionspace.services.common.authority.AuthorityItemRelations;
  76 /**
  77  * AuthorityItemDocumentModelHandler
  78  *
  79  * $LastChangedRevision: $
  80  * $LastChangedDate: $
  81  */
  82 public abstract class AuthorityItemDocumentModelHandler<AICommon>
  83         extends DocHandlerBase<AICommon> {
  84
  85     private final Logger logger = LoggerFactory.getLogger(AuthorityItemDocumentModelHandler.class);
  86     private String authorityItemCommonSchemaName;
  87     private String authorityItemTermGroupXPathBase;
  88     /**
  89      * inVocabulary is the parent Authority for this context
  90      */
  91     protected String inAuthority = null;
  92     protected boolean wildcardedAuthorityRequest = false;
  93     protected String authorityRefNameBase = null;
  94     // Used to determine when the displayName changes as part of the update.
  95     protected String oldDisplayNameOnUpdate = null;
  96     private final static String LIST_SUFFIX = "List";
  97
  98     public AuthorityItemDocumentModelHandler(String authorityItemCommonSchemaName) {
  99         this.authorityItemCommonSchemaName = authorityItemCommonSchemaName;
 100     }
 101
 102     @Override
 103     protected String getRefnameDisplayName(DocumentWrapper<DocumentModel> docWrapper) {
 104         String result = null;
 105
 106         DocumentModel docModel = docWrapper.getWrappedObject();
 107         ServiceContext ctx = this.getServiceContext();
 108         RefName.AuthorityItem refname = (RefName.AuthorityItem)getRefName(ctx, docModel);
 109         result = refname.getDisplayName();
 110
 111         return result;
 112     }
 113
 114     /*
 115      * After calling this method successfully, the document model will contain an updated refname and short ID
 116      * (non-Javadoc)
 117      * @see org.collectionspace.services.nuxeo.client.java.DocumentModelHandler#getRefName(org.collectionspace.services.common.context.ServiceContext, org.nuxeo.ecm.core.api.DocumentModel)
 118      */
 119     @Override
 120     public RefName.RefNameInterface getRefName(ServiceContext ctx,
 121                 DocumentModel docModel) {
 122         RefName.RefNameInterface refname = null;
 123
 124         try {
 125                 String displayName = getPrimaryDisplayName(docModel, authorityItemCommonSchemaName,
 126                     getItemTermInfoGroupXPathBase(), AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 127                 if (Tools.isEmpty(displayName)) {
 128                     throw new Exception("The displayName for this authority term was empty or not set.");
 129                 }
 130
 131                 String shortIdentifier = (String) docModel.getProperty(authorityItemCommonSchemaName, AuthorityItemJAXBSchema.SHORT_IDENTIFIER);
 132                 if (Tools.isEmpty(shortIdentifier)) {
 133                         // We didn't find a short ID in the payload request, so we need to synthesize one.
 134                         shortIdentifier = handleDisplayNameAsShortIdentifier(docModel); // updates the document model with the new short ID as a side-effect
 135                 }
 136
 137                 String authorityRefBaseName = getAuthorityRefNameBase();
 138                 if (Tools.isEmpty(authorityRefBaseName)) {
 139                     throw new Exception("Could not create the refName for this authority term, because the refName for its authority parent was empty.");
 140                 }
 141
 142                 // Create the items refname using the parent's as a base
 143                 RefName.Authority parentsRefName = RefName.Authority.parse(authorityRefBaseName);
 144                 refname = RefName.buildAuthorityItem(parentsRefName, shortIdentifier, displayName);
 145                 // Now update the document model with the refname value
 146                 String refNameStr = refname.toString();
 147                 docModel.setProperty(authorityItemCommonSchemaName, AuthorityItemJAXBSchema.REF_NAME, refNameStr); // REM - This field is deprecated now that the refName is part of the collection_space core schema
 148
 149         } catch (Exception e) {
 150                 logger.error(e.getMessage(), e);
 151         }
 152
 153         return refname;
 154     }
 155
 156     public void setInAuthority(String inAuthority) {
 157         this.inAuthority = inAuthority;
 158     }
 159
 160    public String getInAuthority() {
 161         return this.inAuthority;
 162     }
 163
 164     /** Subclasses may override this to customize the URI segment. */
 165     public String getAuthorityServicePath() {
 166         return getServiceContext().getServiceName().toLowerCase();    // Laramie20110510 CSPACE-3932
 167     }
 168
 169     @Override
 170     public String getUri(DocumentModel docModel) {
 171         // Laramie20110510 CSPACE-3932
 172         String authorityServicePath = getAuthorityServicePath();
 173         if(inAuthority==null) { // Only true with the first document model received, on queries to wildcarded authorities
 174             wildcardedAuthorityRequest = true;
 175         }
 176         // If this search crosses multiple authorities, get the inAuthority value
 177         // from each record, rather than using the cached value from the first record
 178         if(wildcardedAuthorityRequest) {
 179                 try {
 180                         inAuthority = (String) docModel.getProperty(authorityItemCommonSchemaName,
 181                         AuthorityItemJAXBSchema.IN_AUTHORITY);
 182                 } catch (ClientException pe) {
 183                         throw new RuntimeException("Could not get parent specifier for item!");
 184                 }
 185         }
 186         return "/" + authorityServicePath + '/' + inAuthority + '/' + AuthorityClient.ITEMS + '/' + getCsid(docModel);
 187     }
 188
 189     protected String getAuthorityRefNameBase() {
 190         return this.authorityRefNameBase;
 191     }
 192
 193     public void setAuthorityRefNameBase(String value) {
 194         this.authorityRefNameBase = value;
 195     }
 196
 197     /*
 198      * Note: the Vocabulary service's VocabularyItemDocumentModelHandler class overrides this method.
 199      */
 200     protected ListResultField getListResultsDisplayNameField() {
 201         ListResultField result = new ListResultField();
 202         // Per CSPACE-5132, the name of this element remains 'displayName'
 203         // for backwards compatibility, although its value is obtained
 204         // from the termDisplayName field.
 205         //
 206         // Update: this name is now being changed to 'termDisplayName', both
 207         // because this is the actual field name and because the app layer
 208         // work to convert over to this field is underway. Per Patrick, the
 209         // app layer treats lists, in at least some context(s), as sparse record
 210         // payloads, and thus fields in list results must all be present in
 211         // (i.e. represent a strict subset of the fields in) record schemas.
 212         // - ADR 2012-05-11
 213         //
 214         //
 215         // In CSPACE-5134, these list results will change substantially
 216         // to return display names for both the preferred term and for
 217         // each non-preferred term (if any).
 218         result.setElement(AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 219         result.setXpath(NuxeoUtils.getPrimaryXPathPropertyName(
 220                 authorityItemCommonSchemaName, getItemTermInfoGroupXPathBase(), AuthorityItemJAXBSchema.TERM_DISPLAY_NAME));
 221
 222         return result;
 223     }
 224
 225     /*
 226      * Note: the Vocabulary service's VocabularyItemDocumentModelHandler class overrides this method.
 227      */
 228     protected ListResultField getListResultsTermStatusField() {
 229         ListResultField result = new ListResultField();
 230
 231         result.setElement(AuthorityItemJAXBSchema.TERM_STATUS);
 232         result.setXpath(NuxeoUtils.getPrimaryXPathPropertyName(
 233                 authorityItemCommonSchemaName, getItemTermInfoGroupXPathBase(), AuthorityItemJAXBSchema.TERM_STATUS));
 234
 235         return result;
 236     }
 237
 238     private boolean isTermDisplayName(String elName) {
 239         return AuthorityItemJAXBSchema.TERM_DISPLAY_NAME.equals(elName) || VocabularyItemJAXBSchema.DISPLAY_NAME.equals(elName);
 240     }
 241
 242     /*
 243      * (non-Javadoc)
 244      * @see org.collectionspace.services.nuxeo.client.java.DocHandlerBase#getListItemsArray()
 245      *
 246      * Note: We're updating the "global" service and tenant bindings instance here -the list instance here is
 247      * a reference to the tenant bindings instance in the singleton ServiceMain.
 248      */
 249     @Override
 250     public List<ListResultField> getListItemsArray() throws DocumentException {
 251         List<ListResultField> list = super.getListItemsArray();
 252
 253         // One-time initialization for each authority item service.
 254         if (isListItemArrayExtended() == false) {
 255                 synchronized(AuthorityItemDocumentModelHandler.class) {
 256                         if (isListItemArrayExtended() == false) {
 257                         int nFields = list.size();
 258                         // Ensure that each item in a list of Authority items includes
 259                         // a set of common fields, so we do not depend upon configuration
 260                         // for general logic.
 261                         boolean hasDisplayName = false;
 262                         boolean hasShortId = false;
 263                         boolean hasTermStatus = false;
 264                         for (int i = 0; i < nFields; i++) {
 265                             ListResultField field = list.get(i);
 266                             String elName = field.getElement();
 267                             if (isTermDisplayName(elName) == true) {
 268                                 hasDisplayName = true;
 269                             } else if (AuthorityItemJAXBSchema.SHORT_IDENTIFIER.equals(elName)) {
 270                                 hasShortId = true;
 271                             } else if (AuthorityItemJAXBSchema.TERM_STATUS.equals(elName)) {
 272                                 hasTermStatus = true;
 273                             }
 274                         }
 275
 276                         ListResultField field;
 277                         if (!hasDisplayName) {
 278                                 field = getListResultsDisplayNameField();
 279                             list.add(field);
 280                         }
 281                         if (!hasShortId) {
 282                             field = new ListResultField();
 283                             field.setElement(AuthorityItemJAXBSchema.SHORT_IDENTIFIER);
 284                             field.setXpath(AuthorityItemJAXBSchema.SHORT_IDENTIFIER);
 285                             list.add(field);
 286                         }
 287                         if (!hasTermStatus) {
 288                             field = getListResultsTermStatusField();
 289                             list.add(field);
 290                         }
 291                         }
 292
 293                         setListItemArrayExtended(true);
 294                 } // end of synchronized block
 295         }
 296
 297         return list;
 298     }
 299
 300     /* (non-Javadoc)
 301      * @see org.collectionspace.services.nuxeo.client.java.DocumentModelHandler#handleCreate(org.collectionspace.services.common.document.DocumentWrapper)
 302      */
 303     @Override
 304     public void handleCreate(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 305         // first fill all the parts of the document, refname and short ID get set as well
 306         super.handleCreate(wrapDoc);
 307         // Ensure we have required fields set properly
 308         handleInAuthority(wrapDoc.getWrappedObject());
 309     }
 310
 311     /*
 312      * This method gets called after the primary update to an authority item has happened.  If the authority item's refName
 313      * has changed, then we need to updated all the records that use that refname with the new/updated version
 314      *
 315      * (non-Javadoc)
 316      * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#completeUpdate(org.collectionspace.services.common.document.DocumentWrapper)
 317      */
 318     public void completeUpdate(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 319         // Must call our super class' version first
 320         super.completeUpdate(wrapDoc);
 321
 322         //
 323         // Look for and update authority references with the updated refName
 324         //
 325         if (hasRefNameUpdate() == true) {
 326             // We have work to do.
 327             if (logger.isDebugEnabled()) {
 328                 final String EOL = System.getProperty("line.separator");
 329                 logger.debug("Need to find and update references to authority item." + EOL
 330                         + "   Old refName" + oldRefNameOnUpdate + EOL
 331                         + "   New refName" + newRefNameOnUpdate);
 332             }
 333             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = getServiceContext();
 334             RepositoryClient<PoxPayloadIn, PoxPayloadOut> repoClient = getRepositoryClient(ctx);
 335             RepositoryInstance repoSession = this.getRepositorySession();
 336
 337             // Update all the existing records that have a field with the old refName in it
 338             int nUpdated = RefNameServiceUtils.updateAuthorityRefDocs(ctx, repoClient, repoSession,
 339                     oldRefNameOnUpdate, newRefNameOnUpdate, getRefPropName());
 340
 341             // Finished so log a message.
 342             if (logger.isDebugEnabled()) {
 343                 logger.debug("Updated " + nUpdated + " instances of oldRefName to newRefName");
 344             }
 345         }
 346     }
 347
 348     /*
 349      * Note that the Vocabulary service's document-model for items overrides this method.
 350      */
 351         protected String getPrimaryDisplayName(DocumentModel docModel, String schema,
 352                         String complexPropertyName, String fieldName) {
 353                 String result = null;
 354
 355                 result = getStringValueInPrimaryRepeatingComplexProperty(docModel, schema, complexPropertyName, fieldName);
 356
 357                 return result;
 358         }
 359
 360     /* (non-Javadoc)
 361      * @see org.collectionspace.services.nuxeo.client.java.DocumentModelHandler#handleUpdate(org.collectionspace.services.common.document.DocumentWrapper)
 362      */
 363     @Override
 364     // FIXME: Once we remove the refName field from the authority item schemas, we can remove this override method since our super does everthing for us now.
 365     @Deprecated
 366     public void handleUpdate(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 367         // Must call our super's version first, this updates the core schema and the relationship records to deal with possible refName changes/update
 368         super.handleUpdate(wrapDoc);
 369         if (this.hasRefNameUpdate() == true) {
 370                 DocumentModel docModel = wrapDoc.getWrappedObject();
 371             docModel.setProperty(authorityItemCommonSchemaName, AuthorityItemJAXBSchema.REF_NAME, this.newRefNameOnUpdate); // This field is deprecated since it is now a duplicate of what is in the collectionspace_core:refName field
 372         }
 373     }
 374
 375     /**
 376      * If no short identifier was provided in the input payload, generate a
 377      * short identifier from the preferred term display name or term name.
 378      */
 379         private String handleDisplayNameAsShortIdentifier(DocumentModel docModel) throws Exception {
 380                 String result = (String) docModel.getProperty(authorityItemCommonSchemaName,
 381                                 AuthorityItemJAXBSchema.SHORT_IDENTIFIER);
 382
 383                 if (Tools.isEmpty(result)) {
 384                         String termDisplayName = getPrimaryDisplayName(
 385                                         docModel, authorityItemCommonSchemaName,
 386                                         getItemTermInfoGroupXPathBase(),
 387                                         AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 388
 389                         String termName = getPrimaryDisplayName(
 390                                         docModel, authorityItemCommonSchemaName,
 391                                         getItemTermInfoGroupXPathBase(),
 392                                         AuthorityItemJAXBSchema.TERM_NAME);
 393
 394                         String generatedShortIdentifier = AuthorityIdentifierUtils.generateShortIdentifierFromDisplayName(termDisplayName,
 395                                                         termName);
 396                         docModel.setProperty(authorityItemCommonSchemaName, AuthorityItemJAXBSchema.SHORT_IDENTIFIER,
 397                                         generatedShortIdentifier);
 398                         result = generatedShortIdentifier;
 399                 }
 400
 401                 return result;
 402         }
 403
 404     /**
 405      * Generate a refName for the authority item from the short identifier
 406      * and display name.
 407      *
 408      * All refNames for authority items are generated.  If a client supplies
 409      * a refName, it will be overwritten during create (per this method)
 410      * or discarded during update (per filterReadOnlyPropertiesForPart).
 411      *
 412      * @see #filterReadOnlyPropertiesForPart(Map<String, Object>, org.collectionspace.services.common.service.ObjectPartType)
 413      *
 414      */
 415     protected String updateRefnameForAuthorityItem(DocumentModel docModel,
 416             String schemaName) throws Exception {
 417         String result = null;
 418
 419         RefName.RefNameInterface refname = getRefName(getServiceContext(), docModel);
 420         String refNameStr = refname.toString();
 421         docModel.setProperty(schemaName, AuthorityItemJAXBSchema.REF_NAME, refNameStr);
 422         result = refNameStr;
 423
 424         return result;
 425     }
 426
 427     /**
 428      * Check the logic around the parent pointer. Note that we only need do this on
 429      * create, since we have logic to make this read-only on update.
 430      *
 431      * @param docModel
 432      *
 433      * @throws Exception the exception
 434      */
 435     private void handleInAuthority(DocumentModel docModel) throws Exception {
 436         if(inAuthority==null) { // Only happens on queries to wildcarded authorities
 437                 throw new IllegalStateException("Trying to Create an object with no inAuthority value!");
 438         }
 439         docModel.setProperty(authorityItemCommonSchemaName,
 440                 AuthorityItemJAXBSchema.IN_AUTHORITY, inAuthority);
 441     }
 442
 443     public AuthorityRefDocList getReferencingObjects(
 444                 ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 445                 UriTemplateRegistry uriTemplateRegistry,
 446                 List<String> serviceTypes,
 447                 String propertyName,
 448             String itemcsid) throws Exception {
 449         AuthorityRefDocList authRefDocList = null;
 450         RepositoryInstance repoSession = null;
 451         boolean releaseRepoSession = false;
 452
 453         try {
 454                 RepositoryJavaClientImpl repoClient = (RepositoryJavaClientImpl)this.getRepositoryClient(ctx);
 455                 repoSession = this.getRepositorySession();
 456                 if (repoSession == null) {
 457                         repoSession = repoClient.getRepositorySession(ctx);
 458                         releaseRepoSession = true;
 459                 }
 460             DocumentFilter myFilter = getDocumentFilter();
 461
 462                 try {
 463                         DocumentWrapper<DocumentModel> wrapper = repoClient.getDoc(repoSession, ctx, itemcsid);
 464                         DocumentModel docModel = wrapper.getWrappedObject();
 465                         String refName = (String) docModel.getPropertyValue(AuthorityItemJAXBSchema.REF_NAME);
 466                 authRefDocList = RefNameServiceUtils.getAuthorityRefDocs(
 467                                 repoSession, ctx, uriTemplateRegistry, repoClient,
 468                         serviceTypes,
 469                         refName,
 470                         propertyName,
 471                         myFilter, true /*computeTotal*/);
 472                 } catch (PropertyException pe) {
 473                         throw pe;
 474                 } catch (DocumentException de) {
 475                         throw de;
 476                 } catch (Exception e) {
 477                         if (logger.isDebugEnabled()) {
 478                                 logger.debug("Caught exception ", e);
 479                         }
 480                         throw new DocumentException(e);
 481                 } finally {
 482                         // If we got/aquired a new seesion then we're responsible for releasing it.
 483                         if (releaseRepoSession && repoSession != null) {
 484                                 repoClient.releaseRepositorySession(ctx, repoSession);
 485                         }
 486                 }
 487         } catch (Exception e) {
 488                 if (logger.isDebugEnabled()) {
 489                         logger.debug("Caught exception ", e);
 490                 }
 491                 throw new DocumentException(e);
 492         }
 493
 494         return authRefDocList;
 495     }
 496
 497     /* (non-Javadoc)
 498      * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#extractPart(org.nuxeo.ecm.core.api.DocumentModel, java.lang.String, org.collectionspace.services.common.service.ObjectPartType)
 499      */
 500     @Override
 501     protected Map<String, Object> extractPart(DocumentModel docModel, String schema, ObjectPartType partMeta)
 502             throws Exception {
 503         Map<String, Object> unQObjectProperties = super.extractPart(docModel, schema, partMeta);
 504
 505         // Add the CSID to the common part, since they may have fetched via the shortId.
 506         if (partMeta.getLabel().equalsIgnoreCase(authorityItemCommonSchemaName)) {
 507             String csid = getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());
 508             unQObjectProperties.put("csid", csid);
 509         }
 510
 511         return unQObjectProperties;
 512     }
 513
 514     /**
 515      * Filters out selected values supplied in an update request.
 516      *
 517      * For example, filters out AuthorityItemJAXBSchema.IN_AUTHORITY, to ensure
 518      * that the link to the item's parent remains untouched.
 519      *
 520      * @param objectProps the properties filtered out from the update payload
 521      * @param partMeta metadata for the object to fill
 522      */
 523     @Override
 524     public void filterReadOnlyPropertiesForPart(
 525             Map<String, Object> objectProps, ObjectPartType partMeta) {
 526         super.filterReadOnlyPropertiesForPart(objectProps, partMeta);
 527         String commonPartLabel = getServiceContext().getCommonPartLabel();
 528         if (partMeta.getLabel().equalsIgnoreCase(commonPartLabel)) {
 529             objectProps.remove(AuthorityItemJAXBSchema.IN_AUTHORITY);
 530             objectProps.remove(AuthorityItemJAXBSchema.CSID);
 531             objectProps.remove(AuthorityJAXBSchema.SHORT_IDENTIFIER);
 532             objectProps.remove(AuthorityItemJAXBSchema.REF_NAME);
 533         }
 534     }
 535
 536     protected List<String> getPartialTermDisplayNameMatches(List<String> termDisplayNameList, String partialTerm) {
 537         List<String> result = new ArrayList<String>();
 538
 539         for (String termDisplayName : termDisplayNameList) {
 540                 if (termDisplayName.toLowerCase().contains(partialTerm.toLowerCase()) == true) {
 541                         result.add(termDisplayName);
 542                 }
 543         }
 544
 545         return result;
 546     }
 547
 548     @SuppressWarnings("unchecked")
 549         private List<String> getPartialTermDisplayNameMatches(DocumentModel docModel, // REM - CSPACE-5133
 550                         String schema, ListResultField field, String partialTerm) {
 551         List<String> result = null;
 552
 553         String xpath = field.getXpath(); // results in something like "persons_common:personTermGroupList/[0]/termDisplayName"
 554         int endOfTermGroup = xpath.lastIndexOf("/[0]/");
 555         String propertyName = endOfTermGroup != -1 ? xpath.substring(0, endOfTermGroup) : xpath; // it may not be multivalued so the xpath passed in would be the property name
 556         Object value = null;
 557
 558                 try {
 559                         value = docModel.getProperty(schema, propertyName);
 560                 } catch (Exception e) {
 561                         logger.error("Could not extract term display name with property = "
 562                                         + propertyName, e);
 563                 }
 564
 565                 if (value != null && value instanceof ArrayList) {
 566                         ArrayList<HashMap<String, Object>> termGroupList = (ArrayList<HashMap<String, Object>>)value;
 567                         int arrayListSize = termGroupList.size();
 568                         if (arrayListSize > 1) { // if there's only 1 element in the list then we've already matched the primary term's display name
 569                                 List<String> displayNameList = new ArrayList<String>();
 570                                 for (int i = 1; i < arrayListSize; i++) { // start at 1, skip the primary term's displayName since we will always return it
 571                                         HashMap<String, Object> map = (HashMap<String, Object>)termGroupList.get(i);
 572                                         String termDisplayName = (String) map.get(AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 573                                         displayNameList.add(i - 1, termDisplayName);
 574                                 }
 575
 576                                 result = getPartialTermDisplayNameMatches(displayNameList, partialTerm);
 577                         }
 578                 }
 579
 580         return result;
 581     }
 582
 583     @Override
 584         protected Object getListResultValue(DocumentModel docModel, // REM - CSPACE-5133
 585                         String schema, ListResultField field) {
 586                 Object result = null;
 587
 588                 result = NuxeoUtils.getXPathValue(docModel, schema, field.getXpath());
 589                 String elName = field.getElement();
 590                 //
 591                 // If the list result value is the termDisplayName element, we need to check to see if a partial term query was made.
 592                 //
 593                 if (isTermDisplayName(elName) == true) {
 594                         MultivaluedMap<String, String> queryParams = this.getServiceContext().getQueryParams();
 595                 String partialTerm = queryParams != null ? queryParams.getFirst(IQueryManager.SEARCH_TYPE_PARTIALTERM) : null;
 596                 if (partialTerm != null && partialTerm.trim().isEmpty() == false) {
 597                                 String primaryTermDisplayName = (String)result;
 598                         List<String> matches = getPartialTermDisplayNameMatches(docModel, schema, field, partialTerm);
 599                         if (matches != null && matches.isEmpty() == false) {
 600                                 matches.add(0, primaryTermDisplayName); // insert the primary term's display name at the beginning of the list
 601                                 result = matches; // set the result to a list of matching term display names with the primary term's display name at the beginning
 602                         }
 603                 }
 604                 }
 605
 606                 return result;
 607         }
 608
 609     @Override
 610     public void extractAllParts(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 611         MultipartServiceContext ctx = (MultipartServiceContext) getServiceContext();
 612         super.extractAllParts(wrapDoc);
 613     }
 614
 615     @Override
 616     public void fillAllParts(DocumentWrapper<DocumentModel> wrapDoc, Action action) throws Exception {
 617         //
 618         // We currently don't override this method with any AuthorityItemDocumentModelHandler specific functionality, so
 619         // we could remove this method.
 620         //
 621         super.fillAllParts(wrapDoc, action);
 622     }
 623
 624     protected List<RelationsCommonList.RelationListItem> cloneList(List<RelationsCommonList.RelationListItem> inboundList) {
 625         List<RelationsCommonList.RelationListItem> result = newRelationsCommonList();
 626         for (RelationsCommonList.RelationListItem item : inboundList) {
 627             result.add(item);
 628         }
 629         return result;
 630     }
 631
 632
 633     /* don't even THINK of re-using this method.
 634      * String example_uri = "/locationauthorities/7ec60f01-84ab-4908-9a6a/items/a5466530-713f-43b4-bc05";
 635      */
 636     @Deprecated
 637     private String extractInAuthorityCSID(String uri) {
 638         String IN_AUTHORITY_REGEX = "/(.*?)/(.*?)/(.*)";
 639         Pattern p = Pattern.compile(IN_AUTHORITY_REGEX);
 640         Matcher m = p.matcher(uri);
 641         if (m.find()) {
 642             if (m.groupCount() < 3) {
 643                 logger.warn("REGEX-WRONG-GROUPCOUNT looking in " + uri);
 644                 return "";
 645             } else {
 646                 //String service = m.group(1);
 647                 String inauth = m.group(2);
 648                 //String theRest = m.group(3);
 649                 return inauth;
 650                 //print("service:"+service+", inauth:"+inauth+", rest:"+rest);
 651             }
 652         } else {
 653             logger.warn("REGEX-NOT-MATCHED looking in " + uri);
 654             return "";
 655         }
 656     }
 657
 658     //ensures CSPACE-4042
 659     protected void uriPointsToSameAuthority(String thisURI, String inboundItemURI) throws Exception {
 660         String authorityCSID = extractInAuthorityCSID(thisURI);
 661         String authorityCSIDForInbound = extractInAuthorityCSID(inboundItemURI);
 662         if (Tools.isBlank(authorityCSID)
 663                 || Tools.isBlank(authorityCSIDForInbound)
 664                 || (!authorityCSID.equalsIgnoreCase(authorityCSIDForInbound))) {
 665             throw new Exception("Item URI " + thisURI + " must point to same authority as related item: " + inboundItemURI);
 666         }
 667     }
 668
 669     public String getItemTermInfoGroupXPathBase() {
 670         return authorityItemTermGroupXPathBase;
 671     }
 672
 673     public void setItemTermInfoGroupXPathBase(String itemTermInfoGroupXPathBase) {
 674         authorityItemTermGroupXPathBase = itemTermInfoGroupXPathBase;
 675     }
 676
 677     protected String getAuthorityItemCommonSchemaName() {
 678         return authorityItemCommonSchemaName;
 679     }
 680
 681     // @Override
 682     public boolean isJDBCQuery() {
 683         boolean result = false;
 684
 685         MultivaluedMap<String, String> queryParams = getServiceContext().getQueryParams();
 686         //
 687         // Look the query params to see if we need to make a SQL query.
 688         //
 689         String partialTerm = queryParams.getFirst(IQueryManager.SEARCH_TYPE_PARTIALTERM);
 690         if (partialTerm != null && partialTerm.trim().isEmpty() == false) {
 691                 result = true;
 692         }
 693
 694         return result;
 695     }
 696
 697     // By convention, the name of the database table that contains
 698     // repeatable term information group records is derivable from
 699     // an existing XPath base value, by removing a suffix and converting
 700     // to lowercase
 701     protected String getTermGroupTableName() {
 702         String termInfoGroupListName = getItemTermInfoGroupXPathBase();
 703         return termInfoGroupListName.substring(0, termInfoGroupListName.lastIndexOf(LIST_SUFFIX)).toLowerCase();
 704     }
 705
 706     protected String getInAuthorityValue() {
 707         String inAuthorityValue = getInAuthority();
 708         if (Tools.notBlank(inAuthorityValue)) {
 709             return inAuthorityValue;
 710         } else {
 711             return AuthorityResource.PARENT_WILDCARD;
 712         }
 713     }
 714
 715     @Override
 716     public Map<String,String> getJDBCQueryParams() {
 717         // FIXME: Get all of the following values from appropriate external constants.
 718         // At present, these are duplicated in both RepositoryJavaClientImpl
 719         // and in AuthorityItemDocumentModelHandler.
 720         final String TERM_GROUP_LIST_NAME = "TERM_GROUP_LIST_NAME";
 721         final String TERM_GROUP_TABLE_NAME_PARAM = "TERM_GROUP_TABLE_NAME";
 722         final String IN_AUTHORITY_PARAM = "IN_AUTHORITY";
 723
 724         Map<String,String> params = super.getJDBCQueryParams();
 725         params.put(TERM_GROUP_LIST_NAME, getItemTermInfoGroupXPathBase());
 726         params.put(TERM_GROUP_TABLE_NAME_PARAM, getTermGroupTableName());
 727         params.put(IN_AUTHORITY_PARAM, getInAuthorityValue());
 728         return params;
 729     }
 730
 731 }