ATypes.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: ATypes.java
 * Description: Backbean for page with types of annotations
 */

/**
 * @file ATypes.java
 *
 * @brief Backbean for page with 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.entity.AnnotType;
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.model.SelectItem;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import org.openfaces.util.Faces;

/**
 * Backbean for page with types of annotations
 *
 * @brief Backbean for page with types of annotations
 * @author idytrych
 */
@ManagedBean
@SessionScoped
public class ATypes implements Serializable {
  /**
   * Selected user groups
   */
  private List<UserGroup> selGroups = null;
  /**
   * Selected type of annotation
   */
  private AnnotType selType = null;

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

  /**
   * Action listener for edit links in table
   *
   * @return Returns page outcome to go to editing page
   */
  public String actionEdit(Integer id) {
    // query DB for selected type
    List tList = null;
    AnnotType selected = null;
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    tList = AppBean.getPersistenceManager().queryDB("AnnotType.findById", params);
    if (tList != null && !tList.isEmpty()) {
      selected = (AnnotType) tList.get(0);
    }

    // pass selected type of annotation through the session
    SessionManager.getSession().setEditedAT(selected);
    SessionManager.getSession().setFormBackup(null);
    return "editAT";
  }  // actionEdit()

  /**
   * Action listener for delete links in table
   *
   * @return Returns page outcome to go to deleting page
   */
  public String actionDelete(Integer id) {
    // query DB for selected type
    List tList = null;
    AnnotType selected = null;
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    tList = AppBean.getPersistenceManager().queryDB("AnnotType.findById", params);
    if (tList != null && !tList.isEmpty()) {
      selected = (AnnotType) tList.get(0);
    }

    // pass selected type of annotation through the session
    SessionManager.getSession().setEditedAT(selected);
    SessionManager.getSession().setFormBackup(null);
    return "deleteAT";
  }  // actionDelete()

  /**
   * Gets selected type of annotation
   *
   * @return Returns selected type of annotation
   */
  public AnnotType getSelType() {
    return selType;
  }

  /**
   * Sets selected type of annotation
   *
   * @param selType Selected type of annotation
   */
  public void setSelType(AnnotType selType) {
    this.selType = selType;
  }

  /**
   * Gets content of auxiliary variable with actual node for TreeTable
   *
   * @return Returns actual node of tree
   */
  public AnnotType getAnnotT() {
    AnnotType annotT = Faces.var("annotT", AnnotType.class);
    return annotT;
  }

  /**
   * Gets children of actual node in TreeTable
   *
   * @return Returns children of actual node
   */
  public List<AnnotType> getNodeChildren() {
    List<AnnotType> rList = new ArrayList<AnnotType>();
    AnnotType annotT = Faces.var("annotT", AnnotType.class);  // get actual node

    if (annotT != null) {  // if node is set

      // query DB for types, in which ancestors is actual node
      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='" + annotT.getId() + "'");
        tList = query.getResultList();
      } catch (Exception e) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "DB query in getNodeChildren failed.";
          Logger.getLogger(ATypes.class.getName()).log(Level.SEVERE, msg, e);
        }
        tList = null;
      } finally {
        em.close();
      }
      if (tList != null && !tList.isEmpty()) {
        for (Iterator tIt = tList.iterator(); tIt.hasNext();) {
          AnnotType at = (AnnotType) tIt.next();
          rList.add(at);  // add to list to return
        }
      }

      // query DB for types which primary ancestor is actual node
      tList = null;
      Object[] params = new Object[2];
      params[0] = "ancestor";
      params[1] = annotT.getId();
      tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
      if (tList != null && !tList.isEmpty()) {
        for (Iterator tIt = tList.iterator(); tIt.hasNext();) {
          AnnotType at = (AnnotType) tIt.next();
          if (!rList.contains(at)) {
            rList.add(at);  // add to list to return
          }
        }
      }
      
      return rList;
    }  // if node is set

    // if node is not set, actual node is root node of tree
    // (children are all top level types of annotations)

    // types must be get for all selected groups
    for (Iterator<UserGroup> ugIt = selGroups.iterator(); ugIt.hasNext();) {
      UserGroup ug = ugIt.next();
      // query database for root types in given group
      List tList = null;
      EntityManager em = AppBean.getPersistenceManager().getEM();
      try {
        Query query = em.createQuery("SELECT a FROM AnnotType a WHERE a.groupId = '" + ug.getId() + "' AND a.ancestor IS NULL");
        tList = query.getResultList();
      } catch (Exception e) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "DB query in getNodeChildren failed.";
          Logger.getLogger(ATypes.class.getName()).log(Level.SEVERE, msg, e);
        }
        tList = null;
      } finally {
        em.close();
      }

      if (tList != null && !tList.isEmpty()) {  // if types was found
        for (Iterator tIt = tList.iterator(); tIt.hasNext();) {
          AnnotType type = (AnnotType) tIt.next();
          rList.add(type);  // add to list to return
        }
      }
    }  // for all selected groups

    return rList;
  }  // getNodeChildren()


  /**
   * Returns, whether actuall node in tree has children
   *
   * @return If actual node has children, returns true, false otherwise
   */
  public boolean getNodeHasChildren() {
    AnnotType annotT = Faces.var("annotT", AnnotType.class);
    if (annotT != null) {  // if node is set
      // query DB for types, in which ancestors is actual node
      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='" + annotT.getId() + "'");
        tList = query.getResultList();
      } catch (Exception e) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "DB query in getNodeHasChildren failed.";
          Logger.getLogger(ATypes.class.getName()).log(Level.SEVERE, msg, e);
        }
        tList = null;
      } finally {
        em.close();
      }
      if (tList != null && !tList.isEmpty()) {
        return true;
      }

      // query DB for types which primary ancestor is actual node
      Object[] params = new Object[2];
      params[0] = "ancestor";
      params[1] = annotT.getId();
      tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
      if (tList != null && !tList.isEmpty()) {
        return true;
      }
    }  // if (annotT != null ...
    return false;
  }  // getNodeHasChildren()

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