EditTAO.java

Go to the documentation of this file.

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

/**
 * @file EditTAO.java
 *
 * @brief Backbean for managing attributes from ontology
 */

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.MessageProcessor;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.TypeAttrOnto;
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 managing attributes from ontology
 *
 * @brief Backbean for managing attributes from ontology
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class EditTAO implements Serializable {
  /**
   * Value of name field in form
   */
  private String name = null;
  /**
   * Value of group field in form
   */
  private String group = null;
  /**
   * Edited attribute of type of annotation
   */
  private TypeAttrOnto editedTAO = 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 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
   *
   * @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 (!name.equals(editedTAO.getName())) {  // if name should be changed
      // check for duplicity
      Object[] params4 = new Object[4];
      params4[0] = "name";
      params4[1] = name;
      params4[2] = "groupId";
      params4[3] = editedTAO.getGroup().getId();
      List dList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findByNameAndGroup", params4);
      if (dList != null && !dList.isEmpty()) {
        errorMessage = MessageProvider.getMessage("duplicitAttrName");
        return null;
      }
    }  // if name should be changed

    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"
              + editedTAO.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
    editedTAO.setName(name);
    editedTAO.setSimpleType(simpleType);
    editedTAO.setAttributeType(sType);
    editedTAO.setComment(comment);
    editedTAO.setUriInOntology(uriInOntology);

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

    SessionManager.getSession().setSecondFormBackup(null);
    SessionManager.getSession().setEditedTAO(null);
    return "attrO";
  }  // 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() {

    if (group == null || group.isEmpty()) {
      errorMessage = MessageProvider.getMessage("groupCantBeEmpty");
      return null;
    }
    
    UserGroup ug = null;
    if (group != null && !group.isEmpty()) {
      Object[] params = new Object[2];
      params[0] = "name";
      params[1] = group;
      List uList = AppBean.getPersistenceManager().queryDB("UserGroup.findByName", params);
      if (uList != null && !uList.isEmpty()) {
        ug = (UserGroup) uList.get(0);
      }
      if (ug == null) {
        errorMessage = MessageProvider.getMessage("errorUnknownUG");
      }
    }
    
    if (name == null || name.isEmpty()) {
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      return null;
    }

    // check for duplicity
    Object[] params4 = new Object[4];
    params4[0] = "name";
    params4[1] = name;
    params4[2] = "groupId";
    params4[3] = ug.getId();
    List dList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findByNameAndGroup", params4);
    if (dList != null && !dList.isEmpty()) {
      errorMessage = MessageProvider.getMessage("duplicitAttrName");
      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"
              + ug.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
    editedTAO = new TypeAttrOnto(ug, name, simpleType);
    editedTAO.setAttributeType(sType);
    editedTAO.setComment(comment);
    editedTAO.setUriInOntology(uriInOntology);

    // persist new attribute
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      editedTAO = em.merge(editedTAO);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("newAttrNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting of new type attribute from ontology failed.";
        Logger.getLogger(EditTAO.class.getName()).log(Level.SEVERE, msg);
      }
    }

    SessionManager.getSession().setSecondFormBackup(null);
    SessionManager.getSession().setEditedTAO(null);
    return "attrO";
  }  // btnSaveNewAction()

  /**
   * Creates backup of form data
   *
   * @return Returns backup of form data
   */
  private TypeAttrOnto createBackup() {

    UserGroup ug = null;
    if (group != null && !group.isEmpty()) {
      Object[] params = new Object[2];
      params[0] = "name";
      params[1] = group;
      List uList = AppBean.getPersistenceManager().queryDB("UserGroup.findByName", params);
      if (uList != null && !uList.isEmpty()) {
        ug = (UserGroup) uList.get(0);
      }
      if (ug == null) {
        errorMessage = MessageProvider.getMessage("errorUnknownUG");
      }
    }

    if (!adding && editedTAO != null) {
      ug = editedTAO.getGroup();
    }
    
    AnnotType sType = null;
    if (structuredType != null && !structuredType.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g"
              + ug.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
    TypeAttrOnto backup = new TypeAttrOnto(ug, name, simpleType);
    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().setEditedTAO(null);  // clean up variable in session
    return "attrO";
  }

  /**
   * Gets value of name field in form
   *
   * @return Returns value of name field in form
   */
  public String getName() {
    TypeAttrOnto backup = getBackup();
    if (name == null && backup != null) {
      name = backup.getName();
    } else if (name == null && editedTAO != null) {
      name = editedTAO.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() {
    TypeAttrOnto backup = getBackup();
    if (simpleType == null && backup != null) {
      simpleType = backup.getSimpleType();
    } else if (simpleType == null && editedTAO != null) {
      simpleType = editedTAO.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() {
    TypeAttrOnto backup = getBackup();
    if (structuredType == null && backup != null) {
      if(backup.getAttributeType() != null){
        structuredType = backup.getAttributeType().getLinearizedName();
      }
    } else if (structuredType == null && editedTAO != null) {
      if (editedTAO.getAttributeType() != null) {
        structuredType = editedTAO.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() {
    TypeAttrOnto backup = getBackup();
    if (comment == null && backup != null) {
      comment = backup.getComment();
    } else if (comment == null && editedTAO != null) {
      comment = editedTAO.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 uri field in form
   *
   * @return Returns value of uri field in form
   */
  public String getUriInOntology() {
    TypeAttrOnto backup = getBackup();
    if (uriInOntology == null && backup != null) {
      uriInOntology = backup.getUriInOntology();
    } else if (uriInOntology == null && editedTAO != null) {
      uriInOntology = editedTAO.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() {
    if(group != null && !group.isEmpty()){
        TypeAttrOnto backup = createBackup();
        SessionManager.getSession().setSecondFormBackup(backup);
        SessionManager.getSession().setSelectedUG(backup.getGroup());
        SessionManager.getSession().setEditedTAO(editedTAO);
        SessionManager.getSession().setCameFrom("editTAO");
        return "selectAT";
    }else{
        errorMessage = MessageProvider.getMessage("groupMustBeSet");
        return null;
    }
  }

  /**
   * Action listener for button for selecting structured type of attribute
   * (used in page for adding attribute)
   *
   * @return Returns page outcome (identificator of next page)
   */
  public String btnSelectSTypeActionN() {
    if(group != null && !group.isEmpty()){
        TypeAttrOnto backup = createBackup();
        SessionManager.getSession().setSecondFormBackup(backup);
        SessionManager.getSession().setSelectedUG(backup.getGroup());
        SessionManager.getSession().setEditedTAO(editedTAO);
        SessionManager.getSession().setCameFrom("addTAO");
        return "selectAT";
    }else{
        errorMessage = MessageProvider.getMessage("groupMustBeSet");
        return null;
    }
    
  }

  /**
   * Gets backup of form data
   * If user came from another page, gets edited attribute 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 TypeAttrOnto getBackup() {
    if (editedTAO == null) {  // user is camming to this page
      editedTAO = SessionManager.getSession().getEditedTAO();
      AnnotType sAT = SessionManager.getSession().getSelectedAT();
      if (sAT != null && SessionManager.getSession().getCameFrom().equals("editTAO")) {
        structuredType = sAT.getLinearizedName();
        SessionManager.getSession().setSelectedAT(null);
        SessionManager.getSession().setCameFrom(null);
      } else if (sAT != null && SessionManager.getSession().getCameFrom().equals("addTAO")) {
        structuredType = sAT.getLinearizedName();
        SessionManager.getSession().setSelectedAT(null);
        SessionManager.getSession().setCameFrom(null);
        adding = true;
      }
    }
    TypeAttrOnto backup = null;
    if (SessionManager.getSession().getSecondFormBackup() != null) {
      if (SessionManager.getSession().getSecondFormBackup().getClass().getName().endsWith("TypeAttrOnto")) {
        backup = (TypeAttrOnto) SessionManager.getSession().getSecondFormBackup();
        if (!adding) {  // it is not adding of attribute
          if (backup != null && editedTAO != null && backup.getId() != editedTAO.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 from ontology
   *
   * @return Returns edited attribute from ontology
   */
  public TypeAttrOnto getEditedTAO() {
    getBackup();
    return editedTAO;
  }

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

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


  /**
   * 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 EditTAO