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 java.net.URI;
  27 import java.util.Collections;
  28 import java.util.HashSet;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Set;
  32
  33 import javax.ws.rs.core.MultivaluedMap;
  34 import javax.ws.rs.core.PathSegment;
  35 import javax.ws.rs.core.Response;
  36 import javax.ws.rs.core.UriInfo;
  37
  38 import org.apache.commons.httpclient.HttpStatus;
  39 import org.collectionspace.services.client.AbstractCommonListUtils;
  40 import org.collectionspace.services.client.AuthorityClient;
  41 import org.collectionspace.services.client.PayloadInputPart;
  42 import org.collectionspace.services.client.PoxPayloadIn;
  43 import org.collectionspace.services.client.PoxPayloadOut;
  44 import org.collectionspace.services.client.RelationClient;
  45 import org.collectionspace.services.client.XmlTools;
  46 import org.collectionspace.services.client.workflow.WorkflowClient;
  47 import org.collectionspace.services.common.ResourceMap;
  48 import org.collectionspace.services.common.api.RefName;
  49 import org.collectionspace.services.common.api.RefName.Authority;
  50 import org.collectionspace.services.common.api.RefNameUtils;
  51 import org.collectionspace.services.common.api.RefNameUtils.AuthorityTermInfo;
  52 import org.collectionspace.services.common.api.Tools;
  53 import org.collectionspace.services.common.context.ServiceContext;
  54 import org.collectionspace.services.common.document.DocumentException;
  55 import org.collectionspace.services.common.document.DocumentNotFoundException;
  56 import org.collectionspace.services.common.document.DocumentReferenceException;
  57 import org.collectionspace.services.common.document.DocumentWrapper;
  58 import org.collectionspace.services.common.query.UriInfoImpl;
  59 import org.collectionspace.services.common.vocabulary.AuthorityItemJAXBSchema;
  60 import org.collectionspace.services.common.vocabulary.AuthorityJAXBSchema;
  61 import org.collectionspace.services.common.vocabulary.AuthorityResource;
  62 import org.collectionspace.services.common.vocabulary.AuthorityServiceUtils;
  63 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils.AuthorityItemSpecifier;
  64 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils.Specifier;
  65 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils.SpecifierForm;
  66 import org.collectionspace.services.config.service.ListResultField;
  67 import org.collectionspace.services.config.service.ObjectPartType;
  68 import org.collectionspace.services.jaxb.AbstractCommonList;
  69 import org.collectionspace.services.jaxb.AbstractCommonList.ListItem;
  70 import org.collectionspace.services.lifecycle.TransitionDef;
  71 import org.collectionspace.services.nuxeo.client.java.NuxeoDocumentModelHandler;
  72 import org.collectionspace.services.nuxeo.client.java.CoreSessionInterface;
  73 import org.collectionspace.services.nuxeo.client.java.NuxeoRepositoryClientImpl;
  74 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  75 import org.collectionspace.services.relation.RelationsCommonList;
  76 import org.dom4j.Element;
  77 import org.nuxeo.ecm.core.api.ClientException;
  78 import org.nuxeo.ecm.core.api.DocumentModel;
  79 import org.slf4j.Logger;
  80 import org.slf4j.LoggerFactory;
  81
  82 /**
  83  * AuthorityDocumentModelHandler
  84  *
  85  * $LastChangedRevision: $
  86  * $LastChangedDate: $
  87  */
  88 @SuppressWarnings("rawtypes")
  89 public abstract class AuthorityDocumentModelHandler<AuthCommon> extends NuxeoDocumentModelHandler<AuthCommon> {
  90         private static final long SAS_SYNC_PAGE_SIZE = 500;
  91
  92         private final Logger logger = LoggerFactory.getLogger(AuthorityDocumentModelHandler.class);
  93
  94         protected String authorityCommonSchemaName;
  95         protected String authorityItemCommonSchemaName;
  96         protected boolean shouldUpdateRevNumber = true; // default to updating the revision number
  97
  98         public AuthorityDocumentModelHandler(String authorityCommonSchemaName, String authorityItemCommonSchemaName) {
  99                 this.authorityCommonSchemaName = authorityCommonSchemaName;
 100                 this.authorityItemCommonSchemaName = authorityItemCommonSchemaName;
 101         }
 102
 103         public void setShouldUpdateRevNumber(boolean flag) {
 104                 this.shouldUpdateRevNumber = flag;
 105         }
 106
 107         public boolean getShouldUpdateRevNumber() {
 108                 return this.shouldUpdateRevNumber;
 109         }
 110
 111         /**
 112          * The entity type expected from the JAX-RS Response object
 113          */
 114         public Class<String> getEntityResponseType() {
 115                 return String.class;
 116         }
 117
 118         @Override
 119         public void prepareSync() throws Exception {
 120                 this.setShouldUpdateRevNumber(AuthorityServiceUtils.DONT_UPDATE_REV); // Never update rev nums on sync operations
 121         }
 122
 123         protected PayloadInputPart extractPart(Response res, String partLabel) throws Exception {
 124                 PoxPayloadIn input = new PoxPayloadIn((String) res.readEntity(getEntityResponseType()));
 125                 PayloadInputPart payloadInputPart = input.getPart(partLabel);
 126                 if (payloadInputPart == null) {
 127                         logger.error("Part " + partLabel + " was unexpectedly null.");
 128                 }
 129                 return payloadInputPart;
 130         }
 131
 132         @Override
 133         public boolean handleSync(DocumentWrapper<Object> wrapDoc) throws Exception {
 134                 boolean result = false;
 135                 ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = getServiceContext();
 136                 Specifier specifier = (Specifier) wrapDoc.getWrappedObject();
 137                 //
 138                 // Get the rev number of the authority so we can compare with rev number of
 139                 // shared authority
 140                 //
 141                 DocumentModel docModel = NuxeoUtils.getDocFromSpecifier(ctx, getRepositorySession(), authorityCommonSchemaName,
 142                                 specifier);
 143                 if (docModel != null) {
 144                         String authorityCsid = docModel.getName();
 145                         Long localRev = (Long) NuxeoUtils.getProperyValue(docModel, AuthorityJAXBSchema.REV);
 146                         String shortId = (String) NuxeoUtils.getProperyValue(docModel, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 147                         String remoteClientConfigName = (String) NuxeoUtils.getProperyValue(docModel,
 148                                         // If set, contains the name of the remote client configuration (remoteClientConfigName) from the tenant bindings
 149                                         AuthorityJAXBSchema.REMOTECLIENT_CONFIG_NAME);
 150                         //
 151                         // Using the short ID of the local authority, create a URN specifier to retrieve
 152                         // the SAS authority
 153                         //
 154                         Specifier sasSpecifier = new Specifier(SpecifierForm.URN_NAME, shortId);
 155                         PoxPayloadIn sasPayloadIn = AuthorityServiceUtils.requestPayloadInFromRemoteServer(ctx, remoteClientConfigName,
 156                                         sasSpecifier, getEntityResponseType());
 157                         //
 158                         // If the authority on the SAS is newer, synch all the items and then the
 159                         // authority record as well
 160                         //
 161                         //
 162                         Long sasRev = getRevision(sasPayloadIn);
 163                         // FIXME: Along with the revision number, we need to use other meta information
 164                         // to determine if a sync should happen -for now, always sync
 165                         if (sasRev > localRev || true) {
 166                                 //
 167                                 // First, sync all the authority items
 168                                 //
 169                                 syncAllItems(ctx, authorityCsid, sasSpecifier);
 170                                 //
 171                                 // Next, sync the authority resource/record itself
 172                                 //
 173                                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 174                                 // Don't update the rev number, use the rev number for the SAS instance instead
 175                                 ctx.setProperty(AuthorityServiceUtils.SHOULD_UPDATE_REV_PROPERTY, AuthorityServiceUtils.DONT_UPDATE_REV);
 176                                 PoxPayloadOut payloadOut = authorityResource.update(ctx, ctx.getResourceMap(), ctx.getUriInfo(),
 177                                                 docModel.getName(), sasPayloadIn);
 178                                 if (payloadOut != null) {
 179                                         ctx.setOutput(payloadOut);
 180                                         result = true;
 181                                 }
 182                                 //
 183                                 // We may need to transition the authority into a replicated state the first
 184                                 // time we sync it.
 185                                 //
 186                                 String workflowState = docModel.getCurrentLifeCycleState();
 187                                 if (workflowState.contains(WorkflowClient.WORKFLOWSTATE_REPLICATED) == false) {
 188                                         authorityResource.updateWorkflowWithTransition(ctx, ctx.getUriInfo(), authorityCsid,
 189                                                         WorkflowClient.WORKFLOWTRANSITION_REPLICATE);
 190                                 }
 191                         }
 192                 } else {
 193                         String errMsg = String.format("Authority of type '%s' with identifier '%s' does not exist.",
 194                                         getServiceContext().getServiceName(), specifier.getURNValue());
 195                         logger.debug(errMsg);
 196                         throw new DocumentException(errMsg);
 197                 }
 198
 199                 return result;
 200         }
 201
 202         /*
 203          * Get the list of authority items from the remote shared authority server (SAS)
 204          * and synchronize them with the local authority items. If items exist on the
 205          * remote but not the local, create them.
 206          */
 207         protected void syncAllItems(ServiceContext ctx, String parentCsid, Specifier sasAuthoritySpecifier) throws Exception {
 208                 int createdCount = 0;
 209                 int syncedCount = 0;
 210                 int alreadySyncedCount = 0;
 211                 int deletedCount = 0;
 212                 int totalProcessedCount = 0;
 213
 214                 Set<String> remoteShortIds = new HashSet<String>();
 215
 216                 // Iterate over the list of items in the remote authority.
 217
 218                 long pageNum = 0;
 219                 long pageSize = SAS_SYNC_PAGE_SIZE;
 220
 221                 List<Element> itemElements;
 222
 223                 do {
 224                         if (logger.isDebugEnabled()) {
 225                                 logger.debug(String.format("Reading remote items in %s: page size %d, page num %d", sasAuthoritySpecifier.value, pageSize, pageNum));
 226                         }
 227
 228                         PoxPayloadIn itemListPayload = requestItemList(ctx, sasAuthoritySpecifier, pageSize, pageNum);
 229
 230                         itemElements = getItemList(itemListPayload);
 231
 232                         if (itemElements == null) {
 233                                 itemElements = Collections.EMPTY_LIST;
 234                         }
 235
 236                         if (logger.isDebugEnabled()) {
 237                                 logger.debug(String.format("Found %d items", itemElements.size()));
 238                         }
 239
 240                         for (Element e : itemElements) {
 241                                 String remoteRefName = XmlTools.getElementValue(e, AuthorityItemJAXBSchema.REF_NAME);
 242                                 String remoteShortId = XmlTools.getElementValue(e, AuthorityItemJAXBSchema.SHORT_IDENTIFIER);
 243
 244                                 remoteShortIds.add(remoteShortId);
 245
 246                                 long status = syncRemoteItem(ctx, parentCsid, remoteRefName);
 247
 248                                 if (status == 1) {
 249                                         createdCount++;
 250                                 } else if (status == 0) {
 251                                         syncedCount++;
 252                                 } else {
 253                                         alreadySyncedCount++;
 254                                 }
 255
 256                                 totalProcessedCount++;
 257                         }
 258
 259                         pageNum = pageNum + 1;
 260                 } while (itemElements.size() > 0 && itemElements.size() == SAS_SYNC_PAGE_SIZE);
 261
 262                 // Deprecate or delete items that have been hard-deleted from the SAS but still
 263                 // exist locally.
 264                 // Subtract (remove) the set of remote items from the set of local items to
 265                 // determine which
 266                 // of the remote items have been hard deleted.
 267
 268                 Set<String> localShortIds = getItemsInLocalAuthority(ctx, sasAuthoritySpecifier);
 269
 270                 localShortIds.removeAll(remoteShortIds);
 271
 272                 if (localShortIds.size() > 0) {
 273                         // Delete the remaining items (or mark them as deprecated if they still have
 274                         // records referencing them).
 275
 276                         deletedCount = deleteOrDeprecateItems(ctx, parentCsid, localShortIds);
 277
 278                         if (deletedCount != localShortIds.size()) {
 279                                 logger.warn("Could not delete or deprecate some items during sync.");
 280                         }
 281                 }
 282
 283                 logger.info(String.format("Total number of items processed during sync: %d", totalProcessedCount));
 284                 logger.info(String.format("Number of items synchronized: %d", syncedCount));
 285                 logger.info(String.format("Number of items created during sync: %d", createdCount));
 286                 logger.info(String.format("Number of items not needing synchronization: %d", alreadySyncedCount));
 287                 logger.info(String.format("Number of items hard deleted on remote: %d", deletedCount));
 288         }
 289
 290         /**
 291          * This method should ***only*** be used as part of a SAS sync operation.
 292          *
 293          * @param ctx
 294          * @param refNameList
 295          * @return
 296          * @throws Exception
 297          */
 298         private int deleteOrDeprecateItems(ServiceContext ctx, String parentCsid, Set<String> itemShortIds)
 299                         throws Exception {
 300
 301                 // Don't update the revision number when we delete or deprecate items.
 302                 ctx.setProperty(AuthorityServiceUtils.SHOULD_UPDATE_REV_PROPERTY, false);
 303
 304                 Specifier parentSpecifier = new Specifier(SpecifierForm.CSID, parentCsid);
 305                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 306                 int handledCount = 0;
 307
 308                 for (String itemShortId : itemShortIds) {
 309                         Specifier itemSpecifier = new Specifier(SpecifierForm.URN_NAME, itemShortId);
 310
 311                         try {
 312                                 authorityResource.deleteAuthorityItem(ctx, parentSpecifier.getURNValue(),
 313                                                 itemSpecifier.getURNValue(), AuthorityServiceUtils.DONT_UPDATE_REV, AuthorityServiceUtils.DONT_ROLLBACK_ON_EXCEPTION);
 314
 315                                 handledCount++;
 316                         } catch (DocumentReferenceException dre) {
 317                                 logger.info(String.format("Failed to delete %s: item is referenced, and will be deprecated instead", itemShortId));
 318
 319                                 AuthorityItemSpecifier authorityItemSpecifier = new AuthorityItemSpecifier(parentSpecifier, itemSpecifier);
 320                                 boolean deprecated = AuthorityServiceUtils.setAuthorityItemDeprecated(ctx, authorityResource, authorityItemCommonSchemaName, authorityItemSpecifier);
 321
 322                                 if (deprecated == true) {
 323                                         handledCount++;
 324                                 }
 325                         }
 326                 }
 327
 328                 return handledCount;
 329         }
 330
 331         /**
 332          * Gets the list of SAS related items in the local authority. Exludes items with
 333          * the "proposed" flag to include only SAS created items.
 334          *
 335          * @param ctx
 336          * @param authoritySpecifier
 337          * @return
 338          * @throws Exception
 339          */
 340         private Set<String> getItemsInLocalAuthority(ServiceContext ctx, Specifier authoritySpecifier) throws Exception {
 341                 Set<String> itemShortIds = new HashSet<String>();
 342
 343                 ResourceMap resourceMap = ctx.getResourceMap();
 344                 String resourceName = ctx.getClient().getServiceName();
 345                 AuthorityResource authorityResource = (AuthorityResource) resourceMap.get(resourceName);
 346
 347                 long pageNum = 0;
 348                 long pageSize = SAS_SYNC_PAGE_SIZE;
 349
 350                 List<ListItem> listItems;
 351
 352                 do {
 353                         if (logger.isDebugEnabled()) {
 354                                 logger.debug(String.format("Reading local items in %s: page size %d, page num %d", authoritySpecifier.value,
 355                                                 pageSize, pageNum));
 356                         }
 357
 358                         // Construct a UriInfo to retrieve one page of results.
 359
 360                         UriInfo uriInfo = new UriInfoImpl(
 361                                 new URI(""),
 362                                 new URI(""),
 363                                 "",
 364                                 "pgSz=" + pageSize + "&pgNum=" + pageNum,
 365                                 Collections.<PathSegment> emptyList()
 366                         );
 367
 368                         AbstractCommonList acl = authorityResource.getAuthorityItemList(ctx, authoritySpecifier.getURNValue(), uriInfo);
 369
 370                         listItems = acl.getListItem();
 371
 372                         if (logger.isDebugEnabled()) {
 373                                 logger.debug(String.format("Found %d items", listItems.size()));
 374                         }
 375
 376                         for (ListItem listItem : listItems) {
 377                                 Boolean proposed = getBooleanValue(listItem, AuthorityItemJAXBSchema.PROPOSED);
 378
 379                                 if (proposed == false) { // exclude "proposed" (i.e., local-only items)
 380                                         itemShortIds.add(AbstractCommonListUtils.ListItemGetElementValue(listItem, AuthorityItemJAXBSchema.SHORT_IDENTIFIER));
 381                                 }
 382                         }
 383
 384                         pageNum = pageNum + 1;
 385                 } while (listItems.size() > 0 && listItems.size() == SAS_SYNC_PAGE_SIZE);
 386
 387                 return itemShortIds;
 388         }
 389
 390         private Boolean getBooleanValue(ListItem listItem, String name) {
 391                 Boolean result = null;
 392
 393                 String value = AbstractCommonListUtils.ListItemGetElementValue(listItem, name);
 394                 if (value != null) {
 395                         result = Boolean.valueOf(value);
 396                 }
 397
 398                 return result;
 399         }
 400
 401         private String getStringValue(ListItem listItem, String name) {
 402                 return AbstractCommonListUtils.ListItemGetElementValue(listItem, AuthorityItemJAXBSchema.REF_NAME);
 403         }
 404
 405         /**
 406          * This method should only be used during a SAS synchronization request.
 407          *
 408          * @param ctx
 409          * @param parentIdentifier - Must be in short-id-refname form -i.e., urn:cspace:name(shortid)
 410          * @param itemIdentifier   - Must be in short-id-refname form -i.e., urn:cspace:name(shortid)
 411          * @throws Exception
 412          */
 413         protected void createLocalItem(ServiceContext ctx, String parentCsid, String parentIdentifier, String itemIdentifier, Boolean syncHierarchicalRelationships) throws Exception {
 414                 //
 415                 // Create a URN short ID specifier for the getting a copy of the remote authority item
 416                 //
 417                 Specifier parentSpecifier = Specifier.getSpecifier(parentIdentifier);
 418                 Specifier itemSpecifier = Specifier.getSpecifier(itemIdentifier);
 419                 AuthorityItemSpecifier sasAuthorityItemSpecifier = new AuthorityItemSpecifier(parentSpecifier, itemSpecifier);
 420                 //
 421                 // Get the remote client configuration name
 422                 //
 423                 DocumentModel docModel = NuxeoUtils.getDocFromSpecifier(ctx, getRepositorySession(), authorityCommonSchemaName, parentSpecifier);
 424                 String remoteClientConfigName = (String) NuxeoUtils.getProperyValue(docModel, AuthorityJAXBSchema.REMOTECLIENT_CONFIG_NAME); // If set, contains the name of the remote client configuration (remoteClientConfigName) from the tenant bindings
 425                 //
 426                 // Get the remote payload
 427                 //
 428                 PoxPayloadIn sasPayloadIn = AuthorityServiceUtils.requestPayloadInFromRemoteServer(sasAuthorityItemSpecifier, remoteClientConfigName,
 429                                 ctx.getServiceName(), getEntityResponseType(), syncHierarchicalRelationships);
 430
 431                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 432
 433                 // Remove remote uris and csids from relations, and remove relations to items that don't exist locally.
 434                 sasPayloadIn = AuthorityServiceUtils.localizeRelations(ctx, authorityResource, parentCsid, itemSpecifier, sasPayloadIn);
 435
 436                 // Localize domain name parts of refnames in the payload.
 437                 sasPayloadIn = AuthorityServiceUtils.localizeRefNameDomains(ctx, sasPayloadIn);
 438
 439                 //
 440                 // Using the payload from the remote server, create a local copy of the item
 441                 //
 442                 Response response = authorityResource.createAuthorityItemWithParentContext(ctx, parentSpecifier.getURNValue(),
 443                                 sasPayloadIn, AuthorityServiceUtils.DONT_UPDATE_REV, AuthorityServiceUtils.NOT_PROPOSED, AuthorityServiceUtils.SAS_ITEM);
 444                 //
 445                 // Check the response for successful POST result
 446                 //
 447                 if (response.getStatus() != Response.Status.CREATED.getStatusCode()) {
 448                         throw new DocumentException(String.format("Could not create new authority item '%s' during synchronization of the '%s' authority.",
 449                                         itemIdentifier, parentIdentifier));
 450                 }
 451                 //
 452                 // Since we're creating an item that was sourced from the replication server, we need to replicate it locally.
 453                 //
 454                 authorityResource.updateItemWorkflowWithTransition(ctx, parentIdentifier, itemIdentifier,
 455                                 WorkflowClient.WORKFLOWTRANSITION_REPLICATE, AuthorityServiceUtils.DONT_UPDATE_REV); // don't update the rev number of the new replicated item (use the rev number of the sourced item)
 456                 }
 457
 458         /**
 459          * Synchronize a remote item (using its refName) with a local item.  If the local doesn't yet
 460          * exist, create it.
 461          * Result values:
 462          *      -1 = sync not needed; i.e., already in sync
 463          *   0 = sync succeeded
 464          *   1 = local item was missing so we created it
 465          * @param ctx
 466          * @param refName
 467          * @return
 468          * @throws Exception
 469          */
 470         protected long syncRemoteItem(ServiceContext ctx, String parentCsid, String itemRefName) throws Exception {
 471                 if (logger.isInfoEnabled()) {
 472                         logger.info(String.format("Syncing remote item %s", itemRefName));
 473                 }
 474
 475                 // Create specifiers to find the local item corresponding to the remote refname.
 476
 477                 AuthorityTermInfo authorityTermInfo = RefNameUtils.parseAuthorityTermInfo(itemRefName);
 478                 String parentIdentifier = Specifier.createShortIdURNValue(authorityTermInfo.inAuthority.name);
 479                 String itemIdentifier = Specifier.createShortIdURNValue(authorityTermInfo.name);
 480
 481                 // Use the Authority JAX-RS resource to peform sync operations (creates and updates).
 482
 483                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 484                 PoxPayloadOut localItemPayload = null;
 485
 486                 // Find the local item.
 487
 488                 try {
 489                         localItemPayload = authorityResource.getAuthorityItemWithExistingContext(ctx, parentIdentifier, itemIdentifier);
 490                 } catch (DocumentNotFoundException dnf) {
 491                         localItemPayload = null;
 492                 }
 493
 494                 // If no local item exists, create one.
 495
 496                 if (localItemPayload == null) {
 497                         createLocalItem(ctx, parentCsid, parentIdentifier, itemIdentifier, AuthorityClient.INCLUDE_RELATIONS);
 498
 499                         return 1;
 500                 }
 501
 502                 // Sync the local item with the remote item.
 503
 504                 PoxPayloadOut updatePayload = null;
 505
 506                 try {
 507                         updatePayload = authorityResource.synchronizeItemWithExistingContext(ctx, parentIdentifier, itemIdentifier, AuthorityClient.INCLUDE_RELATIONS);
 508                 } catch (DocumentReferenceException de) {
 509                         logger.error(String.format("Could not sync item %s because it is referenced by other records", itemIdentifier));
 510                 }
 511
 512                 if (updatePayload != null) {
 513                         logger.info(String.format("Synced item %s in authority %s", itemIdentifier, parentIdentifier));
 514
 515                         return 0;
 516                 }
 517
 518                 return -1;
 519         }
 520
 521         private void assertStatusCode(Response res, Specifier specifier, AuthorityClient client) throws Exception {
 522                 int statusCode = res.getStatus();
 523
 524                 if (statusCode != HttpStatus.SC_OK) {
 525                         String errMsg = String.format("Could not retrieve authority information for '%s' on remote server '%s'.  Server returned status code %d",
 526                                         specifier.getURNValue(), client.getBaseURL(), statusCode);
 527                         throw new DocumentException(statusCode, errMsg);
 528                 }
 529         }
 530
 531         /**
 532          * Request an authority item list payload from the SAS server.
 533          *
 534          * @param ctx
 535          * @param specifier
 536          * @return
 537          * @throws Exception
 538          */
 539         private PoxPayloadIn requestItemList(ServiceContext ctx, Specifier specifier, long pageSize, long pageNum) throws Exception {
 540                 PoxPayloadIn result = null;
 541                 AuthorityClient client = (AuthorityClient) ctx.getClient();
 542
 543                 Response res = client.readItemList(
 544                         specifier.getURNValue(),
 545                         null, // partial term string
 546                         null, // keyword string
 547                         pageSize,
 548                         pageNum
 549                 );
 550
 551                 assertStatusCode(res, specifier, client);
 552
 553                 try {
 554                         result = new PoxPayloadIn((String) res.readEntity(getEntityResponseType())); // Get the entire response.
 555                 } finally {
 556                         res.close();
 557                 }
 558
 559                 return result;
 560         }
 561
 562         /*
 563          * Non standard injection of CSID into common part, since caller may access through
 564          * shortId, and not know the CSID.
 565          * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#extractPart(org.nuxeo.ecm.core.api.DocumentModel, java.lang.String, org.collectionspace.services.common.service.ObjectPartType)
 566          */
 567         @Override
 568         protected Map<String, Object> extractPart(DocumentModel docModel, String schema, ObjectPartType partMeta)
 569                         throws Exception {
 570                 Map<String, Object> unQObjectProperties = super.extractPart(docModel, schema, partMeta);
 571
 572                 // Add the CSID to the common part
 573                 if (partMeta.getLabel().equalsIgnoreCase(authorityCommonSchemaName)) {
 574                         String csid = getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());
 575                         unQObjectProperties.put("csid", csid);
 576                 }
 577
 578                 return unQObjectProperties;
 579         }
 580
 581         public void fillAllParts(DocumentWrapper<DocumentModel> wrapDoc, Action action) throws Exception {
 582                 super.fillAllParts(wrapDoc, action);
 583                 //
 584                 // Update the record's revision number on both CREATE and UPDATE actions, but not on SYNC
 585                 //
 586                 if (this.getShouldUpdateRevNumber() == true) { // We won't update rev numbers on synchronization with SAS
 587                         updateRevNumbers(wrapDoc);
 588                 }
 589         }
 590
 591         protected void updateRevNumbers(DocumentWrapper<DocumentModel> wrapDoc) {
 592                 DocumentModel documentModel = wrapDoc.getWrappedObject();
 593                 Long rev = (Long)documentModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.REV);
 594                 if (rev == null) {
 595                         rev = (long)0;
 596                 } else {
 597                         rev++;
 598                 }
 599                 documentModel.setProperty(authorityCommonSchemaName, AuthorityJAXBSchema.REV, rev);
 600         }
 601
 602         /*
 603          * We consider workflow state changes as changes that should bump the revision number
 604          * (non-Javadoc)
 605          * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#handleWorkflowTransition(org.collectionspace.services.common.document.DocumentWrapper, org.collectionspace.services.lifecycle.TransitionDef)
 606          */
 607         @Override
 608         public void handleWorkflowTransition(ServiceContext ctx, DocumentWrapper<DocumentModel> wrapDoc, TransitionDef transitionDef) throws Exception {
 609                 boolean updateRevNumber = this.getShouldUpdateRevNumber();
 610                 Boolean contextProperty = (Boolean) ctx.getProperty(AuthorityServiceUtils.SHOULD_UPDATE_REV_PROPERTY);
 611                 if (contextProperty != null) {
 612                         updateRevNumber = contextProperty;
 613                 }
 614
 615                 if (updateRevNumber == true) { // We don't update the rev number of synchronization requests
 616                         updateRevNumbers(wrapDoc);
 617                 }
 618         }
 619
 620         @Override
 621         public void handleCreate(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 622                 super.handleCreate(wrapDoc);
 623                 // CSPACE-3178:
 624                 // Uncomment once debugged and App layer is read to integrate
 625                 // Experimenting with this uncommented now ...
 626                 handleDisplayNameAsShortIdentifier(wrapDoc.getWrappedObject(), authorityCommonSchemaName);
 627                 updateRefnameForAuthority(wrapDoc, authorityCommonSchemaName);//CSPACE-3178
 628         }
 629
 630         protected String buildWhereForShortId(String name) {
 631                 return authorityCommonSchemaName
 632                                 + ":" + AuthorityJAXBSchema.SHORT_IDENTIFIER
 633                                 + "='" + name + "'";
 634         }
 635
 636         private boolean isUnique(DocumentModel docModel, String schemaName) throws DocumentException {
 637                 return true;
 638         }
 639
 640         private boolean temp_isUnique(DocumentModel docModel, String schemaName) throws DocumentException {
 641                 boolean result = true;
 642
 643                 ServiceContext ctx = this.getServiceContext();
 644                 String shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 645                 String nxqlWhereClause = buildWhereForShortId(shortIdentifier);
 646                 try {
 647                         DocumentWrapper<DocumentModel> searchResultWrapper = getRepositoryClient(ctx).findDoc(ctx, nxqlWhereClause);
 648                         if (searchResultWrapper != null) {
 649                                 result = false;
 650                                 if (logger.isInfoEnabled() == true) {
 651                                         DocumentModel searchResult = searchResultWrapper.getWrappedObject();
 652                                         String debugMsg = String.format("Could not create a new authority with a short identifier of '%s', because one already exists with the same short identifer: CSID = '%s'",
 653                                                         shortIdentifier, searchResult.getName());
 654                                         logger.trace(debugMsg);
 655                                 }
 656                         }
 657                 } catch (DocumentNotFoundException e) {
 658                         // Not a problem, just means we couldn't find another authority with that short ID
 659                 }
 660
 661                 return result;
 662         }
 663
 664         /**
 665          * If no short identifier was provided in the input payload,
 666          * generate a short identifier from the display name. Either way though,
 667          * the short identifier needs to be unique.
 668          */
 669         private void handleDisplayNameAsShortIdentifier(DocumentModel docModel, String schemaName) throws Exception {
 670                 String shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 671                 String displayName = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.DISPLAY_NAME);
 672                 String shortDisplayName = "";
 673                 String generateShortIdentifier = null;
 674                 if (Tools.isEmpty(shortIdentifier)) {
 675                         generateShortIdentifier = AuthorityIdentifierUtils.generateShortIdentifierFromDisplayName(displayName, shortDisplayName);
 676                         docModel.setProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER, shortIdentifier);
 677                 }
 678
 679                 if (isUnique(docModel, schemaName) == false) {
 680                         String shortId = generateShortIdentifier == null ? shortIdentifier : generateShortIdentifier;
 681                         String errMsgVerb = generateShortIdentifier == null ? "supplied" : "generated";
 682                         String errMsg = String.format("The %s short identifier '%s' was not unique, so the new authority could not be created.",
 683                                         errMsgVerb, shortId);
 684                         throw new DocumentException(errMsg);
 685                 }
 686         }
 687
 688         /**
 689          * Generate a refName for the authority from the short identifier
 690          * and display name.
 691          *
 692          * All refNames for authorities are generated.  If a client supplies
 693          * a refName, it will be overwritten during create (per this method)
 694          * or discarded during update (per filterReadOnlyPropertiesForPart).
 695          *
 696          * @see #filterReadOnlyPropertiesForPart(Map<String, Object>, org.collectionspace.services.common.service.ObjectPartType)
 697          *
 698          */
 699         protected void updateRefnameForAuthority(DocumentWrapper<DocumentModel> wrapDoc, String schemaName) throws Exception {
 700                 DocumentModel docModel = wrapDoc.getWrappedObject();
 701                 RefName.Authority authority = (Authority) getRefName(getServiceContext(), docModel);
 702                 String refName = authority.toString();
 703                 docModel.setProperty(schemaName, AuthorityJAXBSchema.REF_NAME, refName);
 704         }
 705
 706         @Override
 707         public RefName.RefNameInterface getRefName(ServiceContext ctx,
 708                         DocumentModel docModel) {
 709                 RefName.RefNameInterface refname = null;
 710
 711                 try {
 712                         String shortIdentifier = (String) docModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 713                         String displayName = (String) docModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.DISPLAY_NAME);
 714                         RefName.Authority authority = RefName.Authority.buildAuthority(ctx.getTenantName(),
 715                                         ctx.getServiceName(),
 716                                         null,   // Only use shortId form!!!
 717                                         shortIdentifier,
 718                                         displayName);
 719                         refname = authority;
 720                 } catch (Exception e) {
 721                         logger.error(e.getMessage(), e);
 722                 }
 723
 724                 return refname;
 725         }
 726
 727         @Override
 728         protected String getRefnameDisplayName(DocumentWrapper<DocumentModel> docWrapper) {
 729                 String result = null;
 730
 731                 DocumentModel docModel = docWrapper.getWrappedObject();
 732                 ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = this.getServiceContext();
 733                 RefName.Authority refname = (RefName.Authority)getRefName(ctx, docModel);
 734                 result = refname.getDisplayName();
 735
 736                 return result;
 737         }
 738
 739         public String getShortIdentifier(ServiceContext ctx, String authCSID, String schemaName) throws Exception {
 740                 String shortIdentifier = null;
 741                 CoreSessionInterface repoSession = null;
 742                 boolean releaseSession = false;
 743
 744                 NuxeoRepositoryClientImpl nuxeoRepoClient = (NuxeoRepositoryClientImpl)this.getRepositoryClient(ctx);
 745                 try {
 746                         repoSession = nuxeoRepoClient.getRepositorySession(ctx);
 747                         DocumentWrapper<DocumentModel> wrapDoc = nuxeoRepoClient.getDocFromCsid(ctx, repoSession, authCSID);
 748                         DocumentModel docModel = wrapDoc.getWrappedObject();
 749                         if (docModel == null) {
 750                                 throw new DocumentNotFoundException(String.format("Could not find authority resource with CSID='%s'.", authCSID));
 751                         }
 752                         shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 753                 } catch (ClientException ce) {
 754                         throw new RuntimeException("AuthorityDocHandler Internal Error: cannot get shortId!", ce);
 755                 } finally {
 756                         if (repoSession != null) {
 757                                 nuxeoRepoClient.releaseRepositorySession(ctx, repoSession);
 758                         }
 759                 }
 760
 761                 return shortIdentifier;
 762         }
 763
 764         /**
 765          * Filters out selected values supplied in an update request.
 766          *
 767          * @param objectProps the properties filtered out from the update payload
 768          * @param partMeta metadata for the object to fill
 769          */
 770         @Override
 771         public void filterReadOnlyPropertiesForPart(
 772                         Map<String, Object> objectProps, ObjectPartType partMeta) {
 773                 super.filterReadOnlyPropertiesForPart(objectProps, partMeta);
 774                 String commonPartLabel = getServiceContext().getCommonPartLabel();
 775                 if (partMeta.getLabel().equalsIgnoreCase(commonPartLabel)) {
 776                         objectProps.remove(AuthorityJAXBSchema.CSID);
 777                         objectProps.remove(AuthorityJAXBSchema.SHORT_IDENTIFIER);
 778                         objectProps.remove(AuthorityJAXBSchema.REF_NAME);
 779                 }
 780         }
 781
 782         @Override
 783         protected Object getListResultValue(DocumentModel docModel, // REM - CSPACE-5133
 784                         String schema, ListResultField field) throws DocumentException {
 785                 Object result = null;
 786
 787                 result = super.getListResultValue(docModel, schema, field);
 788
 789                 return result;
 790         }
 791 }