EditUG.java

Go to the documentation of this file.

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

/**
 * @file EditUG.java
 *
 * @brief Backbean for adding, editing and deleting of user group
 */

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.User;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import java.io.Serializable;
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;

/**
 * Backbean for pages for adding, editing and deleting of user group
 *
 * @brief Backbean for adding, editing and deleting of user group
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class EditUG implements Serializable {
  /**
   * Value of user group name field in form
   */
  private String name = null;
  /**
   * Error message displayed in form
   */
  private String errorMessage = "";
  /**
   * Table with users in given user group
   */
  private HtmlDataTable listTable;
  /**
   * User selected in the table
   */
  private User user;
  /**
   * Edited user group or user group to be deleted
   */
  private UserGroup userGroup = null;

  /**
   * Constructor
   */
  public EditUG() {
  }

  /**
   * Action listener for save button in the page for editing of the user group
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnSaveAction() {
    if (name.isEmpty()) {  // if name is empty
      errorMessage = MessageProvider.getMessage("nameCantBeEmpty");
      return null;
    }

    userGroup.setName(name);  // update user group
    // persist changes
    UserGroup saved = (UserGroup) AppBean.getPersistenceManager().saveEntityChanges(userGroup);
    if (saved == null) {
      errorMessage = MessageProvider.getMessage("changesNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting of changes in the user group failed.";
        Logger.getLogger(EditUG.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    } else {  // if changes was successfully saved
      userGroup = saved;
    }

    AppBean.refreshUsersInSessions(null);  // refreshes data in sessions
    
    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedUG(null);
    return "userGroups";
  }  // btnSaveAction()

  /**
   * Action listener for seve button on page for adding new groups
   *
   * @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 = new UserGroup(name);  // create new user group

    // persist new group
    if (AppBean.getPersistenceManager().persistEntity(userGroup)) {
      errorMessage = MessageProvider.getMessage("newGroupNSDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting of new user group failed.";
        Logger.getLogger(EditUG.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    }

    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedUG(null);
    return "userGroups";
  }  // btnSaveNewAction()

  /**
   * 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().setEditedUG(null);  // clean up variable in session
    return "userGroups";
  }

  /**
   * Action listener for delete button on deleting page
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnDeleteAction() {
    if (userGroup.getName().equalsIgnoreCase(Constants.ADMIN_GROUP)) {
      errorMessage = MessageProvider.getMessage("deleteAdmins");
      return null;
    }

    // find annotation types in this group
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = userGroup.getId();
    List gList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUserGroup", params);
    if (gList != null && !gList.isEmpty()) {  // if annotation type was found
      errorMessage = MessageProvider.getMessage("ifTypesExistsGroupCantBeDeleted");
      return null;
    }

    if (!userGroup.getUsers().isEmpty()) {
      errorMessage = MessageProvider.getMessage("ifUsersExistsGroupCantBeDeleted");
      return null;
    }

    if (AppBean.getPersistenceManager().removeEntity(userGroup)) {
      errorMessage = MessageProvider.getMessage("groupCantBeDeletedDatabaseFailure");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Deleting of the user group failed.";
        Logger.getLogger(EditUG.class.getName()).log(Level.SEVERE, msg);
      } 
      return null;
    }

    SessionManager.getSession().setFormBackup(null);
    SessionManager.getSession().setEditedUG(null);
    return "userGroups";
  }  // btnDeleteAction()

  /**
   * Gets edited user group
   * If user group not set yet, pick up it from session
   *
   * @return Returns edited user group
   */
  public UserGroup getUserGroup() {
    if (userGroup == null) {
      userGroup = SessionManager.getSession().getEditedUG();
    }
    return userGroup;
  }

  /**
   * Sets edited user group
   *
   * @param userGroup Edited user group
   */
  public void setUserGroup(UserGroup userGroup) {
    this.userGroup = userGroup;
  }

  /**
   * Gets value of user group name field in form
   * If user group not set yet, pick up it from session
   *
   * @return Returns value of user group name field in form
   */
  public String getName() {
    if (userGroup == null) {
      userGroup = SessionManager.getSession().getEditedUG();
    }
    UserGroup backup = null;
    if (SessionManager.getSession().getFormBackup() != null) {
      if (SessionManager.getSession().getFormBackup().getClass().getName().endsWith("UserGroup")) {
        backup = (UserGroup) SessionManager.getSession().getFormBackup();
        if (backup.getId() != userGroup.getId()) {
          backup = null;
        }
      }
    }
    if (name == null && backup != null) {
      name = backup.getName();
    } else if (name == null && userGroup != null) {
      name = userGroup.getName();
    } else if (name == null) {
      name = "";
    }
    return name;
  }

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

  /**
   * 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 table with users in given user group
   *
   * @return Returns table with users in given user group
   */
  public HtmlDataTable getListTable() {
    return listTable;
  }

  /**
   * Sets table with users in given user group
   *
   * @param listTable Table with users in given user group
   */
  public void setListTable(HtmlDataTable listTable) {
    this.listTable = listTable;
  }

  /**
   * Gets list of all users in edited user group
   *
   * @return List of all users in edited user group
   */
  public List<User> getUsersList() {
    if (userGroup == null) {
      userGroup = SessionManager.getSession().getEditedUG();
    }
    return userGroup.getUsers();
  }

  /**
   * Gets user selected in the table
   *
   * @return Returns user selected in the table
   */
  public User getUser() {
    return user;
  }

  /**
   * Sets user selected in the table
   *
   * @param user User selected in the table
   */
  public void setUser(User user) {
    this.user = user;
  }

  /**
   * Action listener for remove link in the table. Removes user from user group
   *
   * @param id Id of removed user
   * @return Returns null to stay in this page
   */
  public String actionRemoveUser(Integer id) {
    if (userGroup.getName().equalsIgnoreCase(Constants.ADMIN_GROUP) && userGroup.getUsers().size() < 2) {
      // the last administrator can't be removed
      errorMessage = MessageProvider.getMessage("removeLastAdmin");
      return null;
    }
    // get selected row data
    User refU = new User(id);
    int index = getUsersList().indexOf(refU);
    user = getUsersList().get(index);
    try {
      EntityManager em = AppBean.getPersistenceManager().getEM();
      EntityTransaction transaction = em.getTransaction();
      transaction.begin();
      user = em.merge(user);
      userGroup = em.merge(userGroup);
      userGroup.getUsers().remove(user);  // remove user from group
      user.getGroups().remove(userGroup);
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      errorMessage = MessageProvider.getMessage("userCantBeREmovedDF");
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Removing of user from the user group failed.";
        Logger.getLogger(EditUG.class.getName()).log(Level.SEVERE, msg, e);
      }
      return null;
    }
    
    AppBean.refreshUsersInSessions(user);  // refreshes data in sessions
    return null;
  }  // actionRemoveUser()

  /**
   * Action listener for link for add user to edited group
   *
   * @return Returns page outcome (identificator of transition)
   */
  public String actionAddUser() {
    UserGroup backup = new UserGroup(userGroup.getId(),name);
    SessionManager.getSession().setFormBackup(backup);
    SessionManager.getSession().setEditedUG(userGroup);
    return "selectUser";
  }

}  // public class EditUG