GetAnnotServlet.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: GetAnnotServlet.java
 * Description: Servlet which makes available annotations
 */

/**
 * @file GetAnnotServlet.java
 *
 * @brief Servlet which makes available annotations
 */

package cz.vutbr.fit.knot.annotations.comet;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.modules.CoreFuncModule;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet which makes available annotations
 * It accepts following parameters:
 * out - type of output ("v1", "v2" or "sug")
 * uri - URI of requested annotation
 * doc - id of annotated document for which annotations should be retrieved
 * 
 * @brief Servlet which makes available annotations
 */
public class GetAnnotServlet extends HttpServlet {

  private static final int OUTPUT_TYPE_V1 = 0;
  private static final int OUTPUT_TYPE_V2 = 1;
  private static final int OUTPUT_TYPE_SUG = 2;
  
  /**
   * Processes requests for both HTTP
   * <code>GET</code> and
   * <code>POST</code> methods.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
      String uriStr = request.getParameter("uri");
      String idStr = null;
      int outputType = OUTPUT_TYPE_V2;
      if(uriStr != null && uriStr.startsWith(AppBean.getBaseUri() + "/serv/")){
        idStr = uriStr.replace(AppBean.getBaseUri() + "/serv/", "");
      } else if (uriStr != null && uriStr.startsWith(AppBean.getBaseAnnotUri())) {
        idStr = uriStr.replace(AppBean.getBaseAnnotUri(), "");
        outputType = OUTPUT_TYPE_V1;
      }
      
      String reqType = request.getParameter("out");
      if (reqType != null && reqType.equals("v1")) {
        outputType = OUTPUT_TYPE_V1;
      } else if (reqType != null && reqType.equals("v2")) {
        outputType = OUTPUT_TYPE_V2;
      } else if (reqType != null && reqType.equals("sug")) {
        outputType = OUTPUT_TYPE_SUG;
      }

      String reqUserStr = request.getParameter("user");
      Integer reqUserID = null;
      if (reqUserStr != null && !reqUserStr.isEmpty()) {
        try {
          reqUserID = Integer.parseInt(reqUserStr);  // parse id
        } catch (NumberFormatException numberFormatException) {
          // It is not vald id - is it login?
          Object[] params = new Object[2];
          params[0] = "login";
          params[1] = reqUserStr;
          List uList = AppBean.getPersistenceManager().queryDB("User.findByLogin", params);
          if (uList != null && !uList.isEmpty()) {  // if user was found
            User user = (User) uList.get(0);
            reqUserID = user.getId();
          } else {
            reqUserID = null;
          }
        }
      }
      
      Integer id = null;
      if (idStr != null) {
        try {
          id = Integer.parseInt(idStr);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "NumberFormatException";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      
      String docStr = request.getParameter("doc");
      Integer docId = null;
      if (docStr != null && !docStr.isEmpty()) {
        try {
          docId = Integer.parseInt(docStr);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "NumberFormatException";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      
      String withCreatedStr = request.getParameter("withCreated");
      boolean withCreated = false;
      if (withCreatedStr != null && !withCreatedStr.isEmpty()) {
        if (withCreatedStr.equalsIgnoreCase("true")) {
          withCreated = true;
        }
      }
      
      AnnotDocument doc = null;
      if (docId != null) {
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = docId;
        List dList = AppBean.getPersistenceManager().queryDB("AnnotDocument.findById", params);
        if (dList != null && !dList.isEmpty()) {
          doc = (AnnotDocument) dList.get(0);
        }
        if (doc == null) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Document was not found.";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      
      String docUriStr = request.getParameter("docUri");
      if (docUriStr != null && !docUriStr.isEmpty()) {
        try {
          docUriStr = CoreFuncModule.cleanUpURI(docUriStr);
        } catch (URISyntaxException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Wrong URI of document.";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      if (docUriStr != null && !docUriStr.isEmpty()) {
        Object[] params = new Object[2];
        params[0] = "uri";
        params[1] = docUriStr;
        List dList = AppBean.getPersistenceManager().queryDB("AnnotDocument.findByUri", params);
        if (dList != null && !dList.isEmpty()) {
          doc = (AnnotDocument) dList.get(0);
        }
        if (doc == null) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Document was not found.";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      
      Annotation annot = null;
      if (id != null) {
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = id;
        List dList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
        if (dList != null && !dList.isEmpty()) {
          annot = (Annotation) dList.get(0);
        }
        if (annot == null) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Annotation was not found.";
            Logger.getLogger(GetDocServlet.class.getName()).log(Level.ALL, msg);
          }
          out.print(printError());
          return;
        }
      }
      
      List<Annotation> outList = new ArrayList<Annotation>();
      if (annot == null && doc != null && reqUserID != null) {
        outList = getAllAnnotationsForDocAndAuthor(doc, reqUserID);
      } else if (annot == null && doc != null) {
        outList = getAllAnnotationsForDoc(doc);
      } else if (annot == null && reqUserID != null) {
        outList = getAllAnnotationsForAuthor(reqUserID);
      } else if (annot != null && doc == null) {
        outList.add(annot);
      } else if (annot != null && doc != null) {
        if (annot.getSourceDocument().equals(doc)) {
          outList.add(annot);
        }
      }
      
      StringBuilder output = new StringBuilder();
      
      if (outputType == OUTPUT_TYPE_V1) {
        output.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<annotations ");
        //Attach namespaces
        for (int i = 0; i < Constants.nameSpaces[Constants.NAMESPACES_LOD_V1].length; i++) {
          output.append(Constants.nameSpaces[Constants.NAMESPACES_LOD_V1][i]);
        }
        output.append(">");
        Iterator<Annotation> annotIt = outList.iterator();
        while (annotIt.hasNext()) {
          Annotation a = annotIt.next();
          output.append(a.toXMLString(true));
        }
        output.append("</annotations>");
      } else if (outputType == OUTPUT_TYPE_V2) {
        output.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<annotations ");
        //Attach namespaces
        for (int i = 0; i < Constants.nameSpaces[Constants.NAMESPACES_LOD_V2].length; i++) {
          output.append(Constants.nameSpaces[Constants.NAMESPACES_LOD_V2][i]);
        }
        output.append(">");
        Iterator<Annotation> annotIt = outList.iterator();
        while (annotIt.hasNext()) {
          Annotation a = annotIt.next();
          output.append(a.toXMLStringV2(null, Localisation.LANGUAGE_ENG, false));
        }
        output.append("</annotations>");
      } else if (outputType == OUTPUT_TYPE_SUG) {
        output.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
        output.append("<suggestion xmlns:geo=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">");
        Iterator<Annotation> annotIt = outList.iterator();
        while (annotIt.hasNext()) {
          Annotation a = annotIt.next();
          output.append(a.toSXMLString(true, withCreated));
        }
        output.append("</suggestion>");
      } else {
        out.print(printError());
      }
      
      out.append(output);
    } finally {      
      out.close();
    }
  }

  /**
   * Returns all annotations for given document
   *
   * @param doc Document for which annotations should be returned
   * @return Returns list of annotations for given document
   */
  @SuppressWarnings("unchecked")
  private List<Annotation> getAllAnnotationsForDoc(AnnotDocument doc) {
    // query database for annotations for synchronized document
    Object[] params = new Object[2];
    params[0] = "sourceDocumentId";
    params[1] = doc.getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentID", params);
    if (aList != null && !aList.isEmpty()) {  // if some annotation was found
      return aList;
    }

    return new ArrayList<Annotation>();
  }  // getAllAnnotationsForDoc()
  
  /**
   * Returns all annotations for given document and author
   *
   * @param doc Document for which annotations should be returned
   * @param author Id of author of annotations
   * @return Returns list of annotations for given document and author
   */
  @SuppressWarnings("unchecked")
  private List<Annotation> getAllAnnotationsForDocAndAuthor(AnnotDocument doc, Integer author) {
    // query database for annotations for synchronized document
    Object[] params = new Object[4];
    params[0] = "sourceDocumentId";
    params[1] = doc.getId();
    params[2] = "authorId";
    params[3] = author.toString();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentIDAndAuthor", params);
    if (aList != null && !aList.isEmpty()) {  // if some annotation was found
      return aList;
    }

    return new ArrayList<Annotation>();
  }  // getAllAnnotationsForDocAndAuthor()
  
  /**
   * Returns all annotations for given author
   *
   * @param author Id of author of annotations
   * @return Returns list of annotations for given author
   */
  @SuppressWarnings("unchecked")
  private List<Annotation> getAllAnnotationsForAuthor(Integer author) {
    // query database for annotations for synchronized document
    Object[] params = new Object[2];
    params[0] = "authorId";
    params[1] = author.toString();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByAuthor", params);
    if (aList != null && !aList.isEmpty()) {  // if some annotation was found
      return aList;
    }

    return new ArrayList<Annotation>();
  }  // getAllAnnotationsForAuthor()
  
  /**
   * Creates error message for case of bad request
   *
   * @return Simple HTML page with error message
   */
  private String printError() {
    return "<html>"
           + "<head>"
             + "<title>Servlet GetAnnotServlet</title>"
           + "</head>"
           + "<body>"
             + "<h1>Error - requested informations was not found</h1>"
             + "<p>Requested informations was not found.</p>"
           + "</body>"
         + "</html>";
  }
  
  /**
   * Handles the HTTP
   * <code>GET</code> method.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
    processRequest(request, response);
  }

  /**
   * Handles the HTTP
   * <code>POST</code> method.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
    processRequest(request, response);
  }

  /**
   * Returns a short description of the servlet.
   *
   * @return a String containing servlet description
   */
  @Override
  public String getServletInfo() {
    return "Servlet for getting of annotations.";
  }
}  // public class GetAnnotServlet