Documents.java

Go to the documentation of this file.

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

/**
 * @file Documents.java
 *
 * @brief Backbean for page with administration of uploaded documents
 */

package cz.vutbr.fit.knot.annotations.web;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.StoredDocument;
import cz.vutbr.fit.knot.annotations.entity.User;
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 javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.component.html.HtmlDataTable;
import javax.faces.model.SelectItem;

/**
 * Backbean for page with administration of uploaded documents
 *
 * @brief Backbean for page with administration of uploaded documents
 * @author idytrych
 */
@ManagedBean
@SessionScoped
public class Documents implements Serializable {
  /**
   * Table with documents
   */
  private HtmlDataTable listTable;
  /**
   * Document selected in the table
   */
  private StoredDocument doc;
  /**
   * Selected user groups
   */
  private List<UserGroup> selGroups = null;
  /**
   * Selected users
   */
  private List<User> selUsers = null;
  /**
   * Error message displayed in page
   */
  private String errorMessage = "";

  /**
   * Constructor
   * - Sets selected user groups to user's joined groups
   * - Sets selected user to logged in user
   */
  public Documents() {
    errorMessage = "";
    if (selGroups == null) {
      selGroups = SessionManager.getSession().getLoggedUser().getGroupsAL();
    }
    if (selUsers == null) {
      selUsers = new ArrayList<User>();
      selUsers.add(SessionManager.getSession().getLoggedUser());
    }
  }

  /**
   * Gets table with documents
   *
   * @return Returns table with documents
   */
  public HtmlDataTable getListTable() {
    return listTable;
  }

  /**
   * Sets table with documents
   *
   * @param listTable Table with documents
   */
  public void setListTable(HtmlDataTable listTable) {
    this.listTable = listTable;
  }

  /**
   * Gets list of documents to display in the table
   *
   * @return Returns list of documents to display in the table
   */
  public List<StoredDocument> getDocumentsList() {
    List<StoredDocument> rList = new ArrayList<StoredDocument>();
    // documents must be get for all selected groups
    for (Iterator<UserGroup> ugIt = selGroups.iterator(); ugIt.hasNext();) {
      UserGroup ug = ugIt.next();
      // query database for documents in given group
      Object[] params = new Object[2];
      params[0] = "groupId";
      params[1] = ug.getId();
      List dList = AppBean.getPersistenceManager().queryDB("StoredDocument.findByGroupId", params);
      if (dList != null && !dList.isEmpty()) {  // if some documents was found
        for (Iterator dIT = dList.iterator(); dIT.hasNext();) {
          StoredDocument sDoc = (StoredDocument)dIT.next();
          if (!rList.contains(sDoc)) {
            rList.add(sDoc);  // add to list
          }
        }
      }  // if some documents was found
    }  // for all selected groups

    // documents must be get for all selected users too
    for (Iterator<User> uIt = selUsers.iterator(); uIt.hasNext();) {
      User u = uIt.next();
      // query database for documents in given group
      Object[] params = new Object[2];
      params[0] = "ownerId";
      params[1] = u.getId();
      List dList = AppBean.getPersistenceManager().queryDB("StoredDocument.findByOwnerId", params);
      if (dList != null && !dList.isEmpty()) {  // if some documents was found
        for (Iterator dIT = dList.iterator(); dIT.hasNext();) {
          StoredDocument sDoc = (StoredDocument)dIT.next();
          if (!rList.contains(sDoc)) {
            rList.add(sDoc);  // add to list
          }
        }
      }  // if some documents was found
    }  // for all selected users

    return rList;
  }  // getDocumentsList()

  /**
   * Action listener for delete links in table
   * 
   * @return Returns null to stay in this page
   */
  public String actionDelete() {
    doc = (StoredDocument) listTable.getRowData();

    errorMessage = "";

    AnnotDocument aDoc = null;
    // find annotated copy of this document
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = doc.getUri();
    List gList = AppBean.getPersistenceManager().queryDB("AnnotDocument.findByUri", params);
    if (gList != null && !gList.isEmpty()) {  // if annotation was found
      aDoc = (AnnotDocument) gList.get(0);
    }
    
    // find annotations of this document
    if (aDoc != null) {
      params[0] = "sourceDocumentId";
      params[1] = aDoc.getId();
      List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentID", params);
      if (aList != null && !aList.isEmpty()) {  // if annotation was found
        errorMessage = MessageProvider.getMessage("ifAnnotationsExistsDocumentCantBeDeleted");
        return null;
      }
    }

    // check permissions
    if (!doc.getOwner().equals(SessionManager.getSession().getLoggedUser())) {
      if (SessionManager.getSession().isAdmin()) {
        errorMessage = MessageProvider.getMessage("delOnlyOwnDoc");
        return null;
      }
    }

    // delete from DB
    AppBean.getPersistenceManager().removeEntity(doc);
    doc = null;
    
    return null;
  }  // actionDelete()

  /**
   * Gets selected user groups
   *
   * @return Returns selected user groups
   */
  public List<UserGroup> getSelGroups() {
    return selGroups;
  }

  /**
   * Gets base URI of stored documents
   * 
   * @return Returns base URI of stored documents
   */
  public String getBaseUri() {
    return AppBean.getBaseStoredDocumentUri();
  }

  /**
   * 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) {
        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()

  /**
   * Gets selected users
   *
   * @return Returns selected users
   */
  public List<User> getSelUsers() {
    return selUsers;
  }

  /**
   * Sets selected users
   *
   * @param selUsers Selected users
   */
  public void setSelUsers(List<User> selUsers) {
    this.selUsers = selUsers;
  }

  /**
   * Gets selected users
   *
   * @return Returns list of selected users
   */
  public List<User> getSelUsersS() {
    return selUsers;
  }

  /**
   * Sets selected users from strings with users
   *
   * @param selUsersStrings List of strings with selected user groups in format
   *                         "cz.vutbr.fit.knot.annotations.entity.User[id=N]"
   *                         (cz.vutbr.fit.knot.annotations.entity.User.toString())
   */
  public void setSelUsersS(List<String> selUsersStrings) {
    List<User> nList = new ArrayList<User>();
    for (Iterator<String> sIt = selUsersStrings.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 in string
      Integer id = null;
      try {
        id = Integer.parseInt(idS);  // parse id of user
      } catch (NumberFormatException numberFormatException) {
        continue;
      }

      // query DB for user
      Object[] params = new Object[2];
      params[0] = "id";
      params[1] = id;
      
      @SuppressWarnings("unchecked")
      List<User> uList = AppBean.getPersistenceManager().queryDB("User.findById", params);
      if (uList != null && !uList.isEmpty()) {  // if user was found
        for (Iterator<User> uIt = uList.iterator(); uIt.hasNext();) {
          User u = uIt.next();
          nList.add(u);
        }
      }
    }  // for ...
    selUsers = nList;
  }  // setSelUsersS()

  /**
   * Gets all users
   *
   * @return All users in list of SelectItem
   */
  public List<SelectItem> getAllUsers() {
    // query DB for users
    List<SelectItem> rList = new ArrayList<SelectItem>();
    
    @SuppressWarnings("unchecked")
    List<User> uList = AppBean.getPersistenceManager().queryDB("User.findAll");
    if (uList != null && !uList.isEmpty()) {  // if types was found
      for (Iterator<User> uIt = uList.iterator(); uIt.hasNext();) {
        User u = uIt.next();
        rList.add(new SelectItem(u, u.getName() + " (" + u.getLogin() + ")"));
      }
    }
    return rList;
  }  // getAllUsers()

  /**
   * Gets document selected in the table
   *
   * @return Returns document selected in the table
   */
  public StoredDocument getDoc() {
    return doc;
  }

  /**
   * Sets document selected in the table
   *
   * @param doc Document selected in the table
   */
  public void setDoc(StoredDocument doc) {
    this.doc = doc;
  }

  /**
   * Gets error message displayed in page
   *
   * @return Returns error message displayed in page
   */
  public String getErrorMessage() {
    return errorMessage;
  }

  /**
   * Sets error message to be displayed in page
   *
   * @param errorMessage Error message to be displayed in page
   */
  public void setErrorMessage(String errorMessage) {
    this.errorMessage = errorMessage;
  }

}  // public class Documents