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);
 314
 315                                 handledCount++;
 316                         } catch (DocumentReferenceException dre) {
 317                                 logger.info(String.format("Item %s has existing references and cannot be deleted.", itemShortId), dre);
 318
 319                                 AuthorityItemSpecifier authorityItemSpecifier = new AuthorityItemSpecifier(parentSpecifier, itemSpecifier);
 320                                 boolean deprecated = AuthorityServiceUtils.markAuthorityItemAsDeprecated(ctx, authorityItemCommonSchemaName, authorityItemSpecifier);
 321
 322                                 if (deprecated == true) {
 323                                         handledCount++;
 324                                 }
 325                         } catch (Exception e) {
 326                                 logger.error(String.format("Unable to delete or deprecate item %s", itemShortId), e);
 327
 328                                 throw(e);
 329                         }
 330                 }
 331
 332                 return handledCount;
 333         }
 334
 335         /**
 336          * Gets the list of SAS related items in the local authority. Exludes items with
 337          * the "proposed" flag to include only SAS created items.
 338          *
 339          * @param ctx
 340          * @param authoritySpecifier
 341          * @return
 342          * @throws Exception
 343          */
 344         private Set<String> getItemsInLocalAuthority(ServiceContext ctx, Specifier authoritySpecifier) throws Exception {
 345                 Set<String> itemShortIds = new HashSet<String>();
 346
 347                 ResourceMap resourceMap = ctx.getResourceMap();
 348                 String resourceName = ctx.getClient().getServiceName();
 349                 AuthorityResource authorityResource = (AuthorityResource) resourceMap.get(resourceName);
 350
 351                 long pageNum = 0;
 352                 long pageSize = SAS_SYNC_PAGE_SIZE;
 353
 354                 List<ListItem> listItems;
 355
 356                 do {
 357                         if (logger.isDebugEnabled()) {
 358                                 logger.debug(String.format("Reading local items in %s: page size %d, page num %d", authoritySpecifier.value,
 359                                                 pageSize, pageNum));
 360                         }
 361
 362                         // Construct a UriInfo to retrieve one page of results.
 363
 364                         UriInfo uriInfo = new UriInfoImpl(
 365                                 new URI(""),
 366                                 new URI(""),
 367                                 "",
 368                                 "pgSz=" + pageSize + "&pgNum=" + pageNum,
 369                                 Collections.<PathSegment> emptyList()
 370                         );
 371
 372                         AbstractCommonList acl = authorityResource.getAuthorityItemList(ctx, authoritySpecifier.getURNValue(), uriInfo);
 373
 374                         listItems = acl.getListItem();
 375
 376                         if (logger.isDebugEnabled()) {
 377                                 logger.debug(String.format("Found %d items", listItems.size()));
 378                         }
 379
 380                         for (ListItem listItem : listItems) {
 381                                 Boolean proposed = getBooleanValue(listItem, AuthorityItemJAXBSchema.PROPOSED);
 382
 383                                 if (proposed == false) { // exclude "proposed" (i.e., local-only items)
 384                                         itemShortIds.add(AbstractCommonListUtils.ListItemGetElementValue(listItem, AuthorityItemJAXBSchema.SHORT_IDENTIFIER));
 385                                 }
 386                         }
 387
 388                         pageNum = pageNum + 1;
 389                 } while (listItems.size() > 0 && listItems.size() == SAS_SYNC_PAGE_SIZE);
 390
 391                 return itemShortIds;
 392         }
 393
 394         private Boolean getBooleanValue(ListItem listItem, String name) {
 395                 Boolean result = null;
 396
 397                 String value = AbstractCommonListUtils.ListItemGetElementValue(listItem, name);
 398                 if (value != null) {
 399                         result = Boolean.valueOf(value);
 400                 }
 401
 402                 return result;
 403         }
 404
 405         private String getStringValue(ListItem listItem, String name) {
 406                 return AbstractCommonListUtils.ListItemGetElementValue(listItem, AuthorityItemJAXBSchema.REF_NAME);
 407         }
 408
 409         /**
 410          * This method should only be used during a SAS synchronization request.
 411          *
 412          * @param ctx
 413          * @param parentIdentifier - Must be in short-id-refname form -i.e., urn:cspace:name(shortid)
 414          * @param itemIdentifier   - Must be in short-id-refname form -i.e., urn:cspace:name(shortid)
 415          * @throws Exception
 416          */
 417         protected void createLocalItem(ServiceContext ctx, String parentCsid, String parentIdentifier, String itemIdentifier, Boolean syncHierarchicalRelationships) throws Exception {
 418                 //
 419                 // Create a URN short ID specifier for the getting a copy of the remote authority item
 420                 //
 421                 Specifier parentSpecifier = Specifier.getSpecifier(parentIdentifier);
 422                 Specifier itemSpecifier = Specifier.getSpecifier(itemIdentifier);
 423                 AuthorityItemSpecifier sasAuthorityItemSpecifier = new AuthorityItemSpecifier(parentSpecifier, itemSpecifier);
 424                 //
 425                 // Get the remote client configuration name
 426                 //
 427                 DocumentModel docModel = NuxeoUtils.getDocFromSpecifier(ctx, getRepositorySession(), authorityCommonSchemaName, parentSpecifier);
 428                 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
 429                 //
 430                 // Get the remote payload
 431                 //
 432                 PoxPayloadIn sasPayloadIn = AuthorityServiceUtils.requestPayloadInFromRemoteServer(sasAuthorityItemSpecifier, remoteClientConfigName,
 433                                 ctx.getServiceName(), getEntityResponseType(), syncHierarchicalRelationships);
 434
 435                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 436
 437                 // Remove remote uris and csids from relations, and remove relations to items that don't exist locally.
 438                 sasPayloadIn = AuthorityServiceUtils.localizeRelations(ctx, authorityResource, parentCsid, itemSpecifier, sasPayloadIn);
 439
 440                 // Localize domain name parts of refnames in the payload.
 441                 sasPayloadIn = AuthorityServiceUtils.localizeRefNameDomains(ctx, sasPayloadIn);
 442
 443                 //
 444                 // Using the payload from the remote server, create a local copy of the item
 445                 //
 446                 Response response = authorityResource.createAuthorityItemWithParentContext(ctx, parentSpecifier.getURNValue(),
 447                                 sasPayloadIn, AuthorityServiceUtils.DONT_UPDATE_REV, AuthorityServiceUtils.NOT_PROPOSED, AuthorityServiceUtils.SAS_ITEM);
 448                 //
 449                 // Check the response for successful POST result
 450                 //
 451                 if (response.getStatus() != Response.Status.CREATED.getStatusCode()) {
 452                         throw new DocumentException(String.format("Could not create new authority item '%s' during synchronization of the '%s' authority.",
 453                                         itemIdentifier, parentIdentifier));
 454                 }
 455                 //
 456                 // Since we're creating an item that was sourced from the replication server, we need to replicate it locally.
 457                 //
 458                 authorityResource.updateItemWorkflowWithTransition(ctx, parentIdentifier, itemIdentifier,
 459                                 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)
 460                 }
 461
 462         /**
 463          * Synchronize a remote item (using its refName) with a local item.  If the local doesn't yet
 464          * exist, create it.
 465          * Result values:
 466          *      -1 = sync not needed; i.e., already in sync
 467          *   0 = sync succeeded
 468          *   1 = local item was missing so we created it
 469          * @param ctx
 470          * @param refName
 471          * @return
 472          * @throws Exception
 473          */
 474         protected long syncRemoteItem(ServiceContext ctx, String parentCsid, String itemRefName) throws Exception {
 475                 if (logger.isInfoEnabled()) {
 476                         logger.info(String.format("Syncing remote item %s", itemRefName));
 477                 }
 478
 479                 // Create specifiers to find the local item corresponding to the remote refname.
 480
 481                 AuthorityTermInfo authorityTermInfo = RefNameUtils.parseAuthorityTermInfo(itemRefName);
 482                 String parentIdentifier = Specifier.createShortIdURNValue(authorityTermInfo.inAuthority.name);
 483                 String itemIdentifier = Specifier.createShortIdURNValue(authorityTermInfo.name);
 484
 485                 // Use the Authority JAX-RS resource to peform sync operations (creates and updates).
 486
 487                 AuthorityResource authorityResource = (AuthorityResource) ctx.getResource();
 488                 PoxPayloadOut localItemPayload = null;
 489
 490                 // Find the local item.
 491
 492                 try {
 493                         localItemPayload = authorityResource.getAuthorityItemWithExistingContext(ctx, parentIdentifier, itemIdentifier);
 494                 } catch (DocumentNotFoundException dnf) {
 495                         localItemPayload = null;
 496                 }
 497
 498                 // If no local item exists, create one.
 499
 500                 if (localItemPayload == null) {
 501                         createLocalItem(ctx, parentCsid, parentIdentifier, itemIdentifier, AuthorityClient.INCLUDE_RELATIONS);
 502
 503                         return 1;
 504                 }
 505
 506                 // Sync the local item with the remote item.
 507
 508                 PoxPayloadOut updatePayload = null;
 509
 510                 try {
 511                         updatePayload = authorityResource.synchronizeItemWithExistingContext(ctx, parentIdentifier, itemIdentifier, AuthorityClient.INCLUDE_RELATIONS);
 512                 } catch (DocumentReferenceException de) {
 513                         logger.error(String.format("Could not sync item %s because it is referenced by other records", itemIdentifier));
 514                 }
 515
 516                 if (updatePayload != null) {
 517                         logger.info(String.format("Synced item %s in authority %s", itemIdentifier, parentIdentifier));
 518
 519                         return 0;
 520                 }
 521
 522                 return -1;
 523         }
 524
 525         private void assertStatusCode(Response res, Specifier specifier, AuthorityClient client) throws Exception {
 526                 int statusCode = res.getStatus();
 527
 528                 if (statusCode != HttpStatus.SC_OK) {
 529                         String errMsg = String.format("Could not retrieve authority information for '%s' on remote server '%s'.  Server returned status code %d",
 530                                         specifier.getURNValue(), client.getBaseURL(), statusCode);
 531                         throw new DocumentException(statusCode, errMsg);
 532                 }
 533         }
 534
 535         /**
 536          * Request an authority item list payload from the SAS server.
 537          *
 538          * @param ctx
 539          * @param specifier
 540          * @return
 541          * @throws Exception
 542          */
 543         private PoxPayloadIn requestItemList(ServiceContext ctx, Specifier specifier, long pageSize, long pageNum) throws Exception {
 544                 PoxPayloadIn result = null;
 545                 AuthorityClient client = (AuthorityClient) ctx.getClient();
 546
 547                 Response res = client.readItemList(
 548                         specifier.getURNValue(),
 549                         null, // partial term string
 550                         null, // keyword string
 551                         pageSize,
 552                         pageNum
 553                 );
 554
 555                 assertStatusCode(res, specifier, client);
 556
 557                 try {
 558                         result = new PoxPayloadIn((String) res.readEntity(getEntityResponseType())); // Get the entire response.
 559                 } finally {
 560                         res.close();
 561                 }
 562
 563                 return result;
 564         }
 565
 566         /*
 567          * Non standard injection of CSID into common part, since caller may access through
 568          * shortId, and not know the CSID.
 569          * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#extractPart(org.nuxeo.ecm.core.api.DocumentModel, java.lang.String, org.collectionspace.services.common.service.ObjectPartType)
 570          */
 571         @Override
 572         protected Map<String, Object> extractPart(DocumentModel docModel, String schema, ObjectPartType partMeta)
 573                         throws Exception {
 574                 Map<String, Object> unQObjectProperties = super.extractPart(docModel, schema, partMeta);
 575
 576                 // Add the CSID to the common part
 577                 if (partMeta.getLabel().equalsIgnoreCase(authorityCommonSchemaName)) {
 578                         String csid = getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());
 579                         unQObjectProperties.put("csid", csid);
 580                 }
 581
 582                 return unQObjectProperties;
 583         }
 584
 585         public void fillAllParts(DocumentWrapper<DocumentModel> wrapDoc, Action action) throws Exception {
 586                 super.fillAllParts(wrapDoc, action);
 587                 //
 588                 // Update the record's revision number on both CREATE and UPDATE actions, but not on SYNC
 589                 //
 590                 if (this.getShouldUpdateRevNumber() == true) { // We won't update rev numbers on synchronization with SAS
 591                         updateRevNumbers(wrapDoc);
 592                 }
 593         }
 594
 595         protected void updateRevNumbers(DocumentWrapper<DocumentModel> wrapDoc) {
 596                 DocumentModel documentModel = wrapDoc.getWrappedObject();
 597                 Long rev = (Long)documentModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.REV);
 598                 if (rev == null) {
 599                         rev = (long)0;
 600                 } else {
 601                         rev++;
 602                 }
 603                 documentModel.setProperty(authorityCommonSchemaName, AuthorityJAXBSchema.REV, rev);
 604         }
 605
 606         /*
 607          * We consider workflow state changes as changes that should bump the revision number
 608          * (non-Javadoc)
 609          * @see org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl#handleWorkflowTransition(org.collectionspace.services.common.document.DocumentWrapper, org.collectionspace.services.lifecycle.TransitionDef)
 610          */
 611         @Override
 612         public void handleWorkflowTransition(ServiceContext ctx, DocumentWrapper<DocumentModel> wrapDoc, TransitionDef transitionDef) throws Exception {
 613                 boolean updateRevNumber = this.getShouldUpdateRevNumber();
 614                 Boolean contextProperty = (Boolean) ctx.getProperty(AuthorityServiceUtils.SHOULD_UPDATE_REV_PROPERTY);
 615                 if (contextProperty != null) {
 616                         updateRevNumber = contextProperty;
 617                 }
 618
 619                 if (updateRevNumber == true) { // We don't update the rev number of synchronization requests
 620                         updateRevNumbers(wrapDoc);
 621                 }
 622         }
 623
 624         @Override
 625         public void handleCreate(DocumentWrapper<DocumentModel> wrapDoc) throws Exception {
 626                 super.handleCreate(wrapDoc);
 627                 // CSPACE-3178:
 628                 // Uncomment once debugged and App layer is read to integrate
 629                 // Experimenting with this uncommented now ...
 630                 handleDisplayNameAsShortIdentifier(wrapDoc.getWrappedObject(), authorityCommonSchemaName);
 631                 updateRefnameForAuthority(wrapDoc, authorityCommonSchemaName);//CSPACE-3178
 632         }
 633
 634         protected String buildWhereForShortId(String name) {
 635                 return authorityCommonSchemaName
 636                                 + ":" + AuthorityJAXBSchema.SHORT_IDENTIFIER
 637                                 + "='" + name + "'";
 638         }
 639
 640         private boolean isUnique(DocumentModel docModel, String schemaName) throws DocumentException {
 641                 return true;
 642         }
 643
 644         private boolean temp_isUnique(DocumentModel docModel, String schemaName) throws DocumentException {
 645                 boolean result = true;
 646
 647                 ServiceContext ctx = this.getServiceContext();
 648                 String shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 649                 String nxqlWhereClause = buildWhereForShortId(shortIdentifier);
 650                 try {
 651                         DocumentWrapper<DocumentModel> searchResultWrapper = getRepositoryClient(ctx).findDoc(ctx, nxqlWhereClause);
 652                         if (searchResultWrapper != null) {
 653                                 result = false;
 654                                 if (logger.isInfoEnabled() == true) {
 655                                         DocumentModel searchResult = searchResultWrapper.getWrappedObject();
 656                                         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'",
 657                                                         shortIdentifier, searchResult.getName());
 658                                         logger.trace(debugMsg);
 659                                 }
 660                         }
 661                 } catch (DocumentNotFoundException e) {
 662                         // Not a problem, just means we couldn't find another authority with that short ID
 663                 }
 664
 665                 return result;
 666         }
 667
 668         /**
 669          * If no short identifier was provided in the input payload,
 670          * generate a short identifier from the display name. Either way though,
 671          * the short identifier needs to be unique.
 672          */
 673         private void handleDisplayNameAsShortIdentifier(DocumentModel docModel, String schemaName) throws Exception {
 674                 String shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 675                 String displayName = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.DISPLAY_NAME);
 676                 String shortDisplayName = "";
 677                 String generateShortIdentifier = null;
 678                 if (Tools.isEmpty(shortIdentifier)) {
 679                         generateShortIdentifier = AuthorityIdentifierUtils.generateShortIdentifierFromDisplayName(displayName, shortDisplayName);
 680                         docModel.setProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER, shortIdentifier);
 681                 }
 682
 683                 if (isUnique(docModel, schemaName) == false) {
 684                         String shortId = generateShortIdentifier == null ? shortIdentifier : generateShortIdentifier;
 685                         String errMsgVerb = generateShortIdentifier == null ? "supplied" : "generated";
 686                         String errMsg = String.format("The %s short identifier '%s' was not unique, so the new authority could not be created.",
 687                                         errMsgVerb, shortId);
 688                         throw new DocumentException(errMsg);
 689                 }
 690         }
 691
 692         /**
 693          * Generate a refName for the authority from the short identifier
 694          * and display name.
 695          *
 696          * All refNames for authorities are generated.  If a client supplies
 697          * a refName, it will be overwritten during create (per this method)
 698          * or discarded during update (per filterReadOnlyPropertiesForPart).
 699          *
 700          * @see #filterReadOnlyPropertiesForPart(Map<String, Object>, org.collectionspace.services.common.service.ObjectPartType)
 701          *
 702          */
 703         protected void updateRefnameForAuthority(DocumentWrapper<DocumentModel> wrapDoc, String schemaName) throws Exception {
 704                 DocumentModel docModel = wrapDoc.getWrappedObject();
 705                 RefName.Authority authority = (Authority) getRefName(getServiceContext(), docModel);
 706                 String refName = authority.toString();
 707                 docModel.setProperty(schemaName, AuthorityJAXBSchema.REF_NAME, refName);
 708         }
 709
 710         @Override
 711         public RefName.RefNameInterface getRefName(ServiceContext ctx,
 712                         DocumentModel docModel) {
 713                 RefName.RefNameInterface refname = null;
 714
 715                 try {
 716                         String shortIdentifier = (String) docModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 717                         String displayName = (String) docModel.getProperty(authorityCommonSchemaName, AuthorityJAXBSchema.DISPLAY_NAME);
 718                         RefName.Authority authority = RefName.Authority.buildAuthority(ctx.getTenantName(),
 719                                         ctx.getServiceName(),
 720                                         null,   // Only use shortId form!!!
 721                                         shortIdentifier,
 722                                         displayName);
 723                         refname = authority;
 724                 } catch (Exception e) {
 725                         logger.error(e.getMessage(), e);
 726                 }
 727
 728                 return refname;
 729         }
 730
 731         @Override
 732         protected String getRefnameDisplayName(DocumentWrapper<DocumentModel> docWrapper) {
 733                 String result = null;
 734
 735                 DocumentModel docModel = docWrapper.getWrappedObject();
 736                 ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = this.getServiceContext();
 737                 RefName.Authority refname = (RefName.Authority)getRefName(ctx, docModel);
 738                 result = refname.getDisplayName();
 739
 740                 return result;
 741         }
 742
 743         public String getShortIdentifier(ServiceContext ctx, String authCSID, String schemaName) throws Exception {
 744                 String shortIdentifier = null;
 745                 CoreSessionInterface repoSession = null;
 746                 boolean releaseSession = false;
 747
 748                 NuxeoRepositoryClientImpl nuxeoRepoClient = (NuxeoRepositoryClientImpl)this.getRepositoryClient(ctx);
 749                 try {
 750                         repoSession = nuxeoRepoClient.getRepositorySession(ctx);
 751                         DocumentWrapper<DocumentModel> wrapDoc = nuxeoRepoClient.getDocFromCsid(ctx, repoSession, authCSID);
 752                         DocumentModel docModel = wrapDoc.getWrappedObject();
 753                         if (docModel == null) {
 754                                 throw new DocumentNotFoundException(String.format("Could not find authority resource with CSID='%s'.", authCSID));
 755                         }
 756                         shortIdentifier = (String) docModel.getProperty(schemaName, AuthorityJAXBSchema.SHORT_IDENTIFIER);
 757                 } catch (ClientException ce) {
 758                         throw new RuntimeException("AuthorityDocHandler Internal Error: cannot get shortId!", ce);
 759                 } finally {
 760                         if (repoSession != null) {
 761                                 nuxeoRepoClient.releaseRepositorySession(ctx, repoSession);
 762                         }
 763                 }
 764
 765                 return shortIdentifier;
 766         }
 767
 768         /**
 769          * Filters out selected values supplied in an update request.
 770          *
 771          * @param objectProps the properties filtered out from the update payload
 772          * @param partMeta metadata for the object to fill
 773          */
 774         @Override
 775         public void filterReadOnlyPropertiesForPart(
 776                         Map<String, Object> objectProps, ObjectPartType partMeta) {
 777                 super.filterReadOnlyPropertiesForPart(objectProps, partMeta);
 778                 String commonPartLabel = getServiceContext().getCommonPartLabel();
 779                 if (partMeta.getLabel().equalsIgnoreCase(commonPartLabel)) {
 780                         objectProps.remove(AuthorityJAXBSchema.CSID);
 781                         objectProps.remove(AuthorityJAXBSchema.SHORT_IDENTIFIER);
 782                         objectProps.remove(AuthorityJAXBSchema.REF_NAME);
 783                 }
 784         }
 785
 786         @Override
 787         protected Object getListResultValue(DocumentModel docModel, // REM - CSPACE-5133
 788                         String schema, ListResultField field) throws DocumentException {
 789                 Object result = null;
 790
 791                 result = super.getListResultValue(docModel, schema, field);
 792
 793                 return result;
 794         }
 795 }