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;
  25
  26 import org.collectionspace.services.client.IClientQueryParams;
  27 import org.collectionspace.services.client.IQueryManager;
  28 import org.collectionspace.services.client.PoxPayloadIn;
  29 import org.collectionspace.services.client.PoxPayloadOut;
  30 import org.collectionspace.services.client.workflow.WorkflowClient;
  31 import org.collectionspace.services.common.ResourceBase;
  32 import org.collectionspace.services.common.ResourceMap;
  33 import org.collectionspace.services.common.ServiceMain;
  34 import org.collectionspace.services.common.ServiceMessages;
  35 import org.collectionspace.services.common.api.RefName;
  36 import org.collectionspace.services.common.api.Tools;
  37 import org.collectionspace.services.common.authorityref.AuthorityRefDocList;
  38 import org.collectionspace.services.common.authorityref.AuthorityRefList;
  39 import org.collectionspace.services.common.context.JaxRsContext;
  40 import org.collectionspace.services.common.context.MultipartServiceContext;
  41 import org.collectionspace.services.common.context.RemoteServiceContext;
  42 import org.collectionspace.services.common.context.ServiceBindingUtils;
  43 import org.collectionspace.services.common.context.ServiceContext;
  44 import org.collectionspace.services.common.document.DocumentException;
  45 import org.collectionspace.services.common.document.DocumentFilter;
  46 import org.collectionspace.services.common.document.DocumentHandler;
  47 import org.collectionspace.services.common.document.DocumentNotFoundException;
  48 import org.collectionspace.services.common.document.DocumentWrapper;
  49 import org.collectionspace.services.common.query.QueryManager;
  50 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils;
  51 import org.collectionspace.services.common.vocabulary.nuxeo.AuthorityDocumentModelHandler;
  52 import org.collectionspace.services.common.vocabulary.nuxeo.AuthorityItemDocumentModelHandler;
  53 import org.collectionspace.services.common.workflow.service.nuxeo.WorkflowDocumentModelHandler;
  54 import org.collectionspace.services.config.ClientType;
  55 import org.collectionspace.services.jaxb.AbstractCommonList;
  56 import org.collectionspace.services.lifecycle.TransitionDef;
  57 import org.collectionspace.services.nuxeo.client.java.DocumentModelHandler;
  58 import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClientImpl;
  59 import org.collectionspace.services.workflow.WorkflowCommon;
  60 import org.jboss.resteasy.util.HttpResponseCodes;
  61 import org.nuxeo.ecm.core.api.DocumentModel;
  62 import org.nuxeo.ecm.core.api.repository.RepositoryInstance;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66 import javax.ws.rs.Consumes;
  67 import javax.ws.rs.DELETE;
  68 import javax.ws.rs.GET;
  69 import javax.ws.rs.POST;
  70 import javax.ws.rs.PUT;
  71 import javax.ws.rs.Path;
  72 import javax.ws.rs.PathParam;
  73 import javax.ws.rs.Produces;
  74 import javax.ws.rs.QueryParam;
  75 import javax.ws.rs.WebApplicationException;
  76 import javax.ws.rs.core.Context;
  77 import javax.ws.rs.core.MultivaluedMap;
  78 import javax.ws.rs.core.Request;
  79 import javax.ws.rs.core.Response;
  80 import javax.ws.rs.core.UriBuilder;
  81 import javax.ws.rs.core.UriInfo;
  82
  83 import java.util.ArrayList;
  84 import java.util.List;
  85 import org.collectionspace.services.client.*;
  86 import org.collectionspace.services.nuxeo.util.NuxeoUtils;
  87
  88 /**
  89  * The Class AuthorityResource.
  90  */
  91 /**
  92  * @author pschmitz
  93  *
  94  * @param <AuthCommon>
  95  * @param <AuthItemHandler>
  96  */
  97 /**
  98  * @author pschmitz
  99  *
 100  * @param <AuthCommon>
 101  * @param <AuthItemHandler>
 102  */
 103 @Consumes("application/xml")
 104 @Produces("application/xml")
 105 public abstract class AuthorityResource<AuthCommon, AuthItemHandler>
 106         extends ResourceBase {
 107
 108         final static String SEARCH_TYPE_TERMSTATUS = "ts";
 109
 110     protected Class<AuthCommon> authCommonClass;
 111     protected Class<?> resourceClass;
 112     protected String authorityCommonSchemaName;
 113     protected String authorityItemCommonSchemaName;
 114     final static ClientType CLIENT_TYPE = ServiceMain.getInstance().getClientType(); //FIXME: REM - 3 Why is this field needed?  I see no references to it.
 115     final static String URN_PREFIX = "urn:cspace:";
 116     final static int URN_PREFIX_LEN = URN_PREFIX.length();
 117     final static String URN_PREFIX_NAME = "name(";
 118     final static int URN_NAME_PREFIX_LEN = URN_PREFIX_LEN + URN_PREFIX_NAME.length();
 119     final static String URN_PREFIX_ID = "id(";
 120     final static int URN_ID_PREFIX_LEN = URN_PREFIX_LEN + URN_PREFIX_ID.length();
 121     final static String FETCH_SHORT_ID = "_fetch_";
 122         final static String PARENT_WILDCARD = "_ALL_";
 123
 124     final Logger logger = LoggerFactory.getLogger(AuthorityResource.class);
 125
 126     public enum SpecifierForm {
 127
 128         CSID, URN_NAME
 129     };
 130
 131     public class Specifier {
 132
 133         public SpecifierForm form;
 134         public String value;
 135
 136         Specifier(SpecifierForm form, String value) {
 137             this.form = form;
 138             this.value = value;
 139         }
 140     }
 141
 142     protected Specifier getSpecifier(String specifierIn, String method, String op) throws WebApplicationException {
 143         if (logger.isDebugEnabled()) {
 144             logger.debug("getSpecifier called by: " + method + " with specifier: " + specifierIn);
 145         }
 146         if (specifierIn != null) {
 147             if (!specifierIn.startsWith(URN_PREFIX)) {
 148                 // We'll assume it is a CSID and complain if it does not match
 149                 return new Specifier(SpecifierForm.CSID, specifierIn);
 150             } else {
 151                 if (specifierIn.startsWith(URN_PREFIX_NAME, URN_PREFIX_LEN)) {
 152                     int closeParen = specifierIn.indexOf(')', URN_NAME_PREFIX_LEN);
 153                     if (closeParen >= 0) {
 154                         return new Specifier(SpecifierForm.URN_NAME,
 155                                 specifierIn.substring(URN_NAME_PREFIX_LEN, closeParen));
 156                     }
 157                 } else if (specifierIn.startsWith(URN_PREFIX_ID, URN_PREFIX_LEN)) {
 158                     int closeParen = specifierIn.indexOf(')', URN_ID_PREFIX_LEN);
 159                     if (closeParen >= 0) {
 160                         return new Specifier(SpecifierForm.CSID,
 161                                 specifierIn.substring(URN_ID_PREFIX_LEN, closeParen));
 162                     }
 163                 }
 164             }
 165         }
 166         logger.error(method + ": bad or missing specifier!");
 167         Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 168                 op + " failed on bad or missing Authority specifier").type(
 169                 "text/plain").build();
 170         throw new WebApplicationException(response);
 171     }
 172
 173     /**
 174      * Instantiates a new Authority resource.
 175      */
 176     public AuthorityResource(Class<AuthCommon> authCommonClass, Class<?> resourceClass,
 177             String authorityCommonSchemaName, String authorityItemCommonSchemaName) {
 178         this.authCommonClass = authCommonClass;
 179         this.resourceClass = resourceClass;
 180         this.authorityCommonSchemaName = authorityCommonSchemaName;
 181         this.authorityItemCommonSchemaName = authorityItemCommonSchemaName;
 182     }
 183
 184     public abstract String getItemServiceName();
 185
 186     public abstract String getItemTermInfoGroupXPathBase();
 187
 188     @Override
 189     protected String getVersionString() {
 190         return "$LastChangedRevision: 2617 $";
 191     }
 192
 193     @Override
 194     public Class<AuthCommon> getCommonPartClass() {
 195         return authCommonClass;
 196     }
 197
 198     /**
 199      * Creates the item document handler.
 200      *
 201      * @param ctx the ctx
 202      * @param inAuthority the in vocabulary
 203      *
 204      * @return the document handler
 205      *
 206      * @throws Exception the exception
 207      */
 208     protected DocumentHandler createItemDocumentHandler(
 209             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx,
 210             String inAuthority, String parentShortIdentifier)
 211             throws Exception {
 212         String authorityRefNameBase;
 213         AuthorityItemDocumentModelHandler<?> docHandler;
 214
 215         if (parentShortIdentifier == null) {
 216             authorityRefNameBase = null;
 217         } else {
 218             ServiceContext<PoxPayloadIn, PoxPayloadOut> parentCtx =
 219                     createServiceContext(getServiceName());
 220             if (parentShortIdentifier.equals(FETCH_SHORT_ID)) {
 221                 // Get from parent document
 222                 parentShortIdentifier = getAuthShortIdentifier(parentCtx, inAuthority);
 223             }
 224             authorityRefNameBase = buildAuthorityRefNameBase(parentCtx, parentShortIdentifier);
 225         }
 226
 227         docHandler = (AuthorityItemDocumentModelHandler<?>) createDocumentHandler(ctx,
 228                 ctx.getCommonPartLabel(getItemServiceName()),
 229                 authCommonClass);
 230         // FIXME - Richard and Aron think the following three lines should
 231         // be in the constructor for the AuthorityItemDocumentModelHandler
 232         // because all three are required fields.
 233         docHandler.setInAuthority(inAuthority);
 234         docHandler.setAuthorityRefNameBase(authorityRefNameBase);
 235         docHandler.setItemTermInfoGroupXPathBase(getItemTermInfoGroupXPathBase());
 236         return docHandler;
 237     }
 238
 239     public String getAuthShortIdentifier(
 240             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx, String authCSID)
 241             throws DocumentNotFoundException, DocumentException {
 242         String shortIdentifier = null;
 243         try {
 244             AuthorityDocumentModelHandler<?> handler =
 245                     (AuthorityDocumentModelHandler<?>) createDocumentHandler(ctx);
 246             shortIdentifier = handler.getShortIdentifier(authCSID, authorityCommonSchemaName);
 247         } catch (Exception e) {
 248             if (logger.isDebugEnabled()) {
 249                 logger.debug("Caught exception ", e);
 250             }
 251             throw new DocumentException(e);
 252         }
 253         return shortIdentifier;
 254     }
 255
 256     protected String buildAuthorityRefNameBase(
 257             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx, String shortIdentifier) {
 258         RefName.Authority authority = RefName.buildAuthority(ctx.getTenantName(),
 259                 ctx.getServiceName(), shortIdentifier, null);
 260         return authority.toString();
 261     }
 262
 263     public static class CsidAndShortIdentifier {
 264
 265         String CSID;
 266         String shortIdentifier;
 267     }
 268
 269     protected String lookupParentCSID(String parentspecifier, String method, String op, MultivaluedMap<String, String> queryParams)
 270             throws Exception {
 271         CsidAndShortIdentifier tempResult = lookupParentCSIDAndShortIdentifer(parentspecifier, method, op, queryParams);
 272         return tempResult.CSID;
 273     }
 274
 275     private CsidAndShortIdentifier lookupParentCSIDAndShortIdentifer(String parentspecifier, String method, String op, MultivaluedMap<String, String> queryParams)
 276             throws Exception {
 277         CsidAndShortIdentifier result = new CsidAndShortIdentifier();
 278         Specifier parentSpec = getSpecifier(parentspecifier, method, op);
 279         // Note that we have to create the service context for the Items, not the main service
 280         String parentcsid;
 281         String parentShortIdentifier;
 282         if (parentSpec.form == SpecifierForm.CSID) {
 283             parentShortIdentifier = null;
 284             parentcsid = parentSpec.value;
 285             // Uncomment when app layer is ready to integrate
 286             // Uncommented since refNames are currently only generated if not present - ADR CSPACE-3178
 287             parentShortIdentifier = FETCH_SHORT_ID;
 288         } else {
 289             parentShortIdentifier = parentSpec.value;
 290             String whereClause = buildWhereForAuthByName(parentSpec.value);
 291             ServiceContext ctx = createServiceContext(getServiceName(), queryParams);
 292             parentcsid = getRepositoryClient(ctx).findDocCSID(null, ctx, whereClause); //FIXME: REM - If the parent has been soft-deleted, should we be looking for the item?
 293         }
 294         result.CSID = parentcsid;
 295         result.shortIdentifier = parentShortIdentifier;
 296         return result;
 297     }
 298
 299     public String lookupItemCSID(String itemspecifier, String parentcsid, String method, String op, ServiceContext ctx)
 300             throws DocumentException {
 301         String itemcsid;
 302         Specifier itemSpec = getSpecifier(itemspecifier, method, op);
 303         if (itemSpec.form == SpecifierForm.CSID) {
 304             itemcsid = itemSpec.value;
 305         } else {
 306             String itemWhereClause = buildWhereForAuthItemByName(itemSpec.value, parentcsid);
 307             itemcsid = getRepositoryClient(ctx).findDocCSID(null, ctx, itemWhereClause); //FIXME: REM - Should we be looking for the 'wf_deleted' query param and filtering on it?
 308         }
 309         return itemcsid;
 310     }
 311
 312     /*
 313      * Generally, callers will first call RefName.AuthorityItem.parse with a refName, and then
 314      * use the returned item.inAuthority.resource and a resourceMap to get a service-specific
 315      * Resource. They then call this method on that resource.
 316      */
 317     @Override
 318         public DocumentModel getDocModelForAuthorityItem(RepositoryInstance repoSession, RefName.AuthorityItem item)
 319                         throws Exception, DocumentNotFoundException {
 320         if(item == null) {
 321                 return null;
 322         }
 323         String whereClause = buildWhereForAuthByName(item.getParentShortIdentifier());
 324         // Ensure we have the right context.
 325         ServiceContext ctx = createServiceContext(item.inAuthority.resource);
 326
 327         // HACK - this really must be moved to the doc handler, not here. No Nuxeo specific stuff here!
 328         RepositoryJavaClientImpl client = (RepositoryJavaClientImpl)getRepositoryClient(ctx);
 329         String parentcsid = client.findDocCSID(repoSession, ctx, whereClause);
 330
 331         String itemWhereClause = buildWhereForAuthItemByName(item.getShortIdentifier(), parentcsid);
 332         ctx = createServiceContext(getItemServiceName());
 333         DocumentWrapper<DocumentModel> docWrapper = client.findDoc(repoSession, ctx, itemWhereClause);
 334         DocumentModel docModel = docWrapper.getWrappedObject();
 335         return docModel;
 336     }
 337
 338
 339     @POST                                                                                                       //FIXME: REM - 5/1/2012 - We can probably remove this method.
 340     public Response createAuthority(String xmlPayload) {        //REM - This method is never reached by the JAX-RS client -instead the "create" method in ResourceBase.java is getting called.
 341         try {
 342             PoxPayloadIn input = new PoxPayloadIn(xmlPayload);
 343             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(input);
 344             DocumentHandler handler = createDocumentHandler(ctx);
 345             String csid = getRepositoryClient(ctx).create(ctx, handler);
 346             UriBuilder path = UriBuilder.fromResource(resourceClass);
 347             path.path("" + csid);
 348             Response response = Response.created(path.build()).build();
 349             return response;
 350         } catch (Exception e) {
 351             throw bigReThrow(e, ServiceMessages.CREATE_FAILED);
 352         }
 353     }
 354
 355     protected String buildWhereForAuthByName(String name) {
 356         return authorityCommonSchemaName
 357                 + ":" + AuthorityJAXBSchema.SHORT_IDENTIFIER
 358                 + "='" + name + "'";
 359     }
 360
 361     protected String buildWhereForAuthItemByName(String name, String parentcsid) {
 362         return authorityItemCommonSchemaName
 363                 + ":" + AuthorityItemJAXBSchema.SHORT_IDENTIFIER
 364                 + "='" + name + "' AND "
 365                 + authorityItemCommonSchemaName + ":"
 366                 + AuthorityItemJAXBSchema.IN_AUTHORITY + "="
 367                 + "'" + parentcsid + "'";
 368     }
 369
 370     /**
 371      * Gets the authority.
 372      *
 373      * @param specifier either a CSID or one of the urn forms
 374      *
 375      * @return the authority
 376      */
 377     @GET
 378     @Path("{csid}")
 379     @Override
 380     public byte[] get( // getAuthority(
 381             @Context UriInfo ui,
 382             @PathParam("csid") String specifier) {
 383         PoxPayloadOut result = null;
 384         try {
 385             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(ui);
 386             DocumentHandler handler = createDocumentHandler(ctx);
 387
 388             Specifier spec = getSpecifier(specifier, "getAuthority", "GET");
 389             if (spec.form == SpecifierForm.CSID) {
 390                 if (logger.isDebugEnabled()) {
 391                     logger.debug("getAuthority with csid=" + spec.value);
 392                 }
 393                 getRepositoryClient(ctx).get(ctx, spec.value, handler);
 394             } else {
 395                 String whereClause = buildWhereForAuthByName(spec.value);
 396                 DocumentFilter myFilter = new DocumentFilter(whereClause, 0, 1);
 397                 handler.setDocumentFilter(myFilter);
 398                 getRepositoryClient(ctx).get(ctx, handler);
 399             }
 400             result = ctx.getOutput();
 401
 402         } catch (Exception e) {
 403             throw bigReThrow(e, ServiceMessages.GET_FAILED, specifier);
 404         }
 405
 406         if (result == null) {
 407             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 408                     "Get failed, the requested Authority specifier:" + specifier + ": was not found.").type(
 409                     "text/plain").build();
 410             throw new WebApplicationException(response);
 411         }
 412
 413         return result.getBytes();
 414     }
 415
 416     /**
 417      * Finds and populates the authority list.
 418      *
 419      * @param ui the ui
 420      *
 421      * @return the authority list
 422      */
 423     @GET
 424     @Produces("application/xml")
 425     public AbstractCommonList getAuthorityList(@Context UriInfo ui) {
 426         try {
 427             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 428             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(queryParams);
 429             DocumentHandler handler = createDocumentHandler(ctx);
 430             DocumentFilter myFilter = handler.getDocumentFilter();
 431             // Need to make the default sort order for authority items
 432             // be on the displayName field
 433             String sortBy = queryParams.getFirst(IClientQueryParams.SORT_BY_PARAM);
 434             if (sortBy == null || sortBy.isEmpty()) {
 435                 String qualifiedDisplayNameField = authorityCommonSchemaName + ":"
 436                         + AuthorityItemJAXBSchema.DISPLAY_NAME;
 437                 myFilter.setOrderByClause(qualifiedDisplayNameField);
 438             }
 439             String nameQ = queryParams.getFirst("refName");
 440             if (nameQ != null) {
 441                 myFilter.setWhereClause(authorityCommonSchemaName + ":refName='" + nameQ + "'");
 442             }
 443             getRepositoryClient(ctx).getFiltered(ctx, handler);
 444             return (AbstractCommonList) handler.getCommonPartList();
 445         } catch (Exception e) {
 446             throw bigReThrow(e, ServiceMessages.GET_FAILED);
 447         }
 448     }
 449
 450
 451     /**
 452      * Update authority.
 453      *
 454      * @param specifier the csid or id
 455      *
 456      * @return the multipart output
 457      */
 458     @PUT
 459     @Path("{csid}")
 460     public byte[] updateAuthority(
 461             @PathParam("csid") String specifier,
 462             String xmlPayload) {
 463         PoxPayloadOut result = null;
 464         try {
 465             PoxPayloadIn theUpdate = new PoxPayloadIn(xmlPayload);
 466             Specifier spec = getSpecifier(specifier, "updateAuthority", "UPDATE");
 467             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(theUpdate);
 468             DocumentHandler handler = createDocumentHandler(ctx);
 469             String csid;
 470             if (spec.form == SpecifierForm.CSID) {
 471                 csid = spec.value;
 472             } else {
 473                 String whereClause = buildWhereForAuthByName(spec.value);
 474                 csid = getRepositoryClient(ctx).findDocCSID(null, ctx, whereClause);
 475             }
 476             getRepositoryClient(ctx).update(ctx, csid, handler);
 477             result = ctx.getOutput();
 478         } catch (Exception e) {
 479             throw bigReThrow(e, ServiceMessages.UPDATE_FAILED);
 480         }
 481         return result.getBytes();
 482     }
 483
 484     /**
 485      * Delete authority.
 486      *
 487      * @param csid the csid
 488      *
 489      * @return the response
 490      */
 491     @DELETE
 492     @Path("{csid}")
 493     public Response deleteAuthority(@PathParam("csid") String csid) {
 494         if (logger.isDebugEnabled()) {
 495             logger.debug("deleteAuthority with csid=" + csid);
 496         }
 497         try {
 498             ensureCSID(csid, ServiceMessages.DELETE_FAILED, "Authority.csid");
 499             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext();
 500             DocumentHandler handler = createDocumentHandler(ctx);
 501             getRepositoryClient(ctx).delete(ctx, csid, handler);
 502             return Response.status(HttpResponseCodes.SC_OK).build();
 503         } catch (Exception e) {
 504             throw bigReThrow(e, ServiceMessages.DELETE_FAILED, csid);
 505         }
 506     }
 507
 508     /*************************************************************************
 509      * Create an AuthorityItem - this is a sub-resource of Authority
 510      * @param specifier either a CSID or one of the urn forms
 511      * @return Authority item response
 512      *************************************************************************/
 513     @POST
 514     @Path("{csid}/items")
 515     public Response createAuthorityItem(@Context ResourceMap resourceMap, @Context UriInfo ui,
 516                 @PathParam("csid") String specifier, String xmlPayload) {
 517         try {
 518             PoxPayloadIn input = new PoxPayloadIn(xmlPayload);
 519             ServiceContext ctx = createServiceContext(getItemServiceName(), input);
 520             ctx.setResourceMap(resourceMap);
 521             ctx.setUriInfo(ui);    //Laramie
 522
 523             // Note: must have the parentShortId, to do the create.
 524             CsidAndShortIdentifier parent = lookupParentCSIDAndShortIdentifer(specifier, "createAuthorityItem", "CREATE_ITEM", null);
 525             DocumentHandler handler = createItemDocumentHandler(ctx, parent.CSID, parent.shortIdentifier);
 526             String itemcsid = getRepositoryClient(ctx).create(ctx, handler);
 527             UriBuilder path = UriBuilder.fromResource(resourceClass);
 528             path.path(parent.CSID + "/items/" + itemcsid);
 529             Response response = Response.created(path.build()).build();
 530             return response;
 531         } catch (Exception e) {
 532             throw bigReThrow(e, ServiceMessages.CREATE_FAILED);
 533         }
 534     }
 535
 536     @GET
 537     @Path("{csid}/items/{itemcsid}" + WorkflowClient.SERVICE_PATH)
 538     public byte[] getItemWorkflow(
 539             @PathParam("csid") String csid,
 540             @PathParam("itemcsid") String itemcsid) {
 541         PoxPayloadOut result = null;
 542
 543         try {
 544             ServiceContext<PoxPayloadIn, PoxPayloadOut> parentCtx = createServiceContext(getItemServiceName());
 545             String parentWorkspaceName = parentCtx.getRepositoryWorkspaceName();
 546
 547             MultipartServiceContext ctx = (MultipartServiceContext) createServiceContext(WorkflowClient.SERVICE_NAME);
 548             WorkflowDocumentModelHandler handler = createWorkflowDocumentHandler(ctx);
 549             ctx.setRespositoryWorkspaceName(parentWorkspaceName); //find the document in the parent's workspace
 550             getRepositoryClient(ctx).get(ctx, itemcsid, handler);
 551             result = ctx.getOutput();
 552         } catch (Exception e) {
 553             throw bigReThrow(e, ServiceMessages.READ_FAILED + WorkflowClient.SERVICE_PAYLOAD_NAME, csid);
 554         }
 555         return result.getBytes();
 556     }
 557
 558     //FIXME: This method is almost identical to the method org.collectionspace.services.common.updateWorkflowWithTransition() so
 559     // they should be consolidated -be DRY (don't repeat yourself).
 560     @PUT
 561     @Path("{csid}/items/{itemcsid}" + WorkflowClient.SERVICE_PATH + "/{transition}")
 562     public byte[] updateItemWorkflowWithTransition(
 563             @PathParam("csid") String csid,
 564             @PathParam("itemcsid") String itemcsid,
 565             @PathParam("transition") String transition) {
 566         PoxPayloadOut result = null;
 567
 568         try {
 569                 //
 570                 // Create an empty workflow_commons input part and set it into a new "workflow" sub-resource context
 571                 PoxPayloadIn input = new PoxPayloadIn(WorkflowClient.SERVICE_PAYLOAD_NAME, new WorkflowCommon(),
 572                                 WorkflowClient.SERVICE_COMMONPART_NAME);
 573             MultipartServiceContext ctx = (MultipartServiceContext) createServiceContext(WorkflowClient.SERVICE_NAME, input);
 574
 575             // Create a service context and document handler for the parent resource.
 576             ServiceContext<PoxPayloadIn, PoxPayloadOut> parentCtx = createServiceContext(getItemServiceName());
 577             DocumentHandler parentDocHandler = this.createDocumentHandler(parentCtx);
 578             ctx.setProperty(WorkflowClient.PARENT_DOCHANDLER, parentDocHandler); //added as a context param for the workflow document handler -it will call the parent's dochandler "prepareForWorkflowTranstion" method
 579
 580             // When looking for the document, we need to use the parent's workspace name -not the "workflow" workspace name
 581             String parentWorkspaceName = parentCtx.getRepositoryWorkspaceName();
 582             ctx.setRespositoryWorkspaceName(parentWorkspaceName); //find the document in the parent's workspace
 583
 584                 // Get the type of transition we're being asked to make and store it as a context parameter -used by the workflow document handler
 585             TransitionDef transitionDef = getTransitionDef(parentCtx, transition);
 586             ctx.setProperty(WorkflowClient.TRANSITION_ID, transitionDef);
 587
 588             WorkflowDocumentModelHandler handler = createWorkflowDocumentHandler(ctx);
 589             getRepositoryClient(ctx).update(ctx, itemcsid, handler);
 590             result = ctx.getOutput();
 591         } catch (Exception e) {
 592             throw bigReThrow(e, ServiceMessages.UPDATE_FAILED + WorkflowClient.SERVICE_PAYLOAD_NAME, csid);
 593         }
 594
 595         return result.getBytes();
 596     }
 597
 598     /**
 599      * Gets the authority item.
 600      *
 601      * @param parentspecifier either a CSID or one of the urn forms
 602      * @param itemspecifier either a CSID or one of the urn forms
 603      *
 604      * @return the authority item
 605      */
 606     @GET
 607     @Path("{csid}/items/{itemcsid}")
 608     public byte[] getAuthorityItem(
 609             @Context Request request,
 610             @Context UriInfo ui,
 611             @PathParam("csid") String parentspecifier,
 612             @PathParam("itemcsid") String itemspecifier) {
 613         PoxPayloadOut result = null;
 614         try {
 615             JaxRsContext jaxRsContext = new JaxRsContext(request, ui);
 616             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 617             String parentcsid = lookupParentCSID(parentspecifier, "getAuthorityItem(parent)", "GET_ITEM", queryParams);
 618
 619             RemoteServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = null;
 620             ctx = (RemoteServiceContext) createServiceContext(getItemServiceName(), queryParams);
 621             ctx.setJaxRsContext(jaxRsContext);
 622
 623             ctx.setUriInfo(ui); //ARG!   must pass this or subsequent calls will not have a ui.
 624
 625             // We omit the parentShortId, only needed when doing a create...
 626             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid, null);
 627
 628             Specifier itemSpec = getSpecifier(itemspecifier, "getAuthorityItem(item)", "GET_ITEM");
 629             if (itemSpec.form == SpecifierForm.CSID) {
 630                 getRepositoryClient(ctx).get(ctx, itemSpec.value, handler);
 631             } else {
 632                 String itemWhereClause =
 633                         buildWhereForAuthItemByName(itemSpec.value, parentcsid);
 634                 DocumentFilter myFilter = new DocumentFilter(itemWhereClause, 0, 1);
 635                 handler.setDocumentFilter(myFilter);
 636                 getRepositoryClient(ctx).get(ctx, handler);
 637             }
 638             // TODO should we assert that the item is in the passed vocab?
 639             result = ctx.getOutput();
 640         } catch (Exception e) {
 641             throw bigReThrow(e, ServiceMessages.GET_FAILED);
 642         }
 643         if (result == null) {
 644             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 645                     "Get failed, the requested AuthorityItem specifier:" + itemspecifier + ": was not found.").type(
 646                     "text/plain").build();
 647             throw new WebApplicationException(response);
 648         }
 649         return result.getBytes();
 650     }
 651
 652     /**
 653      * Gets the authorityItem list for the specified authority
 654      * If partialPerm is specified, keywords will be ignored.
 655      *
 656      * @param specifier either a CSID or one of the urn forms
 657      * @param partialTerm if non-null, matches partial terms
 658      * @param keywords if non-null, matches terms in the keyword index for items
 659      * @param ui passed to include additional parameters, like pagination controls
 660      *
 661      * @return the authorityItem list
 662      */
 663     @GET
 664     @Path("{csid}/items")
 665     @Produces("application/xml")
 666     public AbstractCommonList getAuthorityItemList(@PathParam("csid") String specifier,
 667             @Context UriInfo ui) {
 668         try {
 669             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 670             String partialTerm = queryParams.getFirst(IQueryManager.SEARCH_TYPE_PARTIALTERM);
 671             String termStatus = queryParams.getFirst(SEARCH_TYPE_TERMSTATUS);
 672             String keywords = queryParams.getFirst(IQueryManager.SEARCH_TYPE_KEYWORDS_KW);
 673             String advancedSearch = queryParams.getFirst(IQueryManager.SEARCH_TYPE_KEYWORDS_AS);
 674
 675             String qualifiedDisplayNameField =
 676                     NuxeoUtils.getPrimaryElPathPropertyName(authorityItemCommonSchemaName,
 677                         getItemTermInfoGroupXPathBase(), AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 678                     // authorityItemCommonSchemaName + ":" + getItemTermInfoGroupXPathBase()
 679                     //    + "/0/" + AuthorityItemJAXBSchema.TERM_DISPLAY_NAME;
 680
 681                     // NuxeoUtils.getPrimaryXPathPropertyName(authorityItemCommonSchemaName,
 682                     //     getItemTermInfoGroupXPathBase(), AuthorityItemJAXBSchema.TERM_DISPLAY_NAME);
 683
 684             // Note that docType defaults to the ServiceName, so we're fine with that.
 685             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = null;
 686
 687             String parentcsid = PARENT_WILDCARD.equals(specifier)?null:
 688                                                 lookupParentCSID(specifier, "getAuthorityItemList", "LIST", queryParams);
 689
 690             ctx = createServiceContext(getItemServiceName(), queryParams);
 691
 692             // For the wildcard case, parentcsid is null, but docHandler will deal with this.
 693             // We omit the parentShortId, only needed when doing a create...
 694             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid, null);
 695
 696             DocumentFilter myFilter = handler.getDocumentFilter();
 697             // Need to make the default sort order for authority items
 698             // be on the displayName field
 699             String sortBy = queryParams.getFirst(IClientQueryParams.SORT_BY_PARAM);
 700             if (sortBy == null || sortBy.isEmpty()) {
 701                 myFilter.setOrderByClause(qualifiedDisplayNameField);
 702             }
 703
 704             // If we are not wildcarding the parent, add a restriction
 705             if(parentcsid!=null) {
 706                     myFilter.appendWhereClause(authorityItemCommonSchemaName + ":"
 707                             + AuthorityItemJAXBSchema.IN_AUTHORITY + "="
 708                             + "'" + parentcsid + "'",
 709                             IQueryManager.SEARCH_QUALIFIER_AND);
 710             }
 711
 712             if (Tools.notBlank(termStatus)) {
 713                 // Start with the qualified termStatus field
 714                 String qualifiedTermStatusField = authorityItemCommonSchemaName + ":"
 715                         + AuthorityItemJAXBSchema.TERM_STATUS;
 716                 String[] filterTerms = termStatus.trim().split("\\|");
 717                 String tsClause = QueryManager.createWhereClauseToFilterFromStringList(qualifiedTermStatusField, filterTerms, IQueryManager.FILTER_EXCLUDE);
 718                 myFilter.appendWhereClause(tsClause, IQueryManager.SEARCH_QUALIFIER_AND);
 719             }
 720
 721             // AND vocabularyitems_common:displayName LIKE '%partialTerm%'
 722             // NOTE: Partial terms searches are mutually exclusive to keyword and advanced-search, but
 723             // the PT query param trumps the KW and AS query params.
 724             if (partialTerm != null && !partialTerm.isEmpty()) {
 725                 String ptClause = QueryManager.createWhereClauseForPartialMatch(
 726                         qualifiedDisplayNameField, partialTerm);
 727                 myFilter.appendWhereClause(ptClause, IQueryManager.SEARCH_QUALIFIER_AND);
 728             } else if (keywords != null || advancedSearch != null) {
 729 //                              String kwdClause = QueryManager.createWhereClauseFromKeywords(keywords);
 730 //                              myFilter.appendWhereClause(kwdClause, IQueryManager.SEARCH_QUALIFIER_AND);
 731                 return search(ctx, handler, queryParams, keywords, advancedSearch);
 732             }
 733             if (logger.isDebugEnabled()) {
 734                 logger.debug("getAuthorityItemList filtered WHERE clause: "
 735                         + myFilter.getWhereClause()
 736                         + " and ORDER BY clause: " + myFilter.getOrderByClause());
 737             }
 738             getRepositoryClient(ctx).getFiltered(ctx, handler);
 739             return (AbstractCommonList) handler.getCommonPartList();
 740         } catch (Exception e) {
 741             throw bigReThrow(e, ServiceMessages.LIST_FAILED);
 742         }
 743     }
 744
 745     /**
 746      * @return the name of the property used to specify references for items in this type of
 747      * authority. For most authorities, it is ServiceBindingUtils.AUTH_REF_PROP ("authRef").
 748      * Some types (like Vocabulary) use a separate property.
 749      */
 750     protected String getRefPropName() {
 751         return ServiceBindingUtils.AUTH_REF_PROP;
 752     }
 753
 754     /**
 755      * Gets the entities referencing this Authority item instance. The service type
 756      * can be passed as a query param "type", and must match a configured type
 757      * for the service bindings. If not set, the type defaults to
 758      * ServiceBindingUtils.SERVICE_TYPE_PROCEDURE.
 759      *
 760      * @param parentspecifier either a CSID or one of the urn forms
 761      * @param itemspecifier either a CSID or one of the urn forms
 762      * @param ui the ui
 763      *
 764      * @return the info for the referencing objects
 765      */
 766     @GET
 767     @Path("{csid}/items/{itemcsid}/refObjs")
 768     @Produces("application/xml")
 769     public AuthorityRefDocList getReferencingObjects(
 770             @PathParam("csid") String parentspecifier,
 771             @PathParam("itemcsid") String itemspecifier,
 772             @Context UriInfo ui) {
 773         AuthorityRefDocList authRefDocList = null;
 774         try {
 775             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 776
 777             String parentcsid = lookupParentCSID(parentspecifier, "getReferencingObjects(parent)", "GET_ITEM_REF_OBJS", queryParams);
 778
 779             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(getItemServiceName(), queryParams);
 780             String itemcsid = lookupItemCSID(itemspecifier, parentcsid, "getReferencingObjects(item)", "GET_ITEM_REF_OBJS", ctx);
 781
 782             List<String> serviceTypes = queryParams.remove(ServiceBindingUtils.SERVICE_TYPE_PROP);
 783             if(serviceTypes == null || serviceTypes.isEmpty()) {
 784                 // Temporary workaround for CSPACE-4983
 785                 // serviceTypes = ServiceBindingUtils.getCommonServiceTypes();
 786                 serviceTypes = ServiceBindingUtils.getCommonProcedureServiceTypes();
 787             }
 788
 789             // Note that we have to create the service context for the Items, not the main service
 790             // We omit the parentShortId, only needed when doing a create...
 791             AuthorityItemDocumentModelHandler<?> handler = (AuthorityItemDocumentModelHandler<?>)
 792                                                                                                 createItemDocumentHandler(ctx, parentcsid, null);
 793
 794             authRefDocList = handler.getReferencingObjects(ctx, serviceTypes, getRefPropName(), itemcsid);
 795         } catch (Exception e) {
 796             throw bigReThrow(e, ServiceMessages.GET_FAILED);
 797         }
 798         if (authRefDocList == null) {
 799             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 800                     "Get failed, the requested Item CSID:" + itemspecifier + ": was not found.").type(
 801                     "text/plain").build();
 802             throw new WebApplicationException(response);
 803         }
 804         return authRefDocList;
 805     }
 806
 807     /**
 808      * Gets the authority terms used in the indicated Authority item.
 809      *
 810      * @param parentspecifier either a CSID or one of the urn forms
 811      * @param itemspecifier either a CSID or one of the urn forms
 812      * @param ui passed to include additional parameters, like pagination controls
 813      *
 814      * @return the authority refs for the Authority item.
 815      */
 816     @GET
 817     @Path("{csid}/items/{itemcsid}/authorityrefs")
 818     @Produces("application/xml")
 819     public AuthorityRefList getAuthorityItemAuthorityRefs(
 820             @PathParam("csid") String parentspecifier,
 821             @PathParam("itemcsid") String itemspecifier,
 822             @Context UriInfo ui) {
 823         AuthorityRefList authRefList = null;
 824         try {
 825             // Note that we have to create the service context for the Items, not the main service
 826             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 827             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = null;
 828
 829             String parentcsid = lookupParentCSID(parentspecifier, "getAuthorityItemAuthRefs(parent)", "GET_ITEM_AUTH_REFS", queryParams);
 830
 831             ctx = createServiceContext(getItemServiceName(), queryParams);
 832             // We omit the parentShortId, only needed when doing a create...
 833             DocumentModelHandler handler =
 834                     (DocumentModelHandler)createItemDocumentHandler(ctx, parentcsid, null);
 835
 836             String itemcsid = lookupItemCSID(itemspecifier, parentcsid, "getAuthorityItemAuthRefs(item)", "GET_ITEM_AUTH_REFS", ctx);
 837
 838             List<RefNameServiceUtils.AuthRefConfigInfo> authRefsInfo = RefNameServiceUtils.getConfiguredAuthorityRefs(ctx);
 839             authRefList = handler.getAuthorityRefs(itemcsid, authRefsInfo);
 840         } catch (Exception e) {
 841             throw bigReThrow(e, ServiceMessages.GET_FAILED + " parentspecifier: " + parentspecifier + " itemspecifier:" + itemspecifier);
 842         }
 843         return authRefList;
 844     }
 845
 846     /**
 847      * Update authorityItem.
 848      *
 849      * @param parentspecifier either a CSID or one of the urn forms
 850      * @param itemspecifier either a CSID or one of the urn forms
 851      *
 852      * @return the multipart output
 853      */
 854     @PUT
 855     @Path("{csid}/items/{itemcsid}")
 856     public byte[] updateAuthorityItem(
 857                 @Context ResourceMap resourceMap,
 858             @Context UriInfo ui,
 859             @PathParam("csid") String parentspecifier,
 860             @PathParam("itemcsid") String itemspecifier,
 861             String xmlPayload) {
 862         PoxPayloadOut result = null;
 863         try {
 864             PoxPayloadIn theUpdate = new PoxPayloadIn(xmlPayload);
 865             // Note that we have to create the service context for the Items, not the main service
 866             //Laramie CSPACE-3175.  passing null for queryParams, because prior to this refactor, the code moved to lookupParentCSID in this instance called the version of getServiceContext() that passes null
 867             String parentcsid = lookupParentCSID(parentspecifier, "updateAuthorityItem(parent)", "UPDATE_ITEM", null);
 868
 869             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(getItemServiceName(), theUpdate);
 870             ctx.setResourceMap(resourceMap);
 871             String itemcsid = lookupItemCSID(itemspecifier, parentcsid, "updateAuthorityItem(item)", "UPDATE_ITEM", ctx);
 872
 873             // We omit the parentShortId, only needed when doing a create...
 874             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid, null);
 875             ctx.setUriInfo(ui);
 876             getRepositoryClient(ctx).update(ctx, itemcsid, handler);
 877             result = ctx.getOutput();
 878
 879         } catch (Exception e) {
 880             throw bigReThrow(e, ServiceMessages.UPDATE_FAILED);
 881         }
 882         return result.getBytes();
 883     }
 884
 885     /**
 886      * Delete authorityItem.
 887      *
 888      * @param parentcsid the parentcsid
 889      * @param itemcsid the itemcsid
 890      *
 891      * @return the response
 892      */
 893     @DELETE
 894     @Path("{csid}/items/{itemcsid}")
 895     public Response deleteAuthorityItem(
 896             @PathParam("csid") String parentcsid,
 897             @PathParam("itemcsid") String itemcsid) {
 898         //try{
 899         if (logger.isDebugEnabled()) {
 900             logger.debug("deleteAuthorityItem with parentcsid=" + parentcsid + " and itemcsid=" + itemcsid);
 901         }
 902         try {
 903             ensureCSID(parentcsid, ServiceMessages.DELETE_FAILED, "AuthorityItem.parentcsid");
 904             ensureCSID(itemcsid, ServiceMessages.DELETE_FAILED, "AuthorityItem.itemcsid");
 905             //Laramie, removing this catch, since it will surely fail below, since itemcsid or parentcsid will be null.
 906             // }catch (Throwable t){
 907             //    System.out.println("ERROR in setting up DELETE: "+t);
 908             // }
 909             // try {
 910             // Note that we have to create the service context for the Items, not the main service
 911             ServiceContext ctx = createServiceContext(getItemServiceName());
 912             DocumentHandler handler = createDocumentHandler(ctx);
 913             getRepositoryClient(ctx).delete(ctx, itemcsid, handler);
 914             return Response.status(HttpResponseCodes.SC_OK).build();
 915         } catch (Exception e) {
 916             throw bigReThrow(e, ServiceMessages.DELETE_FAILED + "  itemcsid: " + itemcsid + " parentcsid:" + parentcsid);
 917         }
 918     }
 919     public final static String hierarchy = "hierarchy";
 920
 921     @GET
 922     @Path("{csid}/items/{itemcsid}/" + hierarchy)
 923     @Produces("application/xml")
 924     public String getHierarchy(@PathParam("csid") String csid,
 925             @PathParam("itemcsid") String itemcsid,
 926             @Context UriInfo ui) throws Exception {
 927         try {
 928             // All items in dive can look at their child uri's to get uri.  So we calculate the very first one.  We could also do a GET and look at the common part uri field, but why...?
 929             String calledUri = ui.getPath();
 930             String uri = "/" + calledUri.substring(0, (calledUri.length() - ("/" + hierarchy).length()));
 931             ServiceContext ctx = createServiceContext(getItemServiceName());
 932             ctx.setUriInfo(ui);
 933             String direction = ui.getQueryParameters().getFirst(Hierarchy.directionQP);
 934             if (Tools.notBlank(direction) && Hierarchy.direction_parents.equals(direction)) {
 935                 return Hierarchy.surface(ctx, itemcsid, uri);
 936             } else {
 937                 return Hierarchy.dive(ctx, itemcsid, uri);
 938             }
 939         } catch (Exception e) {
 940             throw bigReThrow(e, "Error showing hierarchy", itemcsid);
 941         }
 942     }
 943 }