1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.ole.web;
17
18 import gov.loc.repository.bagit.utilities.FormatHelper;
19 import org.apache.commons.fileupload.FileItem;
20 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
21 import org.apache.commons.fileupload.servlet.ServletFileUpload;
22 import org.apache.commons.io.FileUtils;
23 import org.apache.commons.lang.StringUtils;
24 import org.kuali.ole.DocumentUniqueIDPrefix;
25 import org.kuali.ole.RepositoryManager;
26 import org.kuali.ole.docstore.OleDocStoreException;
27 import org.kuali.ole.docstore.discovery.service.OleDocstoreDataRetrieveService;
28 import org.kuali.ole.docstore.discovery.service.OleDocstoreDumpService;
29 import org.kuali.ole.docstore.discovery.service.ServiceLocator;
30 import org.kuali.ole.docstore.model.enums.DocCategory;
31 import org.kuali.ole.docstore.model.enums.DocFormat;
32 import org.kuali.ole.docstore.model.enums.DocType;
33 import org.kuali.ole.docstore.model.xmlpojo.ingest.*;
34 import org.kuali.ole.docstore.model.xstream.ingest.RequestHandler;
35 import org.kuali.ole.docstore.model.xstream.ingest.ResponseHandler;
36 import org.kuali.ole.docstore.process.ProcessParameters;
37 import org.kuali.ole.docstore.service.BeanLocator;
38 import org.kuali.ole.docstore.service.IngestNIndexHandlerService;
39 import org.kuali.ole.pojo.OleException;
40 import org.kuali.ole.repository.DeleteManager;
41 import org.kuali.ole.repository.DocumentStoreManager;
42 import org.kuali.ole.repository.NodeHandler;
43 import org.kuali.ole.service.OleUuidCheckWebService;
44 import org.kuali.ole.service.OleWebServiceProvider;
45 import org.kuali.ole.service.impl.OleWebServiceProviderImpl;
46 import org.kuali.ole.utility.CompressUtils;
47 import org.kuali.rice.core.api.config.property.ConfigContext;
48 import org.slf4j.Logger;
49 import org.slf4j.LoggerFactory;
50 import javax.jcr.Node;
51 import javax.jcr.RepositoryException;
52 import javax.jcr.Session;
53 import javax.servlet.ServletException;
54 import javax.servlet.ServletOutputStream;
55 import javax.servlet.http.HttpServlet;
56 import javax.servlet.http.HttpServletRequest;
57 import javax.servlet.http.HttpServletResponse;
58 import java.io.*;
59 import java.util.*;
60
61 public class DocumentServlet
62 extends HttpServlet {
63
64 private static final long serialVersionUID = -3717561557966540651L;
65 private static final Logger LOG = LoggerFactory
66 .getLogger(DocumentServlet.class);
67 private CompressUtils compressUtils = new CompressUtils();
68
69
70
71 private DocumentStoreManager documentStoreManager = BeanLocator.getDocumentStoreManager();
72
73
74
75 private IngestNIndexHandlerService ingestNIndexHandlerService = BeanLocator
76 .getIngestNIndexHandlerService();
77
78
79
80
81
82 public DocumentServlet() {
83 super();
84 }
85
86
87
88
89 protected void doPost(HttpServletRequest request, HttpServletResponse response)
90 throws ServletException, IOException {
91 String docAction = null;
92 boolean isMultipart = ServletFileUpload.isMultipartContent(request);
93
94
95
96
97
98
99
100 boolean isUpdateEnabled = ProcessParameters.IS_UPDATE_ENABLED;
101 LOG.debug("updateEnabled = " + isUpdateEnabled);
102 if (isMultipart) {
103 LOG.debug("Processing in Multipart : START");
104 try {
105 ArrayList<File> files = extractBagFilesFromRequest(request, response);
106 RequestHandler rh = new RequestHandler();
107 Request dsRequest = null;
108 for (File file : files)
109 if (file.getName().equalsIgnoreCase("request.xml")) {
110 String rqStr = FileUtils.readFileToString(file);
111 dsRequest = rh.toObject(rqStr);
112 for (RequestDocument rd : dsRequest.getRequestDocuments())
113 if (rd.getDocumentName() != null)
114 for (File fl : files)
115 if (fl.getName().equals(rd.getDocumentName())) {
116 rd.setDocumentName(fl.getAbsolutePath());
117 break;
118 }
119 if ("ingest".equalsIgnoreCase(dsRequest.getOperation())) {
120 if (isUpdateEnabled) {
121 Response docStoreResponse = ingestNIndexHandlerService.ingestNIndexRequestDocuments(dsRequest);
122 sendResponseBag(response, docStoreResponse);
123 } else {
124 sendUnavailableResponseString(response);
125 }
126 } else if ("checkOut".equalsIgnoreCase(dsRequest.getOperation())) {
127 File output = documentStoreManager.checkOutMultiPart(dsRequest);
128 sendResponseAsFile(response, output);
129 output.delete();
130 } else if ("checkIn".equalsIgnoreCase(dsRequest.getOperation())) {
131 if (isUpdateEnabled) {
132 Response dsResponse = new Response();
133 checkIn(dsRequest, dsResponse);
134 sendResponseBag(response, dsResponse);
135 } else {
136 sendUnavailableResponseString(response);
137 }
138 } else if ("delete".equalsIgnoreCase(dsRequest.getOperation())) {
139 if (isUpdateEnabled) {
140 Response dsResponse = processDeleteRequest(dsRequest);
141 sendResponseBag(response, dsResponse);
142 } else {
143 sendUnavailableResponseString(response);
144 }
145 } else {
146 response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid Request Operation: " + dsRequest.getOperation());
147 }
148 break;
149 }
150 files.add(files.get(files.size() - 1).getParentFile());
151 compressUtils.deleteFiles(files);
152 LOG.debug("Got Files in here : " + files);
153 } catch (Exception e) {
154 LOG.error("Invalid Request : " + e.getMessage(), e);
155 response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid Request : " + e.getMessage());
156 }
157 LOG.info("Processing in Multipart : END");
158 } else {
159 LOG.debug("isMultipart-->" + isMultipart);
160 docAction = request.getParameter("docAction");
161 LOG.debug("docAction-->" + docAction);
162 String uuid = request.getParameter("uuid");
163 String docFormat = request.getParameter("docFormat");
164 LOG.debug("docFormat=" + docFormat);
165 if (null != uuid && uuid.length() > 0 && (null == docAction || "".equalsIgnoreCase(docAction))) {
166 checkOut(request, response);
167 } else if ("checkOut".equalsIgnoreCase(docAction)) {
168 checkOut(request, response);
169 } else if ("checkIn".equalsIgnoreCase(docAction)) {
170 if (isUpdateEnabled) {
171 Request dsRequest = new RequestHandler().toObject(request.getParameter("stringContent"));
172 String checkInResponse = checkIn(dsRequest, null);
173 response.setContentType("text/xml");
174 response.getWriter().println(checkInResponse);
175 } else {
176 sendUnavailableResponseString(response);
177 }
178 } else if ("link".equalsIgnoreCase(docAction)) {
179 if (isUpdateEnabled) {
180 link(request, response);
181 } else {
182 sendUnavailableResponseString(response);
183 }
184 } else if ("ingestContent".equalsIgnoreCase(docAction)) {
185 if (isUpdateEnabled) {
186 ingestStringContent(request, response);
187 } else {
188 sendUnavailableResponseString(response);
189 }
190 } else if (docAction.contains("delete")) {
191 Response dsResponse = null;
192 if (isUpdateEnabled) {
193 Request dsRequest = null;
194 String identifierType = request.getParameter("identifierType");
195 LOG.info("identifierType->" + identifierType);
196 String ids = request.getParameter("requestContent");
197 if ((ids != null) && (!StringUtils.isBlank(ids))) {
198 LOG.info("requestContent-->" + ids);
199 dsRequest = buildRequest(ids, identifierType, docAction);
200
201 try {
202 dsRequest = buildRequestForDelete(ids, identifierType, docAction);
203 dsResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(dsRequest);
204 } catch (Exception e) {
205 LOG.error("", e);
206 Response response1 = new Response();
207 response1.setMessage(e.getMessage());
208 response1.setOperation("delete");
209 response1.setStatus("Failed");
210 response.setContentType("text/xml");
211 response.getWriter().println(new ResponseHandler().toXML(response1));
212 }
213
214 }
215
216
217 response.getWriter().println(new ResponseHandler().toXML(dsResponse));
218 } else {
219 sendUnavailableResponseString(response);
220 }
221 } else if (docAction.contains("cleanRepository")) {
222 if (isUpdateEnabled) {
223 cleanRepository(request, response);
224 } else {
225 sendUnavailableResponseString(response);
226 }
227 } else if (docAction.contains("transferInstances")) {
228 LOG.debug("In if transferInstances");
229 String operation = request.getParameter("docAction");
230 String requestXML = request.getParameter("stringContent");
231 LOG.debug("In if transferInstances requestXML " + requestXML);
232 Request dsRequest = new RequestHandler().toObject(requestXML);
233 try {
234 BeanLocator.getDocstoreFactory().getDocumentService().process(dsRequest);
235 } catch (Exception e) {
236 LOG.error(e.getMessage(), e);
237 }
238 } else if (docAction.contains("transferItems")) {
239 LOG.debug("In if transferItems");
240 String operation = request.getParameter("docAction");
241 String requestXML = request.getParameter("stringContent");
242 LOG.debug("In if transferItems requestXML " + requestXML);
243 Request dsRequest = new RequestHandler().toObject(requestXML);
244 try {
245 Response transferItemResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(dsRequest);
246 LOG.debug("Document Servlet transferItemResponse " + new ResponseHandler().toXML(transferItemResponse));
247 response.getWriter().println(new ResponseHandler().toXML(transferItemResponse));
248
249 } catch (Exception e) {
250 LOG.error(e.getMessage(), e);
251 }
252 } else if (docAction.equals("instanceDetails")) {
253 String bibUUIDs = request.getParameter("bibIds");
254 String format = request.getParameter("format");
255 List<String> bibUUIDList = getBibIdList(bibUUIDs);
256 OleDocstoreDataRetrieveService oleDocstoreDataRetrieveService = new OleDocstoreDataRetrieveService();
257 String instanceResponse = oleDocstoreDataRetrieveService.getInstanceDetails(bibUUIDList, format);
258
259 if (instanceResponse == null || instanceResponse.isEmpty()) {
260 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
261 if (bibUUIDList.size() == 1)
262 response.getWriter().println("<html><body><b>No record found for the given id </b></body></html>" + bibUUIDList.get(0));
263 else if (bibUUIDList.size() > 1)
264 response.getWriter().println("<html><body><b>No record found for the given id's </b></body></html>");
265 } else {
266 if (null == format) {
267 response.setContentType("text/xml");
268 } else if (format.equalsIgnoreCase("xml")) {
269 response.setContentType("text/xml");
270 } else if (format.equalsIgnoreCase("json")) {
271 response.setContentType("application/json");
272 }
273 response.getWriter().println(instanceResponse);
274 }
275 } else if (docAction.equals("docstoreDBDump")) {
276 String requestXML = request.getParameter("requestContent");
277 OleDocstoreDumpService oleDocstoreDumpService = new OleDocstoreDumpService();
278 try {
279 String instanceResponse = oleDocstoreDumpService.exportDocstoreData(requestXML);
280 response.setContentType("text/xml");
281 response.getWriter().println(instanceResponse);
282 } catch (Exception e) {
283 LOG.error(e.getMessage(), e);
284 }
285
286 } else {
287 response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid docAction.");
288 }
289 }
290
291
292 }
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307 private Request buildRequestForDelete(String ids, String identifierType, String operation) throws Exception {
308 String[] Id = ids.split(",");
309 List<String> idList = new ArrayList<String>();
310 List<String> uuidList = new ArrayList<String>();
311 Request request = null;
312 for (int i = 0; i < Id.length; i++) {
313 idList.add(Id[i]);
314 LOG.debug("adding -->" + idList);
315 }
316 if ((!StringUtils.isBlank(identifierType)) && (identifierType.equalsIgnoreCase("SCN") || identifierType
317 .equalsIgnoreCase("ISBN"))) {
318 uuidList = ServiceLocator.getQueryService().getUUIDList(idList, identifierType);
319 } else {
320 uuidList = idList;
321 }
322 request = identifyDeleteableDocuments(uuidList, operation);
323 return request;
324 }
325
326
327
328
329
330
331
332
333
334 public Request identifyDeleteableDocuments(List<String> uuidsList, String operation) throws Exception {
335 Request dsRequest = new Request();
336 dsRequest.setUser("ole-khuntley");
337 dsRequest.setOperation(operation);
338
339 List<RequestDocument> requestDocuments = null;
340 Response response = null;
341 String uuidsNotInOle = null;
342 String serviceURL = null;
343 StringBuilder uuidsSB = null;
344
345 uuidsSB = new StringBuilder();
346 for (String uuid : uuidsList) {
347 uuidsSB.append(uuid).append(",");
348 }
349 serviceURL = ConfigContext.getCurrentContextConfig().getProperty("uuidCheckServiceURL");
350 LOG.info(" uuidCheckServiceURL --------> " + serviceURL);
351
352
353 OleWebServiceProvider oleWebServiceProvider = new OleWebServiceProviderImpl();
354
355 OleUuidCheckWebService oleUuidCheckWebService = (OleUuidCheckWebService) oleWebServiceProvider
356 .getService("org.kuali.ole.service.OleUuidCheckWebService", "oleUuidCheckWebService", serviceURL);
357
358 uuidsNotInOle = oleUuidCheckWebService.checkUuidExsistence(uuidsSB.substring(0, uuidsSB.length() - 1));
359 LOG.info("response uuids from OLE " + uuidsNotInOle);
360
361 if ((uuidsNotInOle != null) && (uuidsNotInOle.length() > 0)) {
362 String[] uuids = StringUtils.split(uuidsNotInOle, ",");
363 requestDocuments = new ArrayList<RequestDocument>();
364 for (String id : uuids) {
365 RequestDocument requestDocument = new RequestDocument();
366 requestDocument.setCategory(DocCategory.WORK.getCode());
367 requestDocument.setFormat(DocFormat.MARC.getCode());
368 requestDocument.setType(DocType.BIB.getDescription());
369 requestDocument.setUuid(id);
370 requestDocument.setOperation(dsRequest.getOperation());
371 requestDocuments.add(requestDocument);
372 }
373 dsRequest.setRequestDocuments(requestDocuments);
374 }
375 return dsRequest;
376 }
377
378
379
380
381
382
383
384 private Request buildRequest(String ids, String identifierType, String operation) {
385 String[] Id = ids.split(",");
386 List<String> idList = new ArrayList<String>();
387 List<String> uuidList = new ArrayList<String>();
388 Request request = new Request();
389 for (int i = 0; i < Id.length; i++) {
390 idList.add(Id[i]);
391 LOG.debug("adding -->" + idList);
392 }
393 if ((!StringUtils.isBlank(identifierType)) && (identifierType.equalsIgnoreCase("SCN") || identifierType.equalsIgnoreCase("ISBN"))) {
394 uuidList = ServiceLocator.getQueryService().getUUIDList(idList, identifierType);
395 } else {
396 uuidList = idList;
397 }
398
399 request = buildRequest(uuidList, operation);
400 return request;
401 }
402
403
404
405
406
407
408
409 private Request buildRequest(List<String> uuidList, String operation) {
410 Request request = new Request();
411 List<RequestDocument> requestDocumentList = new ArrayList<RequestDocument>();
412 request.setUser("ole-khuntley");
413 request.setOperation(operation);
414 for (int i = 0; i < uuidList.size(); i++) {
415 RequestDocument requestDocument = new RequestDocument();
416
417 requestDocument.setUuid(uuidList.get(i));
418 requestDocumentList.add(requestDocument);
419 }
420 request.setRequestDocuments(requestDocumentList);
421 return request;
422 }
423
424 @Override
425 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
426
427
428 doPost(request, response);
429
430 }
431
432 private void cleanRepository(HttpServletRequest request, HttpServletResponse response) {
433 DeleteManager deleteManager = new DeleteManager();
434 try {
435
436 deleteManager.cleanUpDocStoreData();
437 } catch (Exception e) {
438 LOG.error("Error while cleaning Repository process", e);
439 }
440
441 }
442
443 protected void checkOut(HttpServletRequest request, HttpServletResponse response) throws IOException {
444 String uuid = request.getParameter("uuid");
445 LOG.info("check out request uuid-->" + uuid);
446 String action = request.getParameter("docAction");
447 String requestType = request.getParameter("dataType");
448 String docFormat = request.getParameter("docFormat");
449 LOG.debug("docFormat-->" + docFormat);
450 String userId = getUserId(request);
451 PrintWriter out = null;
452 String checkoutResponse = null;
453 String setContentType = null;
454 Request req = null;
455 try {
456 if (!DocumentUniqueIDPrefix.hasPrefix(uuid)) {
457 uuid = "wbm-" + uuid;
458 }
459 if (DocumentUniqueIDPrefix.hasPrefix(uuid)) {
460 Map<String, String> categoryTypeFormat = DocumentUniqueIDPrefix.getCategoryTypeFormat(uuid);
461 String category = categoryTypeFormat.get("category");
462 String type = categoryTypeFormat.get("type");
463 String format = categoryTypeFormat.get("format");
464 req = new Request();
465 RequestDocument requestDocument = buildRequestDocument(category, type, format, uuid);
466 List<RequestDocument> requestDocuments = new ArrayList<RequestDocument>();
467 requestDocuments.add(requestDocument);
468 req.setOperation("checkOut");
469 req.setUser("checkOutUser");
470 req.setRequestDocuments(requestDocuments);
471 }
472 if (req == null) {
473 req = getRequest(uuid, userId, action, docFormat);
474 }
475 if (docFormat == null || "".equalsIgnoreCase(docFormat)) {
476 if (req != null && req.getRequestDocuments() != null && req.getRequestDocuments().size() > 0) {
477 docFormat = req.getRequestDocuments().get(0).getFormat();
478 }
479 }
480
481 if (docFormat != null && docFormat.equalsIgnoreCase(DocFormat.PDF.getCode())) {
482 setContentType = "application/pdf";
483 checkoutBinary(response, setContentType, req);
484
485 } else if (docFormat != null && docFormat.equalsIgnoreCase(DocFormat.DOC.getCode())) {
486 setContentType = "application/msword";
487 checkoutBinary(response, setContentType, req);
488
489 } else {
490
491 response.setContentType("text/xml");
492 response.setCharacterEncoding("UTF-8");
493 out = response.getWriter();
494
495 Response dsResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(req);
496 if (dsResponse != null) {
497 for (ResponseDocument responseDocument : dsResponse.getDocuments()) {
498 if (responseDocument != null && responseDocument.getContent() != null) {
499 checkoutResponse = responseDocument.getContent().getContent();
500 }
501 checkoutResponse = checkoutResponse + "\n";
502 }
503 }
504
505
506
507
508
509
510
511 out.println(new ResponseHandler().toXML(dsResponse));
512 }
513 } catch (Exception ex) {
514 LOG.error("Error while performing checkout process", ex);
515 checkoutResponse = printResponse(null, "Check-out", "Failure", "Checkout failed",
516 "Error while performing checkout process");
517 out.println(checkoutResponse);
518 }
519
520 }
521
522 private void checkoutBinary(HttpServletResponse response, String uuid, String action, String docFormat,
523 String userId, String checkOutResponse, String setContentType) throws IOException {
524 HashMap<String, String> checkOutMap = null;
525 checkOutMap = new HashMap<String, String>();
526 checkOutMap.put("uuid", uuid);
527 checkOutResponse = documentStoreManager.checkOutBinary(uuid, userId, action, docFormat);
528 LOG.info("checkOutResponse-->" + checkOutResponse);
529 File file = new File(checkOutResponse);
530 String fileName = checkOutResponse
531 .substring(checkOutResponse.lastIndexOf(File.separator), checkOutResponse.length());
532 LOG.info("fileName-->" + fileName);
533 response.setContentType(setContentType);
534 response.addHeader("Content-Disposition", "inline; filename=" + fileName);
535 response.setHeader("Pragma", "No-cache");
536 FileInputStream fileInputStream = new FileInputStream(file);
537 OutputStream responseOutputStream = response.getOutputStream();
538 int bytes;
539 while ((bytes = fileInputStream.read()) != -1) {
540 responseOutputStream.write(bytes);
541 }
542 }
543
544 private Request getRequest(String uuid, String userId, String action, String docFormat)
545 throws OleDocStoreException, OleException {
546
547 Node nodeByUUID = null;
548 Session session = null;
549 Request req = new Request();
550 if (action == null || "".equalsIgnoreCase(action)) {
551 action = "checkOut";
552 }
553 if (userId == null || "".equalsIgnoreCase(action)) {
554 userId = "checkOutUser";
555 }
556 try {
557 session = RepositoryManager.getRepositoryManager().getSession(userId, action);
558 } catch (Exception e) {
559 LOG.error("Excaption while creating a session" + e.getMessage(), e);
560 throw new OleDocStoreException(e.getMessage(), e);
561 }
562 String cat = null;
563 String type = null;
564 String format = null;
565 try {
566 NodeHandler nodeHandler = new NodeHandler();
567 nodeByUUID = nodeHandler.getNodeByUUID(session, uuid);
568 String nodePath = nodeByUUID.getPath();
569 String[] splitLine = nodePath.split("/");
570
571 if (splitLine != null && splitLine.length >= 4) {
572 cat = splitLine[1];
573 type = splitLine[2];
574 format = splitLine[3];
575 } else {
576 throw new OleDocStoreException(" This is not a valid UUID ");
577 }
578 if (docFormat == null || "".equalsIgnoreCase(docFormat)) {
579 docFormat = format;
580 }
581 req.setUser(userId);
582 req.setOperation(action);
583 List<RequestDocument> reqDocList = new ArrayList<RequestDocument>();
584 RequestDocument reqDoc = buildRequestDocument(cat, type, format, uuid);
585 reqDocList.add(reqDoc);
586 req.setRequestDocuments(reqDocList);
587 } catch (Exception e) {
588 LOG.info(e.getMessage(), e);
589 throw new OleDocStoreException(e);
590 } finally {
591 session.logout();
592 }
593 return req;
594 }
595
596 private RequestDocument buildRequestDocument(String cat, String type, String format, String uuid) {
597 RequestDocument reqDoc = new RequestDocument();
598 reqDoc.setCategory(cat);
599 reqDoc.setType(type);
600 reqDoc.setFormat(format);
601 reqDoc.setUuid(uuid);
602 return reqDoc;
603
604 }
605
606 private void checkoutBinary(HttpServletResponse response, String setContentType, Request req)
607 throws IOException, OleDocStoreException, RepositoryException, OleException {
608 Response dsResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(req);
609
610 if (dsResponse != null) {
611 for (ResponseDocument responseDocument : dsResponse.getDocuments()) {
612 if (responseDocument != null && responseDocument.getContent() != null) {
613 String responseContent = responseDocument.getContent().getContent();
614
615 if (responseContent != null) {
616 LOG.info("checkOutResponse-->" + responseContent);
617 File file = new File(responseContent);
618 String fileName = responseContent
619 .substring(responseContent.lastIndexOf(File.separator), responseContent.length());
620 LOG.info("fileName-->" + fileName);
621 response.setContentType(setContentType);
622 response.addHeader("Content-Disposition", "inline; filename=" + fileName);
623 response.setHeader("Pragma", "No-cache");
624 FileInputStream fileInputStream = new FileInputStream(file);
625 OutputStream responseOutputStream = response.getOutputStream();
626 int bytes;
627 while ((bytes = fileInputStream.read()) != -1) {
628 responseOutputStream.write(bytes);
629 }
630 }
631 }
632 }
633 }
634 }
635
636 protected String checkIn(Request dsRequest, Response dsResponse) {
637 if (dsResponse == null) {
638 dsResponse = new Response();
639 }
640 String checkInResponse = null;
641 List<String> latestVersion = new ArrayList<String>();
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662 try {
663 dsResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(dsRequest);
664 checkInResponse = (new ResponseHandler().toXML(dsResponse));
665 } catch (Exception ex) {
666 Response response = ingestNIndexHandlerService.buildResponse(dsRequest);
667 String failOverMessage = ex.getMessage();
668 failOverMessage = failOverMessage.replace("javax.jcr.ItemNotFoundException", "Document Not Found for uuid");
669 checkInResponse = printResponse(response, dsRequest.getOperation(), "Failure", "Checkin failed",
670 failOverMessage);
671 }
672 return checkInResponse;
673 }
674
675 private String printResponse(Response response, String operation, String status, String message,
676 String statusMessage) {
677 String resp = null;
678 if (response == null) {
679 response = new Response();
680 }
681 response.setOperation(operation);
682 response.setStatus(status);
683 response.setMessage(message);
684 response.setStatusMessage(statusMessage);
685 resp = new ResponseHandler().toXML(response);
686 return resp;
687 }
688
689 protected void link(HttpServletRequest request, HttpServletResponse response) {
690 String uuidFile1 = request.getParameter("uuid1");
691 String uuidFile2 = request.getParameter("uuid2");
692 String userId = getUserId(request);
693 String action = request.getParameter("docAction");
694 String result = null;
695 PrintWriter out = null;
696 HashMap<String, String> linkMap = null;
697 String linkResponse = null;
698 try {
699 response.setContentType("text/xml");
700 out = response.getWriter();
701 linkMap = new HashMap<String, String>();
702 linkMap.put("uuid1", uuidFile1);
703 linkMap.put("uuid2", uuidFile2);
704 documentStoreManager.addReference(uuidFile1, uuidFile2, userId, action);
705
706 result = uuidFile2 + " has been successfully linked to " + uuidFile1;
707
708 linkResponse = printResponse(null, "Link", "Success", "Linked successfully", result);
709 out.println(linkResponse);
710 } catch (Exception e) {
711 LOG.error("addReference( " + uuidFile1 + ", " + uuidFile2 + ") failed", e);
712 result = "addReference( " + uuidFile1 + ", " + uuidFile2 + ") failed";
713
714 linkResponse = printResponse(null, "Link", "Failure", "Linking failed", result);
715 out.println(linkResponse);
716 }
717 }
718
719
720 protected void ingestStringContent(HttpServletRequest request, HttpServletResponse response) throws IOException {
721 String stringContent = request.getParameter("stringContent");
722 response.setContentType("text/xml");
723 PrintWriter out = response.getWriter();
724 RequestHandler requestHandler = new RequestHandler();
725 Response dsResponse = new Response();
726
727
728 try {
729 Request dsRequest = requestHandler.toObject(stringContent);
730
731
732 dsResponse = BeanLocator.getDocstoreFactory().getDocumentService().process(dsRequest);
733 out.println(new ResponseHandler().toXML(dsResponse));
734 } catch (Exception e) {
735 dsResponse.setStatus("Failure");
736 dsResponse.setMessage("Ingest string content failed.");
737 dsResponse.setStatusMessage("Ingest string content failed due to invalid input file." + e.getMessage());
738 out.println(new ResponseHandler().toXML(dsResponse));
739 LOG.error("Ingest string content failed", e);
740
741
742 } finally {
743 out.close();
744 }
745 }
746
747
748
749
750
751
752
753
754
755
756
757 protected Response processDeleteRequest(Request dsRequest) throws IOException {
758 DeleteManager deleteManager = new DeleteManager();
759 List<RequestDocument> requestDocuments = new ArrayList<RequestDocument>();
760 requestDocuments = dsRequest.getRequestDocuments();
761 Response response = null;
762 String uuidsNotInOle = null;
763 String serviceURL = null;
764 StringBuilder uuidsSB = null;
765 try {
766 if ((requestDocuments == null) || (requestDocuments.size() == 0)) {
767 response = deleteManager.getResponse(dsRequest, requestDocuments, "Failed",
768 "Deletion failed: No documents specified for deletion.");
769 } else {
770
771 uuidsSB = new StringBuilder();
772 for (RequestDocument requestDocument : requestDocuments) {
773
774 uuidsSB.append(requestDocument.getUuid()).append(",");
775 }
776 serviceURL = ConfigContext.getCurrentContextConfig().getProperty("uuidCheckServiceURL");
777 LOG.info(" uuidCheckServiceURL --------> " + serviceURL);
778 boolean verifiedWithOLE = true;
779 try {
780
781 OleWebServiceProvider oleWebServiceProvider = new OleWebServiceProviderImpl();
782
783 OleUuidCheckWebService oleUuidCheckWebService = (OleUuidCheckWebService) oleWebServiceProvider
784 .getService("org.kuali.ole.service.OleUuidCheckWebService", "oleUuidCheckWebService",
785 serviceURL);
786
787 uuidsNotInOle = oleUuidCheckWebService
788 .checkUuidExsistence(uuidsSB.substring(0, uuidsSB.length() - 1));
789 } catch (Exception e) {
790 verifiedWithOLE = false;
791 LOG.error("Check uuid call to OLE failed:", e);
792 response = deleteManager.getResponse(dsRequest, requestDocuments, "Failure",
793 "Deletion failed: Exception while connecting to OLE service to verify the existence of documents."
794 + e.getMessage());
795
796 }
797 if (verifiedWithOLE) {
798 LOG.info("response uuids from OLE " + uuidsNotInOle);
799
800 if ((uuidsNotInOle != null) && (uuidsNotInOle.length() > 0)) {
801 String[] uuids = StringUtils.split(uuidsNotInOle, ",");
802 requestDocuments = new ArrayList<RequestDocument>();
803 for (String id : uuids) {
804 RequestDocument requestDocument = new RequestDocument();
805
806 requestDocument.setUuid(id);
807 requestDocuments.add(requestDocument);
808 }
809 dsRequest.setRequestDocuments(requestDocuments);
810 try {
811 response = deleteManager.deleteDocs(dsRequest);
812 } catch (Exception e) {
813 response = deleteManager.getResponse(dsRequest, requestDocuments, "Failure",
814 "Deletion failed: Exception while deleting from docstore. "
815 + e.getMessage());
816 }
817 } else {
818 response = deleteManager.getResponse(dsRequest, requestDocuments, "Failure",
819 "Deletion failed: Documents exist in OLE database and cannot be deleted.");
820 }
821 }
822 }
823 } catch (Exception e) {
824 LOG.error("delete operation failed:", e);
825 response = deleteManager.getResponse(dsRequest, requestDocuments, "Failure", "Failed : " + e.getMessage());
826 }
827 return response;
828 }
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919 protected List<FileItem> getMultiPartFileItems(HttpServletRequest request, HttpServletResponse response)
920 throws ServletException {
921 boolean isMultipart = ServletFileUpload.isMultipartContent(request);
922 List<FileItem> items = null;
923 try {
924 if (isMultipart) {
925 DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
926 ServletFileUpload uploadHandler = new ServletFileUpload(fileItemFactory);
927 items = uploadHandler.parseRequest(request);
928 }
929 } catch (Exception ex) {
930 LOG.error("Error in getting the Reading the File:", ex);
931 }
932 return items;
933 }
934
935
936
937
938
939
940
941 protected String getParameter(String reqParam, List<FileItem> items, HttpServletRequest request) {
942 String paramValue = null;
943 if (items != null && items.size() > 0) {
944 Iterator<FileItem> itr = items.iterator();
945 while (itr.hasNext()) {
946 FileItem item = (FileItem) itr.next();
947 if (item.isFormField()) {
948 String name = item.getFieldName();
949 String value = item.getString();
950 if (reqParam.equals(name)) {
951 paramValue = value;
952 }
953 }
954 }
955 } else {
956 paramValue = request.getParameter(reqParam);
957 }
958 return paramValue;
959 }
960
961 protected String getUserId(HttpServletRequest request) {
962 String userId = request.getParameter("userId");
963 if (userId == null) {
964 userId = "defaultUser";
965 }
966 return userId;
967 }
968
969 private ArrayList<File> extractBagFilesFromRequest(HttpServletRequest req, HttpServletResponse res)
970 throws Exception {
971 File targetDir = null;
972 try {
973 File file = null;
974 DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
975 fileItemFactory.setSizeThreshold(1 * 1024 * 1024);
976 Iterator items = new ServletFileUpload(fileItemFactory).parseRequest(req).iterator();
977 while (items.hasNext()) {
978 FileItem item = (FileItem) items.next();
979 file = new File(FileUtils.getTempDirectory(), item.getName());
980 item.write(file);
981 }
982 targetDir = compressUtils.extractZippedBagFile(file.getAbsolutePath(), null);
983 LOG.info("extractedBagFileLocation " + targetDir);
984 } catch (IOException e) {
985 LOG.error("IOException", e);
986 sendResponseBag(res, e.getMessage(), "failure");
987 } catch (FormatHelper.UnknownFormatException unknownFormatException) {
988 LOG.error("unknownFormatException", unknownFormatException);
989 sendResponseBag(res, unknownFormatException.getMessage(), "failure");
990 }
991 return compressUtils.getAllFilesList(targetDir);
992 }
993
994
995
996
997
998
999
1000
1001
1002 private void sendResponseBag(HttpServletResponse res, String message, String status) {
1003 Response response = new Response();
1004 response.setMessage(message);
1005 response.setStatus(status);
1006 sendResponseBag(res, response);
1007 }
1008
1009 private void sendResponseBag(HttpServletResponse res, Response docStoreResponse) {
1010 String responseXML = new ResponseHandler().toXML(docStoreResponse);
1011 try {
1012 File output = File.createTempFile("checkout.", ".output");
1013 FileUtils.deleteQuietly(output);
1014 output.mkdirs();
1015 File file = new File(output + File.separator + "response.xml");
1016 Writer writer = null;
1017 writer = new BufferedWriter(new FileWriter(file));
1018 writer.write(responseXML);
1019 writer.close();
1020 File zipFile = compressUtils.createZippedBagFile(output);
1021 res.setContentType("application/zip");
1022 sendResponseAsFile(res, zipFile);
1023 zipFile.delete();
1024 } catch (IOException e) {
1025 LOG.error("IOException", e);
1026 }
1027 }
1028
1029
1030
1031
1032
1033
1034
1035
1036 private void sendResponseAsFile(HttpServletResponse res, File file) throws IOException {
1037 ServletOutputStream stream = res.getOutputStream();
1038 FileInputStream fos = new FileInputStream(file.getAbsolutePath());
1039 BufferedInputStream buf = new BufferedInputStream(fos);
1040 int readBytes = 0;
1041 while ((readBytes = buf.read()) != -1) {
1042 stream.write(readBytes);
1043 }
1044 if (stream != null) {
1045 stream.close();
1046 }
1047 if (buf != null) {
1048 buf.close();
1049 }
1050 res.flushBuffer();
1051 }
1052
1053 private void sendUnavailableResponseString(HttpServletResponse response) {
1054 try {
1055 PrintWriter out = response.getWriter();
1056 out.println("The Requested Operation is not available");
1057 } catch (IOException e) {
1058 LOG.error("IOException", e);
1059 }
1060 }
1061
1062 private List<String> getBibIdList(String bibUUIDs) {
1063 List<String> bibIdsList = new ArrayList<String>();
1064 String[] queueArray = bibUUIDs.split(",");
1065 for (int i = 0; i < queueArray.length; i++) {
1066 bibIdsList.add(queueArray[i]);
1067 }
1068 return bibIdsList;
1069 }
1070
1071 }