P1Processor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: P1Processor.java
 * Description: Class which process XML with messages in 4A protocol v 1.x
 */

/**
 * @file P1Processor.java
 *
 * @brief Class which process XML with messages in 4A protocol v 1.x
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.PersistM;
import cz.vutbr.fit.knot.annotations.app.TextModification;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
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.comet.SuggestionLogEntry;
import cz.vutbr.fit.knot.annotations.comet.Util;
import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.Fragment;
import cz.vutbr.fit.knot.annotations.entity.Settings;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import cz.vutbr.fit.knot.annotations.entity.attribute.AttributeManager;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.LinkedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.PersonAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.StructuredAttribute;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.CharacterData;
import org.w3c.dom.DOMException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Class which process XML with messages in 4A protocol v 1.0 and 1.1
 *
 * @brief Class which process XML with messages in 4A protocol v 1.x
 */
public class P1Processor {
  /**
   * Processes XML with messages from client
   *
   * @param docEl Document element of parsed XML with messages from client
   * @param requestInfo Informations about client's request
   * @return Object with informations about client request
   */
  public RequestInfo processXML(Element docEl, RequestInfo requestInfo) {
    
    EditorSession session = requestInfo.getSession();
    
    // ********** login **********
    User user = null;
    NodeList loginMsg = docEl.getElementsByTagName("login");
    Element loginEl = (Element) loginMsg.item(0);
    if (loginEl != null) {  // if login message was sent
      user = processLogin(loginEl, requestInfo);  // process message and returns user or null
      requestInfo.setLoggedIn(user);
      session.setUser(user);
      session.actualizeAllCachedSettings();
      if (user != null) {  // if successfully logged in, prepare logged message
        AppBean.getSessionsCleaner().setSessionConfirm(session.getSessionId());
        requestInfo.appendToReply("<logged id=\"" + user.getURI() + "\" name=\"" + user.getName() + "\"/>");
      }
      if (user == null) {  // if user not logged in, disconnect message still can be processed
        NodeList disconnMsg = docEl.getElementsByTagName("disconnect");
        Element disconnEl = (Element) disconnMsg.item(0);
        if (disconnEl != null) {  // if disconnect message was sent
          if(session.getSyncDocument() != null)
          {
            AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
          }
          AppBean.removeSession(session);  // delete session
          requestInfo.setDisconnect(true);
        }
        return requestInfo;
      }
      // Subscribe to own annotations
      requestInfo.getSession().addSource(new SubscribedSource("*", user.getURI(), null));
      // subscribe to own groups
      if (Constants.AUTO_SUBSCRIBE_OWN_GROUPS) {
        Iterator<UserGroup> ownGroupsIt = user.getGroups().iterator();
        while (ownGroupsIt.hasNext()) {  // subscribe all own groups
          UserGroup ownGroup = ownGroupsIt.next();
          requestInfo.getSession().addSource(new SubscribedSource("*", null, ownGroup.getUri()));
        }
      }
    }  // if login message was sent

    if (user == null) {  // if user not set, get him from session
      user = session.getUser();
    }

    if (user == null) {  // if user is not set
      // disconnect message can be processed
      NodeList disconnMsg = docEl.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(MessageProcessor.class.getName()).log(Level.WARNING, msg);
      }
      if (disconnEl != null) {
        //if session 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.
      }
      return requestInfo; // no other messages can be processed without logged in user
    }  // if user is not set

    // ********** queryUserGroups **********
    NodeList queryUserGroupsMsg = docEl.getElementsByTagName("queryUserGroups");
    int qGCount = queryUserGroupsMsg.getLength();
    for (int i = 0; i < qGCount; i++) {  // for all messages that was sent
      Element queryUserGroupsEl = (Element) queryUserGroupsMsg.item(i);
      Boolean withP = Boolean.parseBoolean(queryUserGroupsEl.getAttribute("withPersons"));
      String filter = queryUserGroupsEl.getAttribute("filter");
      if (filter == null || filter.isEmpty()) {
        filter="*";  // empty filter is equivalent to "*" (all items)
      }
      if (withP) {  // if groups are queried with persons
        requestInfo.addQueryUserGroupsWP(filter);  // add to appropriate list
      } else {  // if groups are queried without persons
        requestInfo.addQueryUserGroups(filter);
      }
    }

    // ********** groups (join and leave) **********
    NodeList joinMsgs = docEl.getElementsByTagName("join");
    if (joinMsgs.getLength() > 0) {  // if message was sent
      processJoin(joinMsgs, requestInfo);
    }
    NodeList leaveMsgs = docEl.getElementsByTagName("leave");
    if (leaveMsgs.getLength() > 0) {  // if message was sent
      processLeave(leaveMsgs, requestInfo);
    }

    if (session.getDefaultGroup() == null) {
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, session.getLanguageNum(), Localisation.ERROR_97_NOT_IN_GROUP);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "User is not in any group.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
      }
    } else {  // if user is in any group
    
      // ********** types **********
      NodeList typesMsg = docEl.getElementsByTagName("types");
      Element typesEl = (Element) typesMsg.item(0);
      if (typesEl != null) {  // if types message was sent
        processTypes(typesEl, requestInfo);
      }

      // ********** suggestions **********
      NodeList suggestMsg = docEl.getElementsByTagName("suggestAnnotations");
      if (suggestMsg.getLength() > 0) {  // if messages was sent
        processSuggestions(suggestMsg, requestInfo);  // process messages
      }

      // ********** refused suggestions **********
      NodeList refSuggestMsg = docEl.getElementsByTagName("refusedSuggestions");
      Element refSuggestEl = (Element) refSuggestMsg.item(0);
      if (refSuggestEl != null) {  // if message was sent
        processRefSuggestions(refSuggestEl, requestInfo);
      }
    
    }  // if user is in any group

    // ********** settings **********
    NodeList settingsMsg = docEl.getElementsByTagName("settings");
    Element settingsEl = (Element) settingsMsg.item(0);
    if (settingsEl != null) {  // if message was sent
      processSettings(settingsEl, requestInfo);
    }
    
    // ********** entity request **********
    NodeList entityRequestMsg = docEl.getElementsByTagName("queryEntities");
    Element entityRequestEl = (Element) entityRequestMsg.item(0);
    if (entityRequestEl != null) {  // if message was sent
      processEntityRequest(entityRequestEl, requestInfo);
    }

    // ********** subscribe **********
    NodeList subscribeMsg = docEl.getElementsByTagName("subscribe");
    Element subscribeEl = (Element) subscribeMsg.item(0);
    if (subscribeEl != null) {  // if message was sent
      processSubscribe(subscribeEl, session, requestInfo);
    }

    // ********** unsubscribe **********
    NodeList unsubscribeMsg = docEl.getElementsByTagName("unsubscribe");
    Element unsubscribeEl = (Element) unsubscribeMsg.item(0);
    if (unsubscribeEl != null) {  // if message was sent
      processUnsubscribe(unsubscribeEl, session, requestInfo);
    }

    // ********** synchronize **********
    NodeList synchronizeMsg = docEl.getElementsByTagName("synchronize");
    Element synchronizeEl = (Element) synchronizeMsg.item(0);
    if (synchronizeEl != null) {  // if message was sent
      processSynchronize(synchronizeEl, requestInfo);
    }

    // ********** resynchronize **********
    NodeList resynchronizeMsg = docEl.getElementsByTagName("resynchronize");
    Element resynchronizeEl = (Element) resynchronizeMsg.item(0);
    if (resynchronizeEl != null) {  // if message was sent
      processResynchronize(resynchronizeEl, requestInfo);
    }

    // ********** textModification **********
    NodeList textModificationMsg = docEl.getElementsByTagName("textModification");
    if (textModificationMsg.getLength() > 0) {  // if messages was sent
      processTextModificationMsg(textModificationMsg, requestInfo);  // process messages
    }

    // ********** reload **********
    NodeList reloadMsg = docEl.getElementsByTagName("reload");
    if (reloadMsg.getLength() > 0) {  // if messages was sent
      processReload(reloadMsg, requestInfo);  // process messages
    }

    // ********** queryTypes **********
    NodeList queryTypesMsg = docEl.getElementsByTagName("queryTypes");
    Element queryTypesEl = (Element) queryTypesMsg.item(0);
    if (queryTypesEl != null) {  // if message sent
      String filter = queryTypesEl.getAttribute("filter");
      if (filter == null || filter.isEmpty()) {
        filter = "*";  // empty filter is equivalent to "*" (all items)
      }
      requestInfo.addQueryTypes(filter);
      session.addQueriedTypes(filter);
    }

    // ********** queryAttrFromOnto **********
    NodeList queryAttrFromOntoMsg = docEl.getElementsByTagName("queryAttrFromOnto");
    Element queryAttrFromOntoEl = (Element) queryAttrFromOntoMsg.item(0);
    if (queryAttrFromOntoEl != null) {  // if message sent
      String attrGr = queryAttrFromOntoEl.getAttribute("group");
      if (attrGr == null || attrGr.isEmpty()) {
        attrGr = "*";  // empty group is equivalent to "*" (all items)
      }
      requestInfo.setQueryTypeAttOnto(attrGr);
    }

    // ********** queryPersons **********
    NodeList queryPersonsMsg = docEl.getElementsByTagName("queryPersons");
    int qPCount = queryPersonsMsg.getLength();
    for (int i= 0; i < qPCount; i++) {
      Element queryPersonsEl = (Element) queryPersonsMsg.item(i);
      Boolean withG = Boolean.parseBoolean(queryPersonsEl.getAttribute("withGroups"));
      String filter = queryPersonsEl.getAttribute("filter");
      if (filter == null || filter.isEmpty()) {
        filter = "*";  // empty filter is equivalent to "*" (all items)
      }
      if (withG) {  // if persons are queried with groups
        requestInfo.addQueryPersonsWG(filter);  // add to appropriate list
      } else {  // if persons are queried without groups
        requestInfo.addQueryPersons(filter);
      }
    }
    
    // ********** annotations **********
    if (session.getDefaultGroup() != null) {
      NodeList annotationsMsg = docEl.getElementsByTagName("annotations");
      Element annotationsEl = (Element) annotationsMsg.item(0);
      if (annotationsEl != null) {  // if message sent
        processAnnotations(annotationsEl, requestInfo);
      }
    }
     
    // ********** logout **********
    NodeList logoutMsg = docEl.getElementsByTagName("logout");
    Element logoutEl = (Element) logoutMsg.item(0);
    if (logoutEl != null) {
      if(session.getSyncDocument() != null)
      {
        AppBean.decrementDocumentUsage(session.getSyncDocument().getId());
      }
      session.setUser(null);  // logout user from session
      requestInfo.setLogout(true);
    }

    // ********** disconnect **********
    NodeList disconnMsg = docEl.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.
    }

    return requestInfo;
  }  // processXML()

  /**
   * Process textModification messages (about modifications of annotated copy of document).
   * Informations are stored to requestInfo.
   *
   * @param tmMsg Messages to process
   * @param requestInfo Informations about client request
   */
  private static void processTextModificationMsg(NodeList tmMsg, RequestInfo requestInfo) {
    int tmCnt = tmMsg.getLength();
    for (int i = 0; i < tmCnt; i++) {  // for all messages
      Element tmEl = (Element) tmMsg.item(i);
      String path = tmEl.getAttribute("path");
      String offsetString = tmEl.getAttribute("offset");
      String lengthString = tmEl.getAttribute("length");

      // parse offset
      Integer offset = null;
      if (offsetString != null) {
        if (!offsetString.isEmpty()) {
          try {
            offset = Integer.parseInt(offsetString);
          } catch (NumberFormatException nfe) {  // bad number format - return error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<textModification path=\"" + path + "\" offset=\"" + offsetString + "\" length=\"" + lengthString + "\"/>";
            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: " + offsetString;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
            continue;
          }
        }
      }
      // parse length
      Integer length = null;
      if (lengthString != null) {
        if (!lengthString.isEmpty()) {
          try {
            length = Integer.parseInt(lengthString);
          } catch (NumberFormatException nfe) {  // bad number format - return error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<textModification path=\"" + path + "\" offset=\"" + offsetString + "\" length=\"" + lengthString + "\"/>";
            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: " + lengthString;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
            continue;
          }
        }
      }
      // get new content
      String newContent = MessageProcessor.getElementContent(tmEl);
      /*if (newContent == null) {  // content can be empty, but can't be null
        int langNum = requestInfo.getSession().getLanguageNum();
        String info = "<textModification path=\"" + path + "\" offset=\"" + offsetString + "\" length=\"" + lengthString + "\"/>";
        requestInfo.addError(langNum, Localisation.ERROR_50_BAD_MODIFICATION, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "NULL content in text modification.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        continue;
      }*/
      // improve XPath to be usable
      path = UpdatableFragment.improveXPath(path);
      // create object wit informations and add to flier
      TextModification newMod = new TextModification(path, offset, length, newContent);
      requestInfo.addTextModification(newMod);
    }  // for all messages
  }  // processTextModificationMsg()

  /**
   * Process reload messages (about query to annotations).
   * Informations are stored to requestInfo.
   *
   * @param reloadMsg Messages to process
   * @param requestInfo Informations about client request
   */
  private static void processReload(NodeList reloadMsg, RequestInfo requestInfo) {
    int reloadCnt = reloadMsg.getLength();
    for (int i = 0; i < reloadCnt; i++) {  // for all reload messages
      Element reloadEl = (Element) reloadMsg.item(i);
      String all = reloadEl.getAttribute("all");
      boolean reloadAllAnnots = false;
      
      if (all != null && all.equalsIgnoreCase("true")) {
        requestInfo.setReloadAll(true);
        reloadAllAnnots = true;
      }
      String reloadedUri = reloadEl.getAttribute("uri");
      if (reloadedUri == null) {
        reloadedUri = "";
      }
      // get id of annotation by strip off base URI
      String reloadIdStr = reloadedUri.replace(AppBean.getBaseAnnotUri(), "");
      // parse id of annotation
      Integer reloadId = null;
      if (!reloadIdStr.isEmpty()) {
        try {
          reloadId = Integer.parseInt(reloadIdStr);
        } catch (NumberFormatException nfe) {
          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);
          }
          reloadId = null;
        }
      }
      if (reloadId != null) {  // if id of annotation is available
        // query database for annotation
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = reloadId;
        List rList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
        if (rList != null && !rList.isEmpty()) {  // if annotation was found
          Annotation relAnnot = (Annotation) rList.get(0);
          requestInfo.addReloadAnnotations(relAnnot);  // add to list
        } else {  // if annotation wasn't found - error
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<reload uri=\"" + reloadedUri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_34_RELOAD_ANNOT_NOT_FOUND, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Reloaded annotation was not found: " + reloadId;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      } else {  // if id isn't presented or it's malformed
        if(!reloadAllAnnots){
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<reload uri=\"" + reloadedUri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_34_RELOAD_ANNOT_NOT_FOUND, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Id of reloaded annotation missing.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      }
    }  // for all reload messages
  }  // processReload()

  /**
   * Process join messages (join to user group)
   * Informations are stored into requestInfo and user is added into group
   * (no additional operations needed).
   *
   * @param joinMsgs Messages to process
   * @param requestInfo Informations about client request
   */
  private static void processJoin(NodeList joinMsgs, RequestInfo requestInfo) {
    int joinCnt = joinMsgs.getLength();
    User user = requestInfo.getSession().getUser();
    for (int i = 0; i < joinCnt; i++) {  // for all join messages
      Element joinEl = (Element) joinMsgs.item(i);
      String groupUri = joinEl.getAttribute("group");
      if (groupUri == null) {
        groupUri = "";
      }
      // get id of user group by strip off base URI
      String groupIdStr = groupUri.replace(AppBean.getBaseGroupUri(), "");
      // parse id of user group
      Integer groupId = null;
      if (!groupIdStr.isEmpty()) {
        try {
          groupId = Integer.parseInt(groupIdStr);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad id of joined group: " + groupIdStr;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          groupId = null;
        }
      }
      if (groupId != null) {  // if id of group is available
        // query database for group
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = groupId;
        List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
        if (gList != null && !gList.isEmpty()) {  // if group was found
          UserGroup jGroup = (UserGroup) gList.get(0);
          if (!user.getGroups().contains(jGroup)) {  // if user 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 uri=\"" + groupUri + "\"/>";
              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(MessageProcessor.class.getName()).log(Level.WARNING, msg);
              }
            } else {
              user.addGroup(jGroup);  // add group to user's groups
              jGroup.addUser(user);  // add user to group
              requestInfo.addJoinedGroup(jGroup);  // add group into list of just added groups
            }
          }
        } else {  // if group wasn't found - error
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<group uri=\"" + groupUri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Group to join was not found.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      } else {  // if id of group isn't presented or it's malformed
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<group uri=\"" + groupUri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Join to group without group id.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // for all join messages
  }  // processJoin()

  /**
   * Process leave messages (leave user group)
   * Informations are stored into requestInfo and user is femoved from group
   * (no additional operations needed).
   *
   * @param leaveMsgs Messages to process
   * @param requestInfo Informations about client request
   */
  private static void processLeave(NodeList leaveMsgs, RequestInfo requestInfo) {
    int leaveCnt = leaveMsgs.getLength();
    User user = requestInfo.getSession().getUser();
    for (int i = 0; i < leaveCnt; i++) {  // for all leave messages
      Element leaveEl = (Element) leaveMsgs.item(i);
      String groupUri = leaveEl.getAttribute("group");
      if (groupUri == null) {
        groupUri = "";
      }
      // get id of user group by strip off base URI
      String groupIdStr = groupUri.replace(AppBean.getBaseGroupUri(), "");
      // parse id of user group
      Integer groupId = null;
      if (!groupIdStr.isEmpty()) {
        try {
          groupId = Integer.parseInt(groupIdStr);
        } catch (NumberFormatException nfe) {
          groupId = null;
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad id of leaved group: " + groupIdStr;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      }
      if (groupId != null) {  // if id of group is available
        // query database for group
        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = groupId;
        List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
        if (gList != null && !gList.isEmpty()) {
          UserGroup lGroup = (UserGroup) gList.get(0);
          if (user.getGroups().contains(lGroup)) {  // if user 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();
              String info = "<group uri=\"" + groupUri + "\"/>";
              requestInfo.addError(lod, langNum, Localisation.ERROR_58_LAST_ADMIN, info);
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
                String msg = "Last administrator is trying to leave group.";
                Logger.getLogger(MessageProcessor.class.getName()).log(Level.WARNING, msg);
              }
            } else {
              user.getGroups().remove(lGroup);  // remove group from user's groups
              lGroup.getUsers().remove(user);  // remove user from group
              requestInfo.addLeavedGroup(lGroup);  // add group to list of just leaved groups
            }
          } else {  // if user isn't in this group
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<group uri=\"" + groupUri + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Group to leave is not in joined groups.";
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
        } else {  // if group wasn't found - error
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<group uri=\"" + groupUri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Group to leave was not found.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      } else {  // if id of group isn't presented or it's malformed
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<group uri=\"" + groupUri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Leave without group id.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // for all leave messages
  }  // processLeave()

  /**
   * Process annotations message (added, changed and removed annotations)
   * Informations are stored into requestInfo.
   *
   * @param annotationsEl Element with message to process
   * @param requestInfo Informations about client request
   */
  private static void processAnnotations(Element annotationsEl, RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    if (requestInfo.getSession().getSyncDocument() == null) {  // if not synchronized
      // annotations can't be processed
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_43_NOT_SYNCHRONIZED);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Not synchronized and trying to create annotations.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    // get element with added annotations
    NodeList addedNL = annotationsEl.getElementsByTagName("add");
    if (addedNL.getLength() == 0) {  // if it's not presented, try older version
      addedNL = annotationsEl.getElementsByTagName("added");
    }
    Element addEl = (Element) addedNL.item(0);
    if (addEl != null) {  // if element with added annotations is presented
      // get elements with annotations
      NodeList addAnnotNodes = addEl.getElementsByTagName("annotation");
      int addedAnnotCnt = addAnnotNodes.getLength();
      for (int i = 0; i < addedAnnotCnt; i++) {  // for all annotation elements
        Element addedAnnotEl = (Element) addAnnotNodes.item(i);
        if (addedAnnotEl.getParentNode() != addEl) {
          // if it's nested annotation at any level
          continue;  // skip
        }
        // process element
        Annotation addedAnnot = processAddedAnnotEl(addedAnnotEl, requestInfo);
        if (addedAnnot != null) {  // if element was successfully processed
          flier.AddAddedAnnotation(addedAnnot);  // add annotation to flier
        }
      }
    }
    // get element with changed annotations
    NodeList editedNL = annotationsEl.getElementsByTagName("change");
    if (editedNL.getLength() == 0) {  // if it's not presented, try older version
      editedNL = annotationsEl.getElementsByTagName("edited");
    }
    Element editedEl = (Element) editedNL.item(0);
    if (editedEl != null) {  // if element with changed annotations is presented
      // get elements with annotations
      NodeList updateAnnotNodes = editedEl.getElementsByTagName("annotation");
      int updatedAnnotCnt = updateAnnotNodes.getLength();
      for (int i = 0; i < updatedAnnotCnt; i++) {  // for all annotation elements
        Element updatedAnnotEl = (Element) updateAnnotNodes.item(i);
        if (updatedAnnotEl.getParentNode() != editedEl) {
          // if it's nested annotation at any level
          continue;  // skip
        }
        // process element
        Annotation editedAnnot = processEditedAnnotEl(updatedAnnotEl, requestInfo);
        if (editedAnnot != null) {  // if element was successfully processed
          flier.AddEditedAnnotation(editedAnnot);  // add annotation to flier
        }
      }
    }
    // get element with removed annotations
    NodeList removedNL = annotationsEl.getElementsByTagName("remove");
    if (removedNL.getLength() == 0) {  // if it's not presented, try older version
      removedNL = annotationsEl.getElementsByTagName("removed");
    }
    Element removedEl = (Element) removedNL.item(0);
    if (removedEl != null) {
      // get elements with annotations
      NodeList remAnnotNodes = removedEl.getElementsByTagName("annotation");
      int remAnnotCnt = remAnnotNodes.getLength();
      for (int i = 0; i < remAnnotCnt; i++) {  // for all annotation elements
        Element remAnnotEl = (Element) remAnnotNodes.item(i);
        if (remAnnotEl.getParentNode() != removedEl) {
          // if it's nested annotation at any level
          continue;  // skip
        }
        // process element
        Annotation removedAnnot = processRemAnnotEl(remAnnotEl, requestInfo);
        if (removedAnnot != null) {  // if element was successfully processed
          flier.AddRemovedAnnotation(removedAnnot);  // add annotation to flier
        }
      }
    }  // if (removedEl != null) ...
  }  // processAnnotations()

  /**
   * Process element with added annotation.
   * If error occurs, generates error message.
   *
   * @param addedAnnotEl Element with added annotation to process
   * @param requestInfo Informations about client request
   * @return If element was successfully processed, returns annotation, if error occurred, returns null
   */
  private static Annotation processAddedAnnotEl(Element addedAnnotEl, RequestInfo requestInfo) {
    Annotation retAnnot = null;
    // get attributes of annotation element (informations about suggestions)
    String confirmed = addedAnnotEl.getAttribute("confirmed");
    String tmpId = addedAnnotEl.getAttribute("tmpId");
    if (tmpId == null) {
      tmpId = "";
    }
    // get element with annotation data
    NodeList annotDescNL = addedAnnotEl.getElementsByTagName("rdf:Description");
    int nCount = annotDescNL.getLength();
    int ni = 0;
    Element annotDescEl = (Element) annotDescNL.item(ni);
    if (tmpId.isEmpty()) {
      tmpId = annotDescEl.getAttribute("tmpId");
      if (tmpId == null) {
        tmpId = "";
      }
    }
    ni++;
    if (annotDescEl == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    while (annotDescEl.getParentNode() != addedAnnotEl && ni < nCount) {
      // find proper element
      annotDescEl = (Element) annotDescNL.item(ni);
      ni++;
    }
    if (annotDescEl.getParentNode() != addedAnnotEl) {  // check element
      // if element is not on the proper level
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    Integer cMethod = Constants.CONFIRM_METHODS.indexOf(confirmed);
    if (cMethod < 0) {  // unknown method
      cMethod = null;
    }
    // process element with annotation data
    retAnnot = processAnnotationDescEl(annotDescEl, requestInfo, null, cMethod);
    if (retAnnot == null) {  // if error occurred
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad annotation description: " + annotDescEl.toString();
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    if (retAnnot.getAuthorIdStr() == null) {  // if author's URI wasn't set
      // set informations about annotation author
      User user = requestInfo.getSession().getUser();
      retAnnot.setAuthorIdStr(AppBean.getBaseAuthorUri() + user.getId());
      retAnnot.setAuthorName(user.getName());
      retAnnot.setAuthorAddress(user.getEmail());
    }
    if (!tmpId.isEmpty()) {  // if this annotation is confirmed suggestion
      // parse confirmation method
      Integer method = Constants.CONFIRM_METHODS.indexOf(confirmed);
      if (method < 0) {  // unknown method
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_28_BAD_CONFIRM);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad confirmation method: ";
          if (confirmed != null) {
            msg = msg + confirmed;
          }
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        method = Constants.CONFIRMED_AUTOMATICALLY;  // set to automatically (low confidence)
      }
      if (tmpId != null) {  // if id of suggestion is available
        EditorSession session = requestInfo.getSession();
        // find suggestion
        SuggestionLogEntry cmp = new SuggestionLogEntry(tmpId);
        
         if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
          Integer id = null;
          try {
            id = Integer.parseInt(tmpId);
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "The ID of the confirmed suggestion is not a number: " + tmpId;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
          // ID was parsed successfuly and the ID is contained within sended suggestions
          if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {
            SuggestionLogEntry newEntry = new SuggestionLogEntry(tmpId);
            // set informations about confirmation
            retAnnot.setTmpId(tmpId);
            retAnnot.setId(null);
            newEntry.setConfirmMethod(method);
            newEntry.setConfirmedVersion(retAnnot);
            // add to list of confirmed suggestions
            if (!requestInfo.getConfirmedSuggestions().contains(newEntry)) {
              requestInfo.addConfirmedSuggestion(newEntry);
            }
          } else { // the suggestion's not been found
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Suggestion with the following ID not found: " + tmpId;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
        }
      }
    }  // if this annotation is confirmed suggestion
    return retAnnot;
  }  // processAddedAnnotEl()

  /**
   * Process element with changed annotation.
   * If error occurs, generates error message.
   *
   * @param updatedAnnotEl Element with changed annotation to process
   * @param requestInfo Informations about client request
   * @return If element was successfully processed, returns annotation, if error occurred, returns null
   */
  private static Annotation processEditedAnnotEl(Element updatedAnnotEl, RequestInfo requestInfo) {
    Annotation retAnnot = null;
    // get element with annotation data
    NodeList annotDescNL = updatedAnnotEl.getElementsByTagName("rdf:Description");
    int nCount = annotDescNL.getLength();
    int ni = 0;
    Element annotDescEl = (Element) annotDescNL.item(ni);
    ni++;
    if (annotDescEl == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element of edited annotation is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    while (annotDescEl.getParentNode() != updatedAnnotEl && ni < nCount) {
      // find proper element
      annotDescEl = (Element) annotDescNL.item(ni);
      ni++;
    }
    if (annotDescEl.getParentNode() != updatedAnnotEl) {  // check element
      // if element is not on the proper level
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element of edited annotation is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    // get URI of annotation
    String annotUri = annotDescEl.getAttribute("rdf:about");
    // get id of annotation (strip off base URI)
    String annotIdStr = annotUri.replace(AppBean.getBaseAnnotUri(), "");
    // parse id of annotation
    Integer annotId = null;
    try {
      annotId = Integer.parseInt(annotIdStr);
    } catch (NumberFormatException nfe) {  // malformed id - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<reload uri=\"" + annotUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_29_CHANGED_ANNOT_NOT_FOUND, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad id of edited annotation: " + annotIdStr;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    // query database for annotation
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = annotId;
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
    if (aList != null && !aList.isEmpty()) {  // if annotation was found
      retAnnot = (Annotation) aList.get(0);
    } else {  // if annotation wasn't found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<reload uri=\"" + annotUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_29_CHANGED_ANNOT_NOT_FOUND, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Edited annotation was not found.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // unknown annotation can't be changed
    }

    // process element with annotation data
    Annotation annotFromEl = processAnnotationDescEl(annotDescEl, requestInfo, null, null);
    if (annotFromEl != null) {  // if element was successfully processed
      annotFromEl.setId(retAnnot.getId());  // set id of annotation to id of its old version
    } else {  // if error occurred
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad edited annotation description: " + annotDescEl.toString();
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    return annotFromEl;
  }  // processEditedAnnotEl()

  /**
   * Process element with removed annotation.
   * If error occurs, generates error message.
   *
   * @param remAnnotEl Element with removed annotation to process
   * @param requestInfo Informations about client request
   * @return If element was successfully processed, returns annotation, if error occurred, returns null
   */
  private static Annotation processRemAnnotEl(Element remAnnotEl, RequestInfo requestInfo) {
    Annotation retAnnot = null;
    // get element with annotation data
    NodeList annotDescNL = remAnnotEl.getElementsByTagName("rdf:Description");
    int nCount = annotDescNL.getLength();
    int ni = 0;
    Element annotDescEl = (Element) annotDescNL.item(ni);
    ni++;
    if (annotDescEl == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element of removed annotation is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    while (annotDescEl.getParentNode() != remAnnotEl && ni < nCount) {
      // find proper element
      annotDescEl = (Element) annotDescNL.item(ni);
      ni++;
    }
    if (annotDescEl.getParentNode() != remAnnotEl) {  // check element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_54_BAD_ANNOT_DESCRIPTION);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation description element of removed annotation is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // no annotation returned
    }
    // get URI of annotation
    String annotUri = annotDescEl.getAttribute("rdf:about");
    // get id of annotation (strip off base URI)
    String annotIdStr = annotUri.replace(AppBean.getBaseAnnotUri(), "");
    // parse id of annotation
    Integer annotId = null;
    try {
      annotId = Integer.parseInt(annotIdStr);
    } catch (NumberFormatException nfe) {  // malformed id - error
      String info = "<reload uri=\"" + annotUri + "\"/>";
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_30_REM_ANNOT_NOT_FOUND, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad id of removed annotation: " + annotIdStr;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    // query database for annotation
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = annotId;
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
    if (aList != null && !aList.isEmpty()) {  // if annotation was found
      retAnnot = (Annotation) aList.get(0);
    } else {  // if annotation wasn't found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<reload uri=\"" + annotUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_30_REM_ANNOT_NOT_FOUND, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Removed annotation was not found.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // unknown annotation can't be removed
    }
    return retAnnot;
  }  // processRemAnnotEl()

  /**
   * Process element with annotation data.
   * If error occurs, generates error message.
   * For nested annotations it's called recursively.
   *
   * @param annotationEl Element with annotation data to process
   * @param requestInfo Informations about client request
   * @param nestedIn If this annotation is nested, then parent annotation, null otherwise
   * @param cMethod Confirmation method of parent annotation or null
   * @return If element was successfully processed, returns annotation, if error occurred, returns null
   */
  private static Annotation processAnnotationDescEl(Element annotationEl, RequestInfo requestInfo, Annotation nestedIn, Integer cMethod) {
    EditorSession session = requestInfo.getSession();
    Flier flier = requestInfo.getFlier();
    Annotation retAnnot = null;
    // get URI of annotation
    String annotUri = annotationEl.getAttribute("rdf:about");
    if (annotUri == null) {
      annotUri = "";
    }
    String tmpId = annotationEl.getAttribute("tmpId");
    // prepare informations for error message
    String errInfo = "";
    if (!annotUri.isEmpty()) {
      errInfo = "<reload uri=\"" + annotUri + "\"/>";
    }

    // get element with annotation type
    NodeList typeNL = annotationEl.getElementsByTagName("rdf:type");
    Element typeEl = (Element) typeNL.item(0);
    if (typeEl == null) {
      int langNum = session.getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, errInfo);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation type element is missing.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    // get URI of annotation type
    String annotTypeStr = typeEl.getAttribute("rdf:resource");
    // query database for annotation type
    AnnotType annotType = null;
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = annotTypeStr;
    List aList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    if (aList != null && !aList.isEmpty()) {  // if type was found
      annotType = (AnnotType) aList.get(0);
    } else {  // type was not found, it possibly can be new type
      Iterator<AnnotType> atIter = (Iterator<AnnotType>) flier.getAddedTypes().iterator();
      while (atIter.hasNext() && annotType == null) {  // look over just added types
        AnnotType addedT = atIter.next();
        if (addedT.getUri().equals(annotTypeStr)) {  // if type was found
          annotType = addedT;
        }
      }
    }
    if (annotType == null && annotTypeStr.contains(AppBean.getBaseTypeUri())) {
      // possible client with bad protocol (he don't supply group id)

      // assemble base URI with default user group for this user
      String baseWG = AppBean.getBaseTypeUri() + "g" + requestInfo.getSession().getDefaultGroup().getId() + "/";
      // replace base URI with new URI
      String pomTypeStr = annotTypeStr.replace(AppBean.getBaseTypeUri(), baseWG);
      // query database for annotation type with corrected URI
      params[1] = pomTypeStr;
      aList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (aList != null && !aList.isEmpty()) {  // if type was found
        annotType = (AnnotType) aList.get(0);
      } else {  // type was not found, it possibly can be new type
        Iterator<AnnotType> atIter = (Iterator<AnnotType>) flier.getAddedTypes().iterator();
        while (atIter.hasNext() && annotType == null) {  // look over just added types
          AnnotType addedT = atIter.next();
          if (addedT.getUri().equals(pomTypeStr)) {  // if type was found
            annotType = addedT;
          }
        }
      }
    }
    if (annotType == null) {  // if annotation type was not found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, errInfo);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Annotation type not found: " + annotTypeStr;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    // get element with date of creation
    NodeList dateNL = annotationEl.getElementsByTagName("a:dateTime");
    Element dateEl = (Element) dateNL.item(0);
    Date annotDate = null;
    if (dateEl == null) {  // if date is missing
      annotDate = new Date();  // use actual date
    } else {  // if date is set
      // get date of creation
      String dateString = dateEl.getAttribute("rdf:value");
      // parse date of creation
      try {
        annotDate = Util.parseRFC3339Date(dateString);
      } catch (Exception e) {  // malformed date - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_41_BAD_DATE_FORMAT_ANNOT, errInfo);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad date of annotation creation: " + dateString;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        annotDate = new Date();  // replace with actual date
      }
    }

    // get element with annotation author
    NodeList authorNL = annotationEl.getElementsByTagName("a:author");
    Element authorEl = (Element) authorNL.item(0);
    if (authorEl == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_44_ANNOT_AUTHOR, errInfo);
      return null;  // annotation cannot be processed
    }
    // get informations about author
    String authorName = authorEl.getAttribute("name");  // full name
    String authorAddress = authorEl.getAttribute("address");  // email
    String authorIdStr = authorEl.getAttribute("id");  // URI
    if (authorIdStr == null) {
      authorIdStr = "";
    } else {  // if URI of author was set, strip off base URI and get id of author
      authorIdStr = authorIdStr.replace(AppBean.getBaseAuthorUri(), "");
    }
    // parse id of author
    Integer authorId = null;
    if (!authorIdStr.isEmpty()) {
      try {
        authorId = Integer.parseInt(authorIdStr);
      } catch (NumberFormatException nfe) {  // malformed id - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_44_ANNOT_AUTHOR, errInfo);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad id of annotation author: " + authorIdStr;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // annotation cannot be processed
      }
    }

    // get element with URI of annotated copy of document
    NodeList sourceNL = annotationEl.getElementsByTagName("a:source");
    Element sourceEl = (Element) sourceNL.item(0);
    if (sourceEl == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_24_BAD_SOURCE_IN_ANNOT, errInfo);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Source element is missing in annotation.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    // get URI of annotated copy of document
    String annotSource = sourceEl.getAttribute("rdf:resource");
    if (annotSource == null) {
      annotSource = "";
    }
    if (annotSource.isEmpty()) {  // if URI is empty, use URI of synchronized document
      annotSource = session.getSyncDocument().getUri();
    } else if (!annotSource.equals(session.getSyncDocument().getUriForAnnot())) {
      // if it's not URI of synchronized document - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_24_BAD_SOURCE_IN_ANNOT, errInfo);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Source in annotation is not matching to synchronized document.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    // get textual content of annotation
    NodeList contentNL = annotationEl.getElementsByTagName("a:content");
    Element contentEl = (Element) contentNL.item(0);
    String content = MessageProcessor.getElementContent(contentEl);
    if (content == null) {
      content = "";
    }

    // create annotation object
    retAnnot = new Annotation(annotType, annotDate, authorIdStr, authorName, authorAddress, session.getSyncDocument(), content, nestedIn);

    retAnnot.setTmpId(tmpId);
    SuggestionLogEntry newEntry = null;
    if (nestedIn != null) {
      if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
        Integer id = null;
        try {
          id = Integer.parseInt(tmpId);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "The ID of the refused suggestion is not a number: " + tmpId;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
        int method = Constants.CONFIRMED_AUTOMATICALLY;
        if (cMethod != null) {
          method = cMethod;
        }
        // ID was parsed successfuly and the ID is contained within sended suggestions
        if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {
          newEntry = new SuggestionLogEntry(tmpId);
          // set informations about confirmation
          newEntry.setConfirmMethod(method);
          newEntry.setConfirmedVersion(retAnnot);
          // add to list of confirmed suggestions
          if(!requestInfo.getConfirmedSuggestions().contains(newEntry)){
            requestInfo.addConfirmedSuggestion(newEntry);
          }
        }
      } else { // the suggestion's not been found
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Suggestion with the following ID not found: " + tmpId;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }
    
    if (!annotUri.isEmpty()) {  // if URI of annotation is available
      // get id of annotation from URI (strip off base URI)
      String annotIdInStr = annotUri.replace(AppBean.getBaseAnnotUri(), "");
      Integer id = null;
      try {
        id = Integer.parseInt(annotIdInStr);
      } catch (NumberFormatException nfe) {
        // if id is malformed, handle it as it's not set (it can have unknown base URI)
        id = null;
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Bad id of annotation: " + annotIdInStr;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
      if (id != null) {  // if id is available, set it
        retAnnot.setId(id);
      }
    }  // if URI of annotation is available

    if (authorId != null) {  // if id of author is available
      // query database for author (user)
      params[0] = "id";
      params[1] = authorId;
      List uList = AppBean.getPersistenceManager().queryDB("User.findById", params);
      if (uList != null && !uList.isEmpty()) {  // if user was found
        retAnnot.setUser((User) uList.get(0));  // set author of annotation
      }
    } else if (authorAddress != null && !authorAddress.isEmpty()) {
      // if id was not available, but email is available (possible old version of client)
      // query database for author (find user by email)
      params[0] = "email";
      params[1] = authorAddress;
      List uList = AppBean.getPersistenceManager().queryDB("User.findByEmail", params);
      if (uList != null && !uList.isEmpty()) {  // if user was found
        retAnnot.setUser((User) uList.get(0));  // set author of annotation
      }
      // set URI of author
      if (retAnnot.getUser() != null) {  // if user was set
        retAnnot.setAuthorIdStr(AppBean.getBaseAuthorUri() + retAnnot.getUser().getId());
      } else {  // if user was not found
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_44_ANNOT_AUTHOR, errInfo);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknowwn author address in annotation and id is not set: " + authorAddress;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // annotation cannot be processed
      }
    }

    if (retAnnot.getUser() != null && (authorAddress == null || authorAddress.isEmpty())) {
      // if author is set but his email doesn't
      retAnnot.setAuthorAddress(retAnnot.getUser().getEmail());  // set email
    }
    if (retAnnot.getUser() != null && (authorName == null || authorName.isEmpty())) {
      // if author is set but his full name doesn't
      retAnnot.setAuthorName(retAnnot.getUser().getName());  // set author
    }

    // get elements with fragments
    NodeList fragmentNodes = annotationEl.getElementsByTagName("a:fragment");
    int fragmentCnt = fragmentNodes.getLength();
    for (int i = 0; i < fragmentCnt; i++) {  // for all elements with fragments
      Element fragmentEl = (Element) fragmentNodes.item(i);
      if (fragmentEl.getParentNode() != annotationEl) {
        // if it's fragment of nested annotation at any level
        continue;  // skip
      }
      // process element
      Fragment fragment = processFragmentEl(fragmentEl, retAnnot, requestInfo);
      if (fragment != null) {  // if element was successfully processed
        retAnnot.addFragment(fragment);  // add fragment to annotation
      } else {  // malformed fragment data - add error message and skip fragment
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, errInfo);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad annotated fragment description.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // for all elements with fragments

    // get elements with attributes
    NodeList attributeNodes = annotationEl.getElementsByTagName("a:attribute");
    int attribCnt = attributeNodes.getLength();
    for (int i = 0; i < attribCnt; i++) {  // for all elements with attributes
      Element attributeEl = (Element) attributeNodes.item(i);
      if (attributeEl.getParentNode() != annotationEl) {
        // if it's attribute of nested annotation at any level
        continue;  // skip
      }
      // process element
      BaseAttribute attribute = processAttributeEl(attributeEl, retAnnot, requestInfo, i, cMethod);
      if (attribute != null) {  // if element was successfully processed
        retAnnot.addAttribute(attribute);  // add attribute to annotation
      }
    }  // for all elements with attributes

    if (newEntry != null && !requestInfo.getConfirmedSuggestions().contains(newEntry)) {
      requestInfo.addConfirmedSuggestion(newEntry);
    }
    
    return retAnnot;  // return annotation object
  }  // processAnnotationDescEl()
  
  /**
   * Logs error details connected with processing attribute
   * 
   * @param errAnnotInfo Informations about annotation to reload.
   * @param name Name of attribute
   * @param type Type of attribute
   * @param requestInfo Informations about client request
   * @param errorCode Number of error
   * @param message Message with additional informations
   */
  private static void logAttributeError(String errAnnotInfo, String name, String type, RequestInfo requestInfo, int errorCode, String message) {
    int langNum = requestInfo.getSession().getLanguageNum();
    int lod = requestInfo.getSession().getProtocolLOD();
    String info = errAnnotInfo
            + "<attribute name=\"" + name + "\" type=\"" + type + "\"/>";
    requestInfo.addError(lod, langNum, errorCode, info);
    if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
      Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, message);
    }
  }


  /**
   * Process element with annotation data.
   * If error occurs, generates error message.
   *
   * @param attributeEl Element with attribute of annotation
   * @param annot Annotation to which this attribute belongs
   * @param requestInfo Informations about client request
   * @param order Order of attribute
   * @param cMethod Confirmation method of parent annotation or null
   * @return If element was successfully processed, returns attribute, if error occurred, returns null
   */
  private static BaseAttribute processAttributeEl(Element attributeEl, Annotation annot, RequestInfo requestInfo, int order, Integer cMethod) {
    BaseAttribute retAttribute = null;

    // prepare informations about annotation for error message
    String errAnnotInfo = "";
    if (!(annot.getId() == null)) {
      errAnnotInfo = "<reload uri=\"" + annot.getId() + "\"/>";
    }

    String name = attributeEl.getAttribute("name");
    String type = attributeEl.getAttribute("type");
    String priorityStr = attributeEl.getAttribute("priority");
    if (name == null) {
      name = "";
    }
    if (type == null) {
      type = "";
    }
    if (name.isEmpty()) {  // if name is missing
      logAttributeError(errAnnotInfo, name, type, requestInfo,
                        Localisation.ERROR_26_ATTRIBUTE_MALFORMED,
                        "Name of attribute of annotation is missing.");
      return null;  // bad attribute
    }

    if (type.isEmpty()) {  // if type is missing
      logAttributeError(errAnnotInfo, name, type, requestInfo,
                        Localisation.ERROR_26_ATTRIBUTE_MALFORMED,
                       "Type of atribute of annotation is missing.");
      return null;  // bad attribute
    }

    Integer priority = null;
    if (priorityStr != null) {
      try {
        priority = Integer.parseInt(priorityStr);
      } catch (NumberFormatException ex) {
        priority = null;
      }
    }
    if (priority == null) {
      priority = order;
    }
    
    // process comment
    String attrComment = null;
    NodeList attrCommentNL = attributeEl.getElementsByTagName("a:comment");
    if (attrCommentNL.getLength() != 0) {
      Element attrCommentEl = (Element) attrCommentNL.item(0);
      attrComment = MessageProcessor.getElementContent(attrCommentEl);
    }

    // in next section of code, stars after comments are used for lucidity (delimiting cases)

    // type specific processing
    if (type.contentEquals("person") || type.contentEquals("Person")) {
      // if type of attribute is person (user of system) ***********************
      // (supported only in old version of clients)

      // get element with informations about user
      NodeList personNL = attributeEl.getElementsByTagName("a:person");
      Element personEl = (Element) personNL.item(0);
      if (personEl != null) {  // if element person is presented
        String email = "";
        String userIdStr = "";
        String idInAtt = personEl.getAttribute("id");

        if (idInAtt != null) {  // if attribute is not empty
          if (idInAtt.contains(AppBean.getBaseAuthorUri())) {  // if it's URI
            userIdStr = idInAtt.replace(AppBean.getBaseAuthorUri(), "");
          } else {  // if it's email
            email = idInAtt;
          }
        }  // if attribute is not empty

        if (email.isEmpty()) {  // if email isn't available, it can be presented in attribute address
          // oficially unsupported, but clients can do it
          email = personEl.getAttribute("address");
          if (email == null) {
            email = "";
          }
        }

        if (email.isEmpty() && userIdStr.isEmpty()) {  // if identificator is missing
          logAttributeError(errAnnotInfo, name, type, requestInfo,
                  Localisation.ERROR_7_ATTRIBUTE_VALUE,
                  "Bad attribute of type Person (identificator is missing).");
          return null;  // bad attribute
        }

        Integer userId = null;
        if (!userIdStr.isEmpty()) {
          // parse user id
          try {
            userId = Integer.parseInt(userIdStr);
          } catch (NumberFormatException nfe) {  // if id is malformed
            logAttributeError(errAnnotInfo, name, type, requestInfo,
                              Localisation.ERROR_7_ATTRIBUTE_VALUE,
                              "Bad id of Person in attribute of type Person: " + userIdStr);
            return null;  // bad attribute
          }
        }

        // default is find by email
        Object[] params = new Object[2];
        params[0] = "email";
        params[1] = email;
        String queryName = "User.findByEmail";

        if (userId != null) {  // if id is set, user will be found by id
          params[0] = "id";
          params[1] = userId;
          queryName = "User.findById";
        }

        // query database for user
        List uList = AppBean.getPersistenceManager().queryDB(queryName, params);
        if (uList != null && !uList.isEmpty()) {  // if user was found
          // create attribute object
          retAttribute = new PersonAttribute(name, (User) uList.get(0), annot);
        } else {  // if user wasn't found, it's bad attribute value
          String msg = "Unknown person in attribute of type Person: ";
          if (email != null) {
            msg += email;
          }
          if (userId != null) {
            msg += userId;
          }
          logAttributeError(errAnnotInfo, name, type, requestInfo,
                            Localisation.ERROR_27_UNKNOWN_PERSON_ATTRIBUTE,msg);
          return null;
        }
      } else {  // if element person is not presented (value of attribute is empty)
        // create attribute object
        retAttribute = new PersonAttribute(name, (User) null, annot);
      }

    } else if (type.contentEquals("NestedAnnotation") || type.contentEquals("nestedAnnotation")) {
      // if type of attribute is nested annotation *****************************

      // get element with nested annotation data
      NodeList nestedNL = attributeEl.getElementsByTagName("rdf:Description");
      int nCount = nestedNL.getLength();
      int ni = 0;
      Element nestedEl = (Element) nestedNL.item(ni);
      ni++;
      if (nestedEl != null) {
        while (nestedEl.getParentNode() != attributeEl && ni < nCount) {
          // find proper element
          nestedEl = (Element) nestedNL.item(ni);
          ni++;
        }
        if (nestedEl.getParentNode() != attributeEl) {  // check element
          nestedEl = null;
        }
      }
      if (nestedEl == null) {  // if element is not found
        // try whether element <annotation> is not included
        NodeList nestedANL = attributeEl.getElementsByTagName("annotation");
        nCount = nestedANL.getLength();
        ni = 0;
        Element nestedAEl = (Element) nestedANL.item(ni);
        ni++;
        if (nestedAEl != null) {
          while (nestedAEl.getParentNode() != attributeEl && ni < nCount) {
            // find proper element
            nestedAEl = (Element) nestedANL.item(ni);
            ni++;
          }
          if (nestedAEl.getParentNode() != attributeEl) {  // check element
            nestedEl = null;
          }
        }
        if (nestedAEl != null) {  // if <annotation> element is included
          // get element with nested annotation data
          NodeList nestedDNL = nestedAEl.getElementsByTagName("rdf:Description");
          nCount = nestedDNL.getLength();
          ni = 0;
          nestedEl = (Element) nestedDNL.item(ni);
          ni++;
          if (nestedEl != null) {
            while (nestedEl.getParentNode() != nestedAEl && ni < nCount) {
              // find proper element
              nestedEl = (Element) nestedDNL.item(ni);
              ni++;
            }
            if (nestedEl.getParentNode() != nestedAEl) {  // check element
              nestedEl = null;
            }
          }
        }  // if <annotation> element is included
      }  // if element is not found

      if (nestedEl != null) {  // if element with data is presented
        // process element with annotation data
        Annotation nestedAnnot = processAnnotationDescEl(nestedEl, requestInfo, annot, cMethod);
        if (nestedAnnot != null) {  // if element was successfully processed
          // create attribute object
          try {
            retAttribute = AttributeManager.createAttribute(name, "NestedAnnotation", 
                                nestedAnnot.getAnnotType(), nestedAnnot, annot);
            retAttribute.setAttributeType(nestedAnnot.getAnnotType());
          } catch (Exception e) {
            String message = e.getMessage();
            logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
            return null;
          }
        } else {  // if error occurred - bad attribute value
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = errAnnotInfo
                  + "<attribute name=\"" + name + "\" type=\"" + type + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Bad nested annotation.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;  // bad attribute
        }
      } else {  // if element with data is not presented - empty attribute value
        // create attribute object
        try {
          retAttribute = AttributeManager.createAttribute(name, "NestedAnnotation", (Annotation) null, annot);
        } catch (Exception e) {
          String message = e.getMessage();
          logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
          return null;
        }
      }
    } else if (type.contentEquals("AnnotationLink") || type.contentEquals("annotationLink")) {
      // if type of attribute is link to another annotation ********************
      
      try {
        retAttribute = AttributeManager.createAttribute(name, type, annot);
        String value = attributeEl.getAttribute("uri");
        
        
        boolean onlyDigit = true;
        if(value != null && !value.equals("")){
          //test if string contains only numbers (maybe misplaced tmpId)
          int size = value.length();

          for(int i = 0; i < size; i++){
              if(!Character.isDigit(value.charAt(i))){ 
                onlyDigit = false;
                break;
              }
          }
          
          //try to find annotation in DB by tmpId
          if(onlyDigit){
            ((LinkedAnnotationAttribute) retAttribute).setTmpId(value);
          }
        }

        if (value != null && !value.equals("") && !onlyDigit) {
          // check if is this annotation in DB
          if(Constants.TEST_ANNOT_LINK_URI){
            
            Object[] params = new Object[2];
            
            try{
              String tmpValue = value.replace(AppBean.getBaseAnnotUri(), "");
              params[0] = "id";
              params[1] = Long.decode(tmpValue);
            }
            
            catch(Exception e){
              String message = e.getMessage();
              logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
              return null;
            }
            
            finally{
              @SuppressWarnings("unchecked")
              List<Annotation> annotList = AppBean.getPersistenceManager().queryDB("Annotation.findById",params);
              if(annotList == null || annotList.isEmpty()){
                String message = "Unknown annotation uri: " + value + ".";
                logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
                return null;
              }
            }
          }
          retAttribute.setRawValue(value);
        } else {
          value = attributeEl.getAttribute("tmpId");
          if (value != null && !value.equals("")) {
            ((LinkedAnnotationAttribute) retAttribute).setTmpId(value);
          } else {
            retAttribute = AttributeManager.createAttribute(name, "AnyAnnotation", annot);
          }
        }
      } catch (NumberFormatException e) {
        String message = "Bad tmpId in annotation link.";
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
        return null;
      } catch (ClassNotFoundException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      } catch (IllegalArgumentException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
        return null;
      } catch (UnsupportedOperationException e) {
        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 = "UnsupportedOperationException for setting of attribute value.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
        }
      } catch (RuntimeException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      }
    }
    else if(type.contentEquals("Text")){
      // if type of attribute is Text ******************************************
      NodeList textNodes = attributeEl.getElementsByTagName("a:Content");
      String data = null;
      
      // If correct number of childs are in element.
      if(textNodes.getLength() != 1){
        String msg = "Zero or more than one CDATA sections in Text attribute.";
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, msg);
        return null;
      }
      
      // If element is type of CDATA
      else{
        Node contentNode = textNodes.item(0);
        Node cdataNode = contentNode.getFirstChild();
        if (cdataNode != null && cdataNode instanceof CharacterData) {
          CharacterData cd = (CharacterData) cdataNode;
          try{
            data = cd.getData();
          }
          catch(DOMException e){
            logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, e.getMessage());
            return null;
          }
        }
      }
      try {
        retAttribute = AttributeManager.createAttribute(name, type, annot);
        if (data != null && !data.isEmpty()) {
          retAttribute.setRawValue(data);
        }
      } catch (ClassNotFoundException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      } catch (IllegalArgumentException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
        return null;
      } catch (UnsupportedOperationException e) {
        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 = "UnsupportedOperationException for setting of attribute value.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
        }
      } catch (RuntimeException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      }
    }
    else if(AttributeManager.containsType(type)){
      // other types of attributes *********************************************
      
      try {
        retAttribute = AttributeManager.createAttribute(name, type, annot);
        // simple one-field values

        if (!retAttribute.isStructured()) {
          String value = attributeEl.getAttribute("rdf:value");
          if (!value.isEmpty()) {
            retAttribute.setRawValue(value);
          }

          // structured attributes
        } else {
          // get element with point
          StructuredAttribute structAttr = (StructuredAttribute) retAttribute;
          Node nested = ((Element) attributeEl).getElementsByTagName(structAttr.getXmlAttributeName()).item(0);

          if (nested != null) {
            HashMap<String, String> values = new HashMap<String, String>();
            NodeList elemValues = ((Element) nested).getChildNodes();
            String valueOfAttribute = MessageProcessor.getElementContent(((Element) nested));
            
            int attrLength = ((Element)nested).getAttributes().getLength();
            HashMap<String, String> attributesMap = new HashMap<String, String>();
            for(int index = 0; index < attrLength; index++){
              String attrName = ((Element)nested).getAttributes().item(index).getNodeName();
              String attrValue = ((Element)nested).getAttributes().item(index).getNodeValue();
              attributesMap.put(attrName, attrValue);
            }
            
            
            for (int i = 0; i < elemValues.getLength(); i++) {
              if (elemValues.item(i).getNodeType() == Node.ELEMENT_NODE) {
                values.put(elemValues.item(i).getNodeName(), MessageProcessor.getElementContent((Element) elemValues.item(i)));
              }
            }
            
            ArrayList<Object> newParam = new ArrayList<Object>(3);
            newParam.add(values);
            newParam.add(attributesMap);
            newParam.add(valueOfAttribute);
            ((StructuredAttribute) retAttribute).setRawValues(newParam);
          }

        }
      } catch (ClassNotFoundException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      } catch (IllegalArgumentException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_7_ATTRIBUTE_VALUE, message);
        return null;
      } catch (UnsupportedOperationException e) {
        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 = "UnsupportedOperationException for setting of attribute value.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
        }
      } catch (RuntimeException e) {
        String message = e.getMessage();
        logAttributeError(errAnnotInfo, name, type, requestInfo, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, message);
        return null;
      }
    }
    else {  // if type of attribute is type of annotation **********************
      // It is structured type with empty value. If value will be presented,
      // in type field will be linkedAnnotation or nestedAnnotation.
      if (!type.contains(AppBean.getBaseTypeUri() + "g")) {  // if id of group is not in URI of type
        if (type.contains(AppBean.getBaseTypeUri())) {
          type = type.replace(AppBean.getBaseTypeUri(), "");
          type = AppBean.getBaseTypeUri() + "g" + requestInfo.getSession().getDefaultGroup().getId() + "/" + type;
        }
      }
      Flier flier = requestInfo.getFlier();
      AnnotType aType = null;
      // query database for type of annotation
      Object[] params = new Object[2];
      params[0] = "uri";
      params[1] = type;
      List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {  // if type was found
        aType = (AnnotType) tList.get(0);
      }
      else if (flier.getAddedTypes() != null && !flier.getAddedTypes().isEmpty()) {
        Iterator<AnnotType> newTypesIt = flier.getAddedTypes().iterator();
        while (newTypesIt.hasNext()) {
          AnnotType newType = newTypesIt.next();
          if (newType.getUri().equals(type)) {  // if type was found
            aType = newType;
          }
        }
      }
      if (aType != null) {  // if type was found
        // create attribute object of type nested annotation with empty value
        try{
          retAttribute = AttributeManager.createAttribute(name, "nestedAnnotation", aType, (Annotation)null, annot);
        }
        catch(ClassNotFoundException e){
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = errAnnotInfo
                  + "<attribute name=\"" + name + "\" type=\"" + type + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_15_ATTRIBUTE_TYPE_UNAVAILABLE, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Unknown type of attribute: " + type;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null; // bad attribute
        }
      } else {  // if type was not found - error (unknown type)
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = errAnnotInfo
                + "<attribute name=\"" + name + "\" type=\"" + type + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_15_ATTRIBUTE_TYPE_UNAVAILABLE, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown type of attribute: " + type;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null; // bad attribute
      }
    } // if type of attribute is type of annotation
    retAttribute.setComment(attrComment);
    retAttribute.setPriority(priority);
    return retAttribute;
  }  // processAttributeEl()

  /**
   * Process element with annotated fragment.
   *
   * @param fragmentEl Element with annotated fragment
   * @param annot Annotation to which this fragment belongs
   * @param requestInfo Informations about client request
   * @return If element was successfully processed, returns fragment, if error occurred, returns null
   */
  private static Fragment processFragmentEl(Element fragmentEl, Annotation annot, RequestInfo requestInfo) {
    Fragment retFragment = null;

    // get and parse information about validity
    String valid = fragmentEl.getAttribute("valid");
    Boolean isGood = true;
    if (valid != null) {
      if (valid.equalsIgnoreCase("false")) {
        isGood = false;
      }
    }

    // get element with XPath
    NodeList pathNL = fragmentEl.getElementsByTagName("a:path");
    Element pathEl = (Element) pathNL.item(0);
    // get XPath of fragment
    String path = MessageProcessor.getElementContent(pathEl);

    // get element with offset
    NodeList offsetNL = fragmentEl.getElementsByTagName("a:offset");
    Element offsetEl = (Element) offsetNL.item(0);
    // get offset
    String offsetString = MessageProcessor.getElementContent(offsetEl);
    // parse offset
    Integer offset = null;
    if (offsetString != null) {
      if (!offsetString.isEmpty()) {  // if offset isn't empty
        try {
          offset = Integer.parseInt(offsetString);
        } catch (NumberFormatException nfe) {  // malformed offset - bad fragment
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad fragment offset: " + offsetString;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;  // bad fragment
        }
      } else {  // if offset is empty
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Empty offset of the fragment.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // bad fragment
      }
    }

    // get element with length
    NodeList lengthNL = fragmentEl.getElementsByTagName("a:length");
    Element lengthEl = (Element) lengthNL.item(0);
    // get length
    String lengthString = MessageProcessor.getElementContent(lengthEl);
    // parse length
    Integer length = null;
    if (lengthString != null) {
      if (!lengthString.isEmpty()) {  // if length isn't empty
        try {
          length = Integer.parseInt(lengthString);
        } catch (NumberFormatException nfe) {  // malformed length
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad length of the fragment: " + lengthString;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;  // bad fragment
        }
      } else {  // if length is empty
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "UEmpty length of the fragment.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // bad fragment
      }
    }

    // get element with textual content of fragment
    NodeList textNL = fragmentEl.getElementsByTagName("a:annotatedText");
    Element textEl = (Element) textNL.item(0);
    // get textual content of fragment
    String text = MessageProcessor.getElementContent(textEl);
    if (text == null) {  // if content is not presented (it can be empty, but must be presented)
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Content of the annotated fragment was not presented.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // bad fragment
    }

    if (text.length() != length.intValue()) {  // if length of content don't matching length of fragment
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Length of the fragment is " + length.intValue() 
                     + " which is not matching to real length of the text \": " + text + "\".";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // bad fragment
    }

    // improve XPath to be usable
    path = UpdatableFragment.improveXPath(path);
    // create fragment object
    retFragment = new Fragment(path, offset, length, text, annot, isGood);

    return retFragment;
  }  // processFragmentEl()

  /**
   * Process element with resynchronize message.
   * Informations are stored into requestInfo.
   * If error occurs, generates error message.
   *
   * @param resynchronizeEl Element with resynchronize message
   * @param requestInfo Informations about client request
   */
  private static void processResynchronize(Element resynchronizeEl, RequestInfo requestInfo) {
    // get element with resynchronized document data
    NodeList contentNL = resynchronizeEl.getElementsByTagName("content");
    Element contentEl = (Element) contentNL.item(0);
    if (contentEl != null) {  // if element with data is presented
      // get content of resynchronized document
      String content = MessageProcessor.getElementContent(contentEl);
      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 = "Resynchronization with empty content of the document.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
      requestInfo.setResyncDocContent(content);  // set content in requestInfo
    } else { // if element with data is not presented - 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 = "Resynchronization without content of the document.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
    }
  }  // processResynchronize()

  /**
   * Process synchronize message.
   * Informations are stored into requestInfo.
   * If error occurs, generates error message.
   *
   * @param synchronizeEl Element with synchronize message
   * @param requestInfo Informations about client request
   */
  private static void processSynchronize(Element synchronizeEl, RequestInfo requestInfo) {
    String resource = synchronizeEl.getAttribute("resource");
    String linearize = synchronizeEl.getAttribute("linearize");
    String overwrite = synchronizeEl.getAttribute("overwrite");
    if (resource == null) {
      resource = "";
    }
    if (resource.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(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    // process attribute with linearization
    if (linearize.contentEquals("true")) {
      requestInfo.setSyncLinearized(true);
    }
    // process attribute with overwrite (forced synchronization)
    if (overwrite.contentEquals("true")) {
      requestInfo.setSyncWithOverwrite(true);
    }
    // get element with synchronized document data
    NodeList contentNL = synchronizeEl.getElementsByTagName("content");
    Element contentEl = (Element) contentNL.item(0);
    if (contentEl != null) {  // if element with data is presented
      // get content of synchronized document
      String content = MessageProcessor.getElementContent(contentEl);
      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(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
      // create object with synchronized document
      AnnotDocument syncDoc = new AnnotDocument(resource, content);
      requestInfo.setSyncDocumentData(syncDoc);  // store document into requestInfo
    } else {  // if element with data is not presented, 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 without content of the document.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
    }
  }  // processSynchronize()

  /**
   * Process unsubscribe message (unsubscribe client from sources).
   * Client is unsubscribed from sources (no additional operations needed).
   * If error occurs, generates error message.
   *
   * @param unsubscribeEl Element with unsubscribe message
   * @param session Client session
   * @param requestInfo Informations about client request
   */
  private static void processUnsubscribe(Element unsubscribeEl, EditorSession session, RequestInfo requestInfo) {
    // get list of elements with sources
    NodeList sourceNL = unsubscribeEl.getElementsByTagName("source");
    int sourceCnt = sourceNL.getLength();
    for (int i = 0; i < sourceCnt; i++) {  // for each unsubscribed source
      Element sourceEl = (Element) sourceNL.item(i);
      String type = sourceEl.getAttribute("type");
      String user = sourceEl.getAttribute("user");
      String uri = sourceEl.getAttribute("uri");
      // create object with source description
      SubscribedSource source = new SubscribedSource(type, user, uri);
      if(!session.containsSource(source) && !session.containsUnsubscribedSource(source)){   //if source isn't subscribed or unsubscribed 
          session.addUnsubscribeSource(source); //add source in list of unsubscribed sources (black list)
      }else {
        if(session.containsSource(source) && !session.containsUnsubscribedSource(source)){  //if source is subscribed
            session.removeSource(source); //remove source from list of subscribed sources
        }
      }
    }  // for each unsubscribed source
  }  // processUnsubscribe()

  /**
   * Process subscribe message (subscribe client to sources).
   * Client is subscribed to sources (no additional operations needed).
   * If error occurs, generates error message.
   *
   * @param subscribeEl Element with subscribe message
   * @param session Client session
   * @param requestInfo Informations about client request
   */
  private static void processSubscribe(Element subscribeEl, EditorSession session, RequestInfo requestInfo) {
    // get list of elements with sources
    NodeList sourceNL = subscribeEl.getElementsByTagName("source");
    int sourceCnt = sourceNL.getLength();
    for (int i = 0; i < sourceCnt; i++) {  // for each subscribed source
      Element sourceEl = (Element) sourceNL.item(i);
      String type = sourceEl.getAttribute("type");
      String user = sourceEl.getAttribute("user");
      String uri = sourceEl.getAttribute("uri");
      if (user != null && !user.isEmpty()) {  // if user is presented
        if (user.indexOf(AppBean.getBaseAuthorUri()) != 0) {  // if base URI isn't presented
          // (possibly email supplied)
          // query database for user (find by email)
          Object[] params = new Object[2];
          params[0] = "email";
          params[1] = user;
          List uList = AppBean.getPersistenceManager().queryDB("User.findByEmail", params);
          if (uList != null && !uList.isEmpty()) {  // if user is found
            User u = (User) uList.get(0);
            user = u.getURI();  // get URI of user to source
          } else {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
              String msg = "Subscribe to unknown user's annotations: " + user;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
        }  // if base URI isn't presented
      }  // if user is presented
      // create object with source description
      SubscribedSource source = new SubscribedSource(type, user, uri);
      if(!session.containsUnsubscribedSource(source) && !session.containsSource(source)){ //if source isn't subscribe or unsubscribe
          session.addSource(source);  // add source to the list of subscribed sources
      } else {
        if(session.containsUnsubscribedSource(source) && !session.containsSource(source)){ //if source is in unsubscribe list
            session.removeUnsubscribeSource(source);  // remove source from unsubscribe annotations list 
            session.addSource(source);  // add source to the list of subscribed sources
        }
      }
    }  // for each subscribed source
  }  // processSubscribe()

  /**
   * 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 static 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");
      if (name == null) {
        name = "";
      }
      if (name.isEmpty()) {  // if name is empty, parameter is bad
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        // create error message
        requestInfo.addError(lod, langNum, Localisation.ERROR_21_SETTINGS_MALFORMED);
        // 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(MessageProcessor.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);
      settings.add(param);  // add parameter to the new list of parameters
    }  // for each parameter
    // store new list of parameters to the informations about request
    requestInfo.setSettings(settings);
  }  // processSettings()

  /**
   * Process refusedSuggestions message (refused suggestions of annotations)
   * Informations are stored into requestInfo.
   *
   * @param refSuggestEl Element with refusedSuggestions message
   * @param requestInfo Informations about client request
   */
  private static void processRefSuggestions(Element refSuggestEl, RequestInfo requestInfo) {
    // get elements with informations about suggestions
    NodeList rSugNL = refSuggestEl.getElementsByTagName("suggestion");
    int rSugNLCnt = rSugNL.getLength();
    for (int i = 0; i < rSugNLCnt; i++) {  // for each suggestion
      Element rSugEl = (Element) rSugNL.item(i);
      // get temporary id of suggested annotation
      String tmpId = rSugEl.getAttribute("tmpId");
      // get refuse method
      String methodStr = rSugEl.getAttribute("method");

      // get id of refuse method
      int method = Constants.REFUSE_METHODS.indexOf(methodStr);
      if (method < 0) {  // bad or unknown method
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown refuse method: " + methodStr;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        method = Constants.REFUSED_AUTOMATICALLY;  // set to automatically (low confidence)
      }
      // create reference object for searching in array
      SuggestionLogEntry cmp = new SuggestionLogEntry(tmpId);
      // find suggested annotation in list of suggestions
       if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
        Integer id = null;
        try {
          id = Integer.parseInt(tmpId);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "The ID of the refused suggestion is not a number: " + tmpId;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
        // ID was parsed successfuly and the ID is contained within sended suggestions
        if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {
          SuggestionLogEntry refused = cmp;
          // set refuse method
          refused.setRefuseMethod(method);
          // add refused suggestion to list of just refused suggestions
          requestInfo.addRefusedSuggestion(refused);
        }
      } else { // the suggestion's not been found
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Suggestion with the following ID not found: " + tmpId;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // for each suggestion
  }  // processRefSuggestions()

  /**
   * Process suggestAnnotations messages (fragments to which are to be suggested
   * annotations).
   * Informations are stored into session.
   * If error occurs, generates error message and turn off suggestions.
   * If one message with empty fragment at document beginning is sent, all
   * fragments will be discarded and suggestions will be turned off.
   * If set of messages is sent, all fragments will be used, but type
   * of annotations will be get from first message (fragment) and other
   * attributes with type will be discarded.
   * New set of fragments (messages) replaces old set of them.
   *
   * @param suggestMsg List of elements with
   * @param requestInfo Informations about client request
   */
  private static void processSuggestions(NodeList suggestMsg, RequestInfo requestInfo) {
    EditorSession session = requestInfo.getSession();
    // clear list of fragments to which are to be suggested annotations
    session.getSuggestionsFr().clear();
    session.clearSuggestionsTypes();
    boolean isFirst = true;  // first processed message have additional processing
    int sugCnt = suggestMsg.getLength();
    for (int i = 0; i < sugCnt; i++) {  // for all fragments (suggestAnnotations messages)
      Element suggestEl = (Element) suggestMsg.item(i);

      Fragment fragment = null;
      // get XPath, offset and length
      String sPath = suggestEl.getAttribute("path");
      String sOffset = suggestEl.getAttribute("offset");
      String sLength = suggestEl.getAttribute("length");

      if (sOffset == null) {  // not set is a same as empty
        sOffset = "";
      }
      if (sLength == null) {
        sLength = "";
      }
      Integer iSOffset = null;
      Integer iSLength = null;
      try {
        if (!sOffset.isEmpty()) {  // if offset is available, parse it
          iSOffset = Integer.decode(sOffset);
        }
        if (!sLength.isEmpty()) {  // if length is available, parse it
          iSLength = Integer.decode(sLength);
        }
        // improve XPath to be usable
        sPath = UpdatableFragment.improveXPath(sPath);
        // create object with fragment
        fragment = new Fragment(sPath, iSOffset, iSLength);
      } catch (NumberFormatException nfe) {  // malformed offset or length - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_8_SUG_FRAGMENT);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad offset or length of fragment for suggestions.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg, nfe);
        }
      }

      if (fragment != null) {  // if element was successfully processed
        session.addSuggestionsFr(fragment);  // add new fragment into session
      } else {  // if fragment is bad (error occurred)
        // clear list of fragments in session (discard suggestions)
        session.getSuggestionsFr().clear();
        session.clearSuggestionsTypes();
        // notify change to appropriate module
        requestInfo.setSuggFragmentChanged(true);
        return;  // end of processing suggestAnnotations
      }

      if (isFirst) {  // if it's first processed message
        // get requested type of annotations
        String sType = suggestEl.getAttribute("type");
        AnnotType type = null;
        if (sType != null && sType.isEmpty()) {  // empty attribute is same as if it's not set
          sType = null;
        }

        if (sType != null) {  // if requested type is set
          // query database for annotation type
          Object[] params = new Object[2];
          params[0] = "uri";
          params[1] = sType;
          List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
          if (tList != null && !tList.isEmpty()) {  // if type was found
            type = (AnnotType) tList.get(0);
          }
          if (type == null) {  // if type was not found - error
            // clear list of fragments in session (discard suggestions)
            session.getSuggestionsFr().clear();
            session.clearSuggestionsTypes();
            // notify change to appropriate module
            requestInfo.setSuggFragmentChanged(true);
            // create error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            requestInfo.addError(lod, langNum, Localisation.ERROR_40_BAD_SUGG_TYPE);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Request for suggestions of unknown type: " + sType;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
            return;
          }
        }  // if requested type is set
        if (sType != null) {
          session.addSuggestionType(sType);  // set new requested type to session
        }
        if (sugCnt == 1) {  // if it's only one mesage
          if (sPath != null
              && (sPath.contentEquals("") || sPath.contentEquals("/"))
              && iSOffset != null && iSLength != null
              && (iSOffset == 0 && iSLength == 0)) {  // if suggestions shall be turned off
            // clear list of fragments in session (turn off suggestions)
            session.getSuggestionsFr().clear();
            session.clearSuggestionsTypes();
          }
        }  // if it's only one mesage
        isFirst = false;
      }  // if it's first processed message
    }  // for all fragments (suggestAnnotations messages)
    requestInfo.setSuggFragmentChanged(true);  // notify change to appropriate module
  }  // processSuggestions()

  /**
   * Processes login message (user name or email and password)
   * If error occurs, generates error message.
   * If password was send in plain text, it will be hashed with MD5.
   *
   * @param loginEl Element with login message
   * @param requestInfo Informations about client request
   * @return If message is successfully processed and user credentials are OK, returns user, else returns null
   */
  private static User processLogin(Element loginEl, RequestInfo requestInfo) {
    User user = null;
    PersistM persistMan = AppBean.getPersistenceManager();
    String userAtt = loginEl.getAttribute("user");
    String passAtt = loginEl.getAttribute("password");
    String tokenAtt = loginEl.getAttribute("token");
    String systemAtt = loginEl.getAttribute("system");
    if (userAtt == null) {  // null is a same as not set
      userAtt = "";
    }
    if (passAtt == null) {
      passAtt = "";
    }
    if (tokenAtt == null) {
      tokenAtt = "";
    }
    if (systemAtt == null) {
      systemAtt = "";
    }
    
    if (!userAtt.isEmpty() && (!tokenAtt.isEmpty() && !systemAtt.isEmpty())) {
      // external authentication
      String storedToken = AppBean.getExtAuthData(systemAtt, userAtt);
      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(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      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(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      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()) {  // if user was found
        user = (User) uList.get(0);
      }
      if (user != null) {
        return user;
      }
    }  // external authentication
    
    if (userAtt.isEmpty() || passAtt.isEmpty()) {  // if login (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(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    } else {  // if credentials 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(MessageProcessor.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()) {  // if user 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()) {  // if user 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()) {  // if user 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()) {  // if user 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(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // if credentials are set
    return user;
  }  // processLogin()

  /**
   * Process types message (added, changed and removed types of annotations)
   * If error occurs, generates error message.
   * Informations are stored into requestInfo.
   *
   * @param typesEl Element with types message
   * @param requestInfo Informations about client request
   */
  private static void processTypes(Element typesEl, RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    // get element with added types of annotations
    NodeList addTN = typesEl.getElementsByTagName("add");
    Element addEl = (Element) addTN.item(0);
    if (addEl != null) {  // if there are added types
      // get elements with types
      NodeList addTypeNodes = addEl.getElementsByTagName("type");
      int addedTypesCnt = addTypeNodes.getLength();
      for (int i = 0; i < addedTypesCnt; i++) {  // for each added type
        Element addedTypeEl = (Element) addTypeNodes.item(i);
        // process element with informations about type of annotation
        AnnotType addedType = processTypeEl(addedTypeEl, requestInfo, false);
        if (addedType != null) {  // if element was successfully processed
          // query database for type with same URI
          Object[] params = new Object[2];
          params[0] = "uri";
          params[1] = addedType.getUri();
          List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
          if (tList != null && !tList.isEmpty()) {  // if type was found - error
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = addedType.toXMLStringWA(false);
            requestInfo.addError(lod, langNum, Localisation.ERROR_49_DUPLICIT_TYPE, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Attempt to create of duplicit type of annotation.";
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          } else {  // if type was not found
            // If ancestor not exists, but should and name is probably
            // composed of path in type tree, breakdown path, set name properly
            // and generate ancestors. New names are generated from URI.
            breakdownType(addedType, requestInfo);
            flier.AddAddedType(addedType);  // add new type to flier
          }
        }  // if element was successfully processed
      }  // for each added type
    }  // if there are added types

    // get element with changed types of annotations
    NodeList updateTN = typesEl.getElementsByTagName("change");
    if (updateTN.getLength() == 0) {  // if it's not presented, try older version
      updateTN = typesEl.getElementsByTagName("update");
    }
    Element updateEl = (Element) updateTN.item(0);
    if (updateEl != null) {  // if there are changed types
      NodeList updateTypeNodes = updateEl.getElementsByTagName("type");
      int updatedTypesCnt = updateTypeNodes.getLength();
      for (int i = 0; i < updatedTypesCnt; i++) {  // for each changed type
        Element updatedTypeEl = (Element) updateTypeNodes.item(i);
        // process element with informations about type of annotation
        AnnotType updatedType = processTypeEl(updatedTypeEl, requestInfo, true);
        if (updatedType != null) {  // if element was successfully processed
          flier.AddEditedType(updatedType);  // add changed type to flier
        }
      }  // for each changed type
    }  // if there are changed types

    // get element with removed types of annotations
    NodeList deleteTN = typesEl.getElementsByTagName("remove");
    if (deleteTN.getLength() == 0) {  // if it's not presented, try older version
      deleteTN = typesEl.getElementsByTagName("delete");
    }
    Element deleteEl = (Element) deleteTN.item(0);
    if (deleteEl != null) {  // if there are removed types
      NodeList delTypeNodes = deleteEl.getElementsByTagName("type");
      int delTypesCnt = delTypeNodes.getLength();
      for (int i = 0; i < delTypesCnt; i++) {  // for each removed type
        Element delTypeEl = (Element) delTypeNodes.item(i);
        String delName = delTypeEl.getAttribute("name");
        String delAncestor = delTypeEl.getAttribute("ancestor");
        String delUri = delTypeEl.getAttribute("uri");
        if (delName == null) {  // not set is a same as empty
          delName = "";
        }
        if (delUri == null) {
          delUri = "";
        }
        if (delName.isEmpty() || delUri.isEmpty()) {  // if name or URI is empty
          String info = "";
          // create appropriate error message
          if (!delName.isEmpty()) {
            info = "<type name=\"" + delName + "\"/>";
          } else if (!delUri.isEmpty()) {
            info = "<type uri=\"" + delUri + "\"/>";
          }
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Attempt to remove type of annotation without name or URI: " + info;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        } else {  // if all required informations are available
          // query database for type of annotation
          Object[] params = new Object[2];
          params[0] = "uri";
          params[1] = delUri;
          List dList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
          if (dList != null && !dList.isEmpty()) {  // if type was found
            // query database for annotations of this type
            AnnotType dType = (AnnotType) dList.get(0);
            params[0] = "type";
            params[1] = dType.getId();
            List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
            if (aList != null && !aList.isEmpty()) {  // if annotations was found
              // error - forbidden operation
              int langNum = requestInfo.getSession().getLanguageNum();
              int lod = requestInfo.getSession().getProtocolLOD();
              String info = "<type name=\"" + delName + "\" ancestor=\"" + delAncestor + "\" uri=\"" + delUri + "\"/>";
              requestInfo.addError(lod, langNum, Localisation.ERROR_47_USED_TYPE_DEL, info);
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                String msg = "Attempt to delete used type of annotation: " + delUri;
                Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
              }
            } else {  // if annotations of this type was not found
              // query database for subtypes of this type of annotation
              params[0] = "ancestor";
              params[1] = dType.getId();
              List aTList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
              if (aTList != null && !aTList.isEmpty()) {  // if subtypes was found
                // error - forbidden operation
                int langNum = requestInfo.getSession().getLanguageNum();
                int lod = requestInfo.getSession().getProtocolLOD();
                String info = "<type name=\"" + delName + "\" ancestor=\"" + delAncestor + "\" uri=\"" + delUri + "\"/>";
                requestInfo.addError(lod, langNum, Localisation.ERROR_51_TYPE_W_SUBTYPE_DEL, info);
                if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                  String msg = "Attempt to delete type of annotation with subtypes: " + delUri;
                  Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
                }
              } else {  // if subtypes was not found
                flier.AddRemovedType(dType);  // add type to list of removed types in flier
              }
            }  // if annotations of this type was not found
          } else {   // if type was not found - error
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<type name=\"" + delName + "\" ancestor=\"" + delAncestor + "\" uri=\"" + delUri + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Attempt to delete unknown type of annotation: " + delUri;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
        }  // if all required informations are available
      }  // for each removed type
    }  // if there are removed types
  }  // processTypes()

  /**
   * If ancestor of type of annotation is not exists, but should and name
   * is probably composed of path in type tree, this method breakdowns path,
   * sets name properly and generate ancestors.
   * New names are generated from URI.
   * Ancestors are stored into informations about client request.
   *
   * @param type Type of annotation to check and breakdown
   * @param requestInfo Informations about client request
   */
  public static void breakdownType(AnnotType type, RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    // get user group to which this type belongs
    UserGroup group = type.getGroup();
    // get string with name of type and names of his ancestors
    String namesStr = type.getUri().replace(AppBean.getBaseTypeUri(), "");
    // get array with name of type and names of his ancestors
    String[] namesArr = namesStr.split("/");
    ArrayList<String> names = new ArrayList<String>(Arrays.asList(namesArr));
    int nSize = names.size();  // compute number of names
    if (nSize > 2) {  // if there is more then name of type and id of group
      // get name of type and remove it from list
      String typeName = names.remove(nSize - 1);
      nSize--;
      type.setName(typeName);  // set proper name to type
      AnnotType nextType = type;  // set actually checked type to checked type
      while (nSize > 1) {  // create ancestor types (last name is group name)
        // get name of actual (next to now generated) type
        String nextName = nextType.getName();
        // get name of ancestor (previous in hierarchy)
        String prevName = names.remove(nSize - 1);
        nSize--;
        // get URI of actual type
        String nUri = nextType.getUri();
        // get URI of ancestor type
        // prevUri = uri of next without "/" and name of next
        String prevUri = nUri.substring(0, nUri.lastIndexOf("/"));
        // flag represents a successful search for a type in the newTypes array
        boolean foundInNewTypes = false;

        // query database for ancestor type
        Object[] params = new Object[2];
        params[0] = "uri";
        params[1] = prevUri;
        List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
        if (tList != null && !tList.isEmpty()) {  // if ancestor was found
          AnnotType prevType = (AnnotType) tList.get(0);
          nextType.setAncestorType(prevType);  // set ancestor properly
          nextType.addAncestorType(prevType);
          break;  // end of checking (all other is in database)
        }
        else if (flier.getAddedTypes() != null && !flier.getAddedTypes().isEmpty()) {
          Iterator<AnnotType> newTypesIt = flier.getAddedTypes().iterator();
          while (newTypesIt.hasNext()) {
            AnnotType newType = newTypesIt.next();
            if (newType.getUri().equals(prevUri)) {
              nextType.setAncestorType(newType);  // set ancestor properly
              nextType.addAncestorType(newType);
              foundInNewTypes = true;
              break;
            }
          }
        }

        // if not found in DB nor newTypes, create ancestor type
        if (!foundInNewTypes) {
          // create ancestor type
          AnnotType newType = new AnnotType(prevUri, prevName, null, group);
          nextType.setAncestorType(newType);  // set ancestor of actual type to new ancestor
          nextType.addAncestorType(newType);
          flier.AddAddedType(newType);  // add new ancestor type to flier
          nextType = newType;  // set ancestor as actually checked type
        }
      }  // create ancestor types (last name is group name)
    }  // if there is more then name of type and id of group
  }  // breakdownType()

  /**
   * Process element with request for entities
   *
   * @param entityReqEl Element with informations about request
   * @param requestInfo Informations about client request
   */
  private static void processEntityRequest(Element entityReqEl, RequestInfo requestInfo){
    
      String type = entityReqEl.getAttribute("type");
      String filter = entityReqEl.getAttribute("filter");
      
      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 filter of parameter of dictionary request.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        
        return;
      }
      requestInfo.setEntityRequest(new RequestInfo.EntityRequest(type,filter));
  }  // processEntityRequest()
  
  /**
   * Process element with informations about type of annotation
   * If error occurs, generates error message.
   *
   * @param typeEl Element with informations about type of annotation
   * @param requestInfo Informations about client request
   * @param update If this is updated type (may be found in database), then true, if it's new type, then false
   * @return If element was successfully processed, returns type of annotation, if error occurred, returns null
   */
  private static AnnotType processTypeEl(Element typeEl, RequestInfo requestInfo, boolean update) {
    AnnotType retType = null;
    String name = typeEl.getAttribute("name");
    String ancestor = typeEl.getAttribute("ancestor");
    String uri = typeEl.getAttribute("uri");
    String group = typeEl.getAttribute("group");
    if (name == null) {  // not set is a same as empty
      name = "";
    }
    if (uri == null) {
      uri = "";
    }
    if (ancestor == null) {
      ancestor = "";
    }
    if (name.isEmpty()) {  // if name is empty - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      if (update) {
        requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Empty name of updated type of annotation.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      } else {
        requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "New type of annotation without name.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
      return null;  // bad type
    }

    PersistM pm = AppBean.getPersistenceManager();
    Object[] params = new Object[2];  // parameters for database queries

    Integer groupId = null;
    if (group != null && !group.isEmpty()) {  // if URI of user group is set
      // get id of group by stripping off base URI
      String groupIdStr = group.replace(AppBean.getBaseGroupUri(), "");
      // parse id of group
      try {
        groupId = Integer.parseInt(groupIdStr);
      } catch (NumberFormatException nfe) {  // if id of group is malformed
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<group id=\"" + group + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_46_UNKNOWN_GROUP_TYPE, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad group in type of annotation: " + groupIdStr;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg, nfe);
        }
        // set group by another method
        groupId = null;
      }
    }  // if URI of user group is set

    if (groupId == null) {  // if URI of user group is not set
      if (uri.contains(AppBean.getBaseTypeUri() + "g")) {  // if id of group is in URI of type
        // get id of group and list of names by stripping off base URI
        String groupIdStr = uri.replace(AppBean.getBaseTypeUri() + "g", "");
        // find beginning of list of names
        int index = groupIdStr.indexOf("/");
        if (index > 0) {  // if beginning of list of names was found (URI is not malformed)
          // get id of group by stripping off list of names
          groupIdStr = groupIdStr.substring(0,index);
          // parse id of group
          try {
            groupId = Integer.parseInt(groupIdStr);
          } catch (NumberFormatException nfe) {  // if id of group is malformed
            // create error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<group id=\"" + group + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_46_UNKNOWN_GROUP_TYPE, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad group in URI of type of annotation: " + groupIdStr;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg, nfe);
            }
            // set group by another method
            groupId = null;
          }
        }  // if beginning of list of names was found
      }  // if id of group is in URI of type
    }  // if URI of user group is not set

    // if id of user group is empty, but URI of ancestor is not empty
    if (groupId == null && ancestor != null && !ancestor.isEmpty()) {
      if (ancestor.contains(AppBean.getBaseTypeUri() + "g")) {  // if URI of ancestor contains id of group
        // get id of group and list of names by stripping off base URI
        String groupIdStr = ancestor.replace(AppBean.getBaseTypeUri() + "g", "");
        // find beginning of list of names
        int index = groupIdStr.indexOf("/");
        if (index > 0) {  // if beginning of list of names was found (URI is not malformed)
          // get id of group by stripping off list of names
          groupIdStr = groupIdStr.substring(0,index);
          // parse id of group
          try {
            groupId = Integer.parseInt(groupIdStr);
          } catch (NumberFormatException nfe) {  // if id of group is malformed
            // create error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<group id=\"" + group + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_46_UNKNOWN_GROUP_TYPE, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad group in ancestor type of annotation: " + groupIdStr;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg, nfe);
            }
            // set group by another method
            groupId = null;
          }
        }  // if beginning of list of names was found
      }  // if URI of ancestor contains id of group
    }  // if id of user group is empty, but URI of ancestor is not empty

    if (groupId == null) {  // if URI of user group is still not set
      if (MessageProcessor.isGroupIncluded(name)) {  // if id of group is in linearized name
        // get id of group and list of names by stripping off "g"
        String groupIdStr = uri.replace("g", "");
        // replace arrows
        groupIdStr = MessageProcessor.replaceArrows(groupIdStr);
        // find beginning of list of names
        int index = groupIdStr.indexOf("/");
        if (index > 0) {  // if beginning of list of names was found
          // get id of group by stripping off list of names
          groupIdStr = groupIdStr.substring(0,index);
          // parse id of group
          try {
            groupId = Integer.parseInt(groupIdStr);
            int index1 = name.indexOf("-> ");
            int index2 = name.indexOf("->");
            if (index1 < index2 && index1 > 0) {  // if first arrow is followed by space
              // strip off group
              name = name.substring(index1 + 3);
            } else if (index2 > 0) {  // if first arrow is not followed by space
              // strip off group
              name = name.substring(name.indexOf("->") + 2);
            } else {  // if it's not id of group
              // set group by another method
              groupId = null;
            }
          } catch (NumberFormatException nfe) {  // if it's not id of group
            // set group by another method
            groupId = null;
          } catch (Exception e) {  // if it's not id of group
            // set group by another method
            groupId = null;
          }
        }  // if beginning of list of names was found
      }  // if id of group is in linearized name
    }  // if URI of user group is still not set
    
    UserGroup uGroup = null;
    if (groupId != null) {  // if id of user group is available
      // query database for user group
      params[0] = "id";
      params[1] = groupId;
      List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
      Settings groupParam = null;
      if (gList != null && !gList.isEmpty()) {  // if group was found
        uGroup = (UserGroup) gList.get(0);
      } else {  // if group was not found
        // set to default group
        uGroup = null;
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<group id=\"" + AppBean.getBaseGroupUri() + groupId + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_46_UNKNOWN_GROUP_TYPE, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown user group in the type of annotation: " + info;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
      }
    }  // if id of user group is available

    if (uGroup == null) {  // if user group is not available, set to default
      uGroup = requestInfo.getSession().getDefaultGroup();
    }

    if (uGroup == null) {  // if user group is still null (all attempts failed)
      // print error message
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + name + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_45_UNKNOWN_GROUP, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "All attempts to getting of user group for type of annotation failed.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // bad type of annotation
    }

    AnnotType ancestorType = null;
    if (!ancestor.isEmpty()) {  // if type have URI of ancestor set
      if (!ancestor.contains(AppBean.getBaseTypeUri() + "g") 
          && ancestor.contains(AppBean.getBaseTypeUri())) {
        ancestor = ancestor.substring(0, AppBean.getBaseTypeUri().length()) 
          + "g" + requestInfo.getSession().getDefaultGroup().getId() + "/" 
          + ancestor.substring(AppBean.getBaseTypeUri().length(),ancestor.length());
      }
      // query database for ancestor
      params[0] = "uri";
      params[1] = ancestor;
      List aList = pm.queryDB("AnnotType.findByUri", params);
      if (aList != null && !aList.isEmpty()) {  // if ancestor was found
        ancestorType = (AnnotType) aList.get(0);
      } else {  // if ancestor was not found
        // it possibly can be new type
        Iterator<AnnotType> atIter = (Iterator<AnnotType>) requestInfo.getFlier().getAddedTypes().iterator();
        while (atIter.hasNext() && ancestorType == null) {  // look over just added types
          AnnotType addedT = atIter.next();
          if (addedT.getUri().equals(ancestor)) {  // if type was found
            ancestorType = addedT;
          }
        }
        if (ancestorType == null) {  // if ancestor is not new type
          // create appropriate error message
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + name + "\" uri=\"" + uri + "\"/>";
          if (update) {
            requestInfo.addError(lod, langNum, Localisation.ERROR_18_BAD_EDITED_TYPE, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad ancestor type in updated type of annotation: " + info;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          } else {
            requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad ancestor type in new type of annotation: " + info;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
          return null;  // bad type
        }  // if ancestor is not new type
      }  // if ancestor was not found
    }  // if type have URI of ancestor set

    if (uri.isEmpty() && update) {  // if URI of type of annotation is empty and it's update of type
      // create error message
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + name + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Attempt to update type of annotation without URI.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // type cannot be updated
    }

    AnnotType qType = null;
    if (update) {  // if it's update of type
      // query database for updated type
      params[0] = "uri";
      params[1] = uri;
      List utList = pm.queryDB("AnnotType.findByUri", params);
      if (utList != null && !utList.isEmpty()) {  // if type was found
        qType = (AnnotType) utList.get(0);
      } else {  // if updated type was not found - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + name + "\" ancestor=\"" + ancestor + "\" uri=\"" + uri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown type of annotation for update: " + info;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // type cannot be updated
      }

      if (!qType.getName().equals(name)) {
        // if name was changed, error - forbidden operation
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + name + "\" uri=\"" + uri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Attempt to change name of the type of annotation: " 
                       + qType.getName() + " - " + name;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // type cannot be updated
      }

      if (qType.getGroup() != null) {
        if (!qType.getGroup().equals(uGroup)) {
          // if group was changed, error - forbidden operation
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + name + "\" uri=\"" + uri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Attempt to change group of the type of annotation.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;  // type cannot be updated
        }
      } else {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "Type of annotation without the user group..";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
        }
      }

      if (qType.getAncestorType() != null) {  // if ancestor of updated type is not null
        if (!ancestor.equals(qType.getAncestorType().getUri())) {
          // if ancestor was changed, error - forbidden operation
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + name + "\"  ancestor=\"" + qType.getAncestorType().getUri() + "\" uri=\"" + uri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Attempt to change ancestor type of annotation.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;  // type cannot be updated
        }
      } else if (!ancestor.isEmpty()) {  // if client is trying to set ancestor which is null
        // error - forbidden operation
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + name + "\"  ancestor=\"\" uri=\"" + uri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Attempt to change ancestor type of annotation.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;  // type cannot be updated
      }
    }  // if it's update of type

    // process comment
    String comment = null;
    NodeList commentNL = typeEl.getElementsByTagName("comment");
    if (commentNL.getLength() != 0) {
      Element commentEl = (Element) commentNL.item(0);
      comment = MessageProcessor.getElementContent(commentEl);
    }
    
    // create object with informations about type
    // it's necessary in case of update too (can't directly modify original type)
    retType = new AnnotType(uri, name, ancestorType, uGroup);

    retType.setComment(comment);  // set comment

    // if URI is missing, create it from linearized name, ancestor and user group
    if (!update && uri.isEmpty()) {
      uri = retType.getGeneratedURI();
      retType.setUri(uri);
    }
    
    if (!uri.equals(retType.getGeneratedURI())) {  // if URI is bad
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + name + "\" uri=\"" + uri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_56_BAD_ANNOT_TYPE_URI, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "URI of type of annotation is not matching to generated one: "
                     + uri + " != " + retType.getGeneratedURI();
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // type cannot be added or updated
    }

    // create list for attributes
    ArrayList<AnnotTypeAttr> newAttrs = new ArrayList<AnnotTypeAttr>();
    // get elements with attributes
    NodeList attNodes = typeEl.getElementsByTagName("attribute");
    int attNCnt = attNodes.getLength();  // count attributes
    NodeList attNodes2 = typeEl.getElementsByTagName("a:attribute");  // second variant
    int attNCnt2 = attNodes2.getLength();  // count attributes
    if (attNCnt2 > 0 && attNCnt == 0) {  // switch to second variant
      attNCnt = attNCnt2;
      attNodes = attNodes2;
    }
    // create beginning of information about type for errors
    String groupsS = "";
    if (uGroup != null) {
      groupsS = " group=\"" + uGroup.getUri() + "\"";
    }
    String errInfo = "<type name=\"" + name + "\" uri=\"" + uri + "\"" + groupsS + ">";

    int errCnt = 0;  // error counter
    ArrayList<String> namesArr = new ArrayList<String>();  // used names
    ArrayList<String> namesTypesArr = new ArrayList<String>();  // used names and types
    // process attributes of type of annotation
    for (int i = 0; i < attNCnt; i++) {  // for each attribute element
      Element attrEl = (Element) attNodes.item(i);
      String attrName = attrEl.getAttribute("name");
      String attrType = attrEl.getAttribute("type");
      String priorityStr = attrEl.getAttribute("priority");
      String attrRequiredStr = attrEl.getAttribute("required");
      Boolean attrRequired = Boolean.parseBoolean(attrRequiredStr);

      Integer priority = null;
      if (priorityStr != null) {
        try {
          priority = Integer.parseInt(priorityStr);
        } catch (NumberFormatException ex) {
          priority = null;
        }
      }
      if (priority == null) {
        priority = i;
      }
      
      // process comment
      String attrComment = null;
      NodeList attrCommentNL = attrEl.getElementsByTagName("comment");
      if (attrCommentNL.getLength() != 0) {
        Element attrCommentEl = (Element) attrCommentNL.item(0);
        attrComment = MessageProcessor.getElementContent(attrCommentEl);
      }
      attrCommentNL = attrEl.getElementsByTagName("a:comment");
      if (attrComment == null && attrCommentNL.getLength() != 0) {
        Element attrCommentEl = (Element) attrCommentNL.item(0);
        attrComment = MessageProcessor.getElementContent(attrCommentEl);
      }

      if (Constants.SIMPLE_TYPES.contains(attrType)) {  // if it's simple type
        // create object with attribute of type of annotation
        AnnotTypeAttr newAttr = new AnnotTypeAttr(retType, attrName, attrType, attrRequired);
        newAttr.setPriority(priority);
        newAttr.setComment(attrComment);  // set comment
        if (namesArr.contains(attrName)) {  // duplicit attribute
          int index = namesArr.indexOf(attrName);
          if (namesTypesArr.get(index).equals(attrName + attrType)) {
            continue;  // skip duplicity
          }
          errInfo = errInfo.concat("<attribute name=\"" + attrName + "\" type=\""
                  + attrType + "\"/>");
          errCnt++;  // increase error count and skip attribute
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Duplicit attribute of the type of annotation.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        } else {
          newAttrs.add(newAttr);  // add attribute to the list of attributes
          namesArr.add(attrName);  // add name to the list of names
          namesTypesArr.add(attrName + attrType);
        }
      } else {  // if it's structured type
        // query database for type of attribute (type of annotation)
        params[0] = "uri";
        params[1] = attrType;
        List tList = pm.queryDB("AnnotType.findByUri", params);
        if (tList != null && !tList.isEmpty()) {  // if type was found
          AnnotType attrStructType = (AnnotType) tList.get(0);
          // create object with attribute of type of annotation
          AnnotTypeAttr newAttr = new AnnotTypeAttr(retType, attrName, attrStructType, attrRequired);
          newAttr.setPriority(priority);
          newAttr.setComment(attrComment);  // set comment
          if (namesArr.contains(attrName)) {  // duplicit attribute
            int index = namesArr.indexOf(attrName);
            if (namesTypesArr.get(index).equals(attrName + attrType)) {
              continue;  // skip duplicity
            }
            errInfo = errInfo.concat("<attribute name=\"" + attrName + "\" type=\""
                    + attrType + "\"/>");
            errCnt++;  // increase error count and skip attribute
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Duplicit attribute of the type of annotation.";
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
          } else {
            newAttrs.add(newAttr);  // add attribute to the list of attributes
            namesArr.add(attrName);  // add name to the list of names
            namesTypesArr.add(attrName + attrType);
          }
        } else {  // if type was not found - error
          errInfo = errInfo.concat("<attribute name=\"" + attrName + "\" type=\""
                  + attrType + "\"/>");
          errCnt++;  // increase error count and skip attribute
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Unknown structured type of attribute of the type of annotation: " + attrType;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }
      }  // if it's structured type
    }  // for each attribute element

    int ancErrCnt = 0;  // error counter
    // create list for ancestors
    ArrayList<AnnotType> newAncestors = new ArrayList<AnnotType>();
    // get elements with ancestors
    NodeList ancNodes = typeEl.getElementsByTagName("ancestor");
    int ancNCnt = ancNodes.getLength();  // count ancestors
    // process ancestors of type of annotation
    for (int i = 0; i < ancNCnt; i++) {  // for each ancestor element
      Element ancEl = (Element) ancNodes.item(i);
      String ancTypeUri = ancEl.getAttribute("uri");
      AnnotType ancType = null;

      // query database for type of ancestor (type of annotation)
      params[0] = "uri";
      params[1] = ancTypeUri;
      List tList = pm.queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {  // if type was found
        ancType = (AnnotType) tList.get(0);
        newAncestors.add(ancType);  // add ancestor to the list of ancestors
      } else {  // if type was not found
        // it possibly can be new type
        Iterator<AnnotType> ancIter = (Iterator<AnnotType>) requestInfo.getFlier().getAddedTypes().iterator();
        while (ancIter.hasNext() && ancestorType == null) {  // look over just added types
          AnnotType addedT = ancIter.next();
          if (addedT.getUri().equals(ancTypeUri)) {  // if type was found
            ancType = addedT;
          }
        }
        if (ancType == null) {  // if ancestor is not new type
          errInfo = errInfo.concat("<ancestor uri=\"" + ancTypeUri + "\"/>");
          ancErrCnt++;  // increase error count and skip ancestor
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Unknown ancestor in the list of ancestors of the type of annotation: " 
                         + ancTypeUri;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        } else {  // if ancestor is new type
          newAncestors.add(ancType);  // add ancestor to the list of ancestors
        }
      }  // if type was not found
    }  // for each ancestor element

    // add primary ancestor
    if (!newAncestors.contains(ancestorType) && ancestorType != null) {
      newAncestors.add(ancestorType);
    }
    // if primary ancestor is not set, set it
    if (!newAncestors.isEmpty() && ancestorType == null) {
      ancestorType = newAncestors.get(0);
      retType.setAncestorType(ancestorType);
    }

    if (update) {  // if it's update of type of annotation
      if (errCnt > 0 || ancErrCnt > 0) {  // if errors occurred and some attributes or ancestors was discarded
        errInfo = errInfo.concat("</type>");  // completes informations about type
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_18_BAD_EDITED_TYPE, errInfo);
        return null;  // type of annotation can't be updated
      } else {  // if errors does not occurred
                // (modified attributes are saved only if error count is 0)
        retType.setAttributes(newAttrs);  // save new attributes to object with type
        retType.setAncestorTypes(newAncestors);  // save new ancestors to object with type
        retType.setId(qType.getId());  // set id of type to id of updated (replaced) type
      }
    } else {  // if it's new type of annotation
      if (errCnt > 0 || ancErrCnt > 0) {  // if errors occurred
        errInfo = errInfo.concat("</type>");  // completes informations about type
      } 
      if (errCnt > 0) {  // if errors occurred and some attributes was discarded
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_17_TYPE_ATTRIBUTES_MALFORMED, errInfo);
      }
      if (ancErrCnt > 0) {  // if errors occurred and some ancestors was discarded
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_55_TYPE_ANCESTORS_MALFORMED, errInfo);
      }
      // Attributes of new type are partially or fully saved to type
      retType.setAttributes(newAttrs);
      // Ancestors of new type are partially or fully saved to type
      retType.setAncestorTypes(newAncestors);
    }

    return retType;
  }  // processTypeEl()
}  // public class P1Processor