ResponseCreator.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: ResponseCreator.java
 * Description: Class that creates responses and persists data
 */

/**
 * @file ResponseCreator.java
 *
 * @brief Class that creates responses and persists data
 */

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.Annotation;
import cz.vutbr.fit.knot.annotations.entity.Settings;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Class that creates responses (calls modules) and persists data
 *
 * @brief Class that creates responses and persists data
 * @author idytrych
 */
public class ResponseCreator {
  ArrayList<AnnotServerModule> modules;

  /**
   * Constructor (loads basic modules)
   */
  public ResponseCreator() {
    modules = new ArrayList<AnnotServerModule>();

    // TODO: Remove this and replace with anything better.
    modules.add(new cz.vutbr.fit.knot.annotations.modules.CoreFuncModule());
    modules.add(new cz.vutbr.fit.knot.annotations.modules.PersonsModule());
    modules.add(new cz.vutbr.fit.knot.annotations.modules.StoryscopeInterface.StoryscopeInterfaceModule());
    modules.add(new cz.vutbr.fit.knot.annotations.modules.SECDictionaryInterface.SECDInterfaceModule());
    modules.add(new cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionManagerModule());
    // modules.add(new module());
    // modules.add(new module());
  }

  /**
   * Creates response to client POST request (not to comet request).
   * Calls modules, assembly response and persists data.
   * 
   * @param requestInfo Informations about client POST request
   * @return Returns string with messages for the client in XML
   */
  public String createPostResponse(RequestInfo requestInfo) {
    String response = "";
    try {
      if (requestInfo.getSession() == null) {  // if this request is not in valid session
        requestInfo.setCanNotify(false);
        return "";
      }
      // Call modules (method of module that is called before persisting data)
      Iterator<AnnotServerModule> moduleIter = modules.iterator();
      while (moduleIter.hasNext()) {
        AnnotServerModule module = moduleIter.next();
        try {
          response = response + module.processRequestBeforePersist(requestInfo);
        } catch (Exception e) {
          int lNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String errInfo = "<module name=\"" + module.getModuleName(lNum) + "\"/>";
          requestInfo.addError(lod, lNum, Localisation.ERROR_33_MODULE_ERROR, errInfo, e.toString());
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Exception in the server module " + module.getModuleName(lNum) 
                      + " before persist";
            Logger.getLogger(ResponseCreator.class.getName()).log(Level.SEVERE, msg, e);
          }
        }
      }

      // Persist all entities
      boolean persistFailed = Persister.persist(requestInfo);

      if (persistFailed) {  // if persist failed (transaction rollback)
        int lNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, lNum, Localisation.ERROR_48_PERSISTENCE_ERROR);
        requestInfo.setCanNotify(false);  // comet handlers can't be notified
      }

      // Call modules (method of module that is called after persisting data)
      moduleIter = modules.iterator();
      while (moduleIter.hasNext()) {
        AnnotServerModule module = moduleIter.next();
        try {
          response = response + module.processRequestAfterPersist(requestInfo, persistFailed);
        } catch (Exception e) {
          int lNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String errInfo = "<module name=\"" + module.getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
          requestInfo.addError(lod, lNum, Localisation.ERROR_33_MODULE_ERROR, errInfo, e.toString());
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Exception in the server module " + module.getModuleName(lNum)
                      + " after persist";
            Logger.getLogger(ResponseCreator.class.getName()).log(Level.SEVERE, msg, e);
          }
        }
      }

      // Add reloaded annotations
      response = response + createReloadedAnnot(requestInfo);
      // Add settings
      if (requestInfo.getSession().getProtocolLOD() != Constants.PROTOCOL_LOD_V2) {
        if ((requestInfo.getSettings() != null && !requestInfo.getSettings().isEmpty()) || requestInfo.getLoggedIn() != null) {
          response = response + createSettings(requestInfo);
        }
      } else if (requestInfo.getLoggedIn() != null) {
        // send only when user is just logged (while communicate by protocol v 2.0)
        response = response + createSettings(requestInfo);
      }
    } finally {
      synchronized (AppBean.documentURILocker) {
        if(requestInfo.getSyncDocumentData() != null){
          ReentrantLock lock = AppBean.documentURILocker.get(requestInfo.getSyncDocumentData().getUri());
          if(lock.isLocked()){
            lock.unlock();
          }
        }
      }
    }  
    
    return response;
  }  // createPostResponse()

  /**
   * Creates response to client's comet request (GET or special POST).
   * Calls modules and assembly response.
   *
   * @param flier Flier with informations
   * @param session Client's session
   * @return Returns string with messages for the client in XML
   */
  public String createCometResponse(Flier flier, EditorSession session) {
    String response = "";
    // Call modules and assembly response
    Iterator<AnnotServerModule> moduleIter = modules.iterator();
    while (moduleIter.hasNext()) {
      AnnotServerModule module = moduleIter.next();
      try {
        response = response + module.messagesFromFlier(flier,session);
      } catch (Exception e) {
        int lNum = session.getLanguageNum();
        String errInfo = "<module name=\"" + module.getModuleName(session.getLanguageNum()) + "\"/>";
        response = response + RequestInfo.createErrorMsg(session.getProtocolLOD(), lNum, Localisation.ERROR_33_MODULE_ERROR, errInfo, e.toString());
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "Exception in the server module " + module.getModuleName(lNum)
                  + " during the creating of comet response.";
          Logger.getLogger(ResponseCreator.class.getName()).log(Level.SEVERE, msg, e);
        }
      }
    }

    return response;
  }  // createCometResponse()

  /**
   * Creates message with user settings
   *
   * @param requestInfo Informations about client request
   * @return Returns messages with user settings in XML
   */
  public String createSettings(RequestInfo requestInfo) {
    String retString = "";
    Iterator setIter = requestInfo.getSession().getSettings().iterator();
    while (setIter.hasNext()) {
      Settings param = (Settings) setIter.next();
      retString = retString + param.toXMLString();
    }

    retString = "<settings>" + retString + "</settings>";

    return retString;
  }

  /**
   * Creates message with reloaded annotations
   *
   * @param requestInfo Informations about client request
   * @return Returns requested annotations in XML (in annotations change message)
   */
  public String createReloadedAnnot(RequestInfo requestInfo) {
    String retString = "";
    // check minimal protocol version
    boolean proto11 = requestInfo.getSession().getProtocolLOD() > 1;
    Iterator<Annotation> reloadedIter = requestInfo.getReloadAnnotations().iterator();
    while (reloadedIter.hasNext()) {
      Annotation relAnnot = reloadedIter.next();
      Object[] params = new Object[2];
      params[0] = "id";
      params[1] = relAnnot.getId();
      List rList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
      if (rList != null && !rList.isEmpty()) {
        relAnnot = (Annotation) rList.get(0);
      }
      if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        ArrayList<String> attFilter = requestInfo.getSession().getAttFilter();
        int lNum = requestInfo.getSession().getLanguageNum();
        Boolean KBRefMode = requestInfo.getSession().getKBRefMode();
        retString = retString + relAnnot.toXMLStringV2(attFilter, lNum, KBRefMode);
      }else{
        retString = retString + relAnnot.toXMLString(proto11);
      }
    }
    if (!retString.isEmpty()) {
      if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        return "<annotations><addAnnotations>" + retString + "</addAnnotations></annotations>";
      }else{
        return "<annotations><change>" + retString + "</change></annotations>";
      }
    }
    return retString;
  }

  /**
   * Gets list of active server modules
   *
   * @return Returns list of active server modules
   */
  public ArrayList<AnnotServerModule> getModules() {
    return modules;
  }

  /**
   * Sets list of active server modules
   *
   * @param modules List of active server modules
   */
  public void setModules(ArrayList<AnnotServerModule> modules) {
    this.modules = modules;
  }

  /**
   * Adds server module to list of active modules
   *
   * @param module Module to be added
   */
  public void addModule(AnnotServerModule module) {
    this.modules.add(module);
  }

  /**
   * Removes server module from list of active modules
   *
   * @param module Module to be removed
   * @return If succeed, returns removed module, else returns null
   */
  public boolean removeModule(AnnotServerModule module) {
    return this.modules.remove(module);
  }
}  // class ResponseCreator