P2Processor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Martin Petr
 * File: P2Processor.java
 * Description: Class which process XML with messages in 4A protocol v 2.0
 */

/**
 * @file P2Processor.java
 *
 * @brief Class which process XML with messages in 4A protocol v 2.0
 */

/**
 * @package cz.vutbr.fit.knot.annotations.comet.protocolV2_0
 * 
 * @brief Classes which process XML with messages in 4A protocol v 2.0
 */
package cz.vutbr.fit.knot.annotations.comet.protocolV2_0;

import cz.vutbr.fit.knot.annotations.app.*;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.SubscribedSource;
import cz.vutbr.fit.knot.annotations.entity.*;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Class which parses and process XML with messages for protocol version 2
 *
 * @brief Class which parses and process XML with messages for protocol version 2
 * @author Martin Petr (xpetrm05)
 */
public class P2Processor {
  private RequestInfo requestInfo;

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

  /**
   * Method parses and process XML with messages from client.
   * 
   * @param mainElement element with messages from client
   * @param requestInfo informations about client request
   */
  public void processXMLDocument(Element mainElement,RequestInfo requestInfo){
    this.requestInfo = requestInfo;
    EditorSession session = requestInfo.getSession();
    P2AnnotTypeProcessor annotTypeProcessor = new P2AnnotTypeProcessor();
    P2AnnotationProcessor annotationProcessor = new P2AnnotationProcessor();
    P2SuggestionProcessor suggestionsProcessor = new P2SuggestionProcessor();
    
    // ********** Comet **********
    NodeList cometMsg = mainElement.getElementsByTagName("comet");
    Element cometEl = (Element) cometMsg.item(0);
    if(cometEl != null && cometEl.getParentNode().isSameNode(mainElement)){
      requestInfo.setSessionOnly(true);
      requestInfo.setCanNotify(false);  // nothing to notify
      return;
    }
    
    // ********** login **********    
    User user = null;
    NodeList loginMsg = mainElement.getElementsByTagName("login");
    Element loginEl = (Element) loginMsg.item(0);
    if(loginEl != null && loginEl.getParentNode().isSameNode(mainElement)) {
      // process message and returns user or null
      user = processLogin(loginEl, requestInfo);
      requestInfo.setLoggedIn(user);
      session.setUser(user);
      session.actualizeAllCachedSettings();
      
      if(user != null) {  
        // ifsuccessfully logged in, prepare logged message
        AppBean.getSessionsCleaner().setSessionConfirm(session.getSessionId());
        requestInfo.appendToReply(P2MessagesCreator.getXMLLoggedUser(user));
      }
      
      if(user == null) {  
        // ifuser not logged in, disconnect message still can be processed
        NodeList disconnMsg = mainElement.getElementsByTagName("disconnect");
        Element disconnEl = (Element) disconnMsg.item(0);
        if(disconnEl != null) {  
          // ifdisconnect message was sent
          if(session.getSyncDocument() != null){
            AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
          }
          AppBean.removeSession(session);  
          // delete session
          requestInfo.setDisconnect(true);
        }
        return;
      }
      
      // Subscribe to own annotations
      requestInfo.getSession().addSource(new SubscribedSource("*", user.getURIV2(), null));
      
      // Subscribe annotations from groups where is user presented
      Iterator<UserGroup> groupsIt = user.getGroupsAL().iterator();
      while(groupsIt.hasNext()){
        requestInfo.getSession().addSource(new SubscribedSource("*", null, groupsIt.next().getUri()));
      } 
    }
    
    if(user == null) {  // ifuser not set, get him from session
      user = session.getUser();
    }

    if(user == null) {  // ifuser is not set
      // disconnect message can be processed
      NodeList disconnMsg = mainElement.getElementsByTagName("disconnect");
      Element disconnEl = (Element) disconnMsg.item(0);
      int lod = session.getProtocolLOD();
      requestInfo.addWarning(lod, session.getLanguageNum(), Localisation.WARNING_5_NOT_LOGGED_IN);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "User is not logged in.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.WARNING, msg);
      }
      if(disconnEl != null) {
        //ifsession have sync. document , it must be decrement in document usage list
        if(session.getSyncDocument() != null){
          AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
        }
        
        AppBean.removeSession(session);  // remove session from list of active sessions
        requestInfo.setDisconnect(true);
        // Session remains in requestInfo and in flier and after request
        // is fully processed, it's discarded.
      }
      
      // no other messages can be processed without logged in user
      return; 
    }  // ifuser is not set
    
    // ********** logout **********
    NodeList logoutMsg = mainElement.getElementsByTagName("logout");
    Element logoutEl = (Element) logoutMsg.item(0);
    if(logoutEl != null) {
      if(session.getSyncDocument() != null){
        AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
      }
      
      // logout user from session
      session.setUser(null); 
      requestInfo.setLogout(true);
    }
    
    // ********** users ********** 
    NodeList usersQueryMsg = mainElement.getElementsByTagName("getUsers");
    Element usersQueryEl = (Element) usersQueryMsg.item(0);
    if(usersQueryEl != null) {
      ArrayList<String> searchPattern = processUsersQuerry(usersQueryEl);
      
      // check ifthere any restriction includeOnly restriction
      boolean restrictions[];
      NodeList includeOnlyNodes = usersQueryEl.getElementsByTagName("includeOnly");
      Element includeOnlyEl = (Element) includeOnlyNodes.item(0);
      if(includeOnlyEl != null){
        // user set some restrictions
        restrictions = processIncludeOnly(includeOnlyEl);
      }else{
        // user want all informations
        restrictions = new boolean[]{true,true,true,true,true,true};
      }
      
      // set user query to requestInfo
      requestInfo.setUsersQueryV2(searchPattern);
      requestInfo.setUsersRestrictionsV2(restrictions);
    }
       
    // ********** group - join **********
    NodeList groupJoinMsgs = mainElement.getElementsByTagName("joinUserGroup");
    Element joinEl = (Element) groupJoinMsgs.item(0);
    if(joinEl != null){
      processJoin(joinEl,requestInfo);
    }
    
    // ********** group - leave **********
    NodeList groupLeaveMsgs = mainElement.getElementsByTagName("leaveUserGroup");
    Element leaveEl = (Element) groupLeaveMsgs.item(0);
    if(leaveEl != null){
      processLeave(leaveEl,requestInfo);
    }
    
    // ********** group - query **********
    NodeList groupsQueryMsgs = mainElement.getElementsByTagName("getUserGroups");
    Element groupsQueryEl = (Element) groupsQueryMsgs.item(0);
    if(groupsQueryEl != null){
      ArrayList<String> searchPattern = processGroupsQuery(groupsQueryEl,requestInfo);
      
      if(searchPattern.get(P2Constants.GROUPS_Q_W_USERS).equals("true")){
        boolean restrictions[];
        NodeList includeOnlyNodes = groupsQueryEl.getElementsByTagName("includeOnly");
        Element includeOnlyEl = (Element) includeOnlyNodes.item(0);
        if(includeOnlyEl != null){
          // user set some restrictions
          restrictions = processIncludeOnly(includeOnlyEl);
        }else{
          // user want all informations
          restrictions = new boolean[]{true,true,true,true,true,true};
        }
        
        // set restrictions to requestInfo
        requestInfo.setUsersGroupRestrictionsV2(restrictions);
      }
      
      // set user query to requestInfo
      requestInfo.setGroupsQueryV2(searchPattern);
    }
    
    // ********** synchronization **********
    NodeList documentSyncMsg = mainElement.getElementsByTagName("synchronize");
    Element documentSyncEl = (Element) documentSyncMsg.item(0);
    if(documentSyncEl != null) {
      processSynchronize(documentSyncEl,requestInfo);
    }
    
    // ********** resynchronization **********
    NodeList documentResyncMsg = mainElement.getElementsByTagName("resynchronize");
    Element documentResyncEl = (Element) documentResyncMsg.item(0);
    if(documentResyncEl != null){
      processResynchronize(documentResyncEl, requestInfo);
    }
    
    // ********** subscriptions - add **********
    NodeList subscriptAddMsg = mainElement.getElementsByTagName("createSubscription");
    Element subscriptAddEl = (Element) subscriptAddMsg.item(0);
    if(subscriptAddEl != null) {
      // process add subscriptions package
      procesAddSubscription(subscriptAddEl,requestInfo);
    }
    
    // ********** subscriptions - delete **********
    NodeList subscriptRemoveMsg = mainElement.getElementsByTagName("removeSubscription");
    Element subscriptRemoveEl = (Element) subscriptRemoveMsg.item(0);
    if(subscriptRemoveEl != null) {
      // process delete subscriptions package
      procesRemoveSubscription(subscriptRemoveEl,requestInfo);
    }
    
    // ********** subscriptions - change **********
    NodeList subscriptChangeMsg = mainElement.getElementsByTagName("modifySubscription");
    Element subscriptChangeEl = (Element) subscriptChangeMsg.item(0);
    if(subscriptChangeEl != null) {
      // process change subscriptions package
      procesChangeSubscription(subscriptChangeEl,requestInfo);
    }
    
    // ********** subscriptions - subscribe **********
    NodeList subscribeMsg = mainElement.getElementsByTagName("subscribe");
    Element subscribeEl = (Element) subscribeMsg.item(0);
    if(subscribeEl != null) {
      // process subscriptions
      processSubscribe(subscribeEl,requestInfo);
    }
    
    // ********** subscriptions - unsubscribe **********
    NodeList unsubscribeMsg = mainElement.getElementsByTagName("unsubscribe");
    Element unsubscribeEl = (Element) unsubscribeMsg.item(0);
    if(unsubscribeEl != null) {
      // process subscriptions
      processUnsubscribe(unsubscribeEl,requestInfo);
    }
    
    // ********** subscriptions - query **********
    NodeList subscrQueryMsg = mainElement.getElementsByTagName("getSubscriptions");
    Element subscrQueryEl = (Element) subscrQueryMsg.item(0);
    if(subscrQueryEl != null) {
      // process subscriptions query
      processSubscriptionsQuery(subscrQueryEl,requestInfo);
    }

    // ********** attributes from ontology **********
    NodeList queryAttrFromOntoMsg = mainElement.getElementsByTagName("getOntologyAttributes");
    Element queryAttrFromOntoEl = (Element) queryAttrFromOntoMsg.item(0);
    if (queryAttrFromOntoEl != null) {
      String attrGr = queryAttrFromOntoEl.getAttribute("groupUri");
      if (attrGr == null || attrGr.isEmpty()) {
        attrGr = "*";
      }
      requestInfo.setQueryTypeAttOnto(attrGr);
    }

    // ********** document modification********* 
    NodeList modificationMsg = mainElement.getElementsByTagName("modification");
    Element modificationEl = (Element) modificationMsg.item(0);
    if(modificationEl != null){
      processDocumentModification(modificationEl, requestInfo);
    }
    
    // ********** types - add **********
    NodeList addTypesMsg = mainElement.getElementsByTagName("addTypes");
    Element addTypesEl = (Element) addTypesMsg.item(0);
    if(addTypesEl != null) {
      annotTypeProcessor.procesTypesAdd(addTypesEl, requestInfo);
    }
    
    // ********** types - modify **********
    NodeList modifyTypesMsg = mainElement.getElementsByTagName("modifyTypes");
    Element modifyTypesEl = (Element) modifyTypesMsg.item(0);
    if(modifyTypesEl != null) {
      annotTypeProcessor.procesTypesChange(modifyTypesEl, requestInfo);
    }
    
    // ********** types - remove **********
    NodeList removeTypesMsg = mainElement.getElementsByTagName("removeTypes");
    Element removeTypesEl = (Element) removeTypesMsg.item(0);
    if(removeTypesEl != null) {
      annotTypeProcessor.procesTypesRemove(removeTypesEl,requestInfo);
    }
    
    // ********** types - query **********
    NodeList queryTypesMsg = mainElement.getElementsByTagName("getTypes");
    Element queryTypesEl = (Element) queryTypesMsg.item(0);
    if(queryTypesEl != null) {
      annotTypeProcessor.procesTypeQuery(queryTypesEl,requestInfo);
    }
    
    // ********** annotation - add **********
    NodeList addAnnotationsMsg = mainElement.getElementsByTagName("createAnnotations");
    Element addAnnotationsEl = (Element) addAnnotationsMsg.item(0);
    if(addAnnotationsEl != null) {
      // process annntoations to add
      annotationProcessor.processAddAnnotations(addAnnotationsEl,requestInfo);
    }
    
    // ********** annotation - change **********
    NodeList changeAnnotationsMsg = mainElement.getElementsByTagName("modifyAnnotations");
    Element changeAnnotationsEl = (Element) changeAnnotationsMsg.item(0);
    if(changeAnnotationsEl != null) {
      // process annntoations to change
      annotationProcessor.processChangeAnnotations(changeAnnotationsEl,requestInfo);
    }
    
    // ********** annotation - delete **********
    NodeList removeAnnotationsMsg = mainElement.getElementsByTagName("removeAnnotations");
    Element removeAnnotationsEl = (Element) removeAnnotationsMsg.item(0);
    if(removeAnnotationsEl != null) {
      // process annntoations to delete
      annotationProcessor.processDeleteAnnotations(removeAnnotationsEl, requestInfo);
    }
    
    
    // ********** annotation - reload **********
    NodeList reloadAnnotationMsg = mainElement.getElementsByTagName("reloadAnnotation");
    Element reloadAnnotationEl = (Element) reloadAnnotationMsg.item(0);
    if(reloadAnnotationEl != null){
      processReloadAnnotation(reloadAnnotationEl, requestInfo);
    }
    
    
    // ********** entity - get types **********
    NodeList getEntityTypesMsg = mainElement.getElementsByTagName("getEntityTypes");
    Element getEntityTypesEl = (Element) getEntityTypesMsg.item(0);
    if (getEntityTypesEl != null) {  // if message was sent
      // set to yes in RequestInfo
      requestInfo.setGetEntityTypes(true);
    }
    
    // ********** suggestions - query **********
    NodeList suggQueryMsg = mainElement.getElementsByTagName("suggestAnnotations");
    Element suggQueryEl = (Element) suggQueryMsg.item(0);
    if (suggQueryEl != null) {
      suggestionsProcessor.processSuggestionQuery(suggQueryEl, requestInfo);
    }
    
    // ********** suggestions - confirm **********
    NodeList suggConfirmMsg = mainElement.getElementsByTagName("confirmSuggestions");
    Element suggConfirmEl = (Element) suggConfirmMsg.item(0);
    if (suggConfirmEl != null) {
      suggestionsProcessor.processSuggestionConfirm(suggConfirmEl, requestInfo);
    }
    
    // ********** suggestions - refuse **********
    NodeList suggRefuseMsg = mainElement.getElementsByTagName("refuseSuggestions");
    Element suggRefuseEl = (Element) suggRefuseMsg.item(0);
    if (suggRefuseEl != null) {
      suggestionsProcessor.processSuggestionRefuse(suggRefuseEl, requestInfo);
    }
    
    // ********** suggestions - getAlternativesFor **********
    NodeList getAlternativesForMsg = mainElement.getElementsByTagName("getAlternativesFor");
    Element getAlternativesForEl = (Element) getAlternativesForMsg.item(0);
    if (getAlternativesForEl != null) {
      suggestionsProcessor.processGetAlternatives(getAlternativesForEl, requestInfo);
    }
    
    // ********** entity - query **********
    NodeList entityQueryMsg = mainElement.getElementsByTagName("getEntities");
    Element entityQueryEl = (Element) entityQueryMsg.item(0);
    if (entityQueryEl != null) {  // if message was sent
      // set request to request info
      processEntityQuery(entityQueryEl,requestInfo);
    }
    
    // ********** settings **********
    NodeList settingsMsg = mainElement.getElementsByTagName("updateParameters");
    Element settingsEl = (Element) settingsMsg.item(0);
    if (settingsEl != null) {  // if message was sent
      processSettings(settingsEl, requestInfo);
    }
    
    // ********** disconnect **********
    NodeList disconnMsg = mainElement.getElementsByTagName("disconnect");
    Element disconnEl = (Element) disconnMsg.item(0);
    if(disconnEl != null) {
      if(session.getSyncDocument() != null){
        AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
      }
      AppBean.removeSession(session);  // remove session from list of active sessions
      requestInfo.setDisconnect(true);
      // Session remains in requestInfo and in flier and after request
      // is fully processed, it's discarded.
    }
  }  // processXMLDocument()
  
  /**
   * Method handle user login message.
   * 
   * @param loginEl element with user credentials
   * @param requestInfo Informations about client request
   * @return logged user
   */
  private User processLogin(Element loginEl, RequestInfo requestInfo){
    User user = null;
    PersistM persistMan = AppBean.getPersistenceManager();
    
    // parse user login attribute
    String userAtt = loginEl.getAttribute("login");
    if(userAtt == null){
      // null is a same as not set
      userAtt = "";
    }
    
    // parse user password attribute
    String passAtt = loginEl.getAttribute("password");
    if(passAtt == null){
      // null is a same as not set
      passAtt = "";
    }
    
    // parse user token attribute generated by system
    String tokenAtt = loginEl.getAttribute("token");
    if(tokenAtt == null){
      // null is a same as not set
      tokenAtt = "";
    }
    
    // parse system URI attribute (system that generated token)
    String systemAtt = loginEl.getAttribute("system");
    if(systemAtt == null){
      // null is a same as not set
      systemAtt = "";
    }
    
    // check required parameters for external authentication
    if(!userAtt.isEmpty() && (!tokenAtt.isEmpty() && !systemAtt.isEmpty())) {
      // external authentication
      String storedToken = AppBean.getExtAuthData(systemAtt, userAtt);
      
      // check token
      if(storedToken == null) { 
        // token was not found
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_1_BAD_CREDENTIALS);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown authentication token received.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      
      // check iftoken is valid
      if(!tokenAtt.equals(storedToken)) {  
        // bad token
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_1_BAD_CREDENTIALS);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad authentication token received.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      
      // get user by token
      Object[] params = new Object[4];
      params[0] = "login";
      params[1] = userAtt;
      params[2] = "comeFrom";
      params[3] = systemAtt;      
      List uList = persistMan.queryDB("User.findByLoginAndSystem", params);
      if(uList != null && !uList.isEmpty()) {  // ifuser was found
        user = (User) uList.get(0);
      }
      if(user != null) {
        return user;
      }
    }  // external authentication
    
    if(userAtt.isEmpty() || passAtt.isEmpty()) {  
      // iflogin (email) or password is not set
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_1_BAD_CREDENTIALS);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Login or password is missing.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    } else {  // ifcredentials are set

      // compute MD5 of password
      MessageDigest md5;
      String hash = "";
      try {
        md5 = MessageDigest.getInstance("MD5");
        md5.update(passAtt.getBytes());
        hash = MessageProcessor.getHexString(md5.digest());
      } catch (NoSuchAlgorithmException ex) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_100_UNKNOWN_ERROR, "", "Internal server error.");
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "NoSuchAlgorithmException for MD5 algorithm.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.SEVERE, msg, ex);
        }
      }

      // query database for user (find by login and password)
      Object[] params = new Object[4];
      params[0] = "login";
      params[1] = userAtt;
      params[2] = "password";
      params[3] = hash;  // use MD5 of sent password
      List uList = persistMan.queryDB("User.findByCredentials", params);
      if(uList != null && !uList.isEmpty()) {  // ifuser was found
        user = (User) uList.get(0);
      }

      if(user == null) {  // user wasn't found, possible secure login
        // query database for user (find by login and password)
        params[3] = passAtt;
        uList = persistMan.queryDB("User.findByCredentials", params);
        if(uList != null && !uList.isEmpty()) {  // ifuser was found
          user = (User) uList.get(0);
        }
      }

      if(user == null) {  // user wasn't found, possible login with e-mail
        params[0] = "email";
        params[1] = userAtt;
        params[3] = hash;  // use MD5 of sent password
        uList = persistMan.queryDB("User.findByEmailAndPassword", params);
        if(uList != null && !uList.isEmpty()) {  // ifuser was found
          user = (User) uList.get(0);
        }
      }

      if(user == null) {  // user wasn't found, possible secure login with e-mail
        params[3] = passAtt;
        uList = persistMan.queryDB("User.findByEmailAndPassword", params);
        if(uList != null && !uList.isEmpty()) {  // ifuser was found
          user = (User) uList.get(0);
        }
      }

      if(user == null) {  // user wasn't found - bad credentials
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_1_BAD_CREDENTIALS);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Authentication by login and password failed (bad login or password).";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // ifcredentials are set
    return user;
  }  // processLogin()
  
  /**
   * Method processes the element with a request for the users.
   * 
   * @param userQueryEl element with request
   * @return array of query parameters
   */
  private ArrayList<String> processUsersQuerry(Element userQueryEl){
    ArrayList<String> result = new ArrayList<String>(P2Constants.USERS_Q_ATTR_COUNT);
    
    // search for user URI
    String idAttr = userQueryEl.getAttribute("uri");
    if(idAttr == null){
      // null is a same as not set
      idAttr = "";
    }
    String userPrefix = AppBean.getBaseUserUriV2();
    idAttr = idAttr.replace(userPrefix, "");
    result.add(P2Constants.USERS_Q_URI_ATTR, idAttr);
    
    // search for user e-mail
    String emailAttr = userQueryEl.getAttribute("email");
    if(emailAttr == null){
      // null is a same as not set
      emailAttr = "";
    }
    result.add(P2Constants.USERS_Q_EMAIL_ATTR, emailAttr);
    
    // search for user name
    String nameAttr = userQueryEl.getAttribute("name");
    if(nameAttr == null){
      // null is a same as not set
      nameAttr = "";
    }
    result.add(P2Constants.USERS_Q_NAME_ATTR, nameAttr);
    
    // search for user group uri
    String groupUriAttr = userQueryEl.getAttribute("groupUri");
    if(groupUriAttr == null){
      // null is a same as not set
      groupUriAttr = "";
    }
    String groupPrefix = AppBean.getBaseGroupUri();
    groupUriAttr = groupUriAttr.replace(groupPrefix, "");
    result.add(P2Constants.USERS_Q_GROUP_ATTR, groupUriAttr);
    
    return result;
  }
  
  /**
   * Method analyzes the element with restrictions on printing of pramethers of 
   * user and make array of booleans with results.
   *
   * @param includeOnlyEl element with restrictions
   * @return array of booleans with results
   */
  private boolean[] processIncludeOnly(Element includeOnlyEl){
    boolean result[] = new boolean[P2Constants.USER_ATTR_COUNT];
    result[P2Constants.USER_URI_ATTR] = true;
    
    // find login element
    NodeList restrictionNodes = includeOnlyEl.getElementsByTagName("login");
    Element includeLoginEl = (Element) restrictionNodes.item(0);
    if(includeLoginEl != null){
      result[P2Constants.USER_LOGIN_ATTR] = true;
    }
    
    // find name element
    restrictionNodes = includeOnlyEl.getElementsByTagName("name");
    Element includeNameEl = (Element) restrictionNodes.item(0);
    if(includeNameEl != null){
      result[P2Constants.USER_NAME_ATTR] = true;
    }
    
    // find email element
    restrictionNodes = includeOnlyEl.getElementsByTagName("email");
    Element includeEmailEl = (Element) restrictionNodes.item(0);
    if(includeEmailEl != null){
      result[P2Constants.USER_EMAIL_ATTR] = true;
    }
    
    // find image element
    restrictionNodes = includeOnlyEl.getElementsByTagName("image");
    Element includeImageEl = (Element) restrictionNodes.item(0);
    if(includeImageEl != null){
      result[P2Constants.USER_IMAGE_ATTR] = true;
    }
    
    // find groups element
    restrictionNodes = includeOnlyEl.getElementsByTagName("groups");
    Element includeGroupsEl = (Element) restrictionNodes.item(0);
    if(includeGroupsEl != null){
      result[P2Constants.USER_GROUPS_ATTR] = true;
    }
    
    return result;
  }
  
  /**
   * Method analyzes the element with joining user group element and adds user 
   * to group.
   * 
   * @param joinEl element with informations about joining group
   * @param requestInfo Informations about client request
   */
  private void processJoin(Element joinEl,RequestInfo requestInfo){
    String groupUriAttr = joinEl.getAttribute("uri");
    Integer groupId = getGroupIdFromUri(groupUriAttr);
    
    if(groupId == null){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Join to group without group id.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // add user to group
    joinToGroup(groupId,requestInfo);
  }
  
  /**
   * Method analyzes the element with leaving user group element and removes user 
   * from group.
   * 
   * @param leaveEl element with informations about leaving group
   * @param requestInfo Informations about client reque
   */
  private void processLeave(Element leaveEl,RequestInfo requestInfo){
    String groupUriAttr = leaveEl.getAttribute("uri");
    Integer groupId = getGroupIdFromUri(groupUriAttr);
    
    if(groupId == null){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Leave to group without group id.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // remove user from group
    leaveGroup(groupId,requestInfo);
  }

  /**
   * Method process the element with query and creates a list of query parameters.
   * 
   * @param groupsQueryEl element with query for user group
   * @param requestInfo Informations about client request
   * @return list with parameters of query
   */
  private ArrayList<String> processGroupsQuery(Element groupsQueryEl, RequestInfo requestInfo){
    ArrayList<String> attrs = new ArrayList<String>(P2Constants.GROUPS_Q_ATTR_COUNT);
    String nameAttr = groupsQueryEl.getAttribute("name"); 
    if(nameAttr == null){
      // null is a same as not set
      nameAttr = "";
    }
    attrs.add(P2Constants.GROUPS_Q_NAME, nameAttr);
    
    String uriAttr = groupsQueryEl.getAttribute("uri");
    if(uriAttr == null){
      // null is a same as not set
      uriAttr = "";
    }
    String groupPrefix = AppBean.getBaseGroupUri();
    uriAttr = uriAttr.replace(groupPrefix, "");
    attrs.add(P2Constants.GROUPS_Q_ID, uriAttr);

    String withUsersAttr = groupsQueryEl.getAttribute("withUsers");
    if(withUsersAttr == null && withUsersAttr.isEmpty()){
      // default is false
      withUsersAttr = "false";
    }
    attrs.add(P2Constants.GROUPS_Q_W_USERS, withUsersAttr);
    
    return attrs;
  }
  
  /**
   * Method process the element with subscriptions for add.
   * 
   * @param addSubscriptionEl element with subscriptions for add
   * @param requestInfo Informations about client request
   */
  private void procesAddSubscription(Element addSubscriptionEl, RequestInfo requestInfo){
    Subscription subsPackage = new Subscription();
    String tmpId = addSubscriptionEl.getAttribute("tmpId");
    Integer tmpIdValue = null;
    if(tmpId == null || tmpId.isEmpty()){
      // error - tmpId of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription tmpId=\"\" invalidProperty=\"tmpId\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription's temporary id was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    try{
      tmpIdValue = Integer.decode(tmpId);
    } catch(NumberFormatException ex){
      // error - bad subscription tmpId
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Trying to decode wrong subscription's temporary id: " + tmpId;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    String name = addSubscriptionEl.getAttribute("name");
    if(name == null || name.isEmpty()){
      // error - name of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription tmpId=\"" + tmpId + "\" invalidProperty=\"name\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription's name was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // check name and user dupliciy
    PersistM persistMan = AppBean.getPersistenceManager();
    Subscription currentPackage = null;
    
    Object[] params = new Object[4];
    params[0] = "name";
    params[1] = name;
    params[2] = "userId";
    params[3] = requestInfo.getSession().getUser().getId();
    @SuppressWarnings("unchecked")
    List<Subscription> pakckageList = persistMan.queryDB("Subscription.findByIdAndUserId", params);
    if(pakckageList != null && !pakckageList.isEmpty()) {  // subscription was found
      // error - subscription already exist
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription tmpId=\"" + tmpId + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_106_DUPLICIT_SUBSCRIPTION, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription with this name already exists.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    

    subsPackage.setName(name);
    subsPackage.setUser(requestInfo.getSession().getUser());
    subsPackage.setTmpId(tmpIdValue);
    
    if(subsPackage.getUser().getGroups() != null && !subsPackage.getUser().getGroups().isEmpty()){
      subsPackage.setGroup(subsPackage.getUser().getGroups().get(0));
    }else{
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_97_NOT_IN_GROUP);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "User does not have a group.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // find sources elements
    NodeList sourceNodes = addSubscriptionEl.getElementsByTagName("source");
    if (sourceNodes != null && sourceNodes.getLength() > 0) {
      for (int index = 0; index < sourceNodes.getLength(); index++) {
        Element sourceEl = (Element) sourceNodes.item(index);
        if (sourceEl != null) {
          Source actualSubscription = processSource(sourceEl, requestInfo, subsPackage);
          if (actualSubscription != null) {
            subsPackage.addSubscription(actualSubscription);
          } else {
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<subscription tmpId=\"" + tmpId + "\" invalidProperty=\"source\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
          }
        }
      }
    }
    
    requestInfo.addNewSubscriptions(subsPackage);
  }  // procesAddSubscription()
  
  /**
   * Method process the element with subscriptions for change.
   * 
   * @param changeSubscriptionEl element with subscriptions for change
   * @param requestInfo Informations about client request
   */
  private void procesChangeSubscription(Element changeSubscriptionEl, RequestInfo requestInfo){
    Subscription subsPackage = new Subscription();
    String uri = changeSubscriptionEl.getAttribute("uri");
    Integer id = null;
    if(uri == null || uri.isEmpty()){
      // error - uri of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription uri=\"\" invalidProperty=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription's uri was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    try{
      id = Integer.decode(uri.replace(AppBean.getBaseSubscriptionUri(), ""));
    } catch(NumberFormatException ex){
      // error - bad subscription ID
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription uri=\"" + uri + "\" invalidProperty=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Trying to decode wrong subscription's id.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // get subscription from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    Subscription currentPackage = null;
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    @SuppressWarnings("unchecked")
    List<Subscription> pakckageList = persistMan.queryDB("Subscription.findById", params);
    if(pakckageList != null && !pakckageList.isEmpty()) {  // ifuser was found
      currentPackage = pakckageList.get(0);
    }else{
      // error - cant find subscription
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription with this id doesn't exists: " + id;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    String name = changeSubscriptionEl.getAttribute("name");
    if(name == null || name.isEmpty()){
      // error - name of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<subscription uri=\"" + uri + "\" invalidProperty=\"name\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription name was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    subsPackage.setName(name);
    subsPackage.setUser(requestInfo.getSession().getUser());
    subsPackage.setId(id);
    subsPackage.setGroup(currentPackage.getGroup());
    
    // find sources elements
    NodeList sourceNodes = changeSubscriptionEl.getElementsByTagName("source");
    if(sourceNodes != null && sourceNodes.getLength() > 0){
      for (int index = 0; index < sourceNodes.getLength(); index++) {
        Element sourceEl = (Element) sourceNodes.item(index);
        if (sourceEl != null) {
          Source actualSubscription = processSource(sourceEl, requestInfo, subsPackage);
          if (actualSubscription != null) {
            subsPackage.addSubscription(actualSubscription);
          } else {
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<subscription uri=\"" + uri + "\" invalidProperty=\"source\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_65_SUBSCRIPTION_MALFORMED, info);
          }
        }
      }
    }
    
    requestInfo.addUpdatedSubscriptions(subsPackage);
  }  // procesChangeSubscription()
  
  /**
   * Method process the element with subscriptions for delete.
   * 
   * @param removeSubscriptionEl element with subscriptions for delete
   * @param requestInfo Informations about client request
   */
  private void procesRemoveSubscription(Element removeSubscriptionEl, RequestInfo requestInfo){
    String uri = removeSubscriptionEl.getAttribute("uri");
    Integer id = null;
    if(uri == null || uri.isEmpty()){
      // error - uri of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription's uri was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    try{
      id = Integer.decode(uri.replace(AppBean.getBaseSubscriptionUri(), ""));
    } catch(NumberFormatException ex){
      // error - bad subscription id
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Trying to decode wrong subscription's id.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // get subscription from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    Subscription currentPackage = null;
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    @SuppressWarnings("unchecked")
    List<Subscription> pakckageList = persistMan.queryDB("Subscription.findById", params);
    if(pakckageList != null && !pakckageList.isEmpty()) {  // ifuser was found
      currentPackage = pakckageList.get(0);
    }else{
      // error - can't find subscription
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Subscription with this id doesn't exists.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    requestInfo.addDeletedSubscription(currentPackage);
  }  // procesRemoveSubscription()
  
  /**
   * Method process the element with subscription to subscribe.
   * 
   * @param subscribeEl element with subscription to subscribe
   * @param requestInfo Informations about client request
   */
  private void processSubscribe(Element subscribeEl, RequestInfo requestInfo){
    Subscription subscriptionToSubs = null;
    String uri = subscribeEl.getAttribute("subscriptionUri");
    Integer id = null;
    if(uri == null || uri.isEmpty()){
      // error - uri of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Uri of subscription not found: " + uri;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    try{
      id = Integer.decode(uri.replace(AppBean.getBaseSubscriptionUri(), ""));
    } catch(NumberFormatException ex){
      // error - bad subscription id
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't decode id of subscription: " + id;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // get subscription from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    @SuppressWarnings("unchecked")
    List<Subscription> pakckageList = persistMan.queryDB("Subscription.findById", params);
    if(pakckageList != null && !pakckageList.isEmpty()) {  // ifuser was found
      subscriptionToSubs = pakckageList.get(0);
    }else{
      // error - can't find subscription
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "";
        if(id != null){
          msg = "Can't find subscription with id:" + id.toString();
        }
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    requestInfo.addToSubscribe(subscriptionToSubs);
  }

  /**
   * Method process the element with subscription to unsubscribe.
   * 
   * @param unsubscribeEl element with subscription to unsubscribe
   * @param requestInfo Informations about client request
   */
  private void processUnsubscribe(Element unsubscribeEl, RequestInfo requestInfo){
    Subscription subscriptionToUnsubs = null;
    String uri = unsubscribeEl.getAttribute("subscriptionUri");
    Integer id = null;
    if (uri == null || uri.isEmpty()) {
      // error - uri of subscription not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Uri of subscription not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    try {
      id = Integer.decode(uri.replace(AppBean.getBaseSubscriptionUri(), ""));
    } catch(NumberFormatException ex){
      // error - bad subscription id
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't decode id of subscription: " + id + " from uri " + uri;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // get subscription from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    @SuppressWarnings("unchecked")
    List<Subscription> pakckageList = persistMan.queryDB("Subscription.findById", params);
    if(pakckageList != null && !pakckageList.isEmpty()) {  // ifuser was found
      subscriptionToUnsubs = pakckageList.get(0);
    }else{
      //error - can't find subscription
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_64_UNKNOWN_SUB_URI);

      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to find subscription with id = " + id;
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // insert to list
    requestInfo.addToUnsubscribe(subscriptionToUnsubs);
  }
  
  /**
   * Method process the element with request for list of subscriptions.
   * 
   * @param subscriptionsQueryEl element with request for list of subscriptions
   * @param requestInfo Informations about client request
   */
  private void processSubscriptionsQuery(Element subscriptionsQueryEl,RequestInfo requestInfo){
    ArrayList<String> query = new ArrayList<String>(P2Constants.SUBS_QUERY_COUNT);
    
    String subsUri = subscriptionsQueryEl.getAttribute("subscriptionUri");
    if(subsUri == null){
      subsUri = "";
    }
    query.add(P2Constants.SUBS_QUERY_URI, subsUri);
    
    String authorUri = subscriptionsQueryEl.getAttribute("authorUri");
    if(authorUri == null){
      authorUri = "";
    }
    query.add(P2Constants.SUBS_QUERY_AUTHOR, authorUri);
    
    String groupUri = subscriptionsQueryEl.getAttribute("groupUri");
    if(groupUri == null){
      groupUri = "";
    }
    query.add(P2Constants.SUBS_QUERY_GROUP, groupUri);
    requestInfo.setSubscriptionQuery(query);
  }

  /**
   * Method process text modification message
   * Informations are stored to requestInfo.
   * 
   * @param modificationEl Element to process
   * @param requestInfo Informations about client request
   */
  private void processDocumentModification(Element modificationEl, RequestInfo requestInfo){
    
    String lastModNumberStr = modificationEl.getAttribute("lastApplied");
    
    /* Parsing number */
    int lastModNumber;
    if (lastModNumberStr != null && !lastModNumberStr.isEmpty()) {
      try {
        lastModNumber = Integer.parseInt(lastModNumberStr);
      } catch (NumberFormatException nfe) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<modification id=\"" + lastModNumberStr + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_50_BAD_MODIFICATION, info);

        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad number of last applied modification.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
    } else {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<modification id=\"" + lastModNumberStr + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_50_BAD_MODIFICATION, info);

      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad number of last applied modification.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }

    // Add last modification number to requestInfo
    requestInfo.setLastModificationNumber(lastModNumber);

    //Get all modifications from message
    NodeList childNodes = modificationEl.getChildNodes();
    int tmpNum = childNodes.getLength();

    for (int i = 0; i < tmpNum; i++) {  // for each modification
      Node node = childNodes.item(i);

      if (node.getNodeType() == Node.ELEMENT_NODE) {
        Element e = (Element) node;
        String tagName = e.getTagName();

        if (tagName != null && !tagName.isEmpty()) {

          if (tagName.equals("replace")) {
            processDocumentReplace(e, requestInfo);
          } else if (tagName.equals("insertBefore")) {
            processDocumentInsertBefore(e, requestInfo);
          } else if (tagName.equals("insertAfter")) {
            processDocumentInsertAfter(e, requestInfo);
          }
        }
      }
    }  // for each modification
  }  // processDocumentModification()

  /**
   * Method process the message about text modification - replace
   * Informations are stored to requestInfo.
   * 
   * @param replaceEl Element to process
   * @param requestInfo Informations about client request
   */
  private void processDocumentReplace(Element replaceEl, RequestInfo requestInfo){

    String path = replaceEl.getAttribute("path");
    String offsetStr = replaceEl.getAttribute("offset");
    String lengthStr = replaceEl.getAttribute("length");


    /* parsing offset */
    Integer offset = null;
    if(offsetStr != null && !offsetStr.isEmpty()){
      try{
        offset = Integer.parseInt(offsetStr);
      }
      catch (NumberFormatException nfe) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<modification id=\"" + requestInfo.getLastModificationNumber() + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_50_BAD_MODIFICATION, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad offset in text modification: " + offsetStr;
            Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
    }

    /* parsing length */
    Integer length = null;
    if(lengthStr != null && !lengthStr.isEmpty()){
        try {
            length = Integer.parseInt(lengthStr);
        }
        catch (NumberFormatException nfe) {
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<modification id=\"" + requestInfo.getLastModificationNumber() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_50_BAD_MODIFICATION, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad length in text modification: " + lengthStr;
            Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
          }
          return;
        }
    }

    /* getting content */
    String content = MessageProcessor.getElementContent(replaceEl);

    /* setting up new modification */
    path = UpdatableFragment.improveXPath(path);
    TextModification newMod = new TextModification(path, offset, length, content, Constants.TEXT_MOD_REPLACE);
    requestInfo.addTextModification(newMod);
  }  // processDocumentReplace()

  /**
   * Method process the message about text modification - insertBefore
   * Informations are stored to requestInfo.
   * 
   * @param insertBeforeEl Element to process
   * @param requestInfo Informations about client request
   */
  private void processDocumentInsertBefore(Element insertBeforeEl, RequestInfo requestInfo){
    String path = insertBeforeEl.getAttribute("path");

    /* getting content */
    String content = MessageProcessor.getElementContent(insertBeforeEl);

    /* setting up new modification */
    path = UpdatableFragment.improveXPath(path);
    TextModification newMod = new TextModification(path, content, Constants.TEXT_MOD_INS_BEFORE);
    requestInfo.addTextModification(newMod);
  }

  /**
   * Method process the message about text modification - insertAfter
   * Informations are stored to requestInfo.
   * 
   * @param insertAfterEl Messages to process
   * @param requestInfo Informations about client request
   */
  private void processDocumentInsertAfter(Element insertAfterEl, RequestInfo requestInfo){

    String path = insertAfterEl.getAttribute("path");

    /* getting content */
    String content = MessageProcessor.getElementContent(insertAfterEl);

    /* setting up new modification */
    path = UpdatableFragment.improveXPath(path);
    TextModification newMod = new TextModification(path, content, Constants.TEXT_MOD_INS_AFTER);
    requestInfo.addTextModification(newMod);
  }
  
  /**
   * Method process the element with subscription source and return it as object.
   * 
   * @param subscriptionEl element with subscription source
   * @param requestInfo Informations about client request
   * @param subs Subscription to which this source belongs
   * @return subscription source object
   */
  private Source processSource(Element subscriptionEl, RequestInfo requestInfo, Subscription subs){
    Source newSubscription = new Source();
    String subscribe = subscriptionEl.getAttribute("subscribe");
    if(subscribe == null || subscribe.isEmpty()){
      // error - cant find information about positive or negative subscription
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Cannot find information about positive or negative subscription.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    // get subscribe parameter
    boolean subscribeVal = false;
    if(subscribe.equalsIgnoreCase("true")){
      subscribeVal = true;
    }
    
    // get typeUri parameter
    String typeUri = subscriptionEl.getAttribute("typeUri");
    if(typeUri == null){
      typeUri = "";
    }
    
    // get authorUri parameter
    String authorUri = subscriptionEl.getAttribute("authorUri");
    if(authorUri == null){
      authorUri = "";
    }
    
    // get groupUri parameter
    String groupUri = subscriptionEl.getAttribute("groupUri");
    if(groupUri == null){
      groupUri = "";
    }
    
    newSubscription.setPolarity(subscribeVal);
    newSubscription.setAnnotType(typeUri);
    newSubscription.setUser(authorUri);
    newSubscription.setSource(groupUri);
    newSubscription.setRefSubscription(subs);
    
    return newSubscription;
  }  // processSource()

  /**
   * Method process the element with document for resynchronization.
   * 
   * @param resynchronizeEl element with document for resynchronization
   * @param requestInfo Informations about client request
   */
  private void processResynchronize(Element resynchronizeEl, RequestInfo requestInfo){
    // Get content of resynchronized document
    String content = MessageProcessor.getElementContent(resynchronizeEl);
    if(content == null){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_23_MISSING_DOCUMENT_CONTENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Resynchronization with empty content of the document.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    requestInfo.setResyncDocContent(content);
  }
  
  /**
   * Method process the element with document for synchronize.
   * 
   * @param synchronizeEl element with document for synchronize
   * @param requestInfo Informations about client request
   */
  private void processSynchronize(Element synchronizeEl, RequestInfo requestInfo){
    String uri = synchronizeEl.getAttribute("uri");
    if (uri == null) {
      uri = "";
    }
    
    if (uri.isEmpty()) {  
      // if URI of resource is empty, error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_22_MISSING_DOCUMENT_URI);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Synchronization without URI of the resource.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // process attribute with linearization
    String linearize = synchronizeEl.getAttribute("linearize");
    if (linearize != null && linearize.equalsIgnoreCase("true")) {
      requestInfo.setSyncLinearized(true);
    }else{
      requestInfo.setSyncLinearized(false);
    }
    
    // process attribute with overwrite (forced synchronization)
    String overwrite = synchronizeEl.getAttribute("overwrite");
    if (overwrite != null && overwrite.equalsIgnoreCase("true")) {
      requestInfo.setSyncWithOverwrite(true);
    }else{
      requestInfo.setSyncWithOverwrite(false);
    }
    
    // get content of synchronized document
    String content = MessageProcessor.getElementContent(synchronizeEl);
    if (content == null) {  // if content is empty - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_23_MISSING_DOCUMENT_CONTENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Synchronization with empty content of the document.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
    }
    // create object with synchronized document
    AnnotDocument syncDoc = new AnnotDocument(uri, content);
    requestInfo.setSyncDocumentData(syncDoc);  // store document into requestInfo
    
  }  // processSynchronize()
  
  /**
   * Method that process element with request for reloading either all or single annotation
   * 
   * @param reloadAnnotationEl Element with request
   * @param requestInfo Informations about client request
   */
  private void processReloadAnnotation(Element reloadAnnotationEl, RequestInfo requestInfo){
    String annotUri = reloadAnnotationEl.getAttribute("uri");
    
    /* If uri is missing, user wants to reload all his annotations */
    if(annotUri == null || annotUri.isEmpty()){
      requestInfo.setReloadAll(true);
      return;
    }
    
    //Get ID of annotation
    String reloadIdStr = annotUri.replace(AppBean.getBaseAnnotUri(), "");
    
    //Parse ID
    Integer reloadId = null;
    if (!reloadIdStr.isEmpty()) {
      try {
        reloadId = Integer.parseInt(reloadIdStr);
      } catch (NumberFormatException ex) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String contextMsg = "<annotation uri=\"" + annotUri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_34_RELOAD_ANNOT_NOT_FOUND, contextMsg);
        
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad id of reloaded annotation: " + reloadIdStr;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
    }
    
    // Search for annotation
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = reloadId;
    
    List reloadList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
    if(reloadList != null && !reloadList.isEmpty()){
      Annotation a = (Annotation) reloadList.get(0);
      requestInfo.addReloadAnnotations(a);
    }
    else{
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String contextMsg = "<annotation uri=\"" + annotUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_34_RELOAD_ANNOT_NOT_FOUND, contextMsg);
      
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to find requested annotation: " + annotUri;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
    }
  } //  processReloadAnnotation()
  
  /**
   * Method process the element with query for entity types.
   * 
   * @param entityQueryEl element with query for entity types
   * @param requestInfo Informations about client request
   */
  private void processEntityQuery(Element entityQueryEl, RequestInfo requestInfo){
    String type = entityQueryEl.getAttribute("type");
    String filter = entityQueryEl.getAttribute("name");
    String maxResultsStr = entityQueryEl.getAttribute("maxResults");
    int maxResults = -1;
    
    if (filter.isEmpty()) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_63_EMPTY_ENTITY_FILTER);

      requestInfo.setSettings(requestInfo.getSession().getSettings());
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Empty name of parameter of dictionary request.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }

      return;
    }
    
    if (maxResultsStr != null && !maxResultsStr.isEmpty()) {
      try {
        maxResults = Integer.parseInt(maxResultsStr);
      } catch (NumberFormatException ex) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_96_BAD_MAX_ENTITIES);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad form of maximum results input: " + maxResultsStr;
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
    }
    
    requestInfo.setEntityRequest(new RequestInfo.EntityRequest(type,filter, maxResults));
  }  // processEntityQuery()
  
  /**
   * Process settings message.
   * Informations are stored into requestInfo.
   * If error occurs, generates error message.
   *
   * @param settingsEl Element with settings message
   * @param requestInfo Informations about client request
   */
  private void processSettings(Element settingsEl, RequestInfo requestInfo){
    // create new empty list of parameters of user settings
    ArrayList<Settings> settings = new ArrayList<Settings>();
    // get list of elements with parameters
    NodeList paramNL = settingsEl.getElementsByTagName("param");
    int paramCnt = paramNL.getLength();
    for (int i = 0; i < paramCnt; i++) {  // for each parameter
      Element paramEl = (Element) paramNL.item(i);
      String name = paramEl.getAttribute("name");
      String value = paramEl.getAttribute("value");
      String description = paramEl.getAttribute("description");
      
      if(!paramEl.hasAttribute("value")){
        value = null;
      }
      
      if (name == null) {
        name = "";
      }
      if (description == null) {
        description = "";
      }
      if (name.isEmpty()) {  // if name is empty, parameter is bad
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        // create error message
        String info = "<param name=\"\" invalidAttribute=\"name\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_21_SETTINGS_MALFORMED, info);
        // set old settings to informations about request
        // (sent valid actual settings to client)
        requestInfo.setSettings(requestInfo.getSession().getSettings());
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Empty name of parameter of settings.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return;  // if one parameter is bad, whole setting is bad and can't be updated
      }
      // create object with parameter of user settings
      Settings param = new Settings(requestInfo.getSession().getUser(), name, value, description);
      settings.add(param);  // add parameter to the new list of parameters
    }  // for each parameter
    // store new list of parameters to the informations about request
    if(!settings.isEmpty()){
      requestInfo.setSettings(settings);
    }else{
      requestInfo.setSettings(null);
    }
  }  // processSettings()
  
  /**
   * Gets settings of given user
   * 
   * @param user User which settings should be found
   * @return Settings of given user
   */
  private ArrayList<Settings> getUserSettings(User user){
    ArrayList<Settings> result = new ArrayList<Settings>();
    PersistM persistMan = AppBean.getPersistenceManager();
    
    Object[] params = new Object[2];
    params[0] = "userId";
    params[1] = user.getId();
    @SuppressWarnings("unchecked")
    List<Settings> settingsList = persistMan.queryDB("Settings.findByUser", params);

    if(settingsList != null){
      result.addAll(settingsList);
    }
    
    return result;
  }
  
  /**
   * Method gets id of user group by strip off base URI.
   * 
   * @param uri uri of group
   * @return id of group uri
   */
  private Integer getGroupIdFromUri(String uri){
    if(uri != null){
      String groupIdStr = uri.replace(AppBean.getBaseGroupUri(), "");
      Integer id = null;
      
      try{
        id = Integer.parseInt(groupIdStr);
      }
      
      catch(NumberFormatException ex){
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad id of group: " + groupIdStr;
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      return id;
    }
    
    return null;
  }
  
  /**
   * Method adds a user to the group specified by id.
   * 
   * @param id identification of group
   * @param requestInfo Informations about client request
   */
  private void joinToGroup(Integer id, RequestInfo requestInfo){
    // query database for group
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    
    // find group in DB
    List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
    if(gList != null && !gList.isEmpty()) {  
      // ifgroup was found
      UserGroup jGroup = (UserGroup) gList.get(0);
      User user = requestInfo.getSession().getUser();
      
      // test ifuser is in group
      if(!user.getGroups().contains(jGroup)) {  
        // ifuser isn't in this group
        if(jGroup.getName().equalsIgnoreCase(Constants.ADMIN_GROUP)) {
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<group name=\"" + Constants.ADMIN_GROUP + "\" uri=\"" + AppBean.getBaseGroupUri() + id.toString() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_57_JOIN_ADMINISTRATORS, info);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "User is trying to join to administrators: " + user.getName();
            Logger.getLogger(P2Processor.class.getName()).log(Level.WARNING, msg);
          }
        } else {
          // add group to user's groups
          user.addGroup(jGroup);
          // add user to group
          jGroup.addUser(user);
          // add group into list of just added groups
          requestInfo.addJoinedGroup(jGroup);
        }
      }
    } else {  
      // ifgroup wasn't found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Group to join was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
    }
  }  // joinToGroup()
  
  /**
   * Method removes a user to the group specified by id.
   * 
   * @param id identification of group
   * @param requestInfo Informations about client request
   */
  private void leaveGroup(Integer id, RequestInfo requestInfo){
    // query database for group
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = id;
    
    // find group in DB
    List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
    if(gList != null && !gList.isEmpty()) {
      
      // ifgroup was found
      UserGroup lGroup = (UserGroup) gList.get(0);
      User user = requestInfo.getSession().getUser();
      
      // test ifuser is in group
      if(user.getGroups().contains(lGroup)) {  
        // ifuser is in this group
        if(lGroup.getName().equalsIgnoreCase(Constants.ADMIN_GROUP) && lGroup.getUsers().size() < 2) {
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          requestInfo.addError(lod, langNum, Localisation.ERROR_58_LAST_ADMIN);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Last administrator is trying to leave group.";
            Logger.getLogger(P2Processor.class.getName()).log(Level.WARNING, msg);
          }
        } else {
          // remove group from user's groups
          user.getGroups().remove(lGroup);
          // remove user from group
          lGroup.getUsers().remove(user);
          // add group to list of just leaved groups
          requestInfo.addLeavedGroup(lGroup);
        }
      } else {  
        // ifuser isn't in this group
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Group to leave is not in joined groups.";
          Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
        }
      }
    } else {  
      // ifgroup wasn't found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Group to leave was not found.";
        Logger.getLogger(P2Processor.class.getName()).log(Level.ALL, msg);
      }
    }
  }  // leaveGroup()
}  // public class P2Processor