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 Regents of the University of California
  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.acquisition;
  25
  26 import java.util.List;
  27
  28 import javax.ws.rs.Consumes;
  29 import javax.ws.rs.GET;
  30 import javax.ws.rs.Path;
  31 import javax.ws.rs.Produces;
  32 import javax.ws.rs.DELETE;
  33 import javax.ws.rs.POST;
  34 import javax.ws.rs.PUT;
  35 import javax.ws.rs.PathParam;
  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.client.IQueryManager;
  45 import org.collectionspace.services.client.PoxPayloadIn;
  46 import org.collectionspace.services.client.PoxPayloadOut;
  47 import org.collectionspace.services.client.AcquisitionClient;
  48 import org.collectionspace.services.nuxeo.client.java.DocumentModelHandler;
  49
  50 import org.collectionspace.services.common.AbstractMultiPartCollectionSpaceResourceImpl;
  51 import org.collectionspace.services.common.authorityref.AuthorityRefList;
  52 import org.collectionspace.services.common.ServiceMessages;
  53 import org.collectionspace.services.common.context.MultipartServiceContextImpl;
  54 import org.collectionspace.services.common.context.ServiceBindingUtils;
  55 import org.collectionspace.services.common.context.ServiceContext;
  56 import org.collectionspace.services.common.document.DocumentFilter;
  57 import org.collectionspace.services.common.document.DocumentNotFoundException;
  58 import org.collectionspace.services.common.document.DocumentHandler;
  59 import org.collectionspace.services.common.document.DocumentWrapper;
  60 import org.collectionspace.services.common.query.QueryManager;
  61 import org.collectionspace.services.common.security.UnauthorizedException;
  62 import org.collectionspace.services.nuxeo.client.java.CommonList;
  63
  64 import org.jboss.resteasy.util.HttpResponseCodes;
  65 import org.nuxeo.ecm.core.api.DocumentModel;
  66
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69
  70 /**
  71  * AcquisitionResource.java
  72  *
  73  * Handles requests to the Acquisition service, orchestrates the retrieval
  74  * of relevant resources, and returns responses to the client.
  75  */
  76 @Path(AcquisitionClient.SERVICE_PATH)
  77 @Produces({"application/xml"})
  78 @Consumes({"application/xml"})
  79 public class AcquisitionResource
  80         extends AbstractMultiPartCollectionSpaceResourceImpl {
  81
  82     /** The logger. */
  83     final Logger logger = LoggerFactory.getLogger(AcquisitionResource.class);
  84
  85     /* (non-Javadoc)
  86      * @see org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl#getVersionString()
  87      */
  88     @Override
  89     protected String getVersionString() {
  90         /** The last change revision. */
  91         final String lastChangeRevision = "$LastChangedRevision$";
  92         return lastChangeRevision;
  93     }
  94
  95     /* (non-Javadoc)
  96      * @see org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl#getServiceName()
  97      */
  98     @Override
  99     public String getServiceName() {
 100         return AcquisitionClient.SERVICE_NAME;
 101     }
 102
 103     @Override
 104     public Class<AcquisitionsCommon> getCommonPartClass() {
 105         return AcquisitionsCommon.class;
 106     }
 107
 108     /* (non-Javadoc) //FIXME: REM - Please remove dead code.
 109      * @see org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl#createDocumentHandler(org.collectionspace.services.common.context.ServiceContext)
 110      */
 111 //    @Override
 112 //    public DocumentHandler createDocumentHandler(ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx) throws Exception {
 113 //        DocumentHandler docHandler = ctx.getDocumentHandler();
 114 //        if (ctx.getInput() != null) {
 115 //            Object obj = ((MultipartServiceContext) ctx).getInputPart(ctx.getCommonPartLabel(), AcquisitionsCommon.class);
 116 //            if (obj != null) {
 117 //                docHandler.setCommonPart((AcquisitionsCommon) obj);
 118 //            }
 119 //        }
 120 //        return docHandler;
 121 //    }
 122     /**
 123      * Instantiates a new acquisition resource.
 124      */
 125     public AcquisitionResource() {
 126         // Empty constructor.  Note that all JAX-RS resource classes are singletons.
 127     }
 128
 129     /**
 130      * Creates the acquisition.
 131      *
 132      * @param input the input
 133      *
 134      * @return the response
 135      */
 136     @POST
 137     public Response createAcquisition(String xmlPayload) {
 138         try {
 139                 PoxPayloadIn input = new PoxPayloadIn(xmlPayload);
 140             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(input);
 141             DocumentHandler handler = createDocumentHandler(ctx);
 142             String csid = getRepositoryClient(ctx).create(ctx, handler);
 143             UriBuilder path = UriBuilder.fromResource(AcquisitionResource.class);
 144             path.path("" + csid);
 145             Response response = Response.created(path.build()).build();
 146             return response;
 147         } catch (UnauthorizedException ue) {
 148             Response response = Response.status(
 149                     Response.Status.UNAUTHORIZED).entity(
 150                     ServiceMessages.CREATE_FAILED + ue.getErrorReason()).type("text/plain").build();
 151             throw new WebApplicationException(response);
 152         } catch (Exception e) {
 153             if (logger.isDebugEnabled()) {
 154                 logger.debug("Caught exception in createAcquisition", e);
 155             }
 156             Response response = Response.status(
 157                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 158                     ServiceMessages.CREATE_FAILED + e.getMessage()).type("text/plain").build();
 159             throw new WebApplicationException(response);
 160         }
 161     }
 162
 163     /**
 164      * Gets the acquisition.
 165      *
 166      * @param csid the csid
 167      *
 168      * @return the acquisition
 169      */
 170     @GET
 171     @Path("{csid}")
 172     public byte[] getAcquisition(
 173                 @Context UriInfo ui,
 174             @PathParam("csid") String csid) {
 175         if (logger.isDebugEnabled()) {
 176             logger.debug("getAcquisition with csid=" + csid);
 177         }
 178         if (csid == null || "".equals(csid)) {
 179             logger.error("getAcquisition:" + ServiceMessages.MISSING_CSID);
 180             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 181                     ServiceMessages.READ_FAILED + ServiceMessages.MISSING_CSID).type("text/plain").build();
 182             throw new WebApplicationException(response);
 183         }
 184         PoxPayloadOut result = null;
 185         try {
 186             MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 187             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(queryParams);
 188             DocumentHandler handler = createDocumentHandler(ctx);
 189             getRepositoryClient(ctx).get(ctx, csid, handler);
 190             result = ctx.getOutput();
 191         } catch (UnauthorizedException ue) {
 192             Response response = Response.status(
 193                     Response.Status.UNAUTHORIZED).entity(
 194                     ServiceMessages.READ_FAILED + ue.getErrorReason()).type("text/plain").build();
 195             throw new WebApplicationException(response);
 196         } catch (DocumentNotFoundException dnfe) {
 197             if (logger.isDebugEnabled()) {
 198                 logger.debug("getAcquisition", dnfe);
 199             }
 200             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 201                     ServiceMessages.READ_FAILED + ServiceMessages.resourceNotFoundMsg(csid)).type("text/plain").build();
 202             throw new WebApplicationException(response);
 203         } catch (Exception e) {
 204             if (logger.isDebugEnabled()) {
 205                 logger.debug("getAcquisition", e);
 206             }
 207             Response response = Response.status(
 208                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 209                     ServiceMessages.READ_FAILED + e.getMessage()).type("text/plain").build();
 210             throw new WebApplicationException(response);
 211         }
 212
 213         if (result == null) {
 214             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 215                     ServiceMessages.READ_FAILED + ServiceMessages.resourceNotFoundMsg(csid)).type("text/plain").build();
 216             throw new WebApplicationException(response);
 217         }
 218         return result.getBytes();
 219     }
 220
 221     /**
 222      * Gets the acquisition list.
 223      *
 224      * @param ui the ui
 225      * @param keywords the keywords
 226      *
 227      * @return the acquisition list
 228      */
 229     @GET
 230     @Produces("application/xml")
 231     public CommonList getAcquisitionList(@Context UriInfo ui,
 232             @QueryParam(IQueryManager.SEARCH_TYPE_KEYWORDS_KW) String keywords) {
 233         CommonList result = null;
 234         MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 235         if (keywords != null) {
 236             result = searchAcquisitions(queryParams, keywords);
 237         } else {
 238             result = getAcquisitionsList(queryParams);
 239         }
 240
 241         return result;
 242     }
 243
 244     /**
 245      * Gets the acquisitions list.
 246      *
 247      * @return the acquisitions list
 248      */
 249     private CommonList getAcquisitionsList(MultivaluedMap<String, String> queryParams) {
 250         CommonList commonList;
 251         try {
 252             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(queryParams);
 253             DocumentHandler handler = createDocumentHandler(ctx);
 254             getRepositoryClient(ctx).getFiltered(ctx, handler);
 255             commonList = (CommonList) handler.getCommonPartList();
 256         } catch (UnauthorizedException ue) {
 257             Response response = Response.status(
 258                     Response.Status.UNAUTHORIZED).entity(
 259                     ServiceMessages.LIST_FAILED + ue.getErrorReason()).type("text/plain").build();
 260             throw new WebApplicationException(response);
 261         } catch (Exception e) {
 262             if (logger.isDebugEnabled()) {
 263                 logger.debug("Caught exception in getAcquisitionList", e);
 264             }
 265             Response response = Response.status(
 266                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 267                     ServiceMessages.LIST_FAILED + e.getMessage()).type("text/plain").build();
 268             throw new WebApplicationException(response);
 269         }
 270         return commonList;
 271     }
 272
 273     /**
 274      * Update acquisition.
 275      *
 276      * @param csid the csid
 277      * @param theUpdate the the update
 278      *
 279      * @return the multipart output
 280      */
 281     @PUT
 282     @Path("{csid}")
 283     public byte[] updateAcquisition(
 284             @PathParam("csid") String csid,
 285             String xmlPayload) {
 286         if (logger.isDebugEnabled()) {
 287             logger.debug("updateAcquisition with csid=" + csid);
 288         }
 289         if (csid == null || "".equals(csid)) {
 290             logger.error("updateAcquisition: missing csid!");
 291             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 292                     ServiceMessages.UPDATE_FAILED + ServiceMessages.MISSING_CSID).type("text/plain").build();
 293             throw new WebApplicationException(response);
 294         }
 295         PoxPayloadOut result = null;
 296         try {
 297                 PoxPayloadIn theUpdate = new PoxPayloadIn(xmlPayload);
 298             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(theUpdate);
 299             DocumentHandler handler = createDocumentHandler(ctx);
 300             getRepositoryClient(ctx).update(ctx, csid, handler);
 301             result = ctx.getOutput();
 302         } catch (UnauthorizedException ue) {
 303             Response response = Response.status(
 304                     Response.Status.UNAUTHORIZED).entity(
 305                     ServiceMessages.UPDATE_FAILED + ue.getErrorReason()).type("text/plain").build();
 306             throw new WebApplicationException(response);
 307         } catch (DocumentNotFoundException dnfe) {
 308             if (logger.isDebugEnabled()) {
 309                 logger.debug("caught exception in updateAcquisition", dnfe);
 310             }
 311             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 312                     ServiceMessages.UPDATE_FAILED + ServiceMessages.resourceNotFoundMsg(csid)).type("text/plain").build();
 313             throw new WebApplicationException(response);
 314         } catch (Exception e) {
 315             Response response = Response.status(
 316                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 317                     ServiceMessages.UPDATE_FAILED + e.getMessage()).type("text/plain").build();
 318             throw new WebApplicationException(response);
 319         }
 320         return result.getBytes();
 321     }
 322
 323     /**
 324      * Delete acquisition.
 325      *
 326      * @param csid the csid
 327      *
 328      * @return the response
 329      */
 330     @DELETE
 331     @Path("{csid}")
 332     public Response deleteAcquisition(@PathParam("csid") String csid) {
 333
 334         if (logger.isDebugEnabled()) {
 335             logger.debug("deleteAcquisition with csid=" + csid);
 336         }
 337         if (csid == null || "".equals(csid)) {
 338             logger.error("deleteAcquisition: missing csid!");
 339             Response response = Response.status(Response.Status.BAD_REQUEST).entity(
 340                     ServiceMessages.DELETE_FAILED + ServiceMessages.MISSING_CSID).type("text/plain").build();
 341             throw new WebApplicationException(response);
 342         }
 343         try {
 344             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext();
 345             getRepositoryClient(ctx).delete(ctx, csid);
 346             return Response.status(HttpResponseCodes.SC_OK).build();
 347         } catch (UnauthorizedException ue) {
 348             Response response = Response.status(
 349                     Response.Status.UNAUTHORIZED).entity(
 350                     ServiceMessages.DELETE_FAILED + ue.getErrorReason()).type("text/plain").build();
 351             throw new WebApplicationException(response);
 352         } catch (DocumentNotFoundException dnfe) {
 353             if (logger.isDebugEnabled()) {
 354                 logger.debug("caught exception in deleteAcquisition", dnfe);
 355             }
 356             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 357                     ServiceMessages.DELETE_FAILED + ServiceMessages.resourceNotFoundMsg(csid)).type("text/plain").build();
 358             throw new WebApplicationException(response);
 359         } catch (Exception e) {
 360             Response response = Response.status(
 361                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 362                     ServiceMessages.DELETE_FAILED + e.getMessage()).type("text/plain").build();
 363             throw new WebApplicationException(response);
 364         }
 365     }
 366
 367     /**
 368      * Keywords search acquisitions.
 369      *
 370      * @param ui the ui
 371      * @param keywords the keywords
 372      *
 373      * @return the acquisitions common list
 374      */
 375     @GET
 376     @Path("/search")
 377     @Produces("application/xml")
 378     @Deprecated
 379     public CommonList keywordsSearchAcquisitions(@Context UriInfo ui,
 380             @QueryParam(IQueryManager.SEARCH_TYPE_KEYWORDS) String keywords) {
 381         MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
 382         return searchAcquisitions(queryParams, keywords);
 383     }
 384
 385     /**
 386      * Search acquisitions.
 387      *
 388      * @param keywords the keywords
 389      *
 390      * @return the acquisitions common list
 391      */
 392     private CommonList searchAcquisitions(
 393             MultivaluedMap<String, String> queryParams, String keywords) {
 394         CommonList commonList;
 395         try {
 396             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext(queryParams);
 397             DocumentHandler handler = createDocumentHandler(ctx);
 398
 399             // perform a keyword search
 400             if (keywords != null && !keywords.isEmpty()) {
 401                 String whereClause = QueryManager.createWhereClauseFromKeywords(keywords);
 402                 DocumentFilter documentFilter = handler.getDocumentFilter();
 403                 documentFilter.appendWhereClause(whereClause, IQueryManager.SEARCH_QUALIFIER_AND);
 404                 if (logger.isDebugEnabled()) {
 405                     logger.debug("The WHERE clause is: " + documentFilter.getWhereClause());
 406                 }
 407             }
 408             getRepositoryClient(ctx).getFiltered(ctx, handler);
 409             commonList = (CommonList) handler.getCommonPartList();
 410         } catch (UnauthorizedException ue) {
 411             Response response = Response.status(
 412                     Response.Status.UNAUTHORIZED).entity(
 413                     ServiceMessages.SEARCH_FAILED + ue.getErrorReason()).type("text/plain").build();
 414             throw new WebApplicationException(response);
 415         } catch (Exception e) {
 416             if (logger.isDebugEnabled()) {
 417                 logger.debug("Caught exception in search for Acquisitions", e);
 418             }
 419             Response response = Response.status(
 420                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 421                     ServiceMessages.SEARCH_FAILED + e.getMessage()).type("text/plain").build();
 422             throw new WebApplicationException(response);
 423         }
 424         return commonList;
 425     }
 426
 427     /**
 428      * Gets the authority refs.
 429      *
 430      * @param csid the csid
 431      * @param ui the ui
 432      *
 433      * @return the authority refs
 434      */
 435     @GET
 436     @Path("{csid}/authorityrefs")
 437     public AuthorityRefList getAuthorityRefs(
 438             @PathParam("csid") String csid,
 439             @Context UriInfo ui) {
 440         AuthorityRefList authRefList = null;
 441         try {
 442             ServiceContext<PoxPayloadIn, PoxPayloadOut> ctx = createServiceContext();
 443             DocumentWrapper<DocumentModel> docWrapper =
 444                     getRepositoryClient(ctx).getDoc(ctx, csid);
 445             DocumentModelHandler<PoxPayloadIn, PoxPayloadOut> handler = (DocumentModelHandler<PoxPayloadIn, PoxPayloadOut>) createDocumentHandler(ctx);
 446             List<String> authRefFields =
 447                     ((MultipartServiceContextImpl) ctx).getCommonPartPropertyValues(
 448                     ServiceBindingUtils.AUTH_REF_PROP, ServiceBindingUtils.QUALIFIED_PROP_NAMES);
 449             authRefList = handler.getAuthorityRefs(docWrapper, authRefFields);
 450         } catch (UnauthorizedException ue) {
 451             Response response = Response.status(
 452                     Response.Status.UNAUTHORIZED).entity(
 453                     ServiceMessages.AUTH_REFS_FAILED + ue.getErrorReason()).type("text/plain").build();
 454             throw new WebApplicationException(response);
 455         } catch (Exception e) {
 456             if (logger.isDebugEnabled()) {
 457                 logger.debug("Caught exception in getAuthorityRefs", e);
 458             }
 459             Response response = Response.status(
 460                     Response.Status.INTERNAL_SERVER_ERROR).entity(
 461                     ServiceMessages.AUTH_REFS_FAILED + e.getMessage()).type("text/plain").build();
 462             throw new WebApplicationException(response);
 463         }
 464         return authRefList;
 465     }
 466 }