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

   1 /**\r
   2  * This document is a part of the source code and related artifacts\r
   3  * for CollectionSpace, an open source collections management system\r
   4  * for museums and related institutions:\r
   5  *\r
   6  * http://www.collectionspace.org\r
   7  * http://wiki.collectionspace.org\r
   8  *\r
   9  * Copyright (c)) 2009 Regents of the University of California\r
  10  *\r
  11  * Licensed under the Educational Community License (ECL), Version 2.0.\r
  12  * You may not use this file except in compliance with this License.\r
  13  *\r
  14  * You may obtain a copy of the ECL 2.0 License at\r
  15  * https://source.collectionspace.org/collection-space/LICENSE.txt\r
  16  *\r
  17  * Unless required by applicable law or agreed to in writing, software\r
  18  * distributed under the License is distributed on an "AS IS" BASIS,\r
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  20  * See the License for the specific language governing permissions and\r
  21  * limitations under the License.\r
  22  */\r
  23 \r
  24 package org.collectionspace.services.vocabulary.client.sample;\r
  25 \r
  26 import java.util.ArrayList;\r
  27 import java.util.Arrays;\r
  28 import java.util.HashMap;\r
  29 import java.util.List;\r
  30 \r
  31 import javax.ws.rs.core.MediaType;\r
  32 import javax.ws.rs.core.MultivaluedMap;\r
  33 import javax.ws.rs.core.Response;\r
  34 \r
  35 import org.apache.log4j.BasicConfigurator;\r
  36 import org.collectionspace.services.VocabularyItemJAXBSchema;\r
  37 import org.collectionspace.services.client.VocabularyClient;\r
  38 import org.collectionspace.services.client.VocabularyClientUtils;\r
  39 import org.collectionspace.services.client.test.ServiceRequestType;\r
  40 import org.collectionspace.services.vocabulary.VocabulariesCommon;\r
  41 import org.collectionspace.services.vocabulary.VocabulariesCommonList;\r
  42 import org.collectionspace.services.vocabulary.VocabularyitemsCommon;\r
  43 import org.collectionspace.services.vocabulary.VocabularyitemsCommonList;\r
  44 import org.jboss.resteasy.client.ClientResponse;\r
  45 import org.jboss.resteasy.plugins.providers.multipart.MultipartInput;\r
  46 import org.jboss.resteasy.plugins.providers.multipart.MultipartOutput;\r
  47 import org.jboss.resteasy.plugins.providers.multipart.InputPart;\r
  48 import org.jboss.resteasy.plugins.providers.multipart.OutputPart;\r
  49 import org.slf4j.Logger;\r
  50 import org.slf4j.LoggerFactory;\r
  51 \r
  52 /**\r
  53  * VocabularyServiceTest, carries out tests against a\r
  54  * deployed and running Vocabulary Service.\r
  55  *\r
  56  * $LastChangedRevision$\r
  57  * $LastChangedDate$\r
  58  */\r
  59 public class Sample {\r
  60     private static final Logger logger =\r
  61         LoggerFactory.getLogger(Sample.class);\r
  62 \r
  63     // Instance variables specific to this test.\r
  64     private VocabularyClient client = new VocabularyClient();\r
  65     final String SERVICE_PATH_COMPONENT = "vocabularies";\r
  66     final String ITEM_SERVICE_PATH_COMPONENT = "items";\r
  67 \r
  68 \r
  69     // ---------------------------------------------------------------\r
  70     // Create\r
  71     // ---------------------------------------------------------------\r
  72 \r
  73     public void createEnumeration(String vocabName, List<String> enumValues ) {\r
  74 \r
  75         // Expected status code: 201 Created\r
  76         int EXPECTED_STATUS_CODE = Response.Status.CREATED.getStatusCode();\r
  77         // Type of service request being tested\r
  78         ServiceRequestType REQUEST_TYPE = ServiceRequestType.CREATE;\r
  79 \r
  80         if(logger.isDebugEnabled()){\r
  81                 logger.debug("Import: Create vocabulary: \"" + vocabName +"\"");\r
  82         }\r
  83         String baseVocabRefName = VocabularyClientUtils.createVocabularyRefName(vocabName, false);\r
  84         String fullVocabRefName = VocabularyClientUtils.createVocabularyRefName(vocabName, true);\r
  85         MultipartOutput multipart = VocabularyClientUtils.createEnumerationInstance(\r
  86                         vocabName, fullVocabRefName, client.getCommonPartName());\r
  87         ClientResponse<Response> res = client.create(multipart);\r
  88 \r
  89         int statusCode = res.getStatus();\r
  90 \r
  91         if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
  92                 throw new RuntimeException("Could not create enumeration: \""+vocabName\r
  93                                 +"\" "+ VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
  94         }\r
  95         if(statusCode != EXPECTED_STATUS_CODE) {\r
  96                 throw new RuntimeException("Unexpected Status when creating enumeration: \""\r
  97                                 +vocabName +"\", Status:"+ statusCode);\r
  98         }\r
  99 \r
 100         // Store the ID returned from this create operation\r
 101         // for additional tests below.\r
 102         String newVocabId = VocabularyClientUtils.extractId(res);\r
 103         if(logger.isDebugEnabled()){\r
 104                 logger.debug("Import: Created vocabulary: \"" + vocabName +"\" ID:"\r
 105                                 +newVocabId );\r
 106         }\r
 107         for(String itemName : enumValues){\r
 108             HashMap<String, String> itemInfo = new HashMap<String, String>();\r
 109             itemInfo.put(VocabularyItemJAXBSchema.DISPLAY_NAME, itemName);\r
 110                 VocabularyClientUtils.createItemInVocabulary(newVocabId, \r
 111                                 baseVocabRefName, itemInfo, client);\r
 112         }\r
 113     }\r
 114     \r
 115    // ---------------------------------------------------------------\r
 116    // Read\r
 117    // ---------------------------------------------------------------\r
 118 \r
 119    private VocabulariesCommonList readVocabularies() {\r
 120 \r
 121         // Expected status code: 200 OK\r
 122         int EXPECTED_STATUS_CODE = Response.Status.OK.getStatusCode();\r
 123         // Type of service request being tested\r
 124         ServiceRequestType REQUEST_TYPE = ServiceRequestType.READ;\r
 125 \r
 126         // Submit the request to the service and store the response.\r
 127         ClientResponse<VocabulariesCommonList> res = client.readList();\r
 128         VocabulariesCommonList list = res.getEntity();\r
 129 \r
 130         int statusCode = res.getStatus();\r
 131         if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
 132                 throw new RuntimeException("Could not read list of vocabularies: "\r
 133                 + VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
 134         }\r
 135         if(statusCode != EXPECTED_STATUS_CODE) {\r
 136                 throw new RuntimeException("Unexpected Status when reading " +\r
 137                 "list of vocabularies, Status:"+ statusCode);\r
 138         }\r
 139 \r
 140         return list;\r
 141    }\r
 142 \r
 143     private List<String> readVocabularyIds(VocabulariesCommonList list) {\r
 144 \r
 145         List<String> ids = new ArrayList<String>();\r
 146         List<VocabulariesCommonList.VocabularyListItem> vocabularies =\r
 147             list.getVocabularyListItem();\r
 148         for (VocabulariesCommonList.VocabularyListItem vocabulary : vocabularies) {\r
 149             ids.add(vocabulary.getCsid());\r
 150         }\r
 151         return ids;\r
 152    }\r
 153     \r
 154    private VocabulariesCommon readVocabulary(String vocabId) {\r
 155 \r
 156         // Expected status code: 200 OK\r
 157         int EXPECTED_STATUS_CODE = Response.Status.OK.getStatusCode();\r
 158         // Type of service request being tested\r
 159         ServiceRequestType REQUEST_TYPE = ServiceRequestType.READ;\r
 160 \r
 161         // Submit the request to the service and store the response.\r
 162         VocabulariesCommon vocabulary = null;\r
 163         try {\r
 164             ClientResponse<MultipartInput> res = client.read(vocabId);\r
 165             int statusCode = res.getStatus();\r
 166             if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
 167                 throw new RuntimeException("Could not read vocabulary"\r
 168                     + VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
 169             }\r
 170             if(statusCode != EXPECTED_STATUS_CODE) {\r
 171                 throw new RuntimeException("Unexpected Status when reading " +\r
 172                     "vocabulary, Status:"+ statusCode);\r
 173             }\r
 174             MultipartInput input = (MultipartInput) res.getEntity();\r
 175             vocabulary = (VocabulariesCommon) extractPart(input,\r
 176                     client.getCommonPartName(), VocabulariesCommon.class);\r
 177         } catch (Exception e) {\r
 178             throw new RuntimeException("Could not read vocabulary: ", e);\r
 179         }\r
 180 \r
 181         return vocabulary;\r
 182     }\r
 183 \r
 184     private VocabularyitemsCommonList readItemsInVocab(String vocabId) {\r
 185 \r
 186         // Expected status code: 200 OK\r
 187         int EXPECTED_STATUS_CODE = Response.Status.OK.getStatusCode();\r
 188         // Type of service request being tested\r
 189         ServiceRequestType REQUEST_TYPE = ServiceRequestType.READ;\r
 190 \r
 191         // Submit the request to the service and store the response.\r
 192         ClientResponse<VocabularyitemsCommonList> res =\r
 193                 client.readItemList(vocabId);\r
 194         VocabularyitemsCommonList list = res.getEntity();\r
 195 \r
 196         int statusCode = res.getStatus();\r
 197 \r
 198         if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
 199                 throw new RuntimeException("Could not read items in vocabulary: "\r
 200                 + VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
 201         }\r
 202         if(statusCode != EXPECTED_STATUS_CODE) {\r
 203                 throw new RuntimeException("Unexpected Status when reading " +\r
 204                 "items in vocabulary, Status:"+ statusCode);\r
 205         }\r
 206 \r
 207         return list;\r
 208     }\r
 209 \r
 210     private List<String> readVocabularyItemIds(VocabularyitemsCommonList list) {\r
 211 \r
 212         List<String> ids = new ArrayList<String>();\r
 213         List<VocabularyitemsCommonList.VocabularyitemListItem> items =\r
 214             list.getVocabularyitemListItem();\r
 215         for (VocabularyitemsCommonList.VocabularyitemListItem item : items) {\r
 216             ids.add(item.getCsid());\r
 217         }\r
 218         return ids;\r
 219    }\r
 220 \r
 221     // ---------------------------------------------------------------\r
 222     // Delete\r
 223     // ---------------------------------------------------------------\r
 224 \r
 225     private void deleteVocabulary(String vcsid) {\r
 226          // Expected status code: 200 OK\r
 227         int EXPECTED_STATUS_CODE = Response.Status.OK.getStatusCode();\r
 228         // Type of service request being tested\r
 229         ServiceRequestType REQUEST_TYPE = ServiceRequestType.DELETE;\r
 230 \r
 231         ClientResponse<Response> res = client.delete(vcsid);\r
 232         int statusCode = res.getStatus();\r
 233 \r
 234         if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
 235                 throw new RuntimeException("Could not delete vocabulary: "\r
 236                 + VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
 237         }\r
 238         if(statusCode != EXPECTED_STATUS_CODE) {\r
 239                 throw new RuntimeException("Unexpected Status when deleting " +\r
 240                 "vocabulary, Status:"+ statusCode);\r
 241         }\r
 242     }\r
 243 \r
 244     private void deleteAllVocabularies() {\r
 245         List<String> ids = readVocabularyIds(readVocabularies());\r
 246         for (String id : ids) {\r
 247             deleteVocabulary(id);\r
 248         }\r
 249     }\r
 250 \r
 251         private void deleteVocabularyItem(String vcsid, String itemcsid) {\r
 252          // Expected status code: 200 OK\r
 253         int EXPECTED_STATUS_CODE = Response.Status.OK.getStatusCode();\r
 254         // Type of service request being tested\r
 255         ServiceRequestType REQUEST_TYPE = ServiceRequestType.DELETE;\r
 256 \r
 257         ClientResponse<Response> res = client.deleteItem(vcsid, itemcsid);\r
 258         int statusCode = res.getStatus();\r
 259 \r
 260         if(!REQUEST_TYPE.isValidStatusCode(statusCode)) {\r
 261                 throw new RuntimeException("Could not delete vocabulary item: "\r
 262                 + VocabularyClientUtils.invalidStatusCodeMessage(REQUEST_TYPE, statusCode));\r
 263         }\r
 264         if(statusCode != EXPECTED_STATUS_CODE) {\r
 265                 throw new RuntimeException("Unexpected Status when deleting " +\r
 266                 "vocabulary item, Status:"+ statusCode);\r
 267         }\r
 268     }\r
 269 \r
 270     private void deleteAllItemsForVocab(String vocabId) {\r
 271         List<String> itemIds = readVocabularyItemIds(readItemsInVocab(vocabId));\r
 272         for (String itemId : itemIds) {\r
 273             deleteVocabularyItem(vocabId, itemId);\r
 274         }\r
 275     }\r
 276 \r
 277     // ---------------------------------------------------------------\r
 278     // Utility methods used by tests above\r
 279     // ---------------------------------------------------------------\r
 280 \r
 281     // Retrieve individual fields of vocabulary records.\r
 282 \r
 283     private String displayAllVocabularies(VocabulariesCommonList list) {\r
 284         StringBuffer sb = new StringBuffer();\r
 285             List<VocabulariesCommonList.VocabularyListItem> vocabularies =\r
 286                     list.getVocabularyListItem();\r
 287             int i = 0;\r
 288         for (VocabulariesCommonList.VocabularyListItem vocabulary : vocabularies) {\r
 289             sb.append("vocabulary [" + i + "]" + "\n");\r
 290             sb.append(displayVocabularyDetails(vocabulary));\r
 291             i++;\r
 292         }\r
 293         return sb.toString();\r
 294     }\r
 295 \r
 296     private String displayVocabularyDetails(\r
 297         VocabulariesCommonList.VocabularyListItem vocabulary) {\r
 298             StringBuffer sb = new StringBuffer();\r
 299             sb.append("displayName=" + vocabulary.getDisplayName() + "\n");\r
 300             sb.append("vocabType=" + vocabulary.getVocabType() + "\n");\r
 301             // sb.append("csid=" + vocabulary.getCsid() + "\n");\r
 302             sb.append("URI=" + vocabulary.getUri() + "\n");\r
 303         return sb.toString();\r
 304     }\r
 305 \r
 306     // Retrieve individual fields of vocabulary item records.\r
 307 \r
 308     private String displayAllVocabularyItems(VocabularyitemsCommonList list) {\r
 309         StringBuffer sb = new StringBuffer();\r
 310         List<VocabularyitemsCommonList.VocabularyitemListItem> items =\r
 311                 list.getVocabularyitemListItem();\r
 312         int i = 0;\r
 313         for (VocabularyitemsCommonList.VocabularyitemListItem item : items) {\r
 314             sb.append("vocabulary item [" + i + "]" + "\n");\r
 315             sb.append(displayVocabularyItemDetails(item));\r
 316             i++;\r
 317         }\r
 318         return sb.toString();\r
 319     }\r
 320 \r
 321     private String displayVocabularyItemDetails(\r
 322         VocabularyitemsCommonList.VocabularyitemListItem item) {\r
 323             StringBuffer sb = new StringBuffer();\r
 324             sb.append("csid=" + item.getCsid() + "\n");\r
 325             sb.append("displayName=" + item.getDisplayName() + "\n");\r
 326             // sb.append("URI=" + item.getUri() + "\n");\r
 327         return sb.toString();\r
 328     }\r
 329 \r
 330     // TODO this should be moved to a common utils class\r
 331     private Object extractPart(MultipartInput input, String label,\r
 332         Class clazz) throws Exception {\r
 333         Object obj = null;\r
 334         for(InputPart part : input.getParts()){\r
 335             String partLabel = part.getHeaders().getFirst("label");\r
 336             if(label.equalsIgnoreCase(partLabel)){\r
 337                 String partStr = part.getBodyAsString();\r
 338                 if(logger.isDebugEnabled()){\r
 339                     logger.debug("extracted part str=\n" + partStr);\r
 340                 }\r
 341                 obj = part.getBody(clazz, null);\r
 342                 if(logger.isDebugEnabled()){\r
 343                     logger.debug("extracted part obj=\n", obj, clazz);\r
 344                 }\r
 345                 break;\r
 346             }\r
 347         }\r
 348         return obj;\r
 349     }\r
 350 \r
 351         public static void main(String[] args) {\r
 352 \r
 353         // Configure logging.\r
 354                 BasicConfigurator.configure();\r
 355 \r
 356         logger.info("VocabularyBaseImport starting...");\r
 357 \r
 358                 Sample vbi = new Sample();\r
 359         VocabulariesCommonList vocabularies;\r
 360         List<String> vocabIds;\r
 361         String details = "";\r
 362 \r
 363         // Optionally delete all vocabularies and vocabulary items.\r
 364 \r
 365         boolean ENABLE_DELETE_ALL = false;\r
 366         if (ENABLE_DELETE_ALL) {\r
 367 \r
 368             logger.info("Deleting all vocabulary items and vocabularies ...");\r
 369 \r
 370             // For each vocabulary ...\r
 371             vocabularies = vbi.readVocabularies();\r
 372             vocabIds = vbi.readVocabularyIds(vocabularies);\r
 373             for (String vocabId : vocabIds) {\r
 374                 logger.info("Deleting all vocabulary items for vocabulary ...");\r
 375                 vbi.deleteAllItemsForVocab(vocabId);\r
 376                 logger.info("Deleting vocabulary ...");\r
 377                 vbi.deleteVocabulary(vocabId);\r
 378             }\r
 379 \r
 380             logger.info("Reading vocabularies after deletion ...");\r
 381             vocabularies = vbi.readVocabularies();\r
 382             details = vbi.displayAllVocabularies(vocabularies);\r
 383             logger.info(details);\r
 384 \r
 385             logger.info("Reading items in each vocabulary after deletion ...");\r
 386             vocabIds = vbi.readVocabularyIds(vocabularies);\r
 387             for (String vocabId : vocabIds) {\r
 388                 VocabularyitemsCommonList items = vbi.readItemsInVocab(vocabId);\r
 389                 details = vbi.displayAllVocabularyItems(items);\r
 390                 logger.info(details);\r
 391             }\r
 392 \r
 393         }\r
 394 \r
 395         // Create new vocabularies, each populated with vocabulary items.\r
 396 \r
 397                 final String acquisitionMethodsVocabName = "Acquisition Methods";\r
 398                 final String entryMethodsVocabName = "Entry Methods";\r
 399                 final String entryReasonsVocabName = "Entry Reasons";\r
 400                 final String responsibleDeptsVocabName = "Responsible Departments";\r
 401 \r
 402                 List<String> acquisitionMethodsEnumValues = \r
 403                         Arrays.asList("Gift","Purchase","Exchange","Transfer","Treasure");\r
 404                 List<String> entryMethodsEnumValues = \r
 405                         Arrays.asList("In person","Post","Found on doorstep");\r
 406                 List<String> entryReasonsEnumValues = \r
 407                         Arrays.asList("Enquiry","Commission","Loan");\r
 408                 List<String> respDeptNamesEnumValues = \r
 409                         Arrays.asList("Antiquities","Architecture and Design","Decorative Arts",\r
 410                                                                         "Ethnography","Herpetology","Media and Performance Art",\r
 411                                                                         "Paintings and Sculpture","Paleobotany","Photographs",\r
 412                                                                         "Prints and Drawings");\r
 413         \r
 414                 vbi.createEnumeration(acquisitionMethodsVocabName, acquisitionMethodsEnumValues);\r
 415                 vbi.createEnumeration(entryMethodsVocabName, entryMethodsEnumValues);\r
 416                 vbi.createEnumeration(entryReasonsVocabName, entryReasonsEnumValues);\r
 417                 vbi.createEnumeration(responsibleDeptsVocabName, respDeptNamesEnumValues);\r
 418 \r
 419                 logger.info("VocabularyBaseImport complete.");\r
 420 \r
 421         logger.info("Reading vocabularies and items ...");\r
 422         // Get a list of vocabularies.\r
 423         vocabularies = vbi.readVocabularies();\r
 424         // For each vocabulary ...\r
 425         for (VocabulariesCommonList.VocabularyListItem\r
 426             vocabulary : vocabularies.getVocabularyListItem()) {\r
 427             // Get its display name.\r
 428             logger.info(vocabulary.getDisplayName());\r
 429             // Get a list of the vocabulary items in this vocabulary.\r
 430             VocabularyitemsCommonList items =\r
 431                 vbi.readItemsInVocab(vocabulary.getCsid());\r
 432             // For each vocabulary item ...\r
 433             for (VocabularyitemsCommonList.VocabularyitemListItem\r
 434                 item : items.getVocabularyitemListItem()) {\r
 435                 // Get its display name.\r
 436                 logger.info(" " + item.getDisplayName());\r
 437             }\r
 438         }\r
 439 \r
 440         // Sample alternate methods of reading all vocabularies and\r
 441         // vocabulary items separately.\r
 442         boolean RUN_ADDITIONAL_SAMPLES = false;\r
 443         if (RUN_ADDITIONAL_SAMPLES) {\r
 444 \r
 445             logger.info("Reading all vocabularies ...");\r
 446             details = vbi.displayAllVocabularies(vocabularies);\r
 447             logger.info(details);\r
 448 \r
 449             logger.info("Reading all vocabulary items ...");\r
 450             vocabIds = vbi.readVocabularyIds(vocabularies);\r
 451             for (String vocabId : vocabIds) {\r
 452                 VocabularyitemsCommonList items = vbi.readItemsInVocab(vocabId);\r
 453                 details = vbi.displayAllVocabularyItems(items);\r
 454                 logger.info(details);\r
 455             }\r
 456 \r
 457         }\r
 458 \r
 459         }\r
 460 \r
 461 }\r