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.person;
  25
  26 import java.util.List;
  27
  28 import javax.ws.rs.Consumes;
  29 import javax.ws.rs.DELETE;
  30 import javax.ws.rs.GET;
  31 import javax.ws.rs.POST;
  32 import javax.ws.rs.PUT;
  33 import javax.ws.rs.Path;
  34 import javax.ws.rs.PathParam;
  35 import javax.ws.rs.Produces;
  36 import javax.ws.rs.QueryParam;
  37 import javax.ws.rs.WebApplicationException;
  38 import javax.ws.rs.core.Context;
  39 import javax.ws.rs.core.MultivaluedMap;
  40 import javax.ws.rs.core.Response;
  41 import javax.ws.rs.core.UriBuilder;
  42 import javax.ws.rs.core.UriInfo;
  43
  44 import org.collectionspace.services.PersonAuthorityJAXBSchema;
  45 import org.collectionspace.services.PersonJAXBSchema;
  46 import org.collectionspace.services.common.AbstractMultiPartCollectionSpaceResourceImpl;
  47 import org.collectionspace.services.common.ClientType;
  48 import org.collectionspace.services.common.ServiceMain;
  49 import org.collectionspace.services.common.authorityref.AuthorityRefDocList;
  50 import org.collectionspace.services.common.context.ServiceBindingUtils;
  51 import org.collectionspace.services.common.context.ServiceContext;
  52 import org.collectionspace.services.common.document.BadRequestException;
  53 import org.collectionspace.services.common.document.DocumentFilter;
  54 import org.collectionspace.services.common.document.DocumentHandler;
  55 import org.collectionspace.services.common.document.DocumentNotFoundException;
  56 import org.collectionspace.services.common.document.DocumentWrapper;
  57 import org.collectionspace.services.common.repository.RepositoryClient;
  58 import org.collectionspace.services.common.security.UnauthorizedException;
  59 import org.collectionspace.services.common.vocabulary.RefNameServiceUtils;
  60 import org.collectionspace.services.common.query.IQueryManager;
  61 import org.collectionspace.services.contact.ContactResource;
  62 import org.collectionspace.services.contact.ContactsCommon;
  63 import org.collectionspace.services.contact.ContactsCommonList;
  64 import org.collectionspace.services.contact.ContactJAXBSchema;
  65 import org.collectionspace.services.contact.nuxeo.ContactDocumentModelHandler;
  66 import org.collectionspace.services.person.nuxeo.PersonDocumentModelHandler;
  67
  68 import org.jboss.resteasy.plugins.providers.multipart.MultipartInput;
  69 import org.jboss.resteasy.plugins.providers.multipart.MultipartOutput;
  70 import org.jboss.resteasy.util.HttpResponseCodes;
  71
  72 import org.nuxeo.ecm.core.api.DocumentModel;
  73
  74 import org.slf4j.Logger;
  75 import org.slf4j.LoggerFactory;
  76
  77 /**
  78  * The Class PersonAuthorityResource.
  79  */
  80 @Path("/personauthorities")
  81 @Consumes("multipart/mixed")
  82 @Produces("multipart/mixed")
  83 public class PersonAuthorityResource extends
  84                 AbstractMultiPartCollectionSpaceResourceImpl {
  85
  86     /** The Constant personAuthorityServiceName. */
  87     private final static String personAuthorityServiceName = "personauthorities";
  88
  89     /** The Constant personServiceName. */
  90     private final static String personServiceName = "persons";
  91
  92     /** The logger. */
  93     final Logger logger = LoggerFactory.getLogger(PersonAuthorityResource.class);
  94     //FIXME retrieve client type from configuration
  95     /** The Constant CLIENT_TYPE. */
  96     final static ClientType CLIENT_TYPE = ServiceMain.getInstance().getClientType();
  97
  98     /** The contact resource. */
  99     private ContactResource contactResource = new ContactResource();
 100
 101     /**
 102      * Instantiates a new person authority resource.
 103      */
 104     public PersonAuthorityResource() {
 105         // do nothing
 106     }
 107
 108     /* (non-Javadoc)
 109      * @see org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl#getVersionString()
 110      */
 111     @Override
 112     protected String getVersionString() {
 113         /** The last change revision. */
 114         final String lastChangeRevision = "$LastChangedRevision$";
 115         return lastChangeRevision;
 116     }
 117
 118     /* (non-Javadoc)
 119      * @see org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl#getServiceName()
 120      */
 121     @Override
 122     public String getServiceName() {
 123         return personAuthorityServiceName;
 124     }
 125
 126     @Override
 127     public Class<PersonauthoritiesCommon> getCommonPartClass() {
 128         return PersonauthoritiesCommon.class;
 129     }
 130
 131     /**
 132      * Gets the item service name.
 133      *
 134      * @return the item service name
 135      */
 136     public String getItemServiceName() {
 137         return personServiceName;
 138     }
 139
 140     /**
 141      * Gets the contact service name.
 142      *
 143      * @return the contact service name
 144      */
 145     public String getContactServiceName() {
 146         return contactResource.getServiceName();
 147     }
 148
 149     /**
 150  * Creates the item document handler.
 151  *
 152  * @param ctx the ctx
 153  * @param inAuthority the in authority
 154  *
 155  * @return the document handler
 156  *
 157  * @throws Exception the exception
 158  */
 159     private DocumentHandler createItemDocumentHandler(ServiceContext<MultipartInput, MultipartOutput> ctx,
 160             String inAuthority) throws Exception {
 161         PersonDocumentModelHandler docHandler = (PersonDocumentModelHandler)createDocumentHandler(ctx,
 162                         ctx.getCommonPartLabel(getItemServiceName()),
 163                         PersonsCommon.class);
 164         docHandler.setInAuthority(inAuthority);
 165
 166         return docHandler;
 167     }
 168
 169     /**
 170      * Creates the contact document handler.
 171      *
 172      * @param ctx the ctx
 173      * @param inAuthority the in authority
 174      * @param inItem the in item
 175      *
 176      * @return the document handler
 177      *
 178      * @throws Exception the exception
 179      */
 180     private DocumentHandler createContactDocumentHandler(
 181                 ServiceContext<MultipartInput, MultipartOutput> ctx, String inAuthority,
 182             String inItem) throws Exception {
 183         ContactDocumentModelHandler docHandler = (ContactDocumentModelHandler)createDocumentHandler(ctx,
 184                         ctx.getCommonPartLabel(getContactServiceName()),
 185                         ContactsCommon.class);
 186         docHandler.setInAuthority(inAuthority);
 187         docHandler.setInItem(inItem);
 188
 189         return docHandler;
 190     }
 191
 192     /**
 193      * Creates the person authority.
 194      *
 195      * @param input the input
 196      *
 197      * @return the response
 198      */
 199     @POST
 200     public Response createPersonAuthority(MultipartInput input) {
 201         try {
 202                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(input);
 203             DocumentHandler handler = createDocumentHandler(ctx);
 204             String csid = getRepositoryClient(ctx).create(ctx, handler);
 205             //personAuthorityObject.setCsid(csid);
 206             UriBuilder path = UriBuilder.fromResource(PersonAuthorityResource.class);
 207             path.path("" + csid);
 208             Response response = Response.created(path.build()).build();
 209             return response;
 210         } catch (BadRequestException bre) {
 211             Response response = Response.status(
 212                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
 213             throw new WebApplicationException(response);
 214         } catch (UnauthorizedException ue) {
 215             Response response = Response.status(
 216                     Response.Status.UNAUTHORIZED).entity("Create failed reason " + ue.getErrorReason()).type("text/plain").build();
 217             throw new WebApplicationException(response);
 218         } catch (Exception e) {
 219             if (logger.isDebugEnabled()) {
 220                 logger.debug("Caught exception in createPersonAuthority", e);
 221             }
 222             Response response = Response.status(
 223                     Response.Status.INTERNAL_SERVER_ERROR).entity("Create failed").type("text/plain").build();
 224             throw new WebApplicationException(response);
 225         }
 226     }
 227
 228     /**
 229      * Gets the person authority by name.
 230      *
 231      * @param specifier the specifier
 232      *
 233      * @return the person authority by name
 234      */
 235     @GET
 236     @Path("urn:cspace:name({specifier})")
 237     public MultipartOutput getPersonAuthorityByName(@PathParam("specifier") String specifier) {
 238         if (specifier == null) {
 239             logger.error("getPersonAuthority: missing name!");
 240             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 241                     "get failed on PersonAuthority (missing specifier)").type(
 242                     "text/plain").build();
 243             throw new WebApplicationException(response);
 244         }
 245         String whereClause =
 246                 PersonAuthorityJAXBSchema.PERSONAUTHORITIES_COMMON+
 247                 ":"+PersonAuthorityJAXBSchema.DISPLAY_NAME+
 248                 "='"+specifier+"'";
 249         // We only get a single doc - if there are multiple,
 250         // it is an error in use.
 251
 252         if (logger.isDebugEnabled()) {
 253             logger.debug("getPersonAuthority with name=" + specifier);
 254         }
 255         MultipartOutput result = null;
 256         try {
 257                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext();
 258             DocumentHandler handler = createDocumentHandler(ctx);
 259             DocumentFilter myFilter = new DocumentFilter(whereClause, 0, 1);
 260             handler.setDocumentFilter(myFilter);
 261             getRepositoryClient(ctx).get(ctx, handler);
 262             result = (MultipartOutput) ctx.getOutput();
 263         } catch (UnauthorizedException ue) {
 264             Response response = Response.status(
 265                     Response.Status.UNAUTHORIZED).entity("Get failed reason " + ue.getErrorReason()).type("text/plain").build();
 266             throw new WebApplicationException(response);
 267         } catch (DocumentNotFoundException dnfe) {
 268             if (logger.isDebugEnabled()) {
 269                 logger.debug("getPersonAuthority", dnfe);
 270             }
 271             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 272                     "Get failed on PersonAuthority spec=" + specifier).type(
 273                     "text/plain").build();
 274             throw new WebApplicationException(response);
 275         } catch (Exception e) {
 276             if (logger.isDebugEnabled()) {
 277                 logger.debug("getPersonAuthority", e);
 278             }
 279             Response response = Response.status(
 280                     Response.Status.INTERNAL_SERVER_ERROR).entity("Get failed").type("text/plain").build();
 281             throw new WebApplicationException(response);
 282         }
 283         if (result == null) {
 284             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 285                     "Get failed, the requested PersonAuthority spec:" + specifier + ": was not found.").type(
 286                     "text/plain").build();
 287             throw new WebApplicationException(response);
 288         }
 289         return result;
 290     }
 291
 292     /**
 293      * Gets the entities referencing this Person instance. The service type
 294      * can be passed as a query param "type", and must match a configured type
 295      * for the service bindings. If not set, the type defaults to
 296      * ServiceBindingUtils.SERVICE_TYPE_PROCEDURE.
 297      * @param parentcsid
 298      *
 299      * @param csid the parent csid
 300      * @param itemcsid the person csid
 301      * @param ui the ui
 302      *
 303      * @return the info for the referencing objects
 304      */
 305     @GET
 306     @Path("{csid}/items/{itemcsid}/refObjs")
 307     @Produces("application/xml") //FIXME: REM do this for CSPACE-1079 in Org authority.
 308     public AuthorityRefDocList getReferencingObjects(
 309                 @PathParam("csid") String parentcsid,
 310                 @PathParam("itemcsid") String itemcsid,
 311                 @Context UriInfo ui) {
 312         AuthorityRefDocList authRefDocList = null;
 313         if (logger.isDebugEnabled()) {
 314                 logger.debug("getReferencingObjects with parentcsid="
 315                                 + parentcsid + " and itemcsid=" + itemcsid);
 316         }
 317         if (parentcsid == null || "".equals(parentcsid)
 318                         || itemcsid == null || "".equals(itemcsid)) {
 319                 logger.error("getPerson: missing parentcsid or itemcsid!");
 320                 Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 321                                 "get failed on Person with parentcsid="
 322                                 + parentcsid + " and itemcsid=" + itemcsid).type(
 323                                 "text/plain").build();
 324                 throw new WebApplicationException(response);
 325         }
 326         try {
 327                 MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 328                 // Note that we have to create the service context for the Items, not the main service
 329                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName(),
 330                                 queryParams);
 331                 DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 332                 RepositoryClient repoClient = getRepositoryClient(ctx);
 333                 DocumentFilter myFilter = handler.getDocumentFilter();
 334                 String serviceType = ServiceBindingUtils.SERVICE_TYPE_PROCEDURE;
 335                 List<String> list = queryParams.remove(ServiceBindingUtils.SERVICE_TYPE_PROP);
 336                 if (list != null) {
 337                         serviceType = list.get(0);
 338                 }
 339                 DocumentWrapper<DocumentModel> docWrapper = repoClient.getDoc(ctx, itemcsid);
 340                 DocumentModel docModel = docWrapper.getWrappedObject();
 341                 String refName = (String)docModel.getPropertyValue(PersonJAXBSchema.REF_NAME);
 342
 343                 authRefDocList = RefNameServiceUtils.getAuthorityRefDocs(ctx,
 344                                 repoClient,
 345                                 serviceType,
 346                                 refName,
 347                                 myFilter.getPageSize(), myFilter.getStartPage(), true /*computeTotal*/ );
 348         } catch (UnauthorizedException ue) {
 349                 Response response = Response.status(
 350                                 Response.Status.UNAUTHORIZED).entity("Get failed reason " + ue.getErrorReason()).type("text/plain").build();
 351                 throw new WebApplicationException(response);
 352         } catch (DocumentNotFoundException dnfe) {
 353                 if (logger.isDebugEnabled()) {
 354                         logger.debug("getReferencingObjects", dnfe);
 355                 }
 356                 Response response = Response.status(Response.Status.NOT_FOUND).entity(
 357                                 "GetReferencingObjects failed with parentcsid="
 358                                 + parentcsid + " and itemcsid=" + itemcsid).type(
 359                                 "text/plain").build();
 360                 throw new WebApplicationException(response);
 361         } catch (Exception e) { // Includes DocumentException
 362                 if (logger.isDebugEnabled()) {
 363                         logger.debug("GetReferencingObjects", e);
 364                 }
 365                 Response response = Response.status(
 366                                 Response.Status.INTERNAL_SERVER_ERROR).entity("Get failed").type("text/plain").build();
 367                 throw new WebApplicationException(response);
 368         }
 369         if (authRefDocList == null) {
 370                 Response response = Response.status(Response.Status.NOT_FOUND).entity(
 371                                 "Get failed, the requested Person CSID:" + itemcsid + ": was not found.").type(
 372                                 "text/plain").build();
 373                 throw new WebApplicationException(response);
 374         }
 375         return authRefDocList;
 376     }
 377
 378     @GET
 379     @Path("{csid}")
 380     public MultipartOutput getPersonAuthority(@PathParam("csid") String csid) {
 381         if (csid == null) {
 382             logger.error("getPersonAuthority: missing csid!");
 383             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 384                     "get failed on PersonAuthority csid=" + csid).type(
 385                     "text/plain").build();
 386             throw new WebApplicationException(response);
 387         }
 388         if (logger.isDebugEnabled()) {
 389             logger.debug("getPersonAuthority with path(id)=" + csid);
 390         }
 391         MultipartOutput result = null;
 392         try {
 393                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext();
 394             DocumentHandler handler = createDocumentHandler(ctx);
 395             getRepositoryClient(ctx).get(ctx, csid, handler);
 396             result = (MultipartOutput) ctx.getOutput();
 397         } catch (UnauthorizedException ue) {
 398             Response response = Response.status(
 399                     Response.Status.UNAUTHORIZED).entity("Get failed reason " + ue.getErrorReason()).type("text/plain").build();
 400             throw new WebApplicationException(response);
 401         } catch (DocumentNotFoundException dnfe) {
 402             if (logger.isDebugEnabled()) {
 403                 logger.debug("getPersonAuthority", dnfe);
 404             }
 405             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 406                     "Get failed on PersonAuthority csid=" + csid).type(
 407                     "text/plain").build();
 408             throw new WebApplicationException(response);
 409         } catch (Exception e) {
 410             if (logger.isDebugEnabled()) {
 411                 logger.debug("getPersonAuthority", e);
 412             }
 413             Response response = Response.status(
 414                     Response.Status.INTERNAL_SERVER_ERROR).entity("Get failed").type("text/plain").build();
 415             throw new WebApplicationException(response);
 416         }
 417         if (result == null) {
 418             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 419                     "Get failed, the requested PersonAuthority CSID:" + csid + ": was not found.").type(
 420                     "text/plain").build();
 421             throw new WebApplicationException(response);
 422         }
 423         return result;
 424     }
 425
 426     /**
 427      * Gets the person authority list.
 428      *
 429      * @param ui the ui
 430      *
 431      * @return the person authority list
 432      */
 433     @GET
 434     @Produces("application/xml")
 435     public PersonauthoritiesCommonList getPersonAuthorityList(@Context UriInfo ui) {
 436         PersonauthoritiesCommonList personAuthorityObjectList = new PersonauthoritiesCommonList();
 437         try {
 438             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 439                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(queryParams);
 440             DocumentHandler handler = createDocumentHandler(ctx);
 441             String nameQ = queryParams.getFirst("refName");
 442             if (nameQ != null) {
 443                 handler.getDocumentFilter().setWhereClause("personauthorities_common:refName='" + nameQ + "'");
 444             }
 445             getRepositoryClient(ctx).getFiltered(ctx, handler);
 446             personAuthorityObjectList = (PersonauthoritiesCommonList) handler.getCommonPartList();
 447         } catch (UnauthorizedException ue) {
 448             Response response = Response.status(
 449                     Response.Status.UNAUTHORIZED).entity("Index failed reason " + ue.getErrorReason()).type("text/plain").build();
 450             throw new WebApplicationException(response);
 451         } catch (Exception e) {
 452             if (logger.isDebugEnabled()) {
 453                 logger.debug("Caught exception in getPersonAuthorityList", e);
 454             }
 455             Response response = Response.status(
 456                     Response.Status.INTERNAL_SERVER_ERROR).entity("Index failed").type("text/plain").build();
 457             throw new WebApplicationException(response);
 458         }
 459         return personAuthorityObjectList;
 460     }
 461
 462     /**
 463      * Update person authority.
 464      *
 465      * @param csid the csid
 466      * @param theUpdate the the update
 467      *
 468      * @return the multipart output
 469      */
 470     @PUT
 471     @Path("{csid}")
 472     public MultipartOutput updatePersonAuthority(
 473             @PathParam("csid") String csid,
 474             MultipartInput theUpdate) {
 475         if (logger.isDebugEnabled()) {
 476             logger.debug("updatePersonAuthority with csid=" + csid);
 477         }
 478         if (csid == null || "".equals(csid)) {
 479             logger.error("updatePersonAuthority: missing csid!");
 480             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 481                     "update failed on PersonAuthority csid=" + csid).type(
 482                     "text/plain").build();
 483             throw new WebApplicationException(response);
 484         }
 485         MultipartOutput result = null;
 486         try {
 487                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(theUpdate);
 488             DocumentHandler handler = createDocumentHandler(ctx);
 489             getRepositoryClient(ctx).update(ctx, csid, handler);
 490             result = (MultipartOutput) ctx.getOutput();
 491         } catch (BadRequestException bre) {
 492             Response response = Response.status(
 493                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
 494             throw new WebApplicationException(response);
 495         } catch (UnauthorizedException ue) {
 496             Response response = Response.status(
 497                     Response.Status.UNAUTHORIZED).entity("Update failed reason " + ue.getErrorReason()).type("text/plain").build();
 498             throw new WebApplicationException(response);
 499         } catch (DocumentNotFoundException dnfe) {
 500             if (logger.isDebugEnabled()) {
 501                 logger.debug("caugth exception in updatePersonAuthority", dnfe);
 502             }
 503             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 504                     "Update failed on PersonAuthority csid=" + csid).type(
 505                     "text/plain").build();
 506             throw new WebApplicationException(response);
 507         } catch (Exception e) {
 508             Response response = Response.status(
 509                     Response.Status.INTERNAL_SERVER_ERROR).entity("Update failed").type("text/plain").build();
 510             throw new WebApplicationException(response);
 511         }
 512         return result;
 513     }
 514
 515     /**
 516      * Delete person authority.
 517      *
 518      * @param csid the csid
 519      *
 520      * @return the response
 521      */
 522     @DELETE
 523     @Path("{csid}")
 524     public Response deletePersonAuthority(@PathParam("csid") String csid) {
 525
 526         if (logger.isDebugEnabled()) {
 527             logger.debug("deletePersonAuthority with csid=" + csid);
 528         }
 529         if (csid == null || "".equals(csid)) {
 530             logger.error("deletePersonAuthority: missing csid!");
 531             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 532                     "delete failed on PersonAuthority csid=" + csid).type(
 533                     "text/plain").build();
 534             throw new WebApplicationException(response);
 535         }
 536         try {
 537                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext();
 538             getRepositoryClient(ctx).delete(ctx, csid);
 539             return Response.status(HttpResponseCodes.SC_OK).build();
 540         } catch (UnauthorizedException ue) {
 541             Response response = Response.status(
 542                     Response.Status.UNAUTHORIZED).entity("Delete failed reason " + ue.getErrorReason()).type("text/plain").build();
 543             throw new WebApplicationException(response);
 544         } catch (DocumentNotFoundException dnfe) {
 545             if (logger.isDebugEnabled()) {
 546                 logger.debug("caught exception in deletePersonAuthority", dnfe);
 547             }
 548             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 549                     "Delete failed on PersonAuthority csid=" + csid).type(
 550                     "text/plain").build();
 551             throw new WebApplicationException(response);
 552         } catch (Exception e) {
 553             Response response = Response.status(
 554                     Response.Status.INTERNAL_SERVER_ERROR).entity("Delete failed").type("text/plain").build();
 555             throw new WebApplicationException(response);
 556         }
 557
 558     }
 559
 560     /**
 561      * ***********************************************************************
 562      * Person parts - this is a sub-resource of PersonAuthority
 563      * ***********************************************************************.
 564      *
 565      * @param parentcsid the parentcsid
 566      * @param input the input
 567      * @return the response
 568      */
 569     @POST
 570     @Path("{csid}/items")
 571     public Response createPerson(@PathParam("csid") String parentcsid, MultipartInput input) {
 572         try {
 573                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName(), input);
 574             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 575             String itemcsid = getRepositoryClient(ctx).create(ctx, handler);
 576             UriBuilder path = UriBuilder.fromResource(PersonAuthorityResource.class);
 577             path.path(parentcsid + "/items/" + itemcsid);
 578             Response response = Response.created(path.build()).build();
 579             return response;
 580         } catch (BadRequestException bre) {
 581             Response response = Response.status(
 582                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
 583             throw new WebApplicationException(response);
 584         } catch (UnauthorizedException ue) {
 585             Response response = Response.status(
 586                     Response.Status.UNAUTHORIZED).entity("Create failed reason " + ue.getErrorReason()).type("text/plain").build();
 587             throw new WebApplicationException(response);
 588         } catch (Exception e) {
 589             if (logger.isDebugEnabled()) {
 590                 logger.debug("Caught exception in createPerson", e);
 591             }
 592             Response response = Response.status(
 593                     Response.Status.INTERNAL_SERVER_ERROR).entity("Create failed").type("text/plain").build();
 594             throw new WebApplicationException(response);
 595         }
 596     }
 597
 598     /**
 599      * Gets the person.
 600      *
 601      * @param parentcsid the parentcsid
 602      * @param itemcsid the itemcsid
 603      *
 604      * @return the person
 605      */
 606     @GET
 607     @Path("{csid}/items/{itemcsid}")
 608     public MultipartOutput getPerson(
 609             @PathParam("csid") String parentcsid,
 610             @PathParam("itemcsid") String itemcsid) {
 611         if (logger.isDebugEnabled()) {
 612             logger.debug("getPerson with parentcsid=" + parentcsid + " and itemcsid=" + itemcsid);
 613         }
 614         if (parentcsid == null || "".equals(parentcsid)
 615             || itemcsid == null || "".equals(itemcsid)) {
 616             logger.error("getPerson: missing parentcsid or itemcsid!");
 617             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 618                     "get failed on Person with parentcsid="
 619                         + parentcsid + " and itemcsid=" + itemcsid).type(
 620                     "text/plain").build();
 621             throw new WebApplicationException(response);
 622         }
 623         MultipartOutput result = null;
 624         try {
 625             // Note that we have to create the service context for the Items, not the main service
 626                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName());
 627             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 628             getRepositoryClient(ctx).get(ctx, itemcsid, handler);
 629             // TODO should we assert that the item is in the passed personAuthority?
 630             result = (MultipartOutput) ctx.getOutput();
 631         } catch (UnauthorizedException ue) {
 632             Response response = Response.status(
 633                     Response.Status.UNAUTHORIZED).entity("Get failed reason " + ue.getErrorReason()).type("text/plain").build();
 634             throw new WebApplicationException(response);
 635         } catch (DocumentNotFoundException dnfe) {
 636             if (logger.isDebugEnabled()) {
 637                 logger.debug("getPerson", dnfe);
 638             }
 639             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 640                     "Get failed on Person csid=" + itemcsid).type(
 641                     "text/plain").build();
 642             throw new WebApplicationException(response);
 643         } catch (Exception e) {
 644             if (logger.isDebugEnabled()) {
 645                 logger.debug("getPerson", e);
 646             }
 647             Response response = Response.status(
 648                     Response.Status.INTERNAL_SERVER_ERROR).entity("Get failed").type("text/plain").build();
 649             throw new WebApplicationException(response);
 650         }
 651         if (result == null) {
 652             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 653                     "Get failed, the requested Person CSID:" + itemcsid + ": was not found.").type(
 654                     "text/plain").build();
 655             throw new WebApplicationException(response);
 656         }
 657         return result;
 658     }
 659
 660     /**
 661      * Gets the person list.
 662      *
 663      * @param parentcsid the parentcsid
 664      * @param partialTerm the partial term
 665      * @param ui the ui
 666      *
 667      * @return the person list
 668      */
 669     @GET
 670     @Path("{csid}/items")
 671     @Produces("application/xml")
 672     public PersonsCommonList getPersonList(
 673             @PathParam("csid") String parentcsid,
 674             @QueryParam (IQueryManager.SEARCH_TYPE_PARTIALTERM) String partialTerm,
 675             @Context UriInfo ui) {
 676         PersonsCommonList personObjectList = new PersonsCommonList();
 677         try {
 678             // Note that docType defaults to the ServiceName, so we're fine with that.
 679             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 680                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName(),
 681                                 queryParams);
 682             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 683             // Add the where clause "persons_common:inAuthority='" + parentcsid + "'"
 684             handler.getDocumentFilter().setWhereClause(PersonJAXBSchema.PERSONS_COMMON + ":" +
 685                         PersonJAXBSchema.IN_AUTHORITY + "='" + parentcsid + "'");
 686
 687             // AND persons_common:displayName LIKE '%partialTerm%'
 688             if (partialTerm != null && !partialTerm.isEmpty()) {
 689                 String ptClause = "AND " +
 690                 PersonJAXBSchema.PERSONS_COMMON + ":" +
 691                         PersonJAXBSchema.DISPLAY_NAME +
 692                         " LIKE " +
 693                         "'%" + partialTerm + "%'";
 694                 handler.getDocumentFilter().appendWhereClause(ptClause, IQueryManager.SEARCH_QUALIFIER_AND);
 695             }
 696             getRepositoryClient(ctx).getFiltered(ctx, handler);
 697             personObjectList = (PersonsCommonList) handler.getCommonPartList();
 698         } catch (UnauthorizedException ue) {
 699             Response response = Response.status(
 700                     Response.Status.UNAUTHORIZED).entity("Index failed reason " + ue.getErrorReason()).type("text/plain").build();
 701             throw new WebApplicationException(response);
 702         } catch (Exception e) {
 703             if (logger.isDebugEnabled()) {
 704                 logger.debug("Caught exception in getPersonList", e);
 705             }
 706             Response response = Response.status(
 707                     Response.Status.INTERNAL_SERVER_ERROR).entity("Index failed").type("text/plain").build();
 708             throw new WebApplicationException(response);
 709         }
 710         return personObjectList;
 711     }
 712
 713
 714     /**
 715      * Gets the person list by auth name.
 716      *
 717      * @param parentSpecifier the parent specifier
 718      * @param partialTerm the partial term
 719      * @param ui the ui
 720      *
 721      * @return the person list by auth name
 722      */
 723     @GET
 724     @Path("urn:cspace:name({specifier})/items")
 725     @Produces("application/xml")
 726     public PersonsCommonList getPersonListByAuthName(
 727                 @PathParam("specifier") String parentSpecifier,
 728             @QueryParam (IQueryManager.SEARCH_TYPE_PARTIALTERM) String partialTerm,
 729             @Context UriInfo ui) {
 730         PersonsCommonList personObjectList = new PersonsCommonList();
 731         try {
 732             String whereClause =
 733                 PersonAuthorityJAXBSchema.PERSONAUTHORITIES_COMMON+
 734                 ":" + PersonAuthorityJAXBSchema.DISPLAY_NAME+
 735                 "='" + parentSpecifier+"'";
 736             // Need to get an Authority by name
 737             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 738             ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(queryParams);
 739             String parentcsid =
 740                 getRepositoryClient(ctx).findDocCSID(ctx, whereClause);
 741             ctx = createServiceContext(getItemServiceName(), queryParams);
 742             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 743
 744             // Add the where clause "persons_common:inAuthority='" + parentcsid + "'"
 745             handler.getDocumentFilter().setWhereClause(PersonJAXBSchema.PERSONS_COMMON + ":" +
 746                         PersonJAXBSchema.IN_AUTHORITY + "='" + parentcsid + "'");
 747
 748             // AND persons_common:displayName LIKE '%partialTerm%'
 749             if (partialTerm != null && !partialTerm.isEmpty()) {
 750                 String ptClause = "AND " +
 751                 PersonJAXBSchema.PERSONS_COMMON + ":" +
 752                         PersonJAXBSchema.DISPLAY_NAME +
 753                         " LIKE " +
 754                         "'%" + partialTerm + "%'";
 755                 handler.getDocumentFilter().appendWhereClause(ptClause, IQueryManager.SEARCH_QUALIFIER_AND);
 756             }
 757             getRepositoryClient(ctx).getFiltered(ctx, handler);
 758             personObjectList = (PersonsCommonList) handler.getCommonPartList();
 759         } catch (UnauthorizedException ue) {
 760             Response response = Response.status(
 761                     Response.Status.UNAUTHORIZED).entity("Index failed reason " + ue.getErrorReason()).type("text/plain").build();
 762             throw new WebApplicationException(response);
 763         } catch (Exception e) {
 764             if (logger.isDebugEnabled()) {
 765                 logger.debug("Caught exception in getPersonList", e);
 766             }
 767             Response response = Response.status(
 768                     Response.Status.INTERNAL_SERVER_ERROR).entity("Index failed").type("text/plain").build();
 769             throw new WebApplicationException(response);
 770         }
 771         return personObjectList;
 772     }
 773
 774     /**
 775      * Update person.
 776      *
 777      * @param parentcsid the parentcsid
 778      * @param itemcsid the itemcsid
 779      * @param theUpdate the the update
 780      *
 781      * @return the multipart output
 782      */
 783     @PUT
 784     @Path("{csid}/items/{itemcsid}")
 785     public MultipartOutput updatePerson(
 786             @PathParam("csid") String parentcsid,
 787             @PathParam("itemcsid") String itemcsid,
 788             MultipartInput theUpdate) {
 789         if (logger.isDebugEnabled()) {
 790             logger.debug("updatePerson with parentcsid=" + parentcsid + " and itemcsid=" + itemcsid);
 791         }
 792         if (parentcsid == null || "".equals(parentcsid)) {
 793             logger.error("updatePerson: missing csid!");
 794             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 795                     "update failed on Person parentcsid=" + parentcsid).type(
 796                     "text/plain").build();
 797             throw new WebApplicationException(response);
 798         }
 799         if (itemcsid == null || "".equals(itemcsid)) {
 800             logger.error("updatePerson: missing itemcsid!");
 801             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 802                     "update failed on Person=" + itemcsid).type(
 803                     "text/plain").build();
 804             throw new WebApplicationException(response);
 805         }
 806         MultipartOutput result = null;
 807         try {
 808             // Note that we have to create the service context for the Items, not the main service
 809                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName(),
 810                                 theUpdate);
 811             DocumentHandler handler = createItemDocumentHandler(ctx, parentcsid);
 812             getRepositoryClient(ctx).update(ctx, itemcsid, handler);
 813             result = (MultipartOutput) ctx.getOutput();
 814         } catch (BadRequestException bre) {
 815             Response response = Response.status(
 816                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
 817             throw new WebApplicationException(response);
 818         } catch (UnauthorizedException ue) {
 819             Response response = Response.status(
 820                     Response.Status.UNAUTHORIZED).entity("Update failed reason " + ue.getErrorReason()).type("text/plain").build();
 821             throw new WebApplicationException(response);
 822         } catch (DocumentNotFoundException dnfe) {
 823             if (logger.isDebugEnabled()) {
 824                 logger.debug("caught exception in updatePerson", dnfe);
 825             }
 826             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 827                     "Update failed on Person csid=" + itemcsid).type(
 828                     "text/plain").build();
 829             throw new WebApplicationException(response);
 830         } catch (Exception e) {
 831             Response response = Response.status(
 832                     Response.Status.INTERNAL_SERVER_ERROR).entity("Update failed").type("text/plain").build();
 833             throw new WebApplicationException(response);
 834         }
 835         return result;
 836     }
 837
 838     /**
 839      * Delete person.
 840      *
 841      * @param parentcsid the parentcsid
 842      * @param itemcsid the itemcsid
 843      *
 844      * @return the response
 845      */
 846     @DELETE
 847     @Path("{csid}/items/{itemcsid}")
 848     public Response deletePerson(
 849             @PathParam("csid") String parentcsid,
 850             @PathParam("itemcsid") String itemcsid) {
 851         if (logger.isDebugEnabled()) {
 852             logger.debug("deletePerson with parentcsid=" + parentcsid + " and itemcsid=" + itemcsid);
 853         }
 854         if (parentcsid == null || "".equals(parentcsid)) {
 855             logger.error("deletePerson: missing csid!");
 856             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 857                     "delete failed on Person parentcsid=" + parentcsid).type(
 858                     "text/plain").build();
 859             throw new WebApplicationException(response);
 860         }
 861         if (itemcsid == null || "".equals(itemcsid)) {
 862             logger.error("deletePerson: missing itemcsid!");
 863             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 864                     "delete failed on Person=" + itemcsid).type(
 865                     "text/plain").build();
 866             throw new WebApplicationException(response);
 867         }
 868         try {
 869             // Note that we have to create the service context for the Items, not the main service
 870                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getItemServiceName());
 871             getRepositoryClient(ctx).delete(ctx, itemcsid);
 872             return Response.status(HttpResponseCodes.SC_OK).build();
 873         } catch (UnauthorizedException ue) {
 874             Response response = Response.status(
 875                     Response.Status.UNAUTHORIZED).entity("Delete failed reason " + ue.getErrorReason()).type("text/plain").build();
 876             throw new WebApplicationException(response);
 877         } catch (DocumentNotFoundException dnfe) {
 878             if (logger.isDebugEnabled()) {
 879                 logger.debug("caught exception in deletePerson", dnfe);
 880             }
 881             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 882                     "Delete failed on Person itemcsid=" + itemcsid).type(
 883                     "text/plain").build();
 884             throw new WebApplicationException(response);
 885         } catch (Exception e) {
 886             Response response = Response.status(
 887                     Response.Status.INTERNAL_SERVER_ERROR).entity("Delete failed").type("text/plain").build();
 888             throw new WebApplicationException(response);
 889         }
 890
 891     }
 892
 893     /**
 894      * ***********************************************************************
 895      * Contact parts - this is a sub-resource of Person (or "item")
 896      * ***********************************************************************.
 897      *
 898      * @param parentcsid the parentcsid
 899      * @param itemcsid the itemcsid
 900      * @param input the input
 901      * @return the response
 902      */
 903     @POST
 904     @Path("{parentcsid}/items/{itemcsid}/contacts")
 905     public Response createContact(
 906             @PathParam("parentcsid") String parentcsid,
 907             @PathParam("itemcsid") String itemcsid,
 908             MultipartInput input) {
 909         try {
 910             // Note that we have to create the service context and document
 911             // handler for the Contact service, not the main service.
 912                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getContactServiceName(), input);
 913             DocumentHandler handler = createContactDocumentHandler(ctx, parentcsid, itemcsid);
 914             String csid = getRepositoryClient(ctx).create(ctx, handler);
 915             UriBuilder path = UriBuilder.fromResource(PersonAuthorityResource.class);
 916             path.path("" + parentcsid + "/items/" + itemcsid + "/contacts/" + csid);
 917             Response response = Response.created(path.build()).build();
 918             return response;
 919         } catch (BadRequestException bre) {
 920             Response response = Response.status(
 921                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
 922             throw new WebApplicationException(response);
 923         } catch (UnauthorizedException ue) {
 924             Response response = Response.status(
 925                     Response.Status.UNAUTHORIZED).entity("Create failed reason " + ue.getErrorReason()).type("text/plain").build();
 926             throw new WebApplicationException(response);
 927         } catch (Exception e) {
 928             if (logger.isDebugEnabled()) {
 929                 logger.debug("Caught exception in createContact", e);
 930             }
 931             Response response = Response.status(
 932                 Response.Status.INTERNAL_SERVER_ERROR)
 933                 .entity("Attempt to create Contact failed.")
 934                 .type("text/plain").build();
 935             throw new WebApplicationException(response);
 936         }
 937
 938     }
 939
 940     /**
 941      * Gets the contact list.
 942      *
 943      * @param parentcsid the parentcsid
 944      * @param itemcsid the itemcsid
 945      * @param ui the ui
 946      *
 947      * @return the contact list
 948      */
 949     @GET
 950     @Produces({"application/xml"})
 951     @Path("{parentcsid}/items/{itemcsid}/contacts/")
 952     public ContactsCommonList getContactList(
 953             @PathParam("parentcsid") String parentcsid,
 954             @PathParam("itemcsid") String itemcsid,
 955             @Context UriInfo ui) {
 956         ContactsCommonList contactObjectList = new ContactsCommonList();
 957         try {
 958             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 959                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getContactServiceName(),
 960                                 queryParams);
 961             DocumentHandler handler = createContactDocumentHandler(ctx, parentcsid, itemcsid);
 962             handler.getDocumentFilter().setWhereClause(ContactJAXBSchema.CONTACTS_COMMON + ":" +
 963                 ContactJAXBSchema.IN_AUTHORITY +
 964                 "='" + parentcsid + "'" +
 965                 " AND " +
 966                 ContactJAXBSchema.CONTACTS_COMMON + ":" +
 967                 ContactJAXBSchema.IN_ITEM +
 968                 "='" + itemcsid + "'" +
 969                 " AND ecm:isProxy = 0");
 970             getRepositoryClient(ctx).getFiltered(ctx, handler);
 971             contactObjectList = (ContactsCommonList) handler.getCommonPartList();
 972         } catch (UnauthorizedException ue) {
 973             Response response = Response.status(
 974                     Response.Status.UNAUTHORIZED).entity("Index failed reason " + ue.getErrorReason()).type("text/plain").build();
 975             throw new WebApplicationException(response);
 976         } catch (Exception e) {
 977             if (logger.isDebugEnabled()) {
 978                 logger.debug("Caught exception in getContactsList", e);
 979             }
 980             Response response = Response.status(
 981                     Response.Status.INTERNAL_SERVER_ERROR).entity("Index failed").type("text/plain").build();
 982             throw new WebApplicationException(response);
 983         }
 984         return contactObjectList;
 985     }
 986
 987     /**
 988      * Gets the contact.
 989      *
 990      * @param parentcsid the parentcsid
 991      * @param itemcsid the itemcsid
 992      * @param csid the csid
 993      *
 994      * @return the contact
 995      */
 996     @GET
 997     @Path("{parentcsid}/items/{itemcsid}/contacts/{csid}")
 998     public MultipartOutput getContact(
 999             @PathParam("parentcsid") String parentcsid,
1000             @PathParam("itemcsid") String itemcsid,
1001             @PathParam("csid") String csid) {
1002         MultipartOutput result = null;
1003        if (logger.isDebugEnabled()) {
1004             logger.debug("getContact with parentCsid=" + parentcsid +
1005             " itemcsid=" + itemcsid + " csid=" + csid);
1006         }
1007         try {
1008             // Note that we have to create the service context and document
1009             // handler for the Contact service, not the main service.
1010                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getContactServiceName());
1011             DocumentHandler handler = createContactDocumentHandler(ctx, parentcsid, itemcsid);
1012             getRepositoryClient(ctx).get(ctx, csid, handler);
1013             result = (MultipartOutput) ctx.getOutput();
1014         } catch (UnauthorizedException ue) {
1015             Response response = Response.status(
1016                     Response.Status.UNAUTHORIZED).entity("Get failed reason " + ue.getErrorReason()).type("text/plain").build();
1017             throw new WebApplicationException(response);
1018         } catch (DocumentNotFoundException dnfe) {
1019             if (logger.isDebugEnabled()) {
1020                 logger.debug("getContact", dnfe);
1021             }
1022             Response response = Response.status(Response.Status.NOT_FOUND)
1023                 .entity("Get failed, the requested Contact CSID:" + csid + ": was not found.")
1024                 .type("text/plain").build();
1025             throw new WebApplicationException(response);
1026         } catch (Exception e) {
1027             if (logger.isDebugEnabled()) {
1028                 logger.debug("getContact", e);
1029             }
1030             Response response = Response.status(Response.Status.INTERNAL_SERVER_ERROR)
1031                 .entity("Get contact failed")
1032                 .type("text/plain").build();
1033             throw new WebApplicationException(response);
1034         }
1035         if (result == null) {
1036             Response response = Response.status(Response.Status.NOT_FOUND)
1037                 .entity("Get failed, the requested Contact CSID:" + csid + ": was not found.")
1038                 .type("text/plain").build();
1039             throw new WebApplicationException(response);
1040         }
1041
1042         return result;
1043     }
1044
1045     /**
1046      * Update contact.
1047      *
1048      * @param parentcsid the parentcsid
1049      * @param itemcsid the itemcsid
1050      * @param csid the csid
1051      * @param theUpdate the the update
1052      *
1053      * @return the multipart output
1054      */
1055     @PUT
1056     @Path("{parentcsid}/items/{itemcsid}/contacts/{csid}")
1057     public MultipartOutput updateContact(
1058             @PathParam("parentcsid") String parentcsid,
1059             @PathParam("itemcsid") String itemcsid,
1060             @PathParam("csid") String csid,
1061             MultipartInput theUpdate) {
1062        if (logger.isDebugEnabled()) {
1063             logger.debug("updateContact with parentcsid=" + parentcsid +
1064             " itemcsid=" + itemcsid + " csid=" + csid);
1065         }
1066        if (parentcsid == null || parentcsid.trim().isEmpty()) {
1067             logger.error("updateContact: missing csid!");
1068             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1069                     "update failed on Contact parentcsid=" + parentcsid).type(
1070                     "text/plain").build();
1071             throw new WebApplicationException(response);
1072         }
1073         if (itemcsid == null || itemcsid.trim().isEmpty()) {
1074             logger.error("updateContact: missing itemcsid!");
1075             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1076                     "update failed on Contact=" + itemcsid).type(
1077                     "text/plain").build();
1078             throw new WebApplicationException(response);
1079         }
1080         if (csid == null || csid.trim().isEmpty()) {
1081             logger.error("updateContact: missing csid!");
1082             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1083                     "update failed on Contact=" + csid).type(
1084                     "text/plain").build();
1085             throw new WebApplicationException(response);
1086         }
1087         MultipartOutput result = null;
1088         try {
1089             // Note that we have to create the service context and document
1090             // handler for the Contact service, not the main service.
1091                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getContactServiceName(),
1092                                 theUpdate);
1093             DocumentHandler handler = createContactDocumentHandler(ctx, parentcsid, itemcsid);
1094             getRepositoryClient(ctx).update(ctx, csid, handler);
1095             result = (MultipartOutput) ctx.getOutput();
1096         } catch (BadRequestException bre) {
1097             Response response = Response.status(
1098                     Response.Status.BAD_REQUEST).entity("Create failed reason " + bre.getErrorReason()).type("text/plain").build();
1099             throw new WebApplicationException(response);
1100         } catch (UnauthorizedException ue) {
1101             Response response = Response.status(
1102                     Response.Status.UNAUTHORIZED).entity("Update failed reason " + ue.getErrorReason()).type("text/plain").build();
1103             throw new WebApplicationException(response);
1104         } catch (DocumentNotFoundException dnfe) {
1105             if (logger.isDebugEnabled()) {
1106                 logger.debug("caught exception in updateContact", dnfe);
1107             }
1108             Response response = Response.status(Response.Status.NOT_FOUND).entity(
1109                     "Update failed on Contact csid=" + itemcsid).type(
1110                     "text/plain").build();
1111             throw new WebApplicationException(response);
1112         } catch (Exception e) {
1113             Response response = Response.status(
1114                     Response.Status.INTERNAL_SERVER_ERROR).entity("Update failed").type("text/plain").build();
1115             throw new WebApplicationException(response);
1116         }
1117         return result;
1118     }
1119
1120     /**
1121      * Delete contact.
1122      *
1123      * @param parentcsid the parentcsid
1124      * @param itemcsid the itemcsid
1125      * @param csid the csid
1126      *
1127      * @return the response
1128      */
1129     @DELETE
1130     @Path("{parentcsid}/items/{itemcsid}/contacts/{csid}")
1131     public Response deleteContact(
1132             @PathParam("parentcsid") String parentcsid,
1133             @PathParam("itemcsid") String itemcsid,
1134             @PathParam("csid") String csid) {
1135         if (logger.isDebugEnabled()) {
1136             logger.debug("deleteContact with parentCsid=" + parentcsid +
1137             " itemcsid=" + itemcsid + " csid=" + csid);
1138         }
1139         if (parentcsid == null || parentcsid.trim().isEmpty()) {
1140             logger.error("deleteContact: missing parentcsid!");
1141             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1142                     "delete contact failed on parentcsid=" + parentcsid).type(
1143                     "text/plain").build();
1144             throw new WebApplicationException(response);
1145         }
1146         if (itemcsid == null || itemcsid.trim().isEmpty()) {
1147             logger.error("deleteContact: missing itemcsid!");
1148             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1149                     "delete contact failed on itemcsid=" + itemcsid).type(
1150                     "text/plain").build();
1151             throw new WebApplicationException(response);
1152         }
1153         if (csid == null || csid.trim().isEmpty()) {
1154             logger.error("deleteContact: missing csid!");
1155             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
1156                     "delete contact failed on csid=" + csid).type(
1157                     "text/plain").build();
1158             throw new WebApplicationException(response);
1159         }
1160         try {
1161             // Note that we have to create the service context for the
1162             // Contact service, not the main service.
1163                 ServiceContext<MultipartInput, MultipartOutput> ctx = createServiceContext(getContactServiceName());
1164             getRepositoryClient(ctx).delete(ctx, csid);
1165             return Response.status(HttpResponseCodes.SC_OK).build();
1166          } catch (UnauthorizedException ue) {
1167             Response response = Response.status(
1168                     Response.Status.UNAUTHORIZED).entity("Delete failed reason " + ue.getErrorReason()).type("text/plain").build();
1169             throw new WebApplicationException(response);
1170          } catch (DocumentNotFoundException dnfe) {
1171             if (logger.isDebugEnabled()) {
1172                 logger.debug("Caught exception in deleteContact", dnfe);
1173             }
1174             Response response = Response.status(Response.Status.NOT_FOUND)
1175                 .entity("Delete failed, the requested Contact CSID:" + csid + ": was not found.")
1176                 .type("text/plain").build();
1177             throw new WebApplicationException(response);
1178        } catch (Exception e) {
1179             Response response = Response.status(
1180                     Response.Status.INTERNAL_SERVER_ERROR).entity("Delete failed").type("text/plain").build();
1181             throw new WebApplicationException(response);
1182         }
1183     }
1184
1185 }