git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 package org.collectionspace.hello.services;
   2
   3 import java.io.ByteArrayInputStream;
   4 import org.collectionspace.hello.services.nuxeo.NuxeoRESTClient;
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.HashMap;
   8 import java.util.Iterator;
   9 import java.util.List;
  10 import javax.ws.rs.Consumes;
  11 import javax.ws.rs.GET;
  12 import javax.ws.rs.Path;
  13 import javax.ws.rs.Produces;
  14 import java.util.Map;
  15 import javax.ws.rs.DELETE;
  16 import javax.ws.rs.POST;
  17 import javax.ws.rs.PUT;
  18 import javax.ws.rs.PathParam;
  19 import javax.ws.rs.WebApplicationException;
  20 import javax.ws.rs.core.Context;
  21 import javax.ws.rs.core.Response;
  22 import javax.ws.rs.core.UriBuilder;
  23 import javax.ws.rs.core.UriInfo;
  24 import javax.xml.bind.JAXBContext;
  25 import javax.xml.bind.Marshaller;
  26 import org.collectionspace.hello.*;
  27
  28
  29 import org.collectionspace.hello.People.PeopleItem;
  30 import org.dom4j.Document;
  31 import org.dom4j.Element;
  32 import org.dom4j.Namespace;
  33 import org.dom4j.io.SAXReader;
  34 import org.restlet.resource.Representation;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 @Path("/persons")
  39 @Consumes("application/xml")
  40 @Produces("application/xml")
  41 public class PersonNuxeoResource {
  42
  43     final Logger logger = LoggerFactory.getLogger(PersonNuxeoResource.class);
  44
  45     public PersonNuxeoResource() {
  46     }
  47
  48     @GET
  49     public People getPeople(@Context UriInfo ui) {
  50         People p = new People();
  51         try{
  52             List<People.PeopleItem> list = p.getPeopleItem();
  53             NuxeoRESTClient nxClient = getClient();
  54
  55             List<String> pathParams = new ArrayList<String>();
  56             Map<String, String> queryParams = new HashMap<String, String>();
  57             //browse default repository for People
  58             //For sanjay, People repository id is f084243e-4b81-42a1-9a05-518e974facbd
  59             //For Richard, workspace repos ID is 77187c27-0467-4c3d-b395-122b82113f4d
  60             pathParams = Arrays.asList("default", "1b58eef7-4fff-430b-b773-8c98724f19de", "browse");
  61             Representation res = nxClient.get(pathParams, queryParams);
  62             SAXReader reader = new SAXReader();
  63             Document document = reader.read(res.getStream());
  64             Element root = document.getRootElement();
  65             for(Iterator i = root.elementIterator(); i.hasNext();){
  66                 Element element = (Element) i.next();
  67                 PeopleItem pli = new PeopleItem();
  68                 pli.setTitle(element.attributeValue("title"));
  69                 pli.setUri(element.attributeValue("url"));
  70                 pli.setId(element.attributeValue("id"));
  71                 list.add(pli);
  72             }
  73
  74         }catch(Exception e){
  75             e.printStackTrace();
  76         }
  77         return p;
  78     }
  79
  80     @POST
  81     public Response createPerson(PersonNuxeo p) {
  82
  83         NuxeoRESTClient nxClient = getClient();
  84
  85         List<String> pathParams = new ArrayList<String>();
  86         Map<String, String> queryParams = new HashMap<String, String>();
  87         pathParams.add("default");
  88         pathParams.add("1b58eef7-4fff-430b-b773-8c98724f19de");
  89         pathParams.add("createDocument");
  90         queryParams.put("docType", "Hello");
  91         queryParams.put("dublincore:title", p.getFirstName() + " " + p.getLastName());
  92         queryParams.put("hello:cversion", Integer.valueOf(1).toString());
  93         queryParams.put("hello:firstName", p.getFirstName());
  94         queryParams.put("hello:lastName", p.getLastName());
  95         queryParams.put("hello:street", p.getStreet());
  96         queryParams.put("hello:city", p.getCity());
  97         queryParams.put("hello:state", p.getState());
  98         queryParams.put("hello:zip", p.getZip());
  99         queryParams.put("hello:country", p.getCountry());
 100         ByteArrayInputStream bais = new ByteArrayInputStream(new byte[0]);
 101         Representation res = nxClient.post(pathParams, queryParams, bais);
 102
 103         SAXReader reader = new SAXReader();
 104         try{
 105             Document document = reader.read(res.getStream());
 106             Element root = document.getRootElement();
 107             for(Iterator i = root.elementIterator(); i.hasNext();){
 108                 Element element = (Element) i.next();
 109                 if("docRef".equals(element.getName())){
 110                     String id = (String) element.getData();
 111                     p.setId(id);
 112                 }
 113             }
 114         }catch(Exception e){
 115             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 116                     "Create failed").type("text/plain").build();
 117             throw new WebApplicationException(response);
 118         }
 119
 120         verbose("created person", p);
 121         UriBuilder path = UriBuilder.fromResource(PersonNuxeoResource.class);
 122         path.path("" + p.getId());
 123         Response response = Response.created(path.build()).build();
 124         return response;
 125     }
 126
 127     @GET
 128     @Path("{id}")
 129     public PersonNuxeo getPerson(@PathParam("id") String id) {
 130
 131         PersonNuxeo p = null;
 132         try{
 133
 134             NuxeoRESTClient nxClient = getClient();
 135
 136             List<String> pathParams = new ArrayList<String>();
 137             Map<String, String> queryParams = new HashMap<String, String>();
 138
 139             pathParams.add("default");
 140             pathParams.add(id);
 141             pathParams.add("export");
 142             queryParams.put("format", "XML");
 143
 144             Representation res = nxClient.get(pathParams, queryParams);
 145             SAXReader reader = new SAXReader();
 146
 147             Document document = reader.read(res.getStream());
 148             Element root = document.getRootElement();
 149             p = new PersonNuxeo();
 150             //TODO: recognize schema thru namespace uri
 151 //            Namespace ns = new Namespace("hello", "http://collectionspace.org/hello");
 152             Iterator<Element> siter = root.elementIterator("schema");
 153             while(siter.hasNext()){
 154
 155                 Element s = siter.next();
 156
 157                 System.err.println("PersonNuxeo.getPerson() called.");
 158
 159                 //TODO: recognize schema thru namespace uri
 160                 if("hello".equals(s.attribute("name").getValue())){
 161                     p.setId(id);
 162                     Element ele = s.element("cversion");
 163                     if(ele != null){
 164                         p.setVersion((String) ele.getData());
 165                     }
 166                     ele = s.element("firstName");
 167                     if(ele != null){
 168                         p.setFirstName((String) ele.getData());
 169                     }
 170                     ele = s.element("lastName");
 171                     if(ele != null){
 172                         p.setLastName((String) ele.getData());
 173                     }
 174                     ele = s.element("city");
 175                     if(ele != null){
 176                         p.setCity((String) ele.getData());
 177                     }
 178                     ele = s.element("state");
 179                     if(ele != null){
 180                         p.setState((String) ele.getData());
 181                     }
 182                     ele = s.element("zip");
 183                     if(ele != null){
 184                         p.setZip((String) ele.getData());
 185                     }
 186                     ele = s.element("country");
 187                     if(ele != null){
 188                         p.setCountry((String) ele.getData());
 189                     }
 190                 }
 191             }
 192
 193         }catch(Exception e){
 194             e.printStackTrace();
 195             Response response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
 196                     "Get failed").type("text/plain").build();
 197             throw new WebApplicationException(response);
 198         }
 199         if(p == null){
 200             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 201                     "Get failed, the requested person ID:" + id + ": was not found.").type("text/plain").build();
 202             throw new WebApplicationException(response);
 203         }
 204         verbose("get person", p);
 205         return p;
 206     }
 207
 208     @PUT
 209     @Path("{id}")
 210     public PersonNuxeo updatePerson(
 211             @PathParam("id") String id,
 212             PersonNuxeo update) {
 213
 214         verbose("updating person input", update);
 215
 216         NuxeoRESTClient nxClient = getClient();
 217
 218         List<String> pathParams = new ArrayList<String>();
 219         Map<String, String> queryParams = new HashMap<String, String>();
 220         pathParams.add("default");
 221         pathParams.add(update.getId());
 222         pathParams.add("updateDocumentRestlet");
 223         queryParams.put("dublincore:title", "change title");
 224         //todo: intelligent merge needed
 225         if(update.getFirstName() != null){
 226             queryParams.put("hello:firstName", update.getFirstName());
 227         }
 228
 229         if(update.getLastName() != null){
 230             queryParams.put("hello:lastName", update.getLastName());
 231         }
 232
 233         if(update.getFirstName() != null && update.getLastName() != null){
 234             queryParams.put("dublincore:title", update.getFirstName() + " " + update.getLastName());
 235         }
 236
 237         if(update.getStreet() != null){
 238             queryParams.put("hello:street", update.getStreet());
 239         }
 240
 241         if(update.getCity() != null){
 242             queryParams.put("hello:city", update.getCity());
 243         }
 244
 245         if(update.getState() != null){
 246             queryParams.put("hello:state", update.getState());
 247         }
 248
 249         if(update.getZip() != null){
 250             queryParams.put("hello:zip", update.getZip());
 251         }
 252
 253         if(update.getCountry() != null){
 254             queryParams.put("hello:country", update.getCountry());
 255         }
 256
 257         Representation res = nxClient.get(pathParams, queryParams);
 258         SAXReader reader = new SAXReader();
 259         String status = "";
 260         try{
 261             Document document = reader.read(res.getStream());
 262             Element root = document.getRootElement();
 263             for(Iterator i = root.elementIterator(); i.hasNext();){
 264                 Element element = (Element) i.next();
 265                 if("docRef".equals(element.getName())){
 266                     status = (String) element.getData();
 267                     verbose("updatePerson: response=" + status);
 268                 }
 269
 270             }
 271         }catch(Exception e){
 272             //FIXME: NOT_FOUND?
 273             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 274                     "Update failed ").type("text/plain").build();
 275             throw new WebApplicationException(response);
 276         }
 277         return update;
 278     }
 279
 280     @DELETE
 281     @Path("{id}")
 282     public void deletePerson(@PathParam("id") String id) {
 283         verbose("deleting person with id=" + id);
 284         NuxeoRESTClient nxClient = getClient();
 285         List<String> pathParams = new ArrayList<String>();
 286         Map<String, String> queryParams = new HashMap<String, String>();
 287         pathParams.add("default");
 288         pathParams.add(id);
 289         pathParams.add("deleteDocumentRestlet");
 290         Representation res = nxClient.get(pathParams, queryParams);
 291         SAXReader reader = new SAXReader();
 292         String status = "";
 293         try{
 294             Document document = reader.read(res.getStream());
 295             Element root = document.getRootElement();
 296             for(Iterator i = root.elementIterator(); i.hasNext();){
 297                 Element element = (Element) i.next();
 298                 if("docRef".equals(element.getName())){
 299                     status = (String) element.getData();
 300                     verbose("deletePerson: response=" + status);
 301                 }
 302
 303             }
 304         }catch(Exception e){
 305             //FIXME: NOT_FOUND?
 306             Response response = Response.status(Response.Status.NOT_FOUND).entity(
 307                     "Delete failed ").type("text/plain").build();
 308             throw new WebApplicationException(response);
 309         }
 310
 311     }
 312
 313     private void verbose(String msg, PersonNuxeo p) {
 314         try{
 315             verbose(msg);
 316             JAXBContext jc = JAXBContext.newInstance(
 317                     PersonNuxeo.class);
 318
 319             Marshaller m = jc.createMarshaller();
 320             m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
 321                     Boolean.TRUE);
 322             m.marshal(p, System.out);
 323         }catch(Exception e){
 324             e.printStackTrace();
 325         }
 326
 327     }
 328
 329 //    private void getQueryModel() throws IOException {
 330 //        NuxeoRESTClient nxClient = getClient();
 331 //
 332 //        List<String> pathParams = new ArrayList<String>();
 333 //        Map<String, String> queryParams = new HashMap<String, String>();
 334 //
 335 //        //query model for user documents
 336 //        pathParams = Arrays.asList("execQueryModel", "USER_DOCUMENTS");
 337 //        queryParams.put("QP1", "Administrator");
 338 //        queryParams.put("format", "XML");
 339 //
 340 //
 341 //        Representation res = nxClient.get(pathParams, queryParams);
 342 //        String resStr = res.getText();
 343 //        verbose("getQueryModel:" + resStr);
 344 //
 345 //    }
 346 //
 347 //    private void getVocabulary() throws IOException {
 348 //        NuxeoRESTClient nxClient = getClient();
 349 //
 350 //        List<String> pathParams = new ArrayList<String>();
 351 //        Map<String, String> queryParams = new HashMap<String, String>();
 352 //        //get vocabulary
 353 //        pathParams = Arrays.asList("vocabulary", "continent_country");
 354 //        queryParams.put("lang", "en");
 355 //
 356 //        Representation res = nxClient.get(pathParams, queryParams);
 357 //        String resStr = res.getText();
 358 //        verbose("getVocabulary:" + resStr);
 359 //
 360 //    }
 361     private NuxeoRESTClient getClient() {
 362         NuxeoRESTClient nxClient = new NuxeoRESTClient("http://127.0.0.1:8080/nuxeo");
 363         nxClient.setAuthType(NuxeoRESTClient.AUTH_TYPE_BASIC);
 364         nxClient.setBasicAuthentication("Administrator", "Administrator");
 365         return nxClient;
 366     }
 367
 368     private void verbose(String msg) {
 369         System.out.println("PersonNuxeoResource: " + msg);
 370     }
 371 }