EditATA.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: EditATA.java
 * Description: Backbean for pages for adding and editing attributes of of types
 *              of annotations
 */

/**
 * @file EditATA.java
 *
 * @brief Backbean for managing attributes of types of annotations
 */
package cz.vutbr.fit.knot.annotations.web;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.ResponseCreator;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.model.SelectItem;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

/**
 * Backbean for pages for adding and editing attributes of of types of annotations
 *
 * @brief Backbean for managing attributes of types of annotations
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class EditATA implements Serializable {
  /**
   * Value of name field in form
   */
  private String name = null;
  /**
   * Edited attribute of type of annotation
   */
  private AnnotTypeAttr annotTAttr = null;
  /**
   * Value of simple type field in form
   */
  private String simpleType = null;
  /**
   * Value of structured type field in form
   */
  private String structuredType = null;
  /**
   * Value of comment field in form
   */
  private String comment = null;
  /**
   * Value of required checkbox
   */
  private Boolean required = null;
  /**
   * Value of uri field in form
   */
  private String uriInOntology = null;
  /**
   * Error message displayed in form
   */
  private String errorMessage = "";
  /**
   * Differ between page for adding and between page for editing attribute
   */
  private boolean adding = false;

  /**
   * Action listener for save button in the page for editing of the attribute of type of annotation
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnSaveAction() {

    AnnotType sType = null;

    if (name == null || name.isEmpty()) {
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      return null;
    }
    
    if (simpleType != null && !simpleType.isEmpty()
        && structuredType != null && !structuredType.isEmpty()) {
      errorMessage = MessageProvider.getMessage("simpleAndStructuredError");
      return null;
    } else if (structuredType != null && !structuredType.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g"
              + annotTAttr.getAnnotationType().getGroup().getId()
              + "/" + MessageProcessor.replaceArrows(structuredType);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {
        sType = (AnnotType) tList.get(0);
      }
      if (sType == null) {
        errorMessage = MessageProvider.getMessage("unknownStructuredType");
        return null;
      }
      simpleType = null;
    } else if (simpleType != null && !simpleType.isEmpty()) {
      if (!Constants.SIMPLE_TYPES.contains(simpleType)) {
        errorMessage = MessageProvider.getMessage("unknownSimpleType");
        return null;
      }
    } else {
      errorMessage = MessageProvider.getMessage("typeMustBeSet");
      return null;
    }

    // set new values
    annotTAttr.setName(name);
    annotTAttr.setSimpleType(simpleType);
    annotTAttr.setAttributeType(sType);
    annotTAttr.setComment(comment);
    annotTAttr.setRequired(required);
    annotTAttr.setUriInOntology(uriInOntology);

    // persist changes
    AnnotTypeAttr saved = (AnnotTypeAttr) AppBean.getPersistenceManager().saveEntityChanges(annotTAttr);
    if (saved == null) {
      errorMessage = MessageProvider.getMessage("changesNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting changes in attribute of type of annotation failed.";
        Logger.getLogger(EditATA.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    } else {  // if changes was successfully saved
      annotTAttr = saved;
    }

    // prepare messages for connected clients
    AnnotType editedAT = SessionManager.getSession().getEditedAT();
    ResponseCreator rc = AppBean.getResponseCreator();
    synchronized(AppBean.getSessions()){
      Iterator<EditorSession> sesIt = AppBean.getSessions().iterator();
      while (sesIt.hasNext()) {  // for each client
        EditorSession es = sesIt.next();
        Flier flier = new Flier();
        flier.AddEditedType(editedAT);  // create list of changed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    SessionManager.getSession().setSecondFormBackup(null);
    SessionManager.getSession().setEditedATA(null);
    return "editAT";
  }  // btnSaveAction()
  
  /**
   * Action listener for save button in the page for adding of the attribute of type of annotation
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnSaveNewAction() {

    AnnotType editedAT = SessionManager.getSession().getEditedAT();
    
    if (name == null || name.isEmpty()) {
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      return null;
    }
    
    AnnotType sType = null;

    if (simpleType != null && !simpleType.isEmpty()
        && structuredType != null && !structuredType.isEmpty()) {
      errorMessage = MessageProvider.getMessage("simpleAndStructuredError");
      return null;
    } else if (structuredType != null && !structuredType.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g"
              + editedAT.getGroup().getId()
              + "/" + MessageProcessor.replaceArrows(structuredType);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {
        sType = (AnnotType) tList.get(0);
      }
      if (sType == null) {
        errorMessage = MessageProvider.getMessage("unknownStructuredType");
        return null;
      }
      simpleType = null;
    } else if (simpleType != null && !simpleType.isEmpty()) {
      if (!Constants.SIMPLE_TYPES.contains(simpleType)) {
        errorMessage = MessageProvider.getMessage("unknownSimpleType");
        return null;
      }
    } else {
      errorMessage = MessageProvider.getMessage("typeMustBeSet");
      return null;
    }

    // create new attribute
    annotTAttr = new AnnotTypeAttr(editedAT, name, simpleType, required);
    annotTAttr.setAttributeType(sType);
    annotTAttr.setComment(comment);
    annotTAttr.setUriInOntology(uriInOntology);

    // persist new attribute
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      editedAT = em.merge(editedAT);
      annotTAttr.setAnnotationType(editedAT);
      editedAT.getAttributes().add(annotTAttr);
      SessionManager.getSession().setEditedAT(editedAT); 
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("newAttrNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting new attribute of type of annotation failed.";
        Logger.getLogger(EditATA.class.getName()).log(Level.SEVERE, msg, e);
      }
      return null;
    }

    // prepare messages for connected clients
    ResponseCreator rc = AppBean.getResponseCreator();
    synchronized(AppBean.getSessions()){
      Iterator<EditorSession> sesIt = AppBean.getSessions().iterator();
      while (sesIt.hasNext()) {  // for each client
        EditorSession es = sesIt.next();
        Flier flier = new Flier();
        flier.AddEditedType(editedAT);  // create list of changed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    SessionManager.getSession().setSecondFormBackup(null);
    SessionManager.getSession().setEditedATA(null);
    return "editAT";
  }  // btnSaveNewAction()
  
  /**
   * Creates backup of form data
   * 
   * @return Returns backup of form data
   */
  private AnnotTypeAttr createBackup() {

    AnnotType editedAT = SessionManager.getSession().getEditedAT();

    AnnotType sType = null;

    if (structuredType != null && !structuredType.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g"
              + editedAT.getGroup().getId()
              + "/" + MessageProcessor.replaceArrows(structuredType);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {
        sType = (AnnotType) tList.get(0);
      }
    }
    if (simpleType != null && !simpleType.isEmpty()) {
      if (!Constants.SIMPLE_TYPES.contains(simpleType)) {
        simpleType = null;
      }
    }

    // create backup attribute
    AnnotTypeAttr backup = new AnnotTypeAttr(editedAT, name, simpleType, required);
    backup.setAttributeType(sType);
    backup.setComment(comment);
    backup.setUriInOntology(uriInOntology);
    return backup;
  }  // createBackup()

  /**
   * Action listener for cancel button
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnCancelAction() {
    SessionManager.getSession().setSecondFormBackup(null);
    SessionManager.getSession().setEditedATA(null);  // clean up variable in session
    return "editAT";
  }

  /**
   * Gets value of name field in form
   *
   * @return Returns value of name field in form
   */
  public String getName() {
    AnnotTypeAttr backup = getBackup();
    if (name == null && backup != null) {
      name = backup.getName();
    } else if (name == null && annotTAttr != null) {
      name = annotTAttr.getName();
    } else if (name == null) {
      name = "";
    }
    return name;
  }  // getName()

  /**
   * Sets value of name field in form
   *
   * @param name Value of name field in form
   */
  public void setName(String name) {
    this.name = name;
  }

  /**
   * Gets value of simple type field in form
   * 
   * @return Returns value of simple type field in form
   */
  public String getSimpleType() {
    AnnotTypeAttr backup = getBackup();
    if (simpleType == null && backup != null) {
      simpleType = backup.getSimpleType();
    } else if (simpleType == null && annotTAttr != null) {
      simpleType = annotTAttr.getSimpleType();
    } else if (simpleType == null) {
      simpleType = "";
    }
    if (simpleType != null) {
      if (simpleType.equals("geoPoint")) {
        simpleType = "GeoPoint";
      }
      if (simpleType.equals("person")) {
        simpleType = "Person";
      }
    } else {
      simpleType = "";
    }
    return simpleType;
  }  // getSimpleType()

  /**
   * Sets value of simple type field in form
   *
   * @param simpleType Value of simple type field in form
   */
  public void setSimpleType(String simpleType) {
    this.simpleType = simpleType;
  }

  /**
   * Gets value of structured type field in form
   *
   * @return Returns value of structured type field in form
   */
  public String getStructuredType() {
    AnnotTypeAttr backup = getBackup();
    if (structuredType == null && backup != null) {
      structuredType = backup.getAttributeType().getLinearizedName();
    } else if (structuredType == null && annotTAttr != null) {
      if (annotTAttr.getAttributeType() != null) {
        structuredType = annotTAttr.getAttributeType().getLinearizedName();
      }
    } else if (structuredType == null) {
      structuredType = "";
    }
    return structuredType;
  }  // getStructuredType()

  /**
   * Sets value of structured type field in form
   *
   * @param structuredType Value of structured type field in form
   */
  public void setStructuredType(String structuredType) {
    this.structuredType = structuredType;
  }

  /**
   * Gets value of comment field in form
   *
   * @return Returns value of comment field in form
   */
  public String getComment() {
    AnnotTypeAttr backup = getBackup();
    if (comment == null && backup != null) {
      comment = backup.getComment();
    } else if (comment == null && annotTAttr != null) {
      comment = annotTAttr.getComment();
    } else if (comment == null) {
      comment = "";
    }
    return comment;
  }  // getComment()

  /**
   * Sets value of comment field in form
   *
   * @param comment Value of comment field in form
   */
  public void setComment(String comment) {
    this.comment = comment;
  }

  /**
   * Gets value of required checkbox
   * 
   * @return Returns value of required checkbox
   */
  public Boolean getRequired() {
    AnnotTypeAttr backup = getBackup();
    if (required == null && backup != null) {
      required = backup.getRequired();
    } else if (required == null && annotTAttr != null) {
      required = annotTAttr.getRequired();
    } else if (required == null) {
      required = false;
    }
    return required;
  }

  /**
   * Sets value of required checkbox
   *
   * @param required Value of required checkbox
   */
  public void setRequired(Boolean required) {
    this.required = required;
  }

  /**
   * Gets value of uri field in form
   *
   * @return Returns value of uri field in form
   */
  public String getUriInOntology() {
    AnnotTypeAttr backup = getBackup();
    if (uriInOntology == null && backup != null) {
      uriInOntology = backup.getUriInOntology();
    } else if (uriInOntology == null && annotTAttr != null) {
      uriInOntology = annotTAttr.getUriInOntology();
    } else if (uriInOntology == null) {
      uriInOntology = "";
    }
    return uriInOntology;
  }

  /**
   * Sets value of uri field in form
   * @param uriInOntology Value of uri field in form
   */
  public void setUriInOntology(String uriInOntology) {
    this.uriInOntology = uriInOntology;
  }

  /**
   * Action listener for button for selecting structured type of attribute
   * 
   * @return Returns page outcome (identificator of next page)
   */
  public String btnSelectSTypeAction() {
    AnnotType editedAT = SessionManager.getSession().getEditedAT();
    AnnotTypeAttr backup = createBackup();
    SessionManager.getSession().setSecondFormBackup(backup);
    SessionManager.getSession().setSelectedUG(editedAT.getGroup());
    SessionManager.getSession().setEditedATA(annotTAttr);
    SessionManager.getSession().setCameFrom("editATA");
    return "selectAT";
  }

  /**
   * Action listener for button for selecting structured type of attribute
   * (used in page for adding attribute of annotation)
   * 
   * @return Returns page outcome (identificator of next page)
   */
  public String btnSelectSTypeActionN() {
    AnnotType editedAT = SessionManager.getSession().getEditedAT();
    AnnotTypeAttr backup = createBackup();
    SessionManager.getSession().setSecondFormBackup(backup);
    SessionManager.getSession().setSelectedUG(editedAT.getGroup());
    SessionManager.getSession().setEditedATA(annotTAttr);
    SessionManager.getSession().setCameFrom("addATA");
    return "selectAT";
  }
  
  /**
   * Gets backup of form data
   * If user came from another page, gets edited attribute of type of annotation
   * from session.
   * If user now returned from selection of type, set form field value.
   *
   * @return If backup is available, returns backup of form data, null otherwise
   */
  private AnnotTypeAttr getBackup() {
    if (annotTAttr == null) {  // user is camming to this page
      annotTAttr = SessionManager.getSession().getEditedATA();
      AnnotType sAT = SessionManager.getSession().getSelectedAT();
      if (sAT != null && SessionManager.getSession().getCameFrom().equals("editATA")) {
        structuredType = sAT.getLinearizedName();
        SessionManager.getSession().setSelectedAT(null);
        SessionManager.getSession().setCameFrom(null);
      } else if (sAT != null && SessionManager.getSession().getCameFrom().equals("addATA")) {
        structuredType = sAT.getLinearizedName();
        SessionManager.getSession().setSelectedAT(null);
        SessionManager.getSession().setCameFrom(null);
        adding = true;
      }
    }
    AnnotTypeAttr backup = null;
    if (SessionManager.getSession().getSecondFormBackup() != null) {
      if (SessionManager.getSession().getSecondFormBackup().getClass().getName().endsWith("AnnotTypeAttr")) {
        backup = (AnnotTypeAttr) SessionManager.getSession().getSecondFormBackup();
        if (!adding) {  // it is not adding of attribute
          if (backup.getId() != annotTAttr.getId()) {
            backup = null;
          }
        }
      }
    }
    return backup;
  }  // getBackup()

  /**
   * Gets error message displayed in form
   *
   * @return Returns error message displayed in form
   */
  public String getErrorMessage() {
    return errorMessage;
  }

  /**
   * Sets error message to be displayed in form
   *
   * @param errorMessage Error message to be displayed in form
   */
  public void setErrorMessage(String errorMessage) {
    this.errorMessage = errorMessage;
  }

  /**
   * Gets edited attribute of type of annotation
   * 
   * @return Returns edited attribute of type of annotation
   */
  public AnnotTypeAttr getAnnotTAttr() {
    getBackup();
    return annotTAttr;
  }
  
  /**
   * Gets user group of edited type of annotation
   * 
   * @return User group of edited type of annotation
   */
  public UserGroup getGroup() {
    if (annotTAttr != null) {
      return annotTAttr.getAnnotationType().getGroup();
    }
    return SessionManager.getSession().getEditedAT().getGroup();
  }  // getGroup()

  /**
   * Gets simple types of attribute
   *
   * @return Returns simple types of attribute
   */
  public List<SelectItem> getSimpleTypes() {
    List<SelectItem> rList = new ArrayList<SelectItem>();
    for (Iterator<String> tIt = Constants.SIMPLE_TYPES.iterator(); tIt.hasNext();) {
      String t = tIt.next();
      if (t.equals("person") || t.equals("geoPoint")) {  // skip compatibility variants
        continue;
      }
      rList.add(new SelectItem(t, t));
    }
    rList.add(new SelectItem("", ""));
    return rList;
  }  // getSimpleTypes()

}  // public class EditATA