PersonsModule.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: PersonsModule.java
 * Description: This module implements operations with persons
 *              (users of this server) and with user groups.
 * 
 */

/**
 * @file PersonsModule.java
 *
 * @brief Operations with persons (users of this server) and with user groups
 */

/**
 * @package cz.vutbr.fit.knot.annotations.modules
 * 
 * @brief Modules with server functionality
 */
package cz.vutbr.fit.knot.annotations.modules;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.comet.AnnotServerModule;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2Constants;
import cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2MessagesCreator;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.Query;

/**
 * Class which performs operations with persons (users of this server)
 * and with user groups
 *
 * @brief Operations with persons (users of this server) and with user groups
 * @author idytrych
 */
public class PersonsModule implements AnnotServerModule {

  /**
   * This method is called when client sent message and these message
   * has been processed. Changes in types, annotations and in other entities
   * are persisted after calling this method from all modules.
   *
   * @param requestInfo Info about client request
   * @return String with messages for client or empty string
   */
  @Override
  public String processRequestBeforePersist(RequestInfo requestInfo) {
    return "";
  }

  /**
   * This method is called when client sent message, these message
   * has been processed and changes in entities are persisted.
   * Composed response is sent to client after calling this method from
   * all modules.
   * It performs:
   * - creating message with queried persons
   * - creating message with queried user groups
   *
   * @param requestInfo Informations about client request
   * @param persistFailed True if changes not persisted, false otherwise.
   * @return String with messages for client or empty string
   */
  @Override
  public String processRequestAfterPersist(RequestInfo requestInfo, boolean persistFailed) {
    String retString = "";
    // create message from queried persons
    if (!requestInfo.getQueryPersons().isEmpty()) {
      Iterator<String> reqIter = requestInfo.getQueryPersons().iterator();
      retString = retString + processQP(reqIter, false, requestInfo);
    }
    // create message from queried persons with user groups
    if (!requestInfo.getQueryPersonsWG().isEmpty()) {
      Iterator<String> reqIter = requestInfo.getQueryPersonsWG().iterator();
      retString = retString + processQP(reqIter, true, requestInfo);
    }
    // create message from queried user groups
    if (!requestInfo.getQueryUserGroups().isEmpty()) {
      Iterator<String> reqIter = requestInfo.getQueryUserGroups().iterator();
      retString = retString + processQUG(reqIter, false, requestInfo);
    }
    // create message from queried user groups with persons
    if (!requestInfo.getQueryUserGroupsWP().isEmpty()) {
      Iterator<String> reqIter = requestInfo.getQueryUserGroupsWP().iterator();
      retString = retString + processQUG(reqIter, true, requestInfo);
    }
    // create message from queried persons for protocol version 2.0
    if(requestInfo.getUsersQueryV2() != null && !requestInfo.getUsersQueryV2().isEmpty()){
      ArrayList<User> users = userQuerry(requestInfo.getUsersQueryV2());
      retString = retString + P2MessagesCreator.getXMLUsersList(users,requestInfo.getUsersRestrictionsV2());
    }
    // create message from queried users groups for protocol version 2.0
    if(requestInfo.getGroupsQueryV2() != null && !requestInfo.getGroupsQueryV2().isEmpty()){
      ArrayList<UserGroup> groups = groupQuerry(requestInfo.getGroupsQueryV2());
      boolean withUsers = false;
      if(requestInfo.getGroupsQueryV2().get(P2Constants.GROUPS_Q_W_USERS).equals("true")){
        withUsers = true;
      }
      retString = retString + P2MessagesCreator.getXMLGroupsList(groups,withUsers,requestInfo.getUsersGroupRestrictionsV2());
    }
    
    return retString;
  }  // processRequestAfterPersist()

  /**
   * Gets queried user groups in XML string
   * 
   * @param reqIter Iterator to array with filters (queries)
   * @param withPersons If persons have to be included, then true, false otherwise
   * @param requestInfo Informations about client request
   * @return Returns XML string with queried user groups
   */
  public String processQUG(Iterator<String> reqIter, Boolean withPersons, RequestInfo requestInfo) {
    String retString = "";
    while (reqIter.hasNext()) {  // for each filter (query)
      String reqStr = reqIter.next();
      List gList = null;
      if (reqStr.contains(AppBean.getBaseGroupUri())) {  // if filter contains URI of group
        // get id from group by stripping off base URI
        String idStr = reqStr.replace(AppBean.getBaseGroupUri(), "");
        // parse id
        Integer reqId = null;
        try {
          Integer id = Integer.parseInt(idStr);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad id of group in the query message: " + idStr;
            Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg, nfe);
          }
          continue;  // if id is bad, no results for this query
        }
        // query database for group
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = reqId;
        gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
      } else {  // if filter contains name of group
        EntityManager em = AppBean.getPersistenceManager().getEM();
        String reqName = reqStr.replace("*", "%");  // replace wildcards by those used by database
        // query database
        String gQStr = "SELECT u FROM UserGroup u WHERE u.name LIKE '" + reqName + "'";
        try {
          Query query = em.createQuery(gQStr);
          gList = query.getResultList();
        } catch (Exception e) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Exception during the query for user groups.";
            Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg);
          }
          gList = null;
        } finally {
          em.close();
        }
      }  // if filter contains name of group

      if (gList != null && !gList.isEmpty() && withPersons) {
        // if user groups was found and have to be returned with persons
        Iterator gIter = gList.iterator();
        while (gIter.hasNext()) {  // for each found user group
          UserGroup uGroup = (UserGroup) gIter.next();
          retString = retString + uGroup.toXMLStringWP();  // serialize
        }
      } else if (gList != null && !gList.isEmpty()) {
        // if user groups was found
        Iterator gIter = gList.iterator();
        while (gIter.hasNext()) {  // for each found user group
          UserGroup uGroup = (UserGroup) gIter.next();
          retString = retString + uGroup.toXMLString();  // serialize
        }
      }
    }  // for each filter (query)

    // surround with userGroups message
    retString = "<userGroups>" + retString + "</userGroups>";
    return retString;
  }  // processQUG()

  /**
   * Gets queried persons (users) in XML string
   * 
   * @param reqIter Iterator to array with filters (queries)
   * @param withGroups If users groups have to be included, then true, false otherwise
   * @param requestInfo Informations about client request
   * @return Returns XML string with queried persons
   */
  public String processQP(Iterator<String> reqIter, Boolean withGroups, RequestInfo requestInfo) {
    String retString = "";
    while (reqIter.hasNext()) {  // for each filter (query)
      String reqStr = reqIter.next();
      Integer reqId = null;
      String reqName = null;
      String reqEmail = null;
      
      // get attributes of person from filter (split fields of filter)
      String[] reqAttrArray = reqStr.split(";");
      ArrayList<String> reqAttributes = new ArrayList<String>(Arrays.asList(reqAttrArray));
      Iterator<String> reqAttrIterator = reqAttributes.iterator();
      while (reqAttrIterator.hasNext()) {  // for each attribute of person (field of filter)
        String reqAttr = reqAttrIterator.next();
        if (reqAttr.indexOf(" ") == 0) {  // trim leading white space
          reqAttr = reqAttr.substring(1, reqAttr.length());
        }
        if (reqAttr.indexOf("id:") == 0) {  // if this field contains id (URI)
          String reqIdStr = reqAttr.substring(3, reqAttr.length());  // remove field name
          if (reqIdStr.indexOf(" ") == 0) {  // trim leading white space
            reqIdStr = reqIdStr.substring(1, reqIdStr.length());
          }
          // remove base URI
          reqIdStr = reqIdStr.replace(AppBean.getBaseAuthorUri(), "");
          try {
            // parse id
            reqId = Integer.parseInt(reqIdStr);
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad id of person in the query message: " + reqIdStr;
              Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg, nfe);
            }
            reqId = null;
          }
        } else if (reqAttr.indexOf("email:") == 0) {  // if this field contains email
          reqEmail = reqAttr.substring(6, reqAttr.length());  // remove field name
          if (reqEmail.indexOf(" ") == 0) {  // trim leading white space
            reqEmail = reqEmail.substring(1, reqEmail.length());
          }
        } else if (reqAttr.indexOf("name:") == 0) {  // if this field contains full name
          reqName = reqAttr.substring(5, reqAttr.length());  // remove field name
          if (reqName.indexOf(" ") == 0) {  // trim leading white space
            reqName = reqName.substring(1, reqName.length());
          }
        } else if (reqAttr.indexOf(AppBean.getBaseAuthorUri()) == 0) {  // if this field contains URI (id)
          // remove base URI
          String reqIdStr = reqAttr.substring(AppBean.getBaseAuthorUri().length(), reqAttr.length());
          try {
            // parse id of user
            reqId = Integer.parseInt(reqIdStr);
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad id of person in the query message (in URI): " + reqIdStr;
              Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg, nfe);
            }
            reqId = null;
          }
        } else if (reqAttr.indexOf("@") > 0 && reqEmail == null) {  // if this field probably contains email
          reqEmail = reqAttr;
        } else if (reqName == null) {  // if full name was not set, this field probably contains it
          reqName = reqAttr;
        }
        // unknown attributes are omitted
      }  // for each attribute of person (field of filter)

      // default if find by name and email
      String qStr = "User.findByNameAndEmail";
      String fQStr = null;
      Object[] params = null;
      if (reqId != null) {  // if id is set, it will be used instead
        qStr = "User.findById";
        params = new Object[2];
        params[0] = "id";
        params[1] = reqId;
      } else if (reqEmail != null && reqName != null) {  // if email and name are set
        if (reqName.contains("*") && reqEmail.contains("*")) {  // if wildcards are used in both
          reqName = reqName.replace("*", "%");  // replace wildcards by those used by database
          reqEmail = reqEmail.replace("*", "%");
          // special query must be used
          fQStr = "SELECT u FROM User u WHERE u.name LIKE '" + reqName + "' AND u.email LIKE '" + reqEmail + "'";
        } else if (reqEmail.contains("*")) {  // if wildcards are used in email only
          reqEmail = reqEmail.replace("*", "%");
          // special query must be used
          fQStr = "SELECT u FROM User u WHERE u.name LIKE '" + reqName + "' AND u.email = '" + reqEmail + "'";
        } else if (reqName.contains("*")) {  // if wildcards are used in full name only
          reqName = reqName.replace("*", "%");
          // special query must be used
          fQStr = "SELECT u FROM User u WHERE u.name = '" + reqName + "' AND u.email LIKE '" + reqEmail + "'";
        } else {  // if wildcards aren't used, ordinary named query will be used
          params = new Object[4];
          params[0] = "name";
          params[1] = reqName;
          params[2] = "email";
          params[3] = reqEmail;
        }
      } else if (reqName == null) {  // if only email is set
        if (reqEmail.contains("*")) {  // if wildcards are used
          reqEmail = reqEmail.replace("*", "%");  // replace wildcards by those used by database
          // special query must be used
          fQStr = "SELECT u FROM User u WHERE u.email LIKE '" + reqEmail + "'";
        } else {  // if wildcards aren't used, ordinary named query will be used
          qStr = "User.findByEmail";
          params = new Object[2];
          params[0] = "email";
          params[1] = reqEmail;
        }
      } else {  // if only full name is set
        if (reqName.contains("*")) {  // if wildcards are used
          reqName = reqName.replace("*", "%");  // replace wildcards by those used by database
          // special query must be used
          fQStr = "SELECT u FROM User u WHERE u.name LIKE '" + reqName + "'";
        } else {  // if wildcards aren't used, ordinary named query will be used
          qStr = "User.findByName";
          params = new Object[2];
          params[0] = "name";
          params[1] = reqName;
        }
      }
      List uList = null;
      if (fQStr != null) {  // if special query must be used
        EntityManager em = AppBean.getPersistenceManager().getEM();
        try {
          // query database
          Query query = em.createQuery(fQStr);
          uList = query.getResultList();
        } catch (Exception e) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Exception during the query for persons.";
            Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg);
          }
          uList = null;
        } finally {
          em.close();
        }
      } else {  // if ordinary named query can be used
        // query database
        uList = AppBean.getPersistenceManager().queryDB(qStr, params);
      }

      if (uList != null && !uList.isEmpty() && withGroups) {
        // if persons was found and have to be returned with groups
        Iterator uIter = uList.iterator();
        while (uIter.hasNext()) {  // for each found person
          User user = (User) uIter.next();
          retString = retString + user.toXMLStringWG();  // serialize
        }
      } else if (uList != null && !uList.isEmpty()) {  // if persons was found
        Iterator uIter = uList.iterator();
        while (uIter.hasNext()) {  // for each found person
          User user = (User) uIter.next();
          retString = retString + user.toXMLString();  // serialize
        }
      }
    }  // for each filter (query)

    // surround with persons message
    retString = "<persons>" + retString + "</persons>";
    return retString;
  }  // processQP()
  
  /**
   * Gets queried user groups (for protocol 2.0 only)
   * 
   * @param queryList List with informations about query (filters). 
   *                  For each filter criteria there is one position (index) in the list.
   *                  Value of the filter is the value on the given index.
   * @return Returns list of groups for gven query
   */
  @SuppressWarnings("unchecked")
  private ArrayList<UserGroup> groupQuerry(ArrayList<String> queryList){
    List<UserGroup> result = null;
    boolean isWild = false;
    boolean first = true;
    String name = getWildcardPrefix(queryList.get(P2Constants.GROUPS_Q_NAME));
    
    if(name != null){
      isWild = true;
    }
    
    // make query string
    StringBuilder queryStr = new StringBuilder();
    queryStr.append("SELECT g FROM UserGroup g");
    
    // test id
    if(!queryList.get(P2Constants.GROUPS_Q_ID).isEmpty()){
      if(first){
        queryStr.append(" WHERE g.id = '");
        first = false;
      }else{
        queryStr.append(" AND g.id = '");
      }

      queryStr.append(queryList.get(P2Constants.GROUPS_Q_ID));
      queryStr.append("'");
    }
    
    if(!queryList.get(P2Constants.GROUPS_Q_NAME).isEmpty()){
      if(first){
        queryStr.append(" WHERE g.name ");
        first = false;
      }else{
        queryStr.append(" AND g.name ");
      }

      if(isWild){
        queryStr.append("LIKE '");
        queryStr.append(name);
        queryStr.append("%'");
      }else{
        queryStr.append("= '");
        queryStr.append(queryList.get(P2Constants.GROUPS_Q_NAME));
        queryStr.append("'");
      }
    }
    
    EntityManager em = AppBean.getPersistenceManager().getEM();
    try {
      // query database
      Query query = em.createQuery(queryStr.toString());
      result = query.getResultList();
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the query for groups.";
        Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg);
      }
      result = null;
    } finally {
      em.close();
    }
    
    ArrayList<UserGroup> returnArray;
    if(result == null){
      returnArray = new ArrayList<UserGroup>();
    }else{
      returnArray = new ArrayList<UserGroup>(result);
    }
    
    return returnArray;
  }  // groupQuerry()
  
  /**
   * Gets queried users (for protocol 2.0 only)
   * 
   * @param queryList List with informations about query (filters). 
   *                  For each filter criteria there is one position (index) in the list.
   *                  Value of the filter is the value on the given index.
   * @return Returns list of users for gven query
   */
  @SuppressWarnings("unchecked")
  private ArrayList<User> userQuerry(ArrayList<String> queryList){
    List<User> result = null;
    UserGroup group = null;
    boolean isWild = false;
    boolean first = true;
    String name = getWildcardPrefix(queryList.get(P2Constants.USERS_Q_NAME_ATTR));
    
    if(name != null){
      isWild = true;
    }
    
    // make query string
    StringBuilder queryStr = new StringBuilder();
    queryStr.append("SELECT u FROM User u");
    
    // test id
    if(!queryList.get(P2Constants.USERS_Q_URI_ATTR).isEmpty()){
      if(first){
        queryStr.append(" WHERE u.id = '");
        first = false;
      }else{
        queryStr.append(" AND u.id = '");
      }

      queryStr.append(queryList.get(P2Constants.USERS_Q_URI_ATTR));
      queryStr.append("'");
    }
    
    // test user name
    if(!queryList.get(P2Constants.USERS_Q_NAME_ATTR).isEmpty()){
      if(first){
        queryStr.append(" WHERE u.name ");
        first = false;
      }else{
        queryStr.append(" AND u.name ");
      }
      
      if(isWild){
        queryStr.append("LIKE '");
        queryStr.append(name);
        queryStr.append("%'");
      }else{
        queryStr.append("= '");
        queryStr.append(queryList.get(P2Constants.USERS_Q_NAME_ATTR));
        queryStr.append("'");
      }
    }
    
    // test for email
    if(!queryList.get(P2Constants.USERS_Q_EMAIL_ATTR).isEmpty()){
      if(first){
        queryStr.append(" WHERE u.email = '");
        first = false;
      }else{
        queryStr.append(" AND u.email = '");
      }
      
      queryStr.append(queryList.get(P2Constants.USERS_Q_EMAIL_ATTR));
      queryStr.append("'");
    }
    
    EntityManager em = AppBean.getPersistenceManager().getEM();
    try {
      // query database
      Query query = em.createQuery(queryStr.toString());
      result = query.getResultList();
      if(!queryList.get(P2Constants.USERS_Q_GROUP_ATTR).isEmpty()){
          String qStr2 = "SELECT u FROM UserGroup u WHERE u.id = '" + queryList.get(P2Constants.USERS_Q_GROUP_ATTR) + "'";
          query = em.createQuery(qStr2);
          group = (UserGroup)query.getSingleResult();
      }
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the query for persons.";
        Logger.getLogger(PersonsModule.class.getName()).log(Level.SEVERE, msg);
      }
      result = null;
    } finally {
      em.close();
    }

    //filter groups - if needed
    if(group != null){
      List<User> tmpArray;
      tmpArray = group.getUsers();
      result.retainAll(tmpArray);
    }
    
    if(result != null)
        return new ArrayList<User>(result);
    else
        return new ArrayList<User>();
  }  // userQuerry()
  
  /**
   * Method checks whether the string contains wildchar "*". If the string 
   * contains wildchar the method returns prefix.
   * 
   * @param value string in which will be searched
   * @return prefix before wildchar or null if string don't contains wildchar
   */
  private String getWildcardPrefix(String value){
    int index = value.indexOf('*');
    if(index > 0){
      return value.substring(0, index);
    }else{
      return null;
    }
  }

  /**
   * This method is called for each sleeping comet handler when he receives
   * flier (part of informations about this or another client request).
   *
   * In this module it always returns empty string.
   *
   * @param flier Flier, which has been sent to all comet handlers.
   * @param session Session associated with comet handler.
   * @return If this handler hasn't react to this flier (not interested) return
   *         null, else return messages for client in single string.
   */
  @Override
  public String messagesFromFlier(Flier flier, EditorSession session) {
    return "";
  }

  /**
   * Returns name of this module. Name will be included in XML element
   * attribute so usable characters are restricted.
   *
   * @param lang Requested language of name
   * @return Name of this module
   */
  @Override
  public String getModuleName(int lang) {
    return "Persons module";
  }

  /**
   * Returns description of this module. It will be part of information
   * about server functions.
   *
   * @param lang Requested language of description
   * @return Description of this module
   */
  @Override
  public String getModuleDescription(int lang) {
    return "Persons module performs processing of queryPersons and queryUserGroups messages.";
  }

}  // class PersonsModule