EditAT.java

Go to the documentation of this file.

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

/**
 * @file EditAT.java
 *
 * @brief Backbean for adding, editing and deleting 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.component.html.HtmlDataTable;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

/**
 * Backbean for pages for adding, editing and deleting of types of annotations
 *
 * @brief Backbean for adding, editing and deleting of types of annotations
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class EditAT implements Serializable {
  /**
   * Table with attributes of given type of annotation
   */
  private HtmlDataTable listTable;

  /**
   * Table with ancestors of given type of annotation
   */
  private HtmlDataTable ancTable;
  
  /**
   * Attribute selected in the table
   */
  private AnnotTypeAttr attr;
  
  /**
   * Value of primary ancestor field in form
   */
  private String prAncStr;
  
  /**
   * Ancestor selected in the table
   */
  private AnnotType anc;
  
  /**
   * Edited type of annotation or type of annotation to be deleted
   */
  private AnnotType annotType = null;

  /**
   * Value of name field in form
   */
  private String name = null;

  /**
   * Value of group field in form
   */
  private String group = null;

  /**
   * Value of comment field in form
   */
  private String comment = null;

  /**
   * Value of restricted attributes field in form
   */
  private Boolean restrictedAtt = null;

  /**
   * Value of URI field in form
   */
  private String uriInOntology = null;

  /**
   * Error message displayed in form
   */
  private String errorMessage = "";

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

    annotType.setComment(comment);  // set new comment
    annotType.setRestrictedAtt(restrictedAtt);
    annotType.setUriInOntology(uriInOntology);
    
    if (name.isEmpty()) {
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      return null;
    }
    
    List<AnnotType> affectedTypes = new ArrayList<AnnotType>();

    affectedTypes.add(annotType);  // type will be affected by change

    boolean ancestorChange = false;
    boolean nameChange = false;

    AnnotType pa = null;
    if (prAncStr != null && !prAncStr.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g" + annotType.getGroup().getId()
              + "/" + MessageProcessor.replaceArrows(prAncStr);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List pList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (pList != null && !pList.isEmpty()) {
        pa = (AnnotType) pList.get(0);
      }
      if (pa == null) {
        errorMessage = MessageProvider.getMessage("errorUnknownAnc");
        return null;
      }
    }

    if (annotType.getAncestorType() == null) {  // if type haven't ancestor
      if (!prAncStr.isEmpty()) {
        ancestorChange = true;
      }
    } else {  // if type have ancestor
      if (!annotType.getAncestorType().getLinearizedName().equals(prAncStr)) {
        ancestorChange = true;
      }
    }
    
    if (!annotType.getName().equals(name)) {
      nameChange = true;
    }
    
    // backup informations
    String backupN = annotType.getName();
    AnnotType backupT = annotType.getAncestorType();
    
    if (nameChange) {  // if name should be changed
      // check, whether name can be changed
      Object[] params = new Object[2];  // parameters for database query
      params[0] = "type";
      params[1] = annotType.getId();
      List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
      if (aList != null && !aList.isEmpty()) {  // if some annotations found
        errorMessage = errorMessage + MessageProvider.getMessage("ifAnnotExistsNameCantBeChanged");
        return null;  // name can't be changed
      }

      // check, whether new name is unique
      annotType.setName(name);  // set new name
      params[0] = "uri";
      params[1] = annotType.getGeneratedURI();
      List duplicit = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (duplicit != null && !duplicit.isEmpty()) {
        errorMessage = MessageProvider.getMessage("newNameAlreadyExists");
        annotType.setName(backupN);
        return null;
      }
    }  // if name should be changed
    
    if (ancestorChange) {  // if ancestor should be changed
      annotType.setAncestorType(pa);  // set new primary ancestor
      Object[] params = new Object[2];  // parameters for database query
      params[0] = "uri";
      params[1] = annotType.getGeneratedURI();
      List duplicit = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (duplicit != null && !duplicit.isEmpty()) {
        errorMessage = MessageProvider.getMessage("newNameAlreadyExistsOnPos");
        annotType.setAncestorType(backupT);
        annotType.setName(backupN);
        return null;
      }
    }  // if ancestor should be changed
    
    if (ancestorChange || nameChange) {  // if name or ancestor should be changed
      boolean someChange = true;
      while (someChange) {  // while some types added
        someChange = false;
        List<AnnotType> nowAdd = new ArrayList<AnnotType>();
        for (Iterator<AnnotType> afIt = affectedTypes.iterator(); afIt.hasNext();) {  // for all affected
          AnnotType afT = afIt.next();
          // query DB for types which primary ancestor is actual type
          Object[] params = new Object[2];  // parameters for database query
          params[0] = "ancestor";
          params[1] = afT.getId();
          
          @SuppressWarnings("unchecked")
          List<AnnotType> tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
          if (tList != null && !tList.isEmpty()) {  // if some type found
            for (Iterator<AnnotType> tIt = tList.iterator(); tIt.hasNext();) {
              AnnotType t = tIt.next();
              if (!affectedTypes.contains(t) && !nowAdd.contains(t)) {
                nowAdd.add(t);  // type will be affected by change of ancestor
                someChange = true;
              }
            }
          }  // if some type found
        }  // for all affected
        affectedTypes.addAll(nowAdd);
      }  // while some types added
    }  // if name or ancestor should be changed

    // check whether ancestor can be changed
    if (ancestorChange) {  // if ancestor was changed
      for (Iterator<AnnotType> afTIt = affectedTypes.iterator(); afTIt.hasNext();) {
        AnnotType afTT = afTIt.next();
        Object[] params = new Object[2];  // parameters for database query
        params[0] = "type";
        params[1] = afTT.getId();
        List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
        if (aList != null && !aList.isEmpty()) {  // if some annotations found
          errorMessage = errorMessage + MessageProvider.getMessage("ifAnnotExistsAncCantBeChanged");
          annotType.setName(backupN);
          annotType.setAncestorType(backupT);
          return null;  // name can't be changed
        }
      }
    }  // if ancestor was changed
    
    // persist changes
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    try {
      transaction.begin();

      // update all affected
      for (Iterator<AnnotType> aTIt = affectedTypes.iterator(); aTIt.hasNext();) {  // for each type
        AnnotType aType = aTIt.next();
        AnnotType sType = queryType(aType.getUri(), em);  // get stored variant of type
        if (aType == annotType) {
          sType.setName(annotType.getName());  // update name
          sType.setComment(annotType.getComment());
          sType.setRestrictedAtt(annotType.getRestrictedAtt());
          sType.setUriInOntology(annotType.getUriInOntology());
          if (ancestorChange) {  // if ancestor was changed
            AnnotType oAType = null;
            if (backupT != null) {  // if old ancestor exists, get it
              oAType = queryType(backupT.getUri(), em);
            }
            if (annotType.getAncestorType() == null) {  // if new ancestor is null
              sType.setAncestorType(null);
              if (oAType != null) {
                sType.getAncestorTypes().remove(oAType);  // remove old ancestor from list
              }
            } else {  // if new ancestor is not null
              AnnotType nType = queryType(annotType.getAncestorType().getUri(), em);
              sType.setAncestorType(nType);
              if (!sType.getAncestorTypes().contains(nType)) {
                sType.getAncestorTypes().add(nType);  // add new ancestor to list
              }
            }
          }  // if ancestor was changed
          annotType = sType;
        }
        sType.setUri(sType.getGeneratedURI());  // update URI
      }  // for each type

      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      errorMessage = MessageProvider.getMessage("changesNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Saving of changes in type of annotation failed.";
        Logger.getLogger(EditAT.class.getName()).log(Level.SEVERE, msg, e);
      }
      return null;
    } finally {
      em.close();
    }
    
    // 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();
        // create list of changed types
        for (Iterator<AnnotType> atIt = affectedTypes.iterator(); atIt.hasNext();) {
          AnnotType at = atIt.next();
          flier.AddEditedType(at);
        }
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }

    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedAT(null);
    return "aTypes";
  }  // btnSaveAction()

  /**
   * Query database for type of annotation
   *
   * @param uri URI of type of annotation
   * @param em Entity manager
   * @return Returns type of annotation with given URI
   * @throws RuntimeException If type of annotation was not found, throws exception
   */
  private static AnnotType queryType(String uri, EntityManager em) throws RuntimeException {
    AnnotType annotType = null;
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = uri;
    Query q = em.createNamedQuery("AnnotType.findByUri");
    for (int p = 0; p < params.length; p = p + 2) {
      q.setParameter((String) params[p], params[p + 1]);
    }
    List aList = q.getResultList();
    if (aList != null && !aList.isEmpty()) {  // if type was found
      annotType = (AnnotType) aList.get(0);
    } else {  // if type was not found (merge failed)
      throw new RuntimeException("Type not found!");
    }
    return annotType;
  }  // queryType()
  
  /**
   * Action listener for cancel button
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnCancelAction() {
    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedAT(null);  // clean up variable in session
    return "aTypes";
  }


  /**
   * Action listener for link for remove attribute from edited type of annotation
   *
   * @param id Id of removed attribute
   * @return Returns null to stay in this page
   */
  public String actionRemoveAttr(Integer id) {
    AnnotTypeAttr refAt = new AnnotTypeAttr(id);
    int index = getAttrList().indexOf(refAt);
    attr = getAttrList().get(index);
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      attr = em.merge(attr);
      annotType = em.merge(annotType);
      annotType.getAttributes().remove(attr);
      em.remove(attr);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("attrCantBeRemovedDF");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Removing of attribute from type of annotation failed.";
        Logger.getLogger(EditAT.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(annotType);  // create list of changed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    return null;
  }  // actionRemoveAttr()

  /**
   * Action listener for link for edit attribute
   *
   * @param id Id of edited attribute
   * @return Returns page outcome (identificator of transition)
   */
  public String actionEditAttr(Integer id) {
    AnnotTypeAttr refAt = new AnnotTypeAttr(id);
    int index = getAttrList().indexOf(refAt);
    attr = getAttrList().get(index);

    AnnotType backup = createBackup();
    SessionManager.getSession().setFormBackup(backup);
    SessionManager.getSession().setEditedAT(annotType);
    SessionManager.getSession().setEditedATA(attr);
    return "editATA";
  }  // actionEditAttr()
  
  /**
   * Action listener for link for remove ancestor from edited type of annotation
   *
   * @param id Id of removed attribute
   * @return Returns null to stay in this page
   */
  public String actionRemoveAnc(Integer id) {
    AnnotType refAT = new AnnotType(id);
    int index = getAncList().indexOf(refAT);
    anc = getAncList().get(index);
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      anc = em.merge(anc);
      annotType = em.merge(annotType);
      annotType.getAncestorTypes().remove(anc);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("ancCantBeRemovedDF");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Removing of ancestor from type of annotation failed.";
        Logger.getLogger(EditAT.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(annotType);  // create list of changed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    return null;
  }  // actionRemoveAnc()
  
  
  /**
   * Action listener for link for add attribute to edited type of annotation
   *
   * @return Returns page outcome (identificator of transition)
   */
  public String actionAddAttr() {
    AnnotType backup = createBackup();
    SessionManager.getSession().setFormBackup(backup);
    SessionManager.getSession().setEditedAT(annotType);
    SessionManager.getSession().setEditedATA(null);
    return "addATA";
  }  // actionAddAttr()
  
  /**
   * Creates object with backup of form data
   * 
   * @return Returns object with backup of form data
   */
  private AnnotType 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 (ug == null && annotType != null) {
      ug = annotType.getGroup();
    }
    
    AnnotType pa = null;
    if (prAncStr != null && !prAncStr.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g" + ug.getId()
                   + "/" + MessageProcessor.replaceArrows(prAncStr);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List pList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (pList != null && !pList.isEmpty()) {
        pa = (AnnotType) pList.get(0);
      }
      if (pa == null) {
        errorMessage = MessageProvider.getMessage("errorUnknownAnc");
      }
    }

    AnnotType backup = new AnnotType(null,name,pa,ug);
    backup.setComment(comment);
    backup.setRestrictedAtt(restrictedAtt);
    backup.setUriInOntology(uriInOntology);
    return backup;
  }  // createBackup()

  /**
   * Action listener for link for add ancestor to edited type of annotation
   *
   * @return Returns page outcome (identificator of transition)
   */
  public String actionAddAnc() {
    AnnotType backup = createBackup();
    SessionManager.getSession().setFormBackup(backup);
    SessionManager.getSession().setEditedAT(annotType);
    SessionManager.getSession().setEditedATA(attr);
    SessionManager.getSession().setCameFrom("editAT");
    SessionManager.getSession().setSelectedUG(annotType.getGroup());
    return "selectAT";
  }  // actionAddAnc()
  
  /**
   * Action listener for seve button on page for adding new type of annotation
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnSaveNewAction() {
    if (name.isEmpty()) {
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      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");
        return null;
      }
    } else {
      errorMessage = MessageProvider.getMessage("errorUnknownUG");
      return null;
    }

    AnnotType pa = null;
    if (prAncStr != null && !prAncStr.isEmpty()) {
      String uri = AppBean.getBaseTypeUri() + "g" + ug.getId()
                   + "/" + MessageProcessor.replaceArrows(prAncStr);
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = uri;
      List pList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (pList != null && !pList.isEmpty()) {
        pa = (AnnotType) pList.get(0);
      }
      if (pa == null) {
        errorMessage = MessageProvider.getMessage("errorUnknownAnc");
        return null;
      }
    }

    annotType = new AnnotType(null,name,pa,ug);  // create new type of annotation
    annotType.setUri(annotType.getGeneratedURI());  // generate URI
    annotType.setComment(comment);
    annotType.setRestrictedAtt(restrictedAtt);
    annotType.setUriInOntology(uriInOntology);

    // check for duplicity
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = annotType.getUri();
    List dList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    if (dList != null && !dList.isEmpty()) {
      errorMessage = MessageProvider.getMessage("duplicitUriOfNewType");
      annotType = null;  // discard new type
      return null;
    }

    // persist new type of annotation
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    try {
      transaction.begin();
      
      // merge ancestor
      if (pa != null) {
        pa = em.merge(pa);
        annotType.setAncestorType(pa);
        annotType.addAncestorType(pa);  // add primary ancestor to list of ancestors
      }
      annotType = em.merge(annotType);  // persist new type

      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      errorMessage = MessageProvider.getMessage("newATNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting of new type of annotation failed.";
        Logger.getLogger(EditAT.class.getName()).log(Level.SEVERE, msg, e);
      }
      return null;
    } finally {
      em.close();
    }
    
    // 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.AddAddedType(annotType);  // create list of added types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedAT(null);
    return "aTypes";
  }  // btnSaveNewAction()

  /**
   * Action listener for delete button on deleting page
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnDeleteAction() {
    // find annotations of this type
    Object[] params = new Object[2];
    params[0] = "type";
    params[1] = annotType.getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
    if (aList != null && !aList.isEmpty()) {  // if annotation was found
      errorMessage = MessageProvider.getMessage("ifAnnotationsExistsTypeCantBeDeleted");
      return null;
    }


    // query DB for types, in which ancestors is deleted type
    EntityManager em = AppBean.getPersistenceManager().getEM();
    List tList = null;
    try {
      Query query = em.createQuery("SELECT a FROM AnnotType a JOIN a.ancestorTypes at WHERE at.id='" + annotType.getId() + "'");
      tList = query.getResultList();
    } catch (Exception e) {
      tList = null;
    } finally {
      em.close();
    }
    if (tList != null && !tList.isEmpty()) {
      errorMessage = MessageProvider.getMessage("ifChildrenExistsTypeCantBeDeleted");
      return null;
    }

    // query DB for types which primary ancestor is actual node
    params[0] = "ancestor";
    params[1] = annotType.getId();
    tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
    if (tList != null && !tList.isEmpty()) {
      errorMessage = MessageProvider.getMessage("ifChildrenExistsTypeCantBeDeleted");
      return null;
    }

    if (AppBean.getPersistenceManager().removeEntity(annotType)) {
      errorMessage = MessageProvider.getMessage("typeCantBeDeletedDatabaseFailure");
      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.AddRemovedType(annotType);  // create list of removed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedUG(null);
    return "aTypes";
  }  // btnDeleteAction()

  /**
   * Gets list of attributes of given type of annotation
   * 
   * @return Returns list of attributes of given type of annotation
   */
  public List<AnnotTypeAttr> getAttrList() {
    getBackup();
    return annotType.getAttributes();
  }

  /**
   * Gets list of ancestors of given type of annotation
   * 
   * @return Returns list of ancestors of given type of annotation
   */
  public List<AnnotType> getAncList() {
    getBackup();
    return annotType.getAncestorTypes();
  }
  
  /**
   * Gets value of comment field in form
   * 
   * @return Returns value of comment field in form
   */
  public String getComment() {
    AnnotType backup = getBackup();
    if (comment == null && backup != null) {
      comment = backup.getComment();
    } else if (comment == null && annotType != null) {
      comment = annotType.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 name field in form
   *
   * @return Returns value of name field in form
   */
  public String getName() {
    AnnotType backup = getBackup();
    if (name == null && backup != null) {
      name = backup.getName();
    } else if (name == null && annotType != null) {
      name = annotType.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 group field in form
   *
   * @return Returns value of group field in form
   */
  public String getGroup() {
    AnnotType backup = getBackup();
    if (group == null && backup != null) {
      group = backup.getGroup().getName();
    } else if (group == null && annotType != null) {
      group = annotType.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 value of restricted attributes field in form
   * 
   * @return Returns value of restricted attributes field in form
   */
  public Boolean getRestrictedAtt() {
    AnnotType backup = getBackup();
    if (restrictedAtt == null && backup != null) {
      restrictedAtt = backup.getRestrictedAtt();
    } else if (restrictedAtt == null && annotType != null) {
      restrictedAtt = annotType.getRestrictedAtt();
    } else if (restrictedAtt == null) {
      restrictedAtt = false;
    }
    return restrictedAtt;
  }  // getRestrictedAtt()

  /**
   * Sets value of restricted attributes field in form
   *
   * @param restrictedAtt Value of restricted attributes field in form
   */
  public void setRestrictedAtt(Boolean restrictedAtt) {
    this.restrictedAtt = restrictedAtt;
  }

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

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

  /**
   * Gets selected attribute in table
   *
   * @return Returns selected attribute in table
   */
  public AnnotTypeAttr getAttr() {
    return attr;
  }

  /**
   * Sets selected attribute in table
   *
   * @param attr Selected attribute in table
   */
  public void setAttr(AnnotTypeAttr attr) {
    this.attr = attr;
  }
  
  /**
   * Gets selected ancestor in table
   *
   * @return Returns selected attribute in table
   */
  public AnnotType getAnc() {
    return anc;
  }

  /**
   * Sets selected ancestor in table
   *
   * @param anc Selected ancestor in table
   */
  public void setAnc(AnnotType anc) {
    this.anc = anc;
  }
  

  /**
   * Gets table with attributes of given type of annotation
   *
   * @return Returns table with attributes of given type of annotation
   */
  public HtmlDataTable getListTable() {
    return listTable;
  }

  /**
   * Sets table with attributes of given type of annotation
   *
   * @param listTable Table with attributes of given type of annotation
   */
  public void setListTable(HtmlDataTable listTable) {
    this.listTable = listTable;
  }
  
  /**
   * Gets table with ancestors of given type of annotation
   *
   * @return Returns table with ancestors of given type of annotation
   */
  public HtmlDataTable getAncTable() {
    return ancTable;
  }

  /**
   * Sets table with ancestors of given type of annotation
   *
   * @param ancTable Table with ancestors of given type of annotation
   */
  public void setAncTable(HtmlDataTable ancTable) {
    this.ancTable = ancTable;
  }

  /**
   * Gets value of primary ancestor field in form
   * 
   * @return Returns value of primary ancestor field in form
   */
  public String getPrAncStr() {
    AnnotType backup = getBackup();
    if (prAncStr == null && backup != null) {
      if (backup.getAncestorType() != null) {
        prAncStr = backup.getAncestorType().getLinearizedName();
      } else {
        prAncStr = "";
      }
    } else if (prAncStr == null && annotType != null) {
      if (annotType.getAncestorType() != null) {
        prAncStr = annotType.getAncestorType().getLinearizedName();
      } else {
        prAncStr = "";
      }
    } else if (prAncStr == null) {
      prAncStr = "";
    }
    return prAncStr;
  }  // getPrAncStr()

  /**
   * Gets backup of form data
   * If user came from another page, gets edited type of annotation from session.
   * If user now returned from selection of new ancestor, adds this ancestor to type.
   *
   * @return If backup is available, returns backup of form data, null otherwise
   */
  private AnnotType getBackup() {
    if (annotType == null) {  // user is camming to this page
      annotType = SessionManager.getSession().getEditedAT();
      AnnotType nA = SessionManager.getSession().getSelectedAT();
      if (nA != null && SessionManager.getSession().getCameFrom().equals("editAT")) {
        addSelAncestor(nA);  // add ancestor to type
        SessionManager.getSession().setSelectedAT(null);
        SessionManager.getSession().setCameFrom(null);
      }
    }
    AnnotType backup = null;
    if (SessionManager.getSession().getFormBackup() != null) {
      if (SessionManager.getSession().getFormBackup().getClass().getName().endsWith("AnnotType")) {
        backup = (AnnotType) SessionManager.getSession().getFormBackup();
        if (backup.getId() != annotType.getId()) {
          backup = null;
        }
      }
    }
    return backup;
  }  // getBackup()
  
  /**
   * Adds selected type of annotation to ancestors
   *
   * @param newAnc Type of annotation to add to ancestors
   */
  private void addSelAncestor(AnnotType newAnc) {
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      newAnc = em.merge(newAnc);
      annotType = em.merge(annotType);
      annotType.addAncestorType(newAnc);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("ancCantBeAddedDF");
      return;
    }
    
    // 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(annotType);  // create list of changed types
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
  }  // addSelAncestor()
  
  /**
   * Sets value of primary ancestor field in form
   * 
   * @param prAncStr Value of primary ancestor field in form
   */
  public void setPrAncStr(String prAncStr) {
    this.prAncStr = prAncStr;
  }
 
  /**
   * 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 type of annotation
   *
   * @return Returns edited type of annotation
   */
  public AnnotType getAnnotType() {
    getBackup();
    return annotType;
  }

  /**
   * Sets edited type of annotation
   *
   * @param annotType Edited type of annotation
   */
  public void setAnnotType(AnnotType annotType) {
    this.annotType = annotType;
  }

}  // public class EditAT