AttrO.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: AttrO.java
 * Description: Backbean for page with attributes from ontology
 */

/**
 * @file AttrO.java
 *
 * @brief Backbean for page with 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.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.SessionScoped;
import javax.faces.component.html.HtmlDataTable;
import javax.faces.model.SelectItem;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

/**
 * Backbean for page with attributes from ontology
 *
 * @brief Backbean for page with attributes from ontology
 * @author idytrych
 */
@ManagedBean
@SessionScoped
public class AttrO implements Serializable {
  /**
   * Table with attributes of given type of annotation
   */
  private HtmlDataTable listTable;
  /**
   * Selected user groups
   */
  private List<UserGroup> selGroups = null;
  /**
   * Attribute selected in the table
   */
  private TypeAttrOnto attr;

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

  
  /**
   * Constructor
   * - Sets selected user groups to user's joined groups
   */
  public AttrO() {
    if (selGroups == null) {
      selGroups = SessionManager.getSession().getLoggedUser().getGroupsAL();
    }
  }

  /**
   * Action listener for link for remove attribute
   *
   * @param id Id of removed attribute
   * @return Returns null to stay in this page
   */
  public String actionRemoveAttr(Integer id) {
    TypeAttrOnto refAt = new TypeAttrOnto(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);
      em.remove(attr);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Removing of attribute from ontology failed..";
        Logger.getLogger(AttrO.class.getName()).log(Level.SEVERE, msg, e);
      }
      errorMessage = MessageProvider.getMessage("attrCantBeRemovedDF");
    }
    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) {
    TypeAttrOnto refAt = new TypeAttrOnto(id);
    int index = getAttrList().indexOf(refAt);
    attr = getAttrList().get(index);

    SessionManager.getSession().setEditedTAO(attr);
    return "editTAO";
  }  // actionEditAttr()

  /**
   * Action listener for link for add attribute
   *
   * @return Returns page outcome (identificator of transition)
   */
  public String actionAddAttr() {
    SessionManager.getSession().setEditedTAO(null);
    return "addTAO";
  }  // actionAddAttr()

  /**
   * Gets list of attributes from ontology
   *
   * @return Returns list of attributes from ontology
   */
  public List<TypeAttrOnto> getAttrList() {
    List<TypeAttrOnto> rList = new ArrayList<TypeAttrOnto>();
    // query database for attributes
    Object[] params = new Object[2];
    params[0] = "groupId";
    for (Iterator<UserGroup> sgIt = selGroups.iterator(); sgIt.hasNext();) {  // for all selected groups
      UserGroup ug = sgIt.next();
      params[1] = ug.getId();
      List aList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findByUserGroup", params);
      if (aList != null && !aList.isEmpty()) {  // if some types was found
        for (Iterator aIt = aList.iterator(); aIt.hasNext();) {
          TypeAttrOnto tao = (TypeAttrOnto)aIt.next();
          rList.add(tao);
        }
      }
    }  // for all selected groups
    
    return rList;
  }  // getAttrList()

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

  /**
   * Sets selected attribute in table
   *
   * @param attr Selected attribute in table
   */
  public void setAttr(TypeAttrOnto attr) {
    this.attr = attr;
  }

  /**
   * 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 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 selected user groups
   *
   * @return Returns selected user groups
   */
  public List<UserGroup> getSelGroups() {
    return selGroups;
  }

  /**
   * Sets selected user groups
   *
   * @param selGroups Selected user groups
   */
  public void setSelGroups(List<UserGroup> selGroups) {
    this.selGroups = selGroups;
  }
  
  /**
   * Gets selected user groups
   *
   * @return Returns list of selected user groups
   */
  public List<UserGroup> getSelGroupsS() {
    return selGroups;
  }

  /**
   * Sets selected user groups from strings with groups
   *
   * @param selGroupsStrings List of strings with selected user groups in format
   *                         "cz.vutbr.fit.knot.annotations.entity.UserGroup[id=N]"
   *                         (cz.vutbr.fit.knot.annotations.entity.UserGroup.toString())
   */
  public void setSelGroupsS(List<String> selGroupsStrings) {
    List<UserGroup> nList = new ArrayList<UserGroup>();
    for (Iterator<String> sIt = selGroupsStrings.iterator(); sIt.hasNext();) {
      String s = sIt.next();
      int begin = s.indexOf("[id=") + 4;  // find begin of id
      if (begin < 0 || begin > s.length()) {
        begin = 0;
      }
      int end = s.length() - 1;  // find end of id
      if (end < 0) {
        end = 0;
      }
      String idS = s.substring(begin, end);  // id of user group in string
      Integer id = null;
      try {
        id = Integer.parseInt(idS);  // parse id of group
      } catch (NumberFormatException numberFormatException) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "Exception in setSelGroupS.";
          Logger.getLogger(ATypes.class.getName()).log(Level.SEVERE, msg, numberFormatException);
        }
        continue;
      }

      // query DB for user group
      Object[] params = new Object[2];
      params[0] = "id";
      params[1] = id;
      
      @SuppressWarnings("unchecked")
      List<UserGroup> ugList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
      if (ugList != null && !ugList.isEmpty()) {  // if user group was found
        for (Iterator<UserGroup> ugIt = ugList.iterator(); ugIt.hasNext();) {
          UserGroup ug = ugIt.next();
          nList.add(ug);
        }
      }
    }  // for ...
    selGroups = nList;
  }  // setSelGroupsS()
  
  /**
   * Gets all user groups
   *
   * @return All user groups in list of SelectItem
   */
  public List<SelectItem> getAllGroups() {
    // query DB for user groups
    List<SelectItem> rList = new ArrayList<SelectItem>();
    
    @SuppressWarnings("unchecked")
    List<UserGroup> ugList = AppBean.getPersistenceManager().queryDB("UserGroup.findAll");
    if (ugList != null && !ugList.isEmpty()) {  // if types was found
      for (Iterator<UserGroup> ugIt = ugList.iterator(); ugIt.hasNext();) {
        UserGroup ug = ugIt.next();
        rList.add(new SelectItem(ug, ug.getName()));
      }
    }
    return rList;
  }  // getAllGroups()
  
}  // public class AttrO