CoreFuncModule.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: CoreFuncModule.java
 * Description: This module implements core document, annotations and types
 *              manipulation functionality.
 *
 * This module is under construction. Uncommented functions will be replaced.
 */

/**
 * @file CoreFuncModule.java
 *
 * @brief Document, annotations and types manipulation functionality.
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.TextModification;
import cz.vutbr.fit.knot.annotations.comet.*;
import cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2Constants;
import cz.vutbr.fit.knot.annotations.document.DocumentUpdate;
import cz.vutbr.fit.knot.annotations.document.DocumentUpdate.DocumentUpdateException;
import cz.vutbr.fit.knot.annotations.entity.*;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.LinkedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.Comparator;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.Matcher;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.MatcherProvider;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.XPathHelper;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.compareMethods.ExactMethod;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.compareMethods.LevenshteinMethod;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators.BidirectionallyUnNestNodeIterator;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators.SequenceNodeIterator;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators.XPathNodeIterator;
import cz.vutbr.fit.knot.annotations.textModifications.TextModificationsXMLUnitProvider;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.xml.xpath.XPathExpressionException;
import org.w3c.dom.Document;

/**
 * This module implements core document, annotations and types manipulation
 * functionality.
 *
 * @brief Document, annotations and types manipulation functionality.
 *
 * @author idytrych
 */
public class CoreFuncModule implements AnnotServerModule {

  /**
   * Provider of matchers for finding fragments
   */
  private MatcherProvider matcherProvider;
  /**
   * Provider of matchers for finding fragments (exact matches only)
   */
  private MatcherProvider exactMatcherProvider;
  /**
   * Provider of matchers for finding fragments (nearest matches only)
   */
  private MatcherProvider nearestMatcherProvider;
  /**
   * Provider of matchers for finding fragments (sequence iterator)
   */
  private MatcherProvider sequenceMatcherProvider;
  
  /**
   * Specifies whether is document usage locked
   */
  private static boolean documentUsageLocked = false;

  /**
   * Constructor
   */
  public CoreFuncModule() {
    matcherProvider = new MatcherProvider();
    exactMatcherProvider = new MatcherProvider();
    nearestMatcherProvider = new MatcherProvider();
    sequenceMatcherProvider = new MatcherProvider();
    
    // create default set of matchers
    matcherProvider.add(new Matcher(new XPathNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.STATIC)), 0);
    // Older method disabled - it gives worse results
    // matcherProvider.add(new Matcher(new RecursiveNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.CHARACTER)), 1);
    matcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.CHARACTER_BIDIRECTIONALLY)), 1);
    matcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new LevenshteinMethod(0.56), Comparator.TraversingMethod.WORD, 1.44, 0.56)), 2);
    matcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new LevenshteinMethod(0.83), Comparator.TraversingMethod.FIRST_AND_LAST_WORD_THEN_LETTER, 1.44, 0.56)), 3);
    // Soundex can't handle diacritic
    // matcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new SoundexMethod(), Comparator.TraversingMethod.WORD)), 3);
    matcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new LevenshteinMethod(0.56), Comparator.TraversingMethod.WORD, 1.44, 0.56)), 4);
    matcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new LevenshteinMethod(0.83), Comparator.TraversingMethod.FIRST_AND_LAST_WORD_THEN_LETTER, 1.44, 0.56)), 5);
    
    // create nearest matcher
    nearestMatcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.CHARACTER_BIDIRECTIONALLY)), 0);
    nearestMatcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new LevenshteinMethod(0.56), Comparator.TraversingMethod.WORD, 1.44, 0.56)), 1);
    nearestMatcherProvider.add(new Matcher(new BidirectionallyUnNestNodeIterator(), new Comparator(new LevenshteinMethod(0.83), Comparator.TraversingMethod.FIRST_AND_LAST_WORD_THEN_LETTER, 1.44, 0.56)), 2);
    
    // create sequence mathcer
    sequenceMatcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.CHARACTER_BIDIRECTIONALLY)), 0);
    sequenceMatcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new LevenshteinMethod(0.56), Comparator.TraversingMethod.WORD, 1.44, 0.56)), 1);
    sequenceMatcherProvider.add(new Matcher(new SequenceNodeIterator(), new Comparator(new LevenshteinMethod(0.83), Comparator.TraversingMethod.FIRST_AND_LAST_WORD_THEN_LETTER, 1.44, 0.56)), 2);

    // create exact matcher
    exactMatcherProvider.add(new Matcher(new XPathNodeIterator(), new Comparator(new ExactMethod(), Comparator.TraversingMethod.STATIC)), 0);
  }  // CoreFuncModule()

  /**
   * This method is called when client sent message and these message has been
   * processed. Changes in types, annotations and in other entities are
   * persisted after calling this method from all modules. 
   * It performs: 
   * - checking of synchronized document and synchronization 
   * - applying document modifications 
   * - checking of fragments in added and edited annotations
   *
   * @param requestInfo Informations about client request
   * @return String with messages for client or empty string
   */
  @Override
  public String processRequestBeforePersist(RequestInfo requestInfo) {
    String retStr = "";

    // Synchronize document and generate related text modifications
    if (requestInfo.getSyncDocumentData() != null) {
      synchronizeDocument(requestInfo);
    }

    // Resynchronize document and generate related text modifications
    if (requestInfo.getResyncDocContent() != null) {
      reSynchronizeDocument(requestInfo);
    }

    // Apply document modifications (update document)

    try{
      retStr = retStr + updateDocument(requestInfo);
    }catch(Exception ex){
      // unlock for change
      AppBean.getLockMaster().getDocumentLock(requestInfo.getSession().getSyncDocument().getId()).unlockForChange();
      Logger.getLogger(DrupAuthServlet.class.getName()).log(Level.SEVERE, "Exception during document update:", ex.getMessage());
    }

    // Check, if fragments in added and edited annotations are corresponding.
    // Remove bad fragments from added annotations.
    // Remove bad edited annotations (don't save changes).
    checkAddedAndEdited(requestInfo);
    
    //find and add to edited annotations that will be affected by deleting some annotation
    getAnnotsForUpdate(requestInfo.getFlier().getRemovedAnnotations(),requestInfo.getFlier().getEditedAnnotations());

    // User can also have annotations that he is not subscribed to (target
    // of the annotation link). This annotation must be provided with IDs
    // of annotations that carries the link to it in attribute. IDs have to be stored
    // before persist when all links exist. List of IDs is processed after persist
    // during flier processing (currently String messagesFromFlier(Flier, EditorSession)).
    // If user is not subscribed to the annotation type, the list IDs are insppected
    // and if match is found, annotation is removed from the client application.
    Flier flier = requestInfo.getFlier();
    if (flier != null) {
      if (flier.getRemovedAnnotations() != null && !flier.getRemovedAnnotations().isEmpty()) {
        List<Integer> IDs = new ArrayList<Integer>();
        Iterator<Annotation> removedAnnotIt = flier.getRemovedAnnotations().iterator();
        while (removedAnnotIt.hasNext()) {
          Annotation remAnnot = removedAnnotIt.next();
          IDs.clear();
          findLinkingAnnotationsIds(remAnnot, IDs);
          if (!IDs.isEmpty()) {
            remAnnot.addAllLinkedByBeforeRemove(IDs);
          }
        }
      }
    }
    
    return retStr;
  }  // processRequestBeforePersist()

  /**
   * This method is called when client sent message, these message has been
   * processed and changes in entities are persisted. Composed response is sent
   * to client after calling this method from all modules. 
   * It performs: 
   * - actualization of language in session (set language according to database) 
   * - creating of synchronized message - creating message with queried types 
   * - sending annotations to client after synchronizing or request 
   * - sending just added types to client
   *
   * @param requestInfo Informations about client request
   * @param persistFailed True if changes not persisted, false otherwise.
   * @return String with messages for client or empty string
   */
  @Override
  public String processRequestAfterPersist(RequestInfo requestInfo, boolean persistFailed) {
    String retStr = "";

    // Actualize language in session according to database
    if (requestInfo.getSettings() != null && !requestInfo.getSettings().isEmpty()) {
      requestInfo.getSession().actualizeAllCachedSettings();
    }

    // Synchronized message
    if (requestInfo.getSyncDocumentData() != null && requestInfo.getSyncDocument() != null) {
      AnnotDocument doc = requestInfo.getSyncDocument();
      requestInfo.getSession().initDocumentUsageAndTMNumber();
      if (requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
        retStr = retStr + "<synchronized resource=\"" + AppBean.getBaseDocumentUri() + doc.getId()
              + "\"/>";
      } else {
        retStr = retStr + "<synchronized resource=\"" + AppBean.getBaseDocumentUri() + doc.getId()
              + "\" lastModification=\"" + AppBean.getLastDocModification(doc.getId()) + "\"/>";
      }
    }
    
    // update users data in his other sessions
    if (!persistFailed && requestInfo.getSession().getUser() != null
            && (!requestInfo.getJoinedGroups().isEmpty() || requestInfo.getLeavedGroups().isEmpty())) {
      AppBean.refreshUsersInSessions(requestInfo.getSession().getUser());
    }

    if (canBeDocumentModified(requestInfo)) {
      // Check, if fragments in existing annotations are corresponding.
      // Set status of all fragments which is not corresponding to bad.
      // Notify all partially or fully orphaned annotations to user.
      updateAllExisting(requestInfo);
    }
    
    if (requestInfo.getFlier() != null && requestInfo.getFlier().getAutoUpdatedAnnotations() != null
        && !requestInfo.getFlier().getAutoUpdatedAnnotations().isEmpty()) {
      // save updated annotations into DB
      boolean pFailed = Persister.persistAUpdAnnot(requestInfo);
      if (pFailed) {  // if persist failed
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_59_AUTO_UPDATE_FAILED);
        // annotations will be updated later
        requestInfo.getFlier().setAutoUpdatedAnnotations(new ArrayList<Annotation>());
      }
    }
    
    // Create message with queried types
    retStr = retStr + getQueriedTypes(requestInfo);

    // Create message with annotations after synchronization or request
    if (requestInfo.getSyncDocument() != null || requestInfo.getReloadAll()) {
      if (requestInfo.getSession().getSyncDocument() != null) {
        retStr = retStr + getAllInterestingAnnotations(requestInfo);
      }
    }

    // Create message with just added types
    if (!requestInfo.getFlier().getAddedTypes().isEmpty() 
        && requestInfo.getSession().getProtocolLOD() != Constants.PROTOCOL_LOD_V2) {
      boolean withAnc = true;  // types will be send with ancestors
      if (requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V1_1) {
        withAnc = false;  // old client - types will be send without ancestors
      }
      Iterator<AnnotType> tIter = requestInfo.getFlier().getAddedTypes().iterator();
      
      retStr = retStr + "<types><add>";
      while (tIter.hasNext()) {
        AnnotType annotType = tIter.next();
        retStr = retStr + annotType.toXMLString(withAnc);
      }
      retStr = retStr + "</add></types>";
      
    }

    // Create message with attributes from ontology
    if (requestInfo.getQueryTypeAttOnto() != null) {
      retStr = retStr + getAttrOnto(requestInfo);
    }

    if(requestInfo.getSubscriptionQuery() != null){
      retStr = retStr + getQueriedSubscriptions(requestInfo);
    }
    
    // ***** Subscriptions - change *****
    if(requestInfo.getUnsubscribeList() != null && !requestInfo.getUnsubscribeList().isEmpty()){
      // delete
      Iterator<Subscription> chngedSubsIt = requestInfo.getUpdatedSubscriptions().iterator();
      while(chngedSubsIt.hasNext()){
        Subscription actualSubscription = chngedSubsIt.next();
      }
    }
    
    // ***** Subscriptions - delete *****
    if(requestInfo.getUnsubscribeList() != null && !requestInfo.getUnsubscribeList().isEmpty()){
      // delete
      Iterator<Subscription> deletedSubsIt = requestInfo.getUnsubscribeList().iterator();
      while(deletedSubsIt.hasNext()){
        Subscription actualSubscription = deletedSubsIt.next();
        
        if(requestInfo.getSession().isInSubscribeList(actualSubscription)){
          requestInfo.getSession().deleteFromSubscribes(actualSubscription);
          requestInfo.getSession().deleteFromSubscribeList(actualSubscription);
        }
      }
    }
    
    // ***** Subscriptions - new *****
    if(requestInfo.getNewSubscriptions() != null && !requestInfo.getNewSubscriptions().isEmpty()){
      // add
      Iterator <Subscription> subsIt = requestInfo.getNewSubscriptions().iterator();
      while(subsIt.hasNext()){

        Subscription currentSubs = subsIt.next();
        StringBuilder newSubs = new StringBuilder();
        newSubs.append("<subscriptionCreated tmpId=\"");
        newSubs.append(currentSubs.getTmpId().toString());
        newSubs.append("\" uri=\"");
        newSubs.append(AppBean.getBaseSubscriptionUri());
        newSubs.append(currentSubs.getId());
        newSubs.append("\"/>");
        retStr = retStr + newSubs.toString();
      }
    }
    
    // ***** Subscriptions - add *****
    if(requestInfo.getSubscribeList() != null && !requestInfo.getSubscribeList().isEmpty()){
      // add
      Iterator <Subscription> subsIt = requestInfo.getSubscribeList().iterator();
      while(subsIt.hasNext()){
        Subscription currentSubs = subsIt.next();
        if(!requestInfo.getSession().isInSubscribeList(currentSubs)){
          requestInfo.getSession().addToSubscribes(currentSubs);
          requestInfo.getSession().addToSubscribeList(currentSubs);
        }
      }
    }
    
    // get confirmed suggestions
    ArrayList<Annotation> confirmedSugs = new ArrayList<Annotation>();
    if (requestInfo.getConfirmedSuggestions() != null && !requestInfo.getConfirmedSuggestions().isEmpty()) {
      String confStr = "";
      Iterator<SuggestionLogEntry> slIt = requestInfo.getConfirmedSuggestions().iterator();
      while (slIt.hasNext()) {
        SuggestionLogEntry sle = slIt.next();
        Annotation confirmed = sle.getConfirmedVersion();
        confirmedSugs.add(confirmed);
      }
    }
    
    //Make message for just added annotations
    if( requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2 
            && requestInfo.getFlier().getAddedAnnotations() != null
            && !requestInfo.getFlier().getAddedAnnotations().isEmpty()){
      
      String addedStr = "";
      ArrayList<Annotation> addApprovedAnnotations = new ArrayList<Annotation>();
      ArrayList<Annotation> unapprovedAnnotations = new ArrayList<Annotation>();
      Iterator<Annotation> annotIter = requestInfo.getFlier().getAddedAnnotations().iterator();
      EditorSession session = requestInfo.getSession();
      
      while (annotIter.hasNext()) {   // for each added annotation 
        Annotation annot = annotIter.next();
        if (session.isSubscribed(annot, getUserSources(annot.getUser()))) {   // only subscribed annotations
          addApprovedAnnotations.add(annot);   // add approved anotation to approved list
        } else {
          unapprovedAnnotations.add(annot);   // other annotations add to unapproved list
        }
      }

      addApprovedAnnotations = getRelatedAnnotations(addApprovedAnnotations, unapprovedAnnotations, session);

      // Make message for added annotations
      Iterator<Annotation> approvedIter = addApprovedAnnotations.iterator();
      ArrayList<Annotation> printedAn = new ArrayList<Annotation>();

      while (approvedIter.hasNext()) {  // for each approved annotation
        Annotation annot = approvedIter.next();
        if (printedAn.contains(annot)) {
          continue;
        }
        if (confirmedSugs.contains(annot)) {
          continue;
        }
        printedAn.add(annot);
        if(requestInfo.getFlier().isInJustAdded(annot.getURIV2())){
          String tmpUri = requestInfo.getFlier().getTmpUri(annot.getURIV2());
          if(tmpUri != null){
            addedStr = addedStr + "<annotation tempUri=\"" + tmpUri + "\" servUri=\"" + annot.getURIV2() + "\"/>";
          }
          
          ArrayList<String> nestedAnnotURIs = getAllNestedIdentificators(annot);
          Iterator<String> nestedAnnotURIIt = nestedAnnotURIs.iterator();
          while(nestedAnnotURIIt.hasNext()){
            String nestedUri = nestedAnnotURIIt.next();
            String tmpNestedUri = requestInfo.getFlier().getTmpUri(nestedUri);
            
            if(tmpNestedUri != null){
              addedStr = addedStr + "<annotation tempUri=\"" + tmpNestedUri + "\" servUri=\"" + nestedUri + "\"/>";
            }
          }
        }
      }
      
      if(!addedStr.isEmpty()){
         retStr = retStr + "<annotationsCreated>" + addedStr + "</annotationsCreated>";
      }
    }
    
    // Create message for just confirmed suggestions
    if (!confirmedSugs.isEmpty() && requestInfo.getSession().getProtocolLOD() >= Constants.PROTOCOL_LOD_V2) {
      String confStr = "";
      String autoConfStr = "";
      String removeSugsStr = "";
      Iterator<Annotation> csIt = confirmedSugs.iterator();
      ArrayList<String> attFilter = requestInfo.getSession().getAttFilter();
      int lNum = requestInfo.getSession().getLanguageNum();
      Boolean KBRefMode = requestInfo.getSession().getKBRefMode();
      while (csIt.hasNext()) {
        Annotation confirmed = csIt.next();
        if (requestInfo.isAutoconfirmRequested()) {  // all automatically confirmed
          confStr = confStr + confirmed.toXMLStringV2(attFilter, lNum, KBRefMode);
        } else {  // some manually confirmed
          if (requestInfo.getAutoconfirmedSuggestions().contains(new SuggestionLogEntry(confirmed.getTmpId()))) {
            autoConfStr = autoConfStr + confirmed.toXMLStringV2(attFilter, lNum, KBRefMode);
            removeSugsStr = removeSugsStr + "<suggestion uri=\"" + AppBean.getBaseUri() + "/sugg/" + confirmed.getTmpId() + "\"/>";
          } else {
            confStr = confStr + "<suggestion suggUri=\"" + AppBean.getBaseUri() + "/sugg/"
                    + confirmed.getTmpId() + "\" servUri=\"" + confirmed.getURIV2() + "\"/>";
          }
        }
      }
      if (!confStr.isEmpty()) {
        if (requestInfo.isAutoconfirmRequested()) {  // all automatically confirmed
          retStr = retStr + "<addAnnotations>" + confStr + "</addAnnotations>";
        } else {
          retStr = retStr + "<suggestionsConfirmed>" + confStr + "</suggestionsConfirmed>";
          if (!autoConfStr.isEmpty()) {  // add automatically confirmed ones
            String cometStr = "<addAnnotations>" + autoConfStr + "</addAnnotations>"
                            + "<removeSuggestions>" + removeSugsStr + "</removeSuggestions>";
            requestInfo.getSession().addMessageTS(cometStr);
            requestInfo.getSession().notifyComet();
          }
        }
      }
    }

    return retStr;
  }  // processRequestAfterPersist()

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

    // check minimal version of protocol
    boolean proto11 = session.getProtocolLOD() > 1;
    boolean normalTMadded = false;

    // ***** Text modifications *****
    if (flier.getCreatedInSessId() != null
            && flier.getCreatedInSessId() != session.getSessionId() &&
            !flier.getTextModifications().isEmpty()) {
      // if this is not handler of client which generated modifications
      String tModStr = "";
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        normalTMadded = true;
        tModStr = "<modification id=\"" + flier.getTextModificationSetID() + "\">";
      } 
      Iterator<TextModification> modIter = flier.getTextModifications().iterator();
      if (session.getProtocolLOD() <= Constants.PROTOCOL_LOD_V1_1) {
        while (modIter.hasNext()) {  // for each text modification
          TextModification tMod = modIter.next();
          tModStr = tModStr + tMod.toXMLString();  // create message
        }
      }
      else{
        while (modIter.hasNext()) {  // for each text modification
          TextModification tMod = modIter.next();
          tModStr = tModStr + tMod.toXMLStringV2();  // create message
        } 
      }
      retStr = retStr + tModStr;
    }

    // ***** Reverse text modifications *****
    if (flier.getCreatedInSessId() != null
            && flier.getCreatedInSessId() == session.getSessionId()
            && !flier.getReverseTextModifications().isEmpty()) {
      String tModStr = "";
      if(!normalTMadded && session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        tModStr = "<modification id=\"" + flier.getTextModificationSetID() + "\">";
      } 
      Iterator<TextModification> modIter = flier.getReverseTextModifications().iterator();
      if (session.getProtocolLOD() <= Constants.PROTOCOL_LOD_V1_1) {
        while (modIter.hasNext()) {  // for each text modification
          TextModification tMod = modIter.next();
            tModStr = tModStr + tMod.toXMLString();  // create message
        }
      }
      else{
        while (modIter.hasNext()) {  // for each text modification
          TextModification tMod = modIter.next();
            tModStr = tModStr + tMod.toXMLStringV2();  // create message
        }
      }
      retStr = retStr + tModStr;
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        normalTMadded = false;
        retStr = retStr + "</modification>";
      }
    }
    
    if(normalTMadded && session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
      retStr = retStr + "</modification>";
    }
    
    // ***** Types of annotations *****
    boolean withAnc = true;  // types will be send with ancestors
    if (session.getProtocolLOD() < Constants.PROTOCOL_LOD_V1_1) {
      withAnc = false;  // old client - types will be send without ancestors
    }
    // if a user hasn't queried for any type yet, the update message is useless for him
    if (session.getQueriedTypes() == null || session.getQueriedTypes().isEmpty()) {
      String addedTStr = "";
      Iterator<AnnotType> typeIter = flier.getAddedTypes().iterator();
      while (typeIter.hasNext()) {  // for each added type of annotation
        AnnotType type = typeIter.next();
        // send type only if client is interested = has type or subtree with new type in his cache
        if (isTypeInGroups(type, session) && typeInClientCache(type, session.getQueriedTypes())) {
          if (session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
            if (session.getSessionId() != flier.getCreatedInSessId()){
              addedTStr = addedTStr + type.toXMLStringV2(withAnc);
            }
          } else {
            addedTStr = addedTStr + type.toXMLString(withAnc);
          }
        }
      }

      if (!addedTStr.isEmpty()) {  // if there are any added types to send
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          addedTStr = "<addTypes>" + addedTStr + "</addTypes>";
        }else{
          addedTStr = "<add>" + addedTStr + "</add>";  // surround with add element
        }
      }

      String updatedTStr = "";
      typeIter = flier.getEditedTypes().iterator();
      while (typeIter.hasNext()) {  // for each edited type of annotation
        AnnotType type = typeIter.next();
        // send type only if client is interested = has type or subtree with edited type in his cache
        if (isTypeInGroups(type, session) && typeInClientCache(type, session.getQueriedTypes())) {
          if (session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
            if (session.getSessionId() != flier.getCreatedInSessId()){
              updatedTStr = updatedTStr + type.toXMLStringV2(withAnc);
            }
          } else {
            updatedTStr = updatedTStr + type.toXMLString(withAnc);
          }
        }
      }

      if (!updatedTStr.isEmpty()) {  // if there are any changed types to send
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          updatedTStr = "<modifyTypes>" + updatedTStr + "</modifyTypes>";  // surround with change element
        }else{
          updatedTStr = "<change>" + updatedTStr + "</change>";  // surround with change element
        }
      }

      String deletedTStr = "";
      typeIter = flier.getRemovedTypes().iterator();
      while (typeIter.hasNext()) {  // for each deleted type of annotation
        if(session.getSessionId() != flier.getCreatedInSessId()){
          AnnotType type = typeIter.next();
          // Send type only if the client is interested (has type in cache)
          if (isTypeInGroups(type, session) && typeInClientCache(type, session.getQueriedTypes())) {
            deletedTStr = deletedTStr + type.toXMLStringWA(withAnc);
          }
        }
      }
      if (!deletedTStr.isEmpty()) {  // if there are any removed types to send
        
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          deletedTStr = "<removeTypes>" + deletedTStr + "</removeTypes>";
        }else{
          deletedTStr = "<remove>" + deletedTStr + "</remove>";  // surround with remove element
        }
      }

      String typesStr = addedTStr + updatedTStr + deletedTStr;  // compose add, change and remove
      if (!typesStr.isEmpty()) {  // if there are any element with type to send
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          retStr = typesStr;
        }else{
          retStr = "<types>" + typesStr + "</types>";  // create message
        }
      }
    }

    // ***** Annotations *****  
    // ** Make messages for added annotations
    String addedStr = makeAddedAnnotMsg(flier.getAddedAnnotations(),session,flier,proto11);
    
    // ** Make messages for deleted annotations
    String removedStr = makeDeletedAnnotMsg(flier.getRemovedAnnotations(),flier.getRemovedNestedAnnotations(),session,proto11);
    

    // ** Make message for edited annotations and auto updated annotations
    ArrayList<Annotation> changedAndAutoUpd = addWithoutDuplicity(flier.getEditedAnnotations(), flier.getAutoUpdatedAnnotations());
    String editedStr = makeChangedAnnotMsg(changedAndAutoUpd,session,proto11);

    //Wrap messages into annotation tag
    String annotStr = addedStr + editedStr + removedStr;  // compose add, change and remove
    if (!annotStr.isEmpty()) {  // if there are any element with annotation to send
      if(session.getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
        retStr = retStr + "<annotations>" + annotStr + "</annotations>";
      }else if((session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2) 
              && session.getSessionId() != flier.getCreatedInSessId()){
        if(addedStr != null && !addedStr.isEmpty()){
            retStr += addedStr;
        }
        
        if(removedStr != null && !removedStr.isEmpty()){
            retStr += removedStr;
        }
        
        if(editedStr != null && !editedStr.isEmpty()){
            retStr += editedStr;
        }
      }
    }
    
    // ***** Subscriptions *****
    // updated subscriptions
    if(session != null && flier.getCreatedInSessId() != null
       && !flier.getCreatedInSessId().equals(session.getSessionId()) 
       && flier.getChangedSubscriptions() != null 
       && !flier.getChangedSubscriptions().isEmpty()){
      
      StringBuilder chngedSubsMesg = new StringBuilder();
      
      // for all changed subscriptions
      Iterator<Subscription> changedSubsIt = flier.getChangedSubscriptions().iterator();
      while(changedSubsIt.hasNext()){
        Subscription actualSubscription = changedSubsIt.next();
        if(session.isInSubscribeList(actualSubscription)){
          Subscription oldSubscription = session.getSubscriptionFromList(actualSubscription.getId());
          // update informations about subscription
          session.deleteFromSubscribes(oldSubscription);
          session.addToSubscribes(actualSubscription);
          
          // make message for client
          chngedSubsMesg.append(actualSubscription.toXMLStringV2("modifySubscription"));
        }
      }
      
      retStr += chngedSubsMesg.toString();
    }
    
    return retStr;
  }  // messagesFromFlier()
  
  /**
   * Finds all annotations linking this patricular annotation using database query.
   * Result of the search is stored to list "closed" and is later added to the
   * removed annotation. The method is nescessery for removing annotations that
   * user client have but is not subscribed to, e.g. target of the annotation link.
   * 
   * @param remAnnot Initial removed annotation that is possible target of the annotation link
   * @param closed list of unique IDs of all found linking annotations
   */
  private void findLinkingAnnotationsIds(Annotation remAnnot, List<Integer> closed) {
    Object[] params = {"linked", remAnnot.getId()};
    @SuppressWarnings("unchecked")
    List<LinkedAnnotationAttribute> attrList = AppBean.getPersistenceManager().queryDB("Attribute.findByLinked", params);
    LinkedAnnotationAttribute found;
    if (attrList != null) {
      Iterator<LinkedAnnotationAttribute> linkedAttIt = attrList.iterator();
      while (linkedAttIt.hasNext()) {
        found = linkedAttIt.next();
        if (!closed.contains(found.getAnnotation())) {
          closed.add(found.getAnnotation());
          findLinkingAnnotationsIds(found.getRefAnnotation(), closed);
        }
      }
    }
  }
  
  /**
   * Client has a cache containing a history of type tree queries. It can
   * request for the whole types tree or any subtree. Flier contains
   * added and modified types. Method decides if the user will receive type
   * from the flier for cache update. Type is send only when user previously
   * asked for the subtree that the new/modified type is a part of.
   * 
   * @param type New modified or added type obtained from a flier
   * @param queries History of type query request strings, may contain wildcard char
   * @return True if the user has the modified type or subtree containing new type in cache, false otherwise
   */
  private boolean typeInClientCache(AnnotType type, ArrayList<String> queries) {
    // if user asked for the whole type tree, there is no need to test subtrees
    // (older version of the client sends a "**" string)
    if (queries.contains("*") || queries.contains("**")) {
      return true;
    }
    
    // an annotation type can be identified by an URI or a linearized name
    // (type->subtype->subtype)
    // an asterisk in a queried type string represents a wildcard
    String typeName = type.getLinearizedName();
    String typeUri = type.getUri();
    
    Iterator queriedTypesIt = queries.iterator();
    String queriedType;
    while (queriedTypesIt.hasNext()) {
      queriedType = (String)queriedTypesIt.next();
      if (queriedType.startsWith("http://") || queriedType.startsWith("https://")) {
        // use new types URI for matching
        if (containsMoreThanTwoAsterisks(typeUri, queriedType)) {
          // more than one wildcard character
          if (typeUri.matches(queriedType.replace("*", ".*"))) {
            return true;
          }
        } else if (queriedType.endsWith("*")) {
          // one wildcard character at the end of the query string only,
          // can be removed
          if (typeUri.startsWith(queriedType.replace("*", ""))) {
            return true;
          }
        } else {
          // one wildcard character somewhere in the uri or none
           if (typeUri.matches(queriedType.replace("*", ".*"))) {
            return true;
          }
        }

      } else {
        // simply use regex on the linearized type name
        if (typeName.matches(queriedType.replace("*", ".*"))) {
          return true;
        }
      }
    }
    
    // no match found, the type or the type's supertree wasn't requested
    // by the user yet
    return false;
  }
  
  /**
   * 
   * Checks whether wildcard contains more than one asterisk
   * 
   * @param pattern Pattern string
   * @param wildcard Wildcard string
   * @return True if wildcard contains more than one asterisk, false otherwise
   */
  private boolean containsMoreThanTwoAsterisks(String pattern, String wildcard) {
    return pattern.length() - wildcard.replace("*", "").length() >= 2;
  }

  /**
   * Method takes all added annotations and detects whether client require these 
   * annotations. Then method make message from required annotations.
   * 
   * @param addedAnnotations array of added annotations
   * @param session informations about client session
   * @param flier Flier, which has been sent to all comet handlers.
   * @param proto11 minimal protocol version
   * @return message for client
   */
  private String makeAddedAnnotMsg(ArrayList<Annotation> addedAnnotations,EditorSession session, Flier flier, boolean proto11){
    String addedStr = "";
    ArrayList<Annotation> addApprovedAnnotations = new ArrayList<Annotation>();
    ArrayList<Annotation> unapprovedAnnotations = new ArrayList<Annotation>();
    Iterator<Annotation> annotIter = addedAnnotations.iterator();
    
    while (annotIter.hasNext()) {   // for each added annotation 
      Annotation annot = annotIter.next();
      if (session.isSubscribed(annot, getUserSources(annot.getUser()))) {   // only subscribed annotations
        addApprovedAnnotations.add(annot);   // add approved anotation to approved list
      } else {
        unapprovedAnnotations.add(annot);   // other annotations add to unapproved list
      }
    }

    addApprovedAnnotations = getRelatedAnnotations(addApprovedAnnotations, unapprovedAnnotations, session);
    
    //Make message for added annotations
    Iterator<Annotation> approvedIter = addApprovedAnnotations.iterator();
    ArrayList<Annotation> printedAn = new ArrayList<Annotation>();
    ArrayList<String> attFilter = session.getAttFilter();
    int lNum = session.getLanguageNum();
    Boolean KBRefMode = session.getKBRefMode();

    while (approvedIter.hasNext()) {  // for each approved annotation
      Annotation annot = approvedIter.next();
      if (printedAn.contains(annot)) {
        continue;
      }
      printedAn.add(annot);
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        if(flier.isInJustAdded(annot.getURIV2())){
          addedStr = addedStr + annot.toXMLStringV2(attFilter, lNum, KBRefMode);
        }
      }else{
        addedStr = addedStr + annot.toXMLString(proto11);
      }
    }
    if (!addedStr.isEmpty()) {  // if there are any added annotations to send
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        addedStr = "<addAnnotations>" + addedStr + "</addAnnotations>";  // surround with add element
      }else{
        addedStr = "<add>" + addedStr + "</add>"; 
      }
    }

    return addedStr;
  }
  
  /**
   * Method takes all deleted annotations and detects whether client require these 
   * annotations. Then method make message from required annotations.
   * 
   * @param deletedAnnotations array of deleted annotations
   * @param deletedNestedAnnotations array of deleted nested annotations
   * @param session informations about client session
   * @param proto11 minimal protocol version
   * @return message for client
   */
  private String makeDeletedAnnotMsg(ArrayList<Annotation> deletedAnnotations, ArrayList<Annotation> deletedNestedAnnotations, EditorSession session,  boolean proto11){
    String removedStr = "";
    Iterator<Annotation> deletedIter = deletedAnnotations.iterator();
    
    while (deletedIter.hasNext()) {  // for each removed annotation
      Annotation annot = deletedIter.next();
      addNestedToRemoved(annot, deletedNestedAnnotations);
      if (session.isSubscribed(annot, getUserSources(annot.getUser())) || isSubscribedToLinkingAnnot(session, annot, deletedAnnotations)) {  // if annotation come under client subscriptions
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          removedStr = removedStr + "<annotation uri=\"" + annot.getURIV2() + "\"/>";
        }else{
          removedStr = removedStr + annot.toXMLString(proto11);
        }
      }
    }
    
    deletedIter = deletedNestedAnnotations.iterator();
    while (deletedIter.hasNext()) {  // for each removed nested annotation
      Annotation annot = deletedIter.next();
      if (session.isSubscribed(annot, getUserSources(annot.getUser())) || isSubscribedToLinkingAnnot(session, annot, deletedNestedAnnotations)) {  // if annotation come under client subscriptions
        if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          removedStr = removedStr + "<annotation uri=\"" + annot.getURIV2() + "\"/>";
        }else{
          removedStr = removedStr + annot.toXMLString(proto11);
        }
      }
    }
    
    //Make message for deleted annotations
    if (!removedStr.isEmpty()) {  // if there are any removed annotations to send
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        removedStr = "<removeAnnotations>" + removedStr + "</removeAnnotations>";
      }else{
        removedStr = "<remove>" + removedStr + "</remove>";  // surround with remove element
      }
    }
    
    return removedStr;
  }
  
  /**
   * Checks if removed annotation is linked by annotation that user client is
   * subscribed to. The client can display annotations that the user is not
   * subscribed to in case that the annotation is a target of the annotation link.
   * 
   * @param session User session
   * @param remAnnot Removed annotation which is inspected for linking annotations and their subscribtion status
   * @param deletedAnnotations List of all removed annotations obtained from a flier
   * @return True if the user is subscribed to any of the removed annotations linking annotation
   */
  private boolean isSubscribedToLinkingAnnot(EditorSession session, Annotation remAnnot, ArrayList<Annotation> deletedAnnotations) {
    if (remAnnot.getLinkedByBeforeRemove() == null || remAnnot.getLinkedByBeforeRemove().isEmpty()) {
      return false;
    }
    Iterator<Integer> linkingAnnotIdIt = remAnnot.getLinkedByBeforeRemove().iterator();
    while (linkingAnnotIdIt.hasNext()) {
      Integer id = linkingAnnotIdIt.next();
      Object[] params = {"id", id};
      @SuppressWarnings("unchecked")
      List<Annotation> annotList = AppBean.getPersistenceManager().queryDB("Annotation.findById", params);
      // annotation was found in the database
      if (annotList != null && !annotList.isEmpty()) {
        Annotation linkingAnnot = annotList.get(0);
        if (session.isSubscribed(linkingAnnot, getUserSources(linkingAnnot.getUser()))) {
          return true;
        }
      // annotation wasn't found in the database, try to look it up in the list
      // of recently deleted annotations
      } else {
        if (deletedAnnotations != null && !deletedAnnotations.isEmpty()) {
          Iterator<Annotation> deletedAnnotIt = deletedAnnotations.iterator();
          while (deletedAnnotIt.hasNext()) {
            Annotation delAnnot = deletedAnnotIt.next();
            if (delAnnot.getId() == id) {
              if (session.isSubscribed(delAnnot, getUserSources(delAnnot.getUser()))) {
                return true;
              }
            }
          }
        }
      }
    }
    return false;
  }

  /**
   * Method takes all changed annotations and detects whether client require these 
   * annotations. Then method make message from required annotations.
   * 
   * @param changedAnnotations array of changed annotations
   * @param session informations about client session
   * @param proto11 minimal protocol version
   * @return message for client
   */
  private String makeChangedAnnotMsg(ArrayList<Annotation> changedAnnotations,EditorSession session, boolean proto11){
    String cahngedStr = "";
    ArrayList<Annotation> chngApprovedAnnotations = new ArrayList<Annotation>();
    ArrayList<Annotation> unapprovedAnnotations = new ArrayList<Annotation>();
    Iterator<Annotation> annotIter = changedAnnotations.iterator();
    
    while (annotIter.hasNext()) {   // for each added annotation 
      Annotation annot = annotIter.next();
      if (session.isSubscribed(annot, getUserSources(annot.getUser()))) {   // only subscribed annotations
        chngApprovedAnnotations.add(annot);   // add approved anotation to approved list
      } else {
        unapprovedAnnotations.add(annot);   // other annotations add to unapproved list
      }
    }

    chngApprovedAnnotations = getRelatedAnnotations(chngApprovedAnnotations, unapprovedAnnotations, session);
    chngApprovedAnnotations = getLinkedAnnotations(chngApprovedAnnotations);
    
    ArrayList<String> attFilter = session.getAttFilter();
    int lNum = session.getLanguageNum();
    Boolean KBRefMode = session.getKBRefMode();
    
    //Make message for changed annotations
    annotIter = chngApprovedAnnotations.iterator();

    while (annotIter.hasNext()) {  // for each approved annotation
      Annotation annot = annotIter.next();
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        cahngedStr = cahngedStr + annot.toXMLStringV2(attFilter, lNum, KBRefMode);
      }else{
        cahngedStr = cahngedStr + annot.toXMLString(proto11);
      }
    }
    if (!cahngedStr.isEmpty()) {  // if there are any changed annotations to send
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        cahngedStr = "<modifyAnnotations>" + cahngedStr + "</modifyAnnotations>"; 
      }else{
        cahngedStr = "<change>" + cahngedStr + "</change>";  // surround with change element
      }
      
    }
    
    return cahngedStr;
  }
  
  /**
   * Method merges the two arrays of annotations into a array list without duplicates. 
   * 
   * @param listOfOld first array of annotations
   * @param listOfNew second array of annotations
   * @return array of merged input arrays
   */
  private ArrayList<Annotation> addWithoutDuplicity(ArrayList<Annotation> listOfOld,ArrayList<Annotation> listOfNew){
    if(listOfNew != null && !listOfNew.isEmpty()){
      //if is annotations array list empty
      if(listOfOld.isEmpty()){ 
        //simply add all annotations
        listOfOld.addAll(listOfNew);
      }else{
        //if annotations array list have some annotations
        Iterator<Annotation> listOfNewIter = listOfNew.iterator();

        //check if old annotations list don't contains same annotation that is in new annotations array list
        while(listOfNewIter.hasNext()){
          Annotation actualAnnotation = listOfNewIter.next();
          if(!listOfOld.contains(actualAnnotation)){
            //add only different annotations
            listOfOld.add(actualAnnotation);
          }
        }
      }
    }
    
    return listOfOld;
  }
  
  /**
   * Adds nested annotations of the given annotation to list of removed nested
   * annotations
   * 
   * @param annot current annotation thats nested annotation will be added to list
   * @param removedNested list of removed nested annotations
   */
  private void addNestedToRemoved(Annotation annot, List<Annotation> removedNested) {
    for (Iterator<BaseAttribute> aIt = annot.getAttributes().iterator(); aIt.hasNext();) {
      BaseAttribute attr = aIt.next();
      if (attr.getNestedAnnotation() != null) {
        addNestedToRemoved(attr.getNestedAnnotation(), removedNested);
        removedNested.add(attr.getNestedAnnotation());
      }
    }
  }  // addNestedToRemoved()

  /**
   * Returns serialized attributes of unknown types of annotation from ontology
   *
   * @param requestInfo Informations about client request
   * @return Returns serialized attributes from ontology
   */
  private String getAttrOnto(RequestInfo requestInfo) {
    String retStr = "";

    // query database for attributes
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = requestInfo.getQueryTypeAttOnto();
    List aList = null;
    if (requestInfo.getQueryTypeAttOnto().equals("*")) {
      aList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findAll");
    } else {
      aList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findByUserGroup", params);
    }
    if (aList != null && !aList.isEmpty()) {  // if some types was found
      Iterator aListIt = aList.iterator();
      // If protocol v1.x is used
      if(requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
        while (aListIt.hasNext()) {
                TypeAttrOnto attr = (TypeAttrOnto) aListIt.next();
                retStr = retStr + attr.toXMLString();
        }
      }
      //Protocol v2.x is used 
      else{
        while (aListIt.hasNext()) { 
                TypeAttrOnto attr = (TypeAttrOnto) aListIt.next();
                retStr = retStr + attr.toXMLStringV2();
        }
      }
    }
    // Surrounding if some attributes were serialized is used only in protocol v1.x
    // In protocol v2.x, surrounding is always used, even if string after serial. is empty
    if(requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
      if (!retStr.isEmpty()) {  // if some attributes serialized, surround it
              retStr = "<attrsFromOntology>" + retStr + "</attrsFromOntology>";         
      }
    }
    else{
        retStr = "<ontologyAttributes>" + retStr + "</ontologyAttributes>";
    }

    return retStr;
  }  // getAttrOnto()

  /**
   * Checks whether type come under user groups of logged in user
   *
   * @param annotType Checked type of annotation
   * @param session Client session
   * @return If type come under user groups of logged in user, returns true,
   * false otherwise
   */
  private boolean isTypeInGroups(AnnotType annotType, EditorSession session) {
    if (session.getUser() == null) {  // if user is not logged in, there is no groups
      return false;
    }
    if (annotType.getGroup() == null) { // if type of annotation isn't assigned to user group
      return false;  // it can't come under user groups
    }
    Iterator<UserGroup> grIter = session.getUser().getGroups().iterator();
    while (grIter.hasNext()) {  // for each user group of logged in user
      UserGroup userGroup = grIter.next();
      if (annotType.getGroup().equals(userGroup)) {  // if group of type is matching this group
        return true;
      }
    }
    return false;
  }  // isTypeInGroups()


  /**
   * Creates message with types of subscriptions requested (queried) by client
   *
   * @param requestInfo Informations about client request
   * @return Returns subscriptions message with requested types in subscriptions element. 
   * If there wasn't found any match, element subscriptions will be empty.
   * If user is not logged in, method returns empty string
   */
  private String getQueriedSubscriptions(RequestInfo requestInfo){
    String retQStr = "";
    
    // There is no request for list of subscriptions
    if(requestInfo.getSubscriptionQuery().isEmpty()){
      return retQStr;
    }

    // If user is not logged in, subscriptions cannot be even requested
    User user = requestInfo.getSession().getUser();
    if(user == null){
      return retQStr;
    }
    
    Iterator<String> subIt = requestInfo.getSubscriptionQuery().iterator();
    ArrayList<String> parsedIds = new ArrayList<String>(P2Constants.SUBS_QUERY_COUNT);

    // Filling up parsedIds array with individual id-s
    while(subIt.hasNext()){
      String tmpStr = subIt.next();
      if(!tmpStr.isEmpty()){
        tmpStr = tmpStr.substring(tmpStr.lastIndexOf('/')+1);
        tmpStr = tmpStr.replaceAll("\\s+","");
      }
      else
        tmpStr = "%";
      parsedIds.add(tmpStr);
    }

    retQStr = getQueSubsLike(parsedIds);
    
    return "<subscriptions>" + retQStr + "</subscriptions>";
  }

  /**
   * Gets subscriptions from dababase based upon terms in arrayList
   * Character % is used as wildcard.
   *
   * @param qString ArrayList of strings filled with patterns
   * @return Returns either subscriptions serialized in XML if there was 
   * a pattern match or empty string otherwise
   */
  private String getQueSubsLike(ArrayList<String> qString) {
    
    String retQStr = "";
    List sList = null;
    String qStr = qString.get(P2Constants.SUBS_QUERY_URI);

    EntityManager em = AppBean.getPersistenceManager().getEM();
    try {
      Query query = em.createQuery("SELECT s FROM Subscription s WHERE " +
        "s.id LIKE '" + qString.get(P2Constants.SUBS_QUERY_URI) + "' AND "+
        "s.userId LIKE '" + qString.get(P2Constants.SUBS_QUERY_AUTHOR) + "' AND " +
        "s.groupId LIKE '" + qString.get(P2Constants.SUBS_QUERY_GROUP) + "'");
      query.setHint("javax.persistence.cache.storeMode", "REFRESH");
      sList = query.getResultList();
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception in database query in getQueriedTypeLike.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, e);
      }
      sList = null;
    } finally {
      em.close();
    }

    if (sList != null && !sList.isEmpty()) {
      Iterator sListIt = sList.iterator();
      while (sListIt.hasNext()) {
        Subscription sub = (Subscription) sListIt.next();
        retQStr = retQStr + sub.toXMLStringV2();
      }
    }
    return retQStr;
  }  

  /**
   * Creates message with types of annotations requested (queried) by client
   *
   * @param requestInfo Informations about client request
   * @return Returns types message with requested types in add element. If no
   * types matching supplied filter, element add will be empty. If user is not
   * logged in or no types requested, it returns empty string.
   */
  private String getQueriedTypes(RequestInfo requestInfo) {
    String retQTStr = "";
    if (requestInfo.getQueryTypes().isEmpty()) {  // if no types requested
      return retQTStr;
    }
    User user = requestInfo.getSession().getUser();
    if (user == null) {  // if user is not logged in
      return retQTStr;  // no types can be requested
    }
    Iterator<String> qIter = requestInfo.getQueryTypes().iterator();
    while (qIter.hasNext()) {  // for each filter string from queryTypes message
      String qString = qIter.next();
      if (!qString.contains("*") && qString.contains(AppBean.getBaseTypeUri())) {
        // if filter contains URI without wildcards, exact matching type will be returned
        retQTStr = retQTStr + getQueriedTypeExact(qString, requestInfo);
      } else if (qString.contains("*") && qString.contains(AppBean.getBaseTypeUri())) {
        // if filter contains URI with wildcards
        // replaces wildcards by these required for database query
        qString = qString.replace("*", "%");
        // get matching types
        retQTStr = retQTStr + getQueriedTypeLike(qString, requestInfo);
      } else if (!qString.contains("*")) {
        // if filter contains linearized name without wildcards
        // creates list of names to URI
        qString = MessageProcessor.replaceArrows(qString);
        if (MessageProcessor.isGroupIncluded(qString)) {  // if group number is included
          // create URI of type
          qString = AppBean.getBaseTypeUri() + qString;
          // get exactly matching types
          retQTStr = retQTStr + getQueriedTypeExact(qString, requestInfo);
        } else {  // if group number is not included
          Iterator<UserGroup> gIter = user.getGroups().iterator();
          while (gIter.hasNext()) {  // for each group
            UserGroup userGroup = gIter.next();
            // create URI of type
            String qStringWG = AppBean.getBaseTypeUri() + "g" + userGroup.getId() + "/" + qString;
            // add types exactly matching in this group
            retQTStr = retQTStr + getQueriedTypeExact(qStringWG, requestInfo);
          }
        }
      } else {  // if filter contains linearized name with wildcards
        // replaces wildcards by these required for database query
        qString = qString.replace("*", "%");
        qString = MessageProcessor.replaceArrows(qString);
        if (MessageProcessor.isGroupIncluded(qString)) {  // if group number is included
          // create URI of type
          qString = AppBean.getBaseTypeUri() + qString;
          // get matching types
          retQTStr = retQTStr + getQueriedTypeLike(qString, requestInfo);
        } else {  // if group number is not included
          Iterator<UserGroup> gIter = user.getGroups().iterator();
          while (gIter.hasNext()) {  // for each group
            UserGroup userGroup = gIter.next();
            // create URI of type
            String qStringWG = AppBean.getBaseTypeUri() + "g" + userGroup.getId() + "/" + qString;
            // add types matching in this group
            retQTStr = retQTStr + getQueriedTypeLike(qStringWG, requestInfo);
          }
        }
      }  // if filter contains linearized name with wildcards
    }  //  // for each filter string from queryTypes message
    if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
      retQTStr = "<addTypes>" + retQTStr + "</addTypes>"; 
    }else{
      retQTStr = "<types><add>" + retQTStr + "</add></types>";  // create message
    }
    return retQTStr;
  }  // getQueriedTypes()

  /**
   * Gets type of annotations with given URI serialized in XML
   *
   * @param qString URI of requested type of annotations
   * @param requestInfo Informations about client request
   * @return Returns type of annotations with given URI serialized in XML or
   * empty string if there are no matching type
   */
  private String getQueriedTypeExact(String qString, RequestInfo requestInfo) {
    boolean withAnc = true;  // types will be send with ancestors
    if (requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V1_1) {
      withAnc = false;  // old client - types will be send without ancestors
    }
    String retQTStr = "";
    // query database for type with given URI
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = qString;
    List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    if (tList != null && !tList.isEmpty()) {  // if type was found
      AnnotType aType = (AnnotType) tList.get(0);
      if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        retQTStr = retQTStr + aType.toXMLStringV2(withAnc);
      }else{
        retQTStr = retQTStr + aType.toXMLString(withAnc);
      }
    }
    return retQTStr;
  }  // getQueriedTypeExact()

  /**
   * Gets type of annotations with URI matching given pattern serialized in XML
   * Character % is used as wildcard.
   *
   * @param qString Pattern of URI of requested type of annotations
   * @param requestInfo Informations about client request
   * @return Returns type of annotations with URI matching given pattern
   * serialized in XML or empty string if there are no matching type
   */
  private String getQueriedTypeLike(String qString, RequestInfo requestInfo) {
    boolean withAnc = true;  // types will be send with ancestors
    if (requestInfo.getSession().getProtocolLOD() < Constants.PROTOCOL_LOD_V1_1) {
      withAnc = false;  // old client - types will be send without ancestors
    }
    String retQTStr = "";
    List tList = null;
    // query database for matching types
    EntityManager em = AppBean.getPersistenceManager().getEM();
    try {
      Query query = em.createQuery("SELECT a FROM AnnotType a WHERE a.uri LIKE '" + qString + "'");
      query.setHint("javax.persistence.cache.storeMode", "REFRESH");
      tList = query.getResultList();
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception in database query in getQueriedTypeLike.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, e);
      }
      tList = null;
    } finally {
      em.close();
    }

    if (tList != null && !tList.isEmpty()) {  // if some types was found
      Iterator tListIt = tList.iterator();
      while (tListIt.hasNext()) {  // serialize types
        AnnotType aType = (AnnotType) tListIt.next();
        if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          retQTStr = retQTStr + aType.toXMLStringV2(withAnc);
        }else{
          retQTStr = retQTStr + aType.toXMLString(withAnc);
        }
      }
    }
    return retQTStr;
  }  // getQueriedTypeLike()

  /**
   * Creates message with annotations interesting for client Annotations are
   * returned in element add of annotations message.
   *
   * @param requestInfo Informations about client request
   * @return Returns message with annotations interesting for client or empty
   * string if there are no such annotations.
   */
  private String getAllInterestingAnnotations(RequestInfo requestInfo) {
    String retStr = "";
    boolean proto11 = requestInfo.getSession().getProtocolLOD() > 1;
    ArrayList<Annotation> approvedAnnotations = new ArrayList<Annotation>();
    ArrayList<Annotation> unapprovedAnnotations = new ArrayList<Annotation>();
    // query database for annotations for synchronized document
    Object[] params = new Object[2];
    params[0] = "sourceDocumentId";
    params[1] = requestInfo.getSession().getSyncDocument().getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentIDNoNested", params);
    if (aList != null && !aList.isEmpty()) {  // if some annotation was found
      Iterator aListIt = aList.iterator();
      while (aListIt.hasNext()) {  // for each annotation for given document
        Annotation annot = (Annotation) aListIt.next();
        //Debug try catch construction
        try{
          if (requestInfo.getSession().isSubscribed(annot, getUserSources(annot.getUser()))) {   // only subscribed annotations
            approvedAnnotations.add(annot);   // add approved anotation to approved list
          } else {
            unapprovedAnnotations.add(annot);   // other annotations add to unapproved list
          }
        }
        catch(Exception e){
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          requestInfo.addError(lod, langNum, Localisation.ERROR_100_UNKNOWN_ERROR, e.getMessage());
        }
      }
      
      approvedAnnotations = getRelatedAnnotations(approvedAnnotations, unapprovedAnnotations, requestInfo.getSession());
      
      ArrayList<String> attFilter = requestInfo.getSession().getAttFilter();
      int lNum = requestInfo.getSession().getLanguageNum();
      Boolean KBRefMode = requestInfo.getSession().getKBRefMode();

      Iterator<Annotation> approvedIter = approvedAnnotations.iterator();

      while (approvedIter.hasNext()) {  // for each approved annotation
        Annotation annot = approvedIter.next();
        if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          retStr = retStr + annot.toXMLStringV2(attFilter, lNum, KBRefMode);
        }else{
          retStr = retStr + annot.toXMLString(proto11);
        }
      }
    }  // if some annotation was found
    if (!retStr.isEmpty()) {  // if there are any annotation to send
      if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        retStr = "<addAnnotations>" + retStr + "</addAnnotations>"; 
      }else{
        retStr = "<annotations><add>" + retStr + "</add></annotations>";  // create message
      }
    }
    return retStr;
  }  // getAllInterestingAnnotations()

  /**
   * Gets provider of matchers for finding fragments
   *
   * @return Returns provider of matchers for finding fragments
   */
  public MatcherProvider getMatcherProvider() {
    return matcherProvider;
  }

  /**
   * Updates all annotations for synchronized document (eg. after modification
   * of document)
   *
   * @param requestInfo Informations about client request
   */
  private void updateAllExisting(RequestInfo requestInfo) {
    if (requestInfo.getSession().getSyncDocument() == null) {
      // if no document synchronized, no annotations can be updated
      return;
    }
    // query database for all annotations for synchronized document
    Flier flier = requestInfo.getFlier();
    Object[] params = new Object[2];
    params[0] = "sourceDocumentId";
    params[1] = requestInfo.getSession().getSyncDocument().getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentID", params);
    if (aList != null && !aList.isEmpty()) {  // if there are annotations for given document
      Iterator aListIt = aList.iterator();
      while (aListIt.hasNext()) {  // for each annotation
        Annotation annot = (Annotation) aListIt.next();
        // update annotation
        if (updateAnnotation(annot, requestInfo)) {
          // if annotation was updated, add it to flier (informations for clients)
          flier.addAutoUpdatedAnnotation(annot);
        }
      }
    }  // if there are annotations for given document
  }  // updateAllExisting()

  /**
   * Updates fragments in annotation
   *
   * @param annotation Annotation to update
   * @param requestInfo Informations about client request
   * @return If annotation was updated, returns true, if no update needed or
   * error occurred, returns false
   */
  private boolean updateAnnotation(Annotation annotation, RequestInfo requestInfo) {
    if (annotation.getFragments().size() < 1) {
      // if annotation haven't fragments, it can't be updated
      return false;
    }

    // get synchronized document
    AnnotDocument annotDoc = requestInfo.getSession().getSyncDocument();
    Document parsedDoc = requestInfo.getSession().getParsedSyncDocument();
    if (parsedDoc == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
      String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Bad document for update of the annotation.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return false;  // updating is not possible
    }

    int badFragCnt = 0;  // total count of bad fragments
    int nowOrphFragCnt = 0;  // count of just orphaned fragments
    int updatedFragCnt = 0;  // count of just updated fragments
    Iterator<Fragment> fragIt = annotation.getFragments().iterator();
    while (fragIt.hasNext()) {  // for each annotated fragment
      Fragment fragment = fragIt.next();
      try {
        // find fragment
        UpdatableFragment uf = exactMatcherProvider.match(parsedDoc, fragment.toUpdatableFragment());
        if (uf != null) {  // if fragment was found
          if (fragment.getIsGood() == false) {  // if fragment was marked as bad
            fragment.setIsGood(true);  // mark as good
            updatedFragCnt++;  // fragment was now updated
          }
        } else {  // if fragment was not found
          // find fragment in document with full matching capability
          //ArrayList <UpdatableFragment> ufl = matcherProvider.matchAllIncrementally(parsedDoc, fragment.toUpdatableFragment());
          ArrayList<UpdatableFragment> ufl;
          // find nearest fragment
          ufl = nearestMatcherProvider.matchIn3ClosestNodes(parsedDoc, fragment.toUpdatableFragment());
          if (ufl.isEmpty()) {
            // find fragment with sequence iterator
            ufl = sequenceMatcherProvider.matchAllIncrementally(parsedDoc, fragment.toUpdatableFragment());
          }
          if (ufl.size() == 1) {  // if one fragment was found
            // get fragment (index unknown)
            Iterator<UpdatableFragment> ufIt = ufl.iterator();
            uf = ufIt.next();
            fragment.updateWithUpdatableFragment(uf);  // update fragment in annotation
            updatedFragCnt++;
            if (fragment.getIsGood() == false) {  // if fragment was marked as bad
              fragment.setIsGood(true);  // mark as good
            }
          } else if (ufl.isEmpty()) {  // if no fragment found
            if (fragment.getIsGood() == true) {  // if fragment was not bad
              fragment.setIsGood(false);  // mark as bad
              nowOrphFragCnt++;  // fragment was now orphaned
            }
            badFragCnt++;
          } else {  // if searching is ambiguous
            // select the best fragment
            int minBadness = Integer.MAX_VALUE;  // minimal badness
            UpdatableFragment minBFR = null;  // fragment with minimal L.D.
            String origPath = fragment.getPath();  // original XPath
            String origText = fragment.getAnnotatedText();  // original annotated text
            int origOffset = fragment.getOffset();  // original offset
            for (Iterator<UpdatableFragment> uflIt = ufl.iterator(); uflIt.hasNext();) {
              UpdatableFragment ufr = uflIt.next();
              int lD = Util.levenshtein(origPath, ufr.getXPathString());
              int lDT = Util.levenshtein(origText, ufr.getText());
              double LTPerc = (lDT / (double)origText.length()) * 100;
              int offDistance = Math.abs(origOffset - ufr.getOffset());
              int badness = 355 * lD + 5 * (int)LTPerc + offDistance;
              if (badness < minBadness) {
                minBadness = badness;
                minBFR = ufr;
              }
            }
            uf = minBFR;
            fragment.updateWithUpdatableFragment(uf);  // update fragment in annotation
            updatedFragCnt++;
            if (fragment.getIsGood() == false) {  // if fragment was marked as bad
              fragment.setIsGood(true);  // mark as good
            }
          }  // if searching is ambiguous
        }  // if fragment was not found
      } catch (XPathExpressionException ex) {  // bad XPath in fragment
        if (fragment.getIsGood() == true) {  // if fragment was not bad
          fragment.setIsGood(false);  // mark as bad
          nowOrphFragCnt++;  // fragment was now orphaned
        }
        badFragCnt++;
      } catch (Exception e) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "Exception during the update of the annotation.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, e);
        }
        badFragCnt++;
        break;
      }
    }  // for each annotated fragment

    if (badFragCnt == annotation.getFragments().size() && nowOrphFragCnt > 0) {
      // if annotation was just orphaned
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      if (lod < Constants.PROTOCOL_LOD_V2) {
        String info = AppBean.getBaseAnnotUri() + annotation.getId();
        requestInfo.addWarning(lod, langNum, Localisation.WARNING_2_ANNOT_ORPHANED, info);
      } else {
        String info = annotation.getURIV2();
        requestInfo.addWarning(lod, langNum, Localisation.WARNING_2_ANNOT_ORPHANED, info);
      }
    } else if (nowOrphFragCnt > 0) {
      // if annotation was just partially orphaned (bad fragments found)
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      if (lod < Constants.PROTOCOL_LOD_V2) {
        String info = AppBean.getBaseAnnotUri() + annotation.getId();
        requestInfo.addWarning(lod, langNum, Localisation.WARNING_4_ANNOT_PART_ORPHANED, info);
      } else {
        String info = annotation.getURIV2();
        requestInfo.addWarning(lod, langNum, Localisation.WARNING_4_ANNOT_PART_ORPHANED, info);
      }
    }
    if (nowOrphFragCnt > 0 || updatedFragCnt > 0) {
      // if new bad fragments found or some fragments was updated
      return true;
    }
    return false;  // nothing updated (no update needed)
  }  // updateAnnotation()

  /**
   * Checks whether added and changed annotations have good fragments and
   * required attributes
   *
   * @param requestInfo Informations about client request
   */
  private void checkAddedAndEdited(RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    String info;
    // get synchronized document
    AnnotDocument syncDoc = requestInfo.getSession().getSyncDocument();
    // check fragments in added annotations
    Iterator<Annotation> addedIter = flier.getAddedAnnotations().iterator();
    while (addedIter.hasNext()) {  // for each added annotation
      Annotation annot = addedIter.next();
      // Update all AnnotationLink attributes in added annotations
      updateAnnotationLinks(annot, requestInfo);
      Boolean cmpErr = false;
      Integer updFr = 0;
      // check annotation and get number of bad fragments
      int badCnt = checkAnnotationFragments(annot, syncDoc, requestInfo, cmpErr, updFr);
      int lod = requestInfo.getSession().getProtocolLOD();
      if (lod >= Constants.PROTOCOL_LOD_V2 && badCnt > 0) {
        addedIter.remove();  // remove bad annotation - in protocol 2.0 it can not be saved
        continue;
      }
      if (badCnt > 0 && annot.getFragments().isEmpty()) {  // if annotation was orphaned
        int langNum = requestInfo.getSession().getLanguageNum();
        if (lod < Constants.PROTOCOL_LOD_V2) {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_2_ANNOT_ORPHANED, annot.getURI());
        } else {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_2_ANNOT_ORPHANED, annot.getURIV2());
        }
        
      }
      if ((cmpErr || updFr > 0) && !requestInfo.getErrorList().contains(Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC)) {
        // If there are errors of searching fragments, it can be synchronization error
        // that´s why it must be treated as synchronization error.
        // This error will be sent only once.
        // Protocol V2 is used
        if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          info = "<resynchronize resource=\"" + requestInfo.getSession().getSyncDocument().getUri()
            + "\" method=\"soft\"/>";
        }
        // Protocol 1.x is used
        else{
          info = "<resynchronize/>";
        }
        int langNum = requestInfo.getSession().getLanguageNum();
        requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC, info);
        requestInfo.appendToReply(info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Synchronization error during the added annotation check.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
        }
      }
      if (updFr > 0) {  // if there are updated fragments
        // create warning message
        int langNum = requestInfo.getSession().getLanguageNum();
        if (lod < Constants.PROTOCOL_LOD_V2) {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_6_FRAGMENTS_UPDATED);
        } else {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_6_FRAGMENTS_UPDATED, annot.getURIV2());
        }
        
      }
    }  // for each added annotation
    // check fragments in changed annotations
    Iterator<Annotation> editedIter = flier.getEditedAnnotations().iterator();
    while (editedIter.hasNext()) {  // for each changed annotation
      Annotation annot = editedIter.next();
      // Update all AnnotationLink attributes in edited annotations
      updateAnnotationLinks(annot, requestInfo);
      Boolean cmpErr = false;
      Integer updFr = 0;
      // check annotation and get number of bad fragments
      int badCnt = checkAnnotationFragments(annot, syncDoc, requestInfo, cmpErr, updFr);
      if (badCnt > 0) {  // if there are bad fragments
        // create error message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        if (lod < Constants.PROTOCOL_LOD_V2) {
          info = "<reload uri=\"" + annot.getURI() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        } else {
          info = "<annotation uri=\"" + annot.getURIV2() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, info);
        }
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Edited annotation was not saved due bad fragments.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
        }
        // remove annotation from changed annotations (changes can't be saved)
        editedIter.remove();
        if (cmpErr && !requestInfo.getErrorList().contains(Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC)) {
          // If there are errors of searching fragments, it can be synchronization error
          // that´s why it must be treated as synchronization error.
          // This error will be sent only once.
          // Protocol V2 is used
          if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
            info = "<resynchronize resource=\"" + requestInfo.getSession().getSyncDocument().getUri()
              + "\" method=\"soft\"/>";
          }
          // Protocol 1.x is used
          else{
            info = "<resynchronize/>";
          }
          requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC, info);
          requestInfo.appendToReply(info);
        }
      } else if (updFr > 0) {  // if there are updated fragments, but no bad fragments
        // create warning message
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        if (lod < Constants.PROTOCOL_LOD_V2) {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_6_FRAGMENTS_UPDATED, annot.getURI());
        } else {
          requestInfo.addWarning(lod, langNum, Localisation.WARNING_6_FRAGMENTS_UPDATED, annot.getURIV2());
        }
        if (!requestInfo.getErrorList().contains(Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC)) {
          // probably synchronization error (will be sent only once)
          // Protocol V2 is used
          if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
            info = "<resynchronize resource=\"" + requestInfo.getSession().getSyncDocument().getUri()
              + "\" method=\"soft\"/>";
          }
          // Protocol 1.x is used
          else{
            info = "<resynchronize/>";
          }
          requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC, info);
          requestInfo.appendToReply(info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Synchronization error during the edited annotation check.";
            Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
          }
        }
      }
    }  // for each changed annotation

    // check required attributes in added annotations
    addedIter = flier.getAddedAnnotations().listIterator();
    while (addedIter.hasNext()) {  // for each added annotation
      Annotation annot = addedIter.next();
      if (checkReqAttrsInAnnot(annot, requestInfo)) {  // if attributes aren't presented or filled
        addedIter.remove();  // remove annotation (annotation can't be saved)
      }
    }
    // check required attributes in changed annotations
    editedIter = flier.getEditedAnnotations().iterator();
    while (editedIter.hasNext()) {  // for each changed annotation
      Annotation annot = editedIter.next();
      if (checkReqAttrsInAnnot(annot, requestInfo)) {  // if attributes aren't presented or filled
        editedIter.remove();  // remove annotation (changes can't be saved)
      }
    }
  }  // checkAddedAndEdited()

  /**
   * Checks whether annotation have all required attributes filled
   *
   * @param annot Annotation to check
   * @param requestInfo Informations about client request
   * @return If annotation have all required attributes filled, returns true,
   * false otherwise
   */
  private boolean checkReqAttrsInAnnot(Annotation annot, RequestInfo requestInfo) {
    if (annot.getAnnotType() == null) {  // if annotation haven't valid type
      return false;  // required attributes can't be checked and annotation is bad
    }
    // get attributes of annotation
    Iterator<BaseAttribute> annotAttrIt = annot.getAttributes().iterator();
    ArrayList<String> names = new ArrayList<String>();  // names of filled attributes
    while (annotAttrIt.hasNext()) {  // for each attribute
      BaseAttribute attr = annotAttrIt.next();
      if (!attr.isEmpty()) {  // if attribute has value (not empty)
        names.add(attr.getName());  // add name of attribute
      }
    }
    StringBuilder missing = new StringBuilder();
    StringBuilder missing2 = new StringBuilder();
    AnnotType annotType = annot.getAnnotType();
    
    //Check if annotation type, is in modified types
    Iterator<AnnotType> modifiedIt = requestInfo.getFlier().getEditedTypes().iterator();
    while(modifiedIt.hasNext()){
      AnnotType tmp = modifiedIt.next();
      if(tmp.getId() == annotType.getId()){
        annotType = tmp;
        break;
      }
    }
    
    Iterator<AnnotTypeAttr> attrIt = annotType.getAttributes().iterator();
    while (attrIt.hasNext()) {  // for each attribute of given type of annotation
      AnnotTypeAttr attr = attrIt.next();
      if (attr.getRequired()) {  // if attribute is required
        if (!names.contains(attr.getName())) {  // if attribute is not in filled attributes
          missing.append(attr.toXMLString(false));  // add to list of missing attributes
          missing2.append("<attribute annotationUri=\"").append(annot.getURIV2());
          missing2.append("\" uri=\"").append(attr.getUriInOntology());
          missing2.append("\" name=\"").append(attr.getName());
          missing2.append("\" valueType=\"").append(attr.getValueType());
          missing2.append("\" type=\"").append(attr.getTypeUriV2()).append("\"/>");
        }
      }
    }
    int lod = requestInfo.getSession().getProtocolLOD();
    int langNum = requestInfo.getSession().getLanguageNum();
    if (missing2.length() > 0 && lod >= Constants.PROTOCOL_LOD_V2) {
      requestInfo.addError(lod, langNum, Localisation.ERROR_6_ATTRIBUTE_REQUIRED, missing2.toString());
      return true;  // annotation haven't all attributes filled
    } else if (missing.length() > 0) {  // if there are missing attributes
      // create error message
      String info = "";
      if (annot.getId() != null) {
        info = "<reload uri=\"" + annot.getId() + "\"/>";
      }
      info = info + missing.toString();
      requestInfo.addError(lod, langNum, Localisation.ERROR_6_ATTRIBUTE_REQUIRED, info);
      return true;  // annotation haven't all attributes filled
    }
    return false;  // annotation have all required attributes filled
  }  // checkReqAttrsInAnnot()

  /**
   * Check whether annotated fragments in given annotation are good (can be
   * found in synchronized document)
   *
   * @param annotation Annotation to check
   * @param annotDoc Synchronized document
   * @param requestInfo Informations about client request
   * @param cmpErr In this object this method returns, whether there are errors
   * of searching fragments (maybe synchronization error)
   * @param updFr In this object this method returns count of updated fragments
   * @return Returns number of bad fragments
   */
  private int checkAnnotationFragments(Annotation annotation, AnnotDocument annotDoc, RequestInfo requestInfo, Boolean cmpErr, Integer updFr) {
    int badFragCnt = 0;
    Document syncDoc = requestInfo.getSession().getParsedSyncDocument();
    if (syncDoc == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
      String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Bad document for check of the annotation fragments.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return 1;  // there are bad fragments (probably all, but suffices report one)
      // If this is new annotation, all fragments will be saved, but they will
      // be checked and updated or marked as bad in actualization further.
    }

    ListIterator<Fragment> fragIt = annotation.getFragments().listIterator();
    while (fragIt.hasNext()) {  // for each fragment
      Fragment fragment = fragIt.next();
      try {
        // find fragment in document
        ArrayList<UpdatableFragment> ufl = exactMatcherProvider.matchAll(syncDoc, fragment.toUpdatableFragment());
        if (ufl.isEmpty() && fragment.getPath() != null && fragment.getPath().indexOf("text()") == -1) {
          // if "/text()" is not presented, we can try append it
          Fragment fwt = new Fragment(fragment.getPath(), fragment.getOffset(), fragment.getLength(), fragment.getAnnotatedText(), fragment.getRefAnnotation(), fragment.getIsGood());
          fwt.setPath(fragment.getPath() + "/text()");
          ufl = exactMatcherProvider.matchAll(syncDoc, fwt.toUpdatableFragment());
        }
        UpdatableFragment uf = null;
        if (ufl.size() > 1) {  // if there is more then one matching fragment
          // In some cases, one fragment can be selected and its exact XPath used
          // It's necessary to try:
          
          //   - remove fragments with different string
          ListIterator<UpdatableFragment> uflIt = ufl.listIterator();
          while (uflIt.hasNext()) {
            UpdatableFragment inspectedUf = uflIt.next();
            if (!fragment.getAnnotatedText().equals(inspectedUf.getText())) {
              uflIt.remove();
            }
          }
          
          //   - remove duplicit fragments
          if (ufl.size() > 1) {
            uflIt = ufl.listIterator();
            while (uflIt.hasNext()) {
              UpdatableFragment inspectedUf = uflIt.next();
              ListIterator<UpdatableFragment> uflItDup = ufl.listIterator();
              while (uflItDup.hasNext()) {
                UpdatableFragment ufInList = uflIt.next();
                if (ufInList.equals(inspectedUf)) {
                  uflItDup.remove();
                }
              }
            }
          }
          
          // evaluate correction process
          if (ufl.size() == 1) {
            uf = ufl.get(0);
          } else {
            // create error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "";
            if (annotation.getId() != null && lod < Constants.PROTOCOL_LOD_V2) {
              info = "<reload uri=\"" + annotation.getURI() + "\"/>" + fragment.toXMLString();
            } else if (annotation.getId() != null) {
              info = "<annotation uri=\"" + annotation.getURIV2() + "\"/>";
            }
            requestInfo.addError(lod, langNum, Localisation.ERROR_52_AMBIGUOUS_FRAGMENT, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Ambiguous fragment found.";
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
            }
            // remove fragment from annotation
            fragIt.remove();
            badFragCnt++;
            continue;
          }
        } else if (!ufl.isEmpty()) {  // if fragment was found
          // get fragment (index unknown)
          Iterator<UpdatableFragment> ufIt = ufl.iterator();
          uf = ufIt.next();
        } else {  // if fragment was not found        
          // find nearest fragment
          ufl = nearestMatcherProvider.matchIn3ClosestNodes(syncDoc, fragment.toUpdatableFragment());
          if (ufl.isEmpty()) {
            // find fragment with sequence iterator
            ufl = sequenceMatcherProvider.matchAllIncrementally(syncDoc, fragment.toUpdatableFragment());
          }
          // find fragment in document with full matching capability
          //ufl = matcherProvider.matchAllIncrementally(syncDoc, fragment.toUpdatableFragment());
          if (ufl.size() == 1) {
            // get fragment (index unknown)
            Iterator<UpdatableFragment> ufIt = ufl.iterator();
            uf = ufIt.next();
          } else if (ufl.isEmpty()) {  // if fragment still was not found
            // create error message
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "";
            if (annotation.getId() != null && lod < Constants.PROTOCOL_LOD_V2) {
              info = "<reload uri=\"" + annotation.getId() + "\"/>" + fragment.toXMLString();
            } else if (annotation.getId() != null) {
              info = "<annotation uri=\"" + annotation.getURIV2() + "\"/>";
            }
            requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Bad fragment found during the check.";
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
            }
            cmpErr = true;  // error of comparation with document content
            badFragCnt++;  // bad fragment found
            fragIt.remove();  // remove fragment from annotation
          } else {  // if searching is ambiguous
            // try select proper fragment
            int pathLenght = fragment.getPath().length();
            int textLenght = fragment.getAnnotatedText().length();
            if (pathLenght > Constants.MIN_XPATH_L_TO_AUTO_MODIFY_FR
                    && textLenght > Constants.MIN_TEXT_L_TO_AUTO_MODIFY_FR) {  // if lengths are sufficient
              int minLD = Integer.MAX_VALUE;  // minimal Levenshtein distance
              UpdatableFragment minLDFR = null;  // fragment with minimal L.D.
              int sMinLD = Integer.MAX_VALUE;  // second minimal Levenshtein distance
              double minLDPercentage = 1;
              double sMinLDPercentage = 1;
              String origPath = fragment.getPath();  // original XPath
              String origText = fragment.getAnnotatedText();  // original text
              for (Iterator<UpdatableFragment> uflIt = ufl.iterator(); uflIt.hasNext();) {
                UpdatableFragment ufr = uflIt.next();
                if (Math.abs(ufr.getOffset() - fragment.getOffset()) > Constants.MAX_OFFSET_DIFF_TO_AUTO_MODIFY_FR) {
                  continue;  // bad fragment
                }
                if (((double) Util.levenshtein(origText, ufr.getText()) / origText.length()) > Constants.MAX_TEXT_LD_TO_AUTO_MODIFY_FR) {
                  continue;  // bad fragment
                }
                int lD = Util.levenshtein(origPath, ufr.getXPathString());
                if (lD < minLD) {
                  sMinLD = minLD;
                  minLD = lD;
                  minLDPercentage = (double) lD / pathLenght;
                  minLDFR = ufr;
                } else if (lD < sMinLD) {
                  sMinLD = lD;
                  sMinLDPercentage = (double) lD / pathLenght;
                }
              }
              if (minLDPercentage <= Constants.MAX_XPATH_LD_TO_AUTO_MODIFY_FR
                      && (sMinLDPercentage - minLDPercentage) >= Constants.MIN_XPATH_LD_DIFF_TO_AUTO_MODIFY_FR) {
                uf = minLDFR; // similar fragment will be used
                // create warning message
                int langNum = requestInfo.getSession().getLanguageNum();
                int lod = requestInfo.getSession().getProtocolLOD();
                String info = "";
                if (annotation.getId() != null && lod < Constants.PROTOCOL_LOD_V2) {
                  info = annotation.getURI();
                } else if (lod >= Constants.PROTOCOL_LOD_V2) {
                  info = annotation.getURIV2();
                }
                requestInfo.addWarning(lod, langNum, Localisation.WARNING_3_ANNOT_UPDATED, info);
              }
            }  // if lengths are sufficient

            if (uf == null) {  // if searching is too ambiguous
              // create error message
              int langNum = requestInfo.getSession().getLanguageNum();
              int lod = requestInfo.getSession().getProtocolLOD();
              String info = "";
              if (annotation.getId() != null && lod < Constants.PROTOCOL_LOD_V2) {
                info = "<reload uri=\"" + annotation.getURI() + "\">" + fragment.toXMLString() + "</reload>";
              } else if (annotation.getId() != null) {
                info = "<annotation uri=\"" + annotation.getURIV2() + "\"/>";
              }
              requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, info);
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                String msg = "Too ambiguous fragment found.";
                Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
              }
              cmpErr = true;  // error ofcomparation with document content
              badFragCnt++;  // bad fragment found
              fragIt.remove();  // remove fragment from annotation
            }
          } // if searching is ambiguous
        }  // if fragment was not found
        if (uf != null && !fragment.fragmentEqualsWUF(uf)) {  // if fragment was found, but modified
          cmpErr = true;  // error ofcomparation with document content
          updFr++;  // increase count of updated fragments
          fragment.updateWithUpdatableFragment(uf);  // update fragment data
        }
      } catch (XPathExpressionException ex) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "";
        if (lod < Constants.PROTOCOL_LOD_V2) {
          if (annotation.getId() != null) {
            info = "<reload uri=\"" + annotation.getURI() + "\"/>" + fragment.toXMLString();
          }
          requestInfo.addError(lod, langNum, Localisation.ERROR_35_BAD_XPATH, info);
        } else {
          if (annotation.getId() != null) {
            info = "<annotation uri=\"" + annotation.getURIV2() + "\"/>" + fragment.toXMLString();
          }
          requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, info);
        }
        fragIt.remove();  // remove fragment from annotation
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad XPath found in the fragment.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
        }
        badFragCnt++;
      } catch (Exception e) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "Exception dugring the checking of the annotation fragments.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, e);
        }
        badFragCnt++;
      }
    }  // for each fragment
    return badFragCnt;
  }  // checkAnnotationFragments()

  /**
   * Checks whether annotations of document will be affected by updating
   * annotated copy of document to new version If annotation can be
   * automatically updated (all fragments found), it's not treated as affection.
   *
   * @param doc Old version of annotated document
   * @param newDoc New version of annotated document
   * @param requestInfo Informations about client request
   * @return If annotations are affected, returns true, false otherwise
   */
  private double isAnnotationsAffected(AnnotDocument doc, AnnotDocument newDoc, RequestInfo requestInfo) {
    // query database for annotations for given document
    Object[] params = new Object[2];
    params[0] = "sourceDocumentId";
    params[1] = doc.getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findBySourceDocumentID", params);
    if (aList != null && !aList.isEmpty()) {  // if annotations was found
      int annCount = aList.size();
      double incrValue = 100 / annCount;
      double affected = 0;
      Iterator aListIt = aList.iterator();
      while (aListIt.hasNext()) {  // for each annotation
        Annotation annot = (Annotation) aListIt.next();
        affected += incrValue * isAnnotationAffected(annot, newDoc, requestInfo);
      }
      return affected;
    }  // if annotations was found
    return 0;
  }  // isAnnotationsAffected()

  /**
   * Checks whether annotation will be affected by updating annotated copy of
   * document to new version If annotation can be automatically updated (all
   * fragments found), it's not treated as affection.
   *
   * @param annotation Checked annotation
   * @param newDoc New version of annotated document
   * @param requestInfo Informations about client request
   * @return If annotations are affected, returns true, false otherwise
   */
  private double isAnnotationAffected(Annotation annotation, AnnotDocument newDoc, RequestInfo requestInfo) {
    // parse new version of document
    Document parsedDoc = null;
    try{
      parsedDoc = matcherProvider.getDocumentFromString(newDoc.getContent(), false, true);
    }
    catch(Exception e){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
      requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Parsing document for the annotation affection check failed.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return 1;
    }
    //Document parsedDoc = requestInfo.getSession().getParsedSyncDocument();
    if (parsedDoc == null) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
      requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Bad document for the annotation affection check.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return 1;
    }

    Iterator<Fragment> fragIt = annotation.getFragments().iterator();
    int fragCount = annotation.getFragments().size();
    // Zero fragments
    if(fragCount <= 0){
        return 0;
    }
    double incrValue = 1 / fragCount;
    double affected = 0;
    while (fragIt.hasNext()) {  // for each annotated fragment
      Fragment fragment = fragIt.next();
      try {
        // find annotated fragment
        UpdatableFragment uf;
        uf = exactMatcherProvider.match(parsedDoc, fragment.toUpdatableFragment());
        if (uf == null) {  // if fragment was not found, annotation will be affected
          // find annotated fragment with full matching capability
          ArrayList<UpdatableFragment> ufl = nearestMatcherProvider.matchIn3ClosestNodes(parsedDoc, fragment.toUpdatableFragment());
          if(ufl.isEmpty()){
            ufl = sequenceMatcherProvider.matchAllIncrementally(parsedDoc, fragment.toUpdatableFragment());
          }
          if(ufl.size() >= 1){
            if(ufl.size() == 1){
              affected += incrValue * fragmentTreshold(fragment, ufl.get(0));
              continue;
            }
            else{
              // select the best fragment
              int minBadness = Integer.MAX_VALUE;  // minimal badness
              UpdatableFragment minBFR = null;  // fragment with minimal L.D.
              String origPath = fragment.getPath();  // original XPath
              String origText = fragment.getAnnotatedText();  // original annotated text
              int origOffset = fragment.getOffset();  // original offset
              for (Iterator<UpdatableFragment> uflIt = ufl.iterator(); uflIt.hasNext();) {
                UpdatableFragment ufr = uflIt.next();
                int lD = Util.levenshtein(origPath, ufr.getXPathString());
                int lDT = Util.levenshtein(origText, ufr.getText());
                double LTPerc = (lDT / (double)origText.length()) * 100;
                int offDistance = Math.abs(origOffset - ufr.getOffset());
                int badness = 355 * lD + 5 * (int)LTPerc + offDistance;
                if (badness < minBadness) {
                  minBadness = badness;
                  minBFR = ufr;
                }
              }
              uf = minBFR;
              affected += incrValue * fragmentTreshold(fragment, uf);
            }
          }
          else{
            if (fragment.getIsGood()) {  // if fragment was good
              affected += incrValue;
            }
          }
        }  // if fragment was not found, annotation will be affected
      } catch (XPathExpressionException ex) {
        if (fragment.getIsGood()) {
          affected += incrValue;
        }
      } catch (Exception e) {
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
          String msg = "Exception during the annotation affection check.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, e);
        }
        affected += incrValue;
      }
    }  // for each annotated fragment
    return affected;
  }  // isAnnotationAffected()

  /**
   * Treshold method which tells you how much is the fragment changed.
   * @param origFragment
   * @param foundFragment
   * @return fragment affection percentage
   */
  private double fragmentTreshold(Fragment origFragment, UpdatableFragment foundFragment){
    int affectedParts = 0;
    // Offset treshold
    if(Math.abs(origFragment.getOffset() - foundFragment.getOffset()) > Constants.MAX_OFFSET_DIFF_TO_AUTO_MODIFY_FR){
      ++affectedParts;
    }
    // XPath treshold
    int XPathLD = Util.levenshtein(origFragment.getPath(), foundFragment.getXPathString());
    double XPathLDPercentage = (double) XPathLD / origFragment.getPath().length();
    if(XPathLDPercentage > Constants.MAX_XPATH_LD_TO_AUTO_MODIFY_FR){
      ++affectedParts;
    }
    // Text treshold
    int TextLD = Util.levenshtein(origFragment.getAnnotatedText(), foundFragment.getText());
    double TextLDPercentage = (double) TextLD / origFragment.getAnnotatedText().length();
    if(TextLDPercentage > Constants.MAX_TEXT_LD_TO_AUTO_MODIFY_FR){
      ++affectedParts;
    }
    return (double)affectedParts / 3;
  }
  
  /**
   * Synchronizes document
   *
   * @param requestInfo Informations about client request
   */
  private void synchronizeDocument(RequestInfo requestInfo) {
    // reset data for optimization
    requestInfo.getSession().setParsedLinDocument(null);
    requestInfo.getSession().setParsedSyncDocument(null);

    // get synchronized document data
    AnnotDocument newDoc = requestInfo.getSyncDocumentData();
    try {
      // Clean up document URI from sessionId and other mess.
      newDoc.setUri(cleanUpURI(newDoc.getUri()));
    } catch (URISyntaxException ex) {  // if URI is bad
      // create error messages
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_53_BAD_DOCUMENT_URI);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad URI of synchronized document: " + newDoc.getUri();
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg, ex);
      }
      return;  // synchronization failed
    }

    /* To prevent searching for the same document by multiple threads in the same time, it's needed to use
     * locks 
     */
    String documentUri = newDoc.getUri();
    ReentrantLock lock;
        
    /* If lock is null create new lock and put it into map */
    synchronized(AppBean.documentURILocker){
      /* Get lock from map */
      lock = AppBean.documentURILocker.get(documentUri);
      if(lock == null){
        lock = new ReentrantLock();
      }
      
      AppBean.documentURILocker.put(documentUri, lock);
    }
    lock.lock();
    
    // Query database for the annotation document
    AnnotDocument doc = null;  // synchronized document
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = newDoc.getUri();
    List dList = AppBean.getPersistenceManager().queryDB("AnnotDocument.findByUri", params);
    if (dList != null && !dList.isEmpty()) {  // if document was found
      doc = (AnnotDocument) dList.get(0);
      if(lock.isLocked()){
        lock.unlock();
      }
    }

    if (requestInfo.isSyncLinearized()) {  // if linearization is requested
      // synchronize with linearization
      synchronizeLinearizedDocument(doc, newDoc, requestInfo);
    } else {
      // synchronize without linearization
      synchronizeStructuredDocument(doc, newDoc, requestInfo);
    }

  }

  /**
   * Locks document usage
   * 
   * @throws InterruptedException 
   */
  public synchronized void lockDocumentUsage() throws InterruptedException{
    while(documentUsageLocked){
      wait();
    }
    documentUsageLocked = true;
  }

  /**
   * Unlocks document usage
   */
  public synchronized void unlockDocumentUsage() {
    documentUsageLocked = false;
    notify();
  }
  
  /**
   * Synchronizes structured document
   *
   * @param doc persisted annotated document whether exists, otherwise null
   * @param newDoc New version of annotated document
   * @param requestInfo Informations about client request
   */
  private void synchronizeStructuredDocument(AnnotDocument doc, AnnotDocument newDoc, RequestInfo requestInfo) {
    EditorSession session = requestInfo.getSession();
    int langNum = session.getLanguageNum();
    int lod = requestInfo.getSession().getProtocolLOD();

    session.setLinearization(false); // if linearization is enabled, disable it
   
    Document parsedSyncDocument = null;
    try {
      parsedSyncDocument = this.matcherProvider.getDocumentFromString(newDoc.getContent(), false, true);
    } catch(Exception e){
      langNum = requestInfo.getSession().getLanguageNum();
      lod = requestInfo.getSession().getProtocolLOD();
      String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
      requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Parsing document to get structured synchronized document failed.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return;  // synchronization failed
    }

    try {
      try {
        lockDocumentUsage();
      } catch (InterruptedException ex) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "Interrupted exception on trying to lock document usage counter.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
        }
        String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR,info);
        return;
      }
            
      session.setSyncDocument(null);
      session.setParsedLinDocument(null);
      session.setParsedSyncDocument(null);
      
      if (doc == null) {  // if synchronizes new document
        // set informations about synchronized document
        requestInfo.setNewDocument(true);
        requestInfo.setSyncDocument(newDoc);
        // set synchronized document in session
        session.setSyncDocument(newDoc);
        session.setParsedLinDocument(Linearizer.linearizeDocument(parsedSyncDocument));
        session.setParsedSyncDocument(parsedSyncDocument);

      } else {  // if synchronizes existing document

        // if documents have same content
        if (doc.getContent().equals(newDoc.getContent())) {
          requestInfo.setSyncDocument(doc);  // set informations about synchronized document
          // set synchronized document in session
          session.setSyncDocument(doc);
          session.setParsedLinDocument(Linearizer.linearizeDocument(parsedSyncDocument));
          session.setParsedSyncDocument(parsedSyncDocument);
        } 
        // if documents have different content and another client has it opened/synchronized
        else if (AppBean.getDocumentUsage(doc.getId()) > 0 && !requestInfo.isSyncWithOverwrite()) {
          // synchronization error
          StringBuilder docSB = new StringBuilder();
          docSB.append("<content><![CDATA[");
          docSB.append(doc.getContent());
          docSB.append("]]></content>");
          requestInfo.addError(lod, langNum, Localisation.ERROR_62_SYNC_ERROR_OTHER_DIFFERENT, docSB.toString());
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Document is already opened by another client. Versions of document differs.";
            Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
          }
        } 
        // if documents have different content, but annotations aren't affected 
        else if (isAnnotationsAffected(doc, newDoc, requestInfo) <= Constants.MAX_ANNOTATION_DIFFERENCE) {
          requestInfo.setSyncDocument(doc);  // set informations about synchronized document
          // set synchronized document in session
          session.setSyncDocument(doc);
          session.setParsedLinDocument(Linearizer.linearizeDocument(parsedSyncDocument));
          session.setParsedSyncDocument(parsedSyncDocument);
          // generate modifications for other clients
          generateTextModificationsToFlier(doc.getContent(), newDoc.getContent(), false, requestInfo);
          Integer lastModID = AppBean.incrementLastDocModification(doc.getId());
          if (lastModID == null) {
            String msg = "Unable to increment text modification set ID.";
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
            }
            requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, msg);
          } else {
            requestInfo.getFlier().setTextModificationSetID(lastModID);
            AppBean.addDocModificationSet(doc.getId(), lastModID, requestInfo.getFlier().getTextModifications());
          }
          doc.setModified(new Date());  // set date of modification
          doc.setContent(newDoc.getContent());  // actualize content of document
        } 
        // if documents have different content, but overwrite is set
        else if (requestInfo.isSyncWithOverwrite()) {
          requestInfo.setSyncDocument(doc);  // set informations about synchronized document
          // set synchronized document in session
          session.setSyncDocument(doc);
          session.setParsedLinDocument(Linearizer.linearizeDocument(parsedSyncDocument));
          session.setParsedSyncDocument(parsedSyncDocument);
          // generate modifications for other clients
          generateTextModificationsToFlier(doc.getContent(), newDoc.getContent(), false, requestInfo);
          Integer lastModID = AppBean.incrementLastDocModification(doc.getId());
          if (lastModID == null) {
            String msg = "Unable to increment text modification set ID.";
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
            }
            requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, msg);
          } else {
            requestInfo.getFlier().setTextModificationSetID(lastModID);
            AppBean.addDocModificationSet(doc.getId(), lastModID, requestInfo.getFlier().getTextModifications());
          }
          doc.setModified(new Date());  // set date of modification
          doc.setContent(newDoc.getContent());  // overwrite content of document
        } 
        // if documents have different content and annotations are affected
        else {
          // synchronization error
          StringBuilder docSB = new StringBuilder();
          docSB.append("<content><![CDATA[");
          docSB.append(doc.getContent());
          docSB.append("]]></content>");
          requestInfo.addError(lod, langNum, Localisation.ERROR_9_SYNC_ERROR_DIFFERENT, docSB.toString());
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Common synchronization error (different contents).";
            Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
          }
        }
      }
    } finally {
      unlockDocumentUsage();
    }
    
  }  // synchronizeDocument()

  /**
   * Resynchronizes document
   *
   * @param requestInfo Informations about client request
   */
  private void reSynchronizeDocument(RequestInfo requestInfo) {
    // reset data for optimization
    requestInfo.getSession().setParsedLinDocument(null);
    requestInfo.getSession().setParsedSyncDocument(null);

    AnnotDocument doc = requestInfo.getSession().getSyncDocument();  // get synchronized ocument
    if (doc == null) {  // if document was not synchronized
      // error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_10_SYNC_ERROR_NOT_POSSIBLE);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Resynchronization in state where document is not synchronized.";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
      }
      return;
    }

    // get new content of document
    String newContent = requestInfo.getResyncDocContent();
    // create annotated document with new data
    AnnotDocument newDoc = new AnnotDocument(doc.getUri(), newContent);
    newDoc.setId(doc.getId());

    if (requestInfo.getSession().isLinearization()) {  // if linearization is enabled
      reSynchronizeLinearizedDocument(doc, newDoc, requestInfo);
    } else {
      reSynchronizeStructuredDocument(doc, newDoc, requestInfo);
    }
  }

  /**
   * Resynchronizes document
   *
   * @param doc Old version of document
   * @param newDoc New version of document
   * @param requestInfo Informations about client request
   */
  private void reSynchronizeStructuredDocument(AnnotDocument doc, AnnotDocument newDoc, RequestInfo requestInfo) {

    if (doc.getContent().equals(newDoc.getContent())) {
      // if new content is a same as old content
      requestInfo.setSyncDocument(doc);  // set informations about synchronization
    } else if (isAnnotationsAffected(doc, newDoc, requestInfo) <= Constants.MAX_ANNOTATION_DIFFERENCE) {
      // if new content is not a same as old content, but annotations aren't affected
      // generate modifications for other clients
      generateTextModificationsToFlier(doc.getContent(), newDoc.getContent(), false, requestInfo);
      doc.setModified(new Date());  // set date of modification
      doc.setContent(newDoc.getContent());  // actualize content of document
      requestInfo.setSyncDocument(doc);  // set informations about synchronization
    } else {  // if new content is not a same as old content and annotations are affected
      // synchronization error
      
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Common resynchronization error (different contents).";
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
      }
      //If protocol version 2 is used, hard resynchronization should attempt
      if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
        String context = "<content><![CDATA[" + doc.getContent() + "]]></content>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_9_SYNC_ERROR_DIFFERENT, context);
      }
      else{
        requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC);
      }
    }
  }  // reSynchronizeDocument()

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

  /**
   * Returns description of this module. It will be part of information about
   * server functions.
   *
   * @param lang Requested language of description
   * @return Description of this module
   */
  @Override
  public String getModuleDescription(int lang) {
    return "Core module perform basic document, types and annotations manipulations.";
  }

  /**
   * Normalizes URI and removes id of session and other mess.
   *
   * @param uri URI to clean up
   * @return Cleaned URI
   */
  public static String cleanUpURI(String uri) throws URISyntaxException {
    URI jUri = new URI(uri);
    // normalize URI
    jUri = jUri.normalize();
    // convert back to string
    String cUri = jUri.toString();

    // find fragment part
    int fIndex = cUri.lastIndexOf("#");
    if (fIndex > 0) {  // if fragment was found, remove it
      cUri = cUri.substring(0, fIndex);
    }

    // find beginning of parameters
    int pIndex = cUri.indexOf('?');
    if (pIndex < 0) {  // if there are no parameters
      return cUri;  // uri is clean
    }

    // Remove unnecessary parameters
    int length = cUri.length();  // get length of string
    int i = pIndex + 1;
    while (i < length && i > 0) {  // traverse URI
      boolean rem = false;  // was parameter removed in this round of cycle?
      int eInd = cUri.indexOf("&", i);  // find end of parameter value
      if (eInd < 0) {  // if it is last parameter
        eInd = length - 1;  // parameter ends at the end of the string
      }
      Iterator<String> pIt = Constants.REM_URI_PARAMS.iterator();
      int sInd = -1;
      while (pIt.hasNext() && sInd != i) {  // for each parameter to bee removed
        String rParam = pIt.next();
        sInd = cUri.indexOf(rParam, i);  // find parameter
      }
      if (sInd == i) {  // if parameter is at the beginning of the string
        rem = true;
        cUri = cUri.substring(0, i) + cUri.substring(eInd + 1, length);  // remove parameter
        length = cUri.length();  // actualize length
      }
      if (!rem) {  // if parameter wasn't removed
        i = cUri.indexOf("&", i) + 1;  // move to beginning of next parameter
      }
    }  // traverse URI

    if (cUri.endsWith("?")) {  // if "&" is at the end, remove it
      cUri = cUri.substring(0, length - 1);
      length--;
    }
    if (cUri.endsWith("&")) {  // if "?" is at the end, remove it
      cUri = cUri.substring(0, length - 1);
    }
    return cUri;
  }  // cleanUpURI()

  // TODO (at global level) Howto make linearization possible:
  // - Implement synchronizeLinearizedDocument() and reSynchronizeLinearizedDocument()
  // - Implement toXMLStringLin() for annotation and use this instead of toXMLString() if linearization is enabled
  // - Implement toXMLStringLin() for TextModification
  // - Add conversions of linearized data to MessageProcessor
  //
  // If linearized document may be handled (without having structured version), there are two possibilities:
  // - Create simple structured document from linearized in synchronization
  // - Make a lot of changes on a lot of places
  //   * @param doc persisted annotated document whether exists, otherwise null
  //   * @param newDoc New version of annotated document
  private void synchronizeLinearizedDocument(AnnotDocument doc, AnnotDocument newDoc, RequestInfo requestInfo) {
    // TODO: Implement required functionality and remove this.
    int langNum = requestInfo.getSession().getLanguageNum();
    int lod = requestInfo.getSession().getProtocolLOD();
    if (lod < Constants.PROTOCOL_LOD_V2) {
      requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC);
      requestInfo.addError(lod, langNum, Localisation.ERROR_100_UNKNOWN_ERROR, "", "Linearization not yet implemented.");
    } else {
      requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC);
      requestInfo.addError(lod, langNum, Localisation.ERROR_99_UNSUPPORTED_OPERATION);
    }
    if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
      String msg = "Attempt to synchronize linearized document (not yet implemented).";
      Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
    }
    // This must be used in this function:
    // requestInfo.getSession().setLinearization(true);
  }

  private void reSynchronizeLinearizedDocument(AnnotDocument doc, AnnotDocument newDoc, RequestInfo requestInfo) {
    // TODO: Implement required functionality and remove this.
    int langNum = requestInfo.getSession().getLanguageNum();
    int lod = requestInfo.getSession().getProtocolLOD();
    requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC);
    requestInfo.addError(lod, langNum, Localisation.ERROR_100_UNKNOWN_ERROR, "", "Linearization not yet implemented.");
    if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
      String msg = "Attempt to resynchronize linearized document (not yet implemented).";
      Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
    }
  }

  /**
   * Generates text modifications and saves them into flier.
   * 
   * @param oldVersion Old version of document against which to generate text modifications.
   * @param newVersion New version of document.
   * @param linearized Specifies whether should be generated linearized text modifications or structured.
   * @param requestInfo Informations about client request
   * @return True on success, false on fail.
   */
  private void generateTextModificationsToFlier(String oldVersion, String newVersion, boolean linearized, RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();

    // TODO: Work with linearized document should be handled separately 
    //       as text modification provider below doesn't support it.
    
    ArrayList<TextModification> tmsUnit;
    try{
      tmsUnit = TextModificationsXMLUnitProvider.getTextModifications
              (oldVersion, newVersion, getLowestProtocolFromSessionList(requestInfo));
    }
    catch(Exception ex){
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, ex.getMessage());
      }
      tmsUnit = new ArrayList<TextModification>();
      tmsUnit.add(new TextModification(XPathHelper.DOCUMENT_XPATH, null, null, newVersion));
    }
    flier.setTextModifications(tmsUnit);
  }
  
  /**
   * Gets the lowest version of the protocol used in
   * the clients where is the actual session document used.
   * @param requestInfo actual requestInfo
   * @return Lowest version of the protocol
   */
  private static int getLowestProtocolFromSessionList(RequestInfo requestInfo){
    EditorSession actualSession = requestInfo.getSession();
    int protocol = actualSession.getProtocolLOD();
    
    ArrayList<EditorSession> sesList = AppBean.getSessions();
    if(sesList != null){
      Iterator<EditorSession> it = sesList.iterator();
      while(it.hasNext()){
        EditorSession ses = it.next();
        if(actualSession.getSyncDocument().getId() == ses.getSyncDocument().getId() && ses.getProtocolLOD() < protocol){
          protocol = ses.getProtocolLOD();
        }
      }
    }
    return protocol;
  }

  /**
   * Updates document with text modifications from request.
   * If update finishes with success, stores text modifications into flier.
   * If update fails, generates reverse text modifications.
   * 
   * @param requestInfo Informations about client request
   * @return String with messages for client or empty string
   */
  private String updateDocument(RequestInfo requestInfo) {
    int langNum = requestInfo.getSession().getLanguageNum();
    int lod = requestInfo.getSession().getProtocolLOD();
    String retStr = "";
    Flier flier = requestInfo.getFlier();
    
    if (requestInfo.getTextModifications().isEmpty()) {
      return retStr;
    }
    
    requestInfo.setDocumentChanged(true);
    EditorSession session = requestInfo.getSession();
    AnnotDocument doc = session.getSyncDocument();
    
    if (doc == null) {
      requestInfo.addError(lod, langNum, Localisation.ERROR_43_NOT_SYNCHRONIZED);
      return retStr;
    }

    int lastModID = 0;
    
    if(doc != null){
      // lock for change
      while(true){
        if(AppBean.getLockMaster().getDocumentLock(doc.getId()).lockForChange()){
          break;
        }
      }
    
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2) {
        lastModID = AppBean.getLastDocModification(doc.getId());
        // If the modification number from the request and the saved modification number for the document are the same
        // Do update
        if (lastModID != requestInfo.getLastModificationNumber()){
          // If they are not the same check similiarity in last three modification set IDs
          // If the sent modification ID is the same with the last three applied modifications
          // then check these modification sets for conflicts
          if(!AppBean.lastModificationSetsContains(doc.getId(), lastModID) || 
                  AppBean.hasModificationSetsConflicts(doc.getId(), lastModID, requestInfo.getTextModifications()))
          {
            // send text modification error and cancel text modifications with error
            AppBean.getLockMaster().getDocumentLock(doc.getId()).unlockForChange();
            String info = "<modification id=\"" + requestInfo.getLastModificationNumber() 
                        + "\" mustApply=\"" + lastModID + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_39_MODIFICATION_NOT_APPLICABLE, info);

            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "An error has occured while trying to apply text modications: modification conflict";
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg, new DocumentUpdateException());
            }
            return retStr;
          }
        }
      }
    }

    //Prepare document for update
    DocumentUpdate docUpdate = new DocumentUpdate(doc.getContent(), session);
    docUpdate.appendModifications(requestInfo.getTextModifications());
    
    boolean failed = false;
    
    try{
      docUpdate.updateDocument();
      doc.setModified(new Date());
      doc.setContent(docUpdate.getDocumentString());
      session.setParsedLinDocument(Linearizer.linearizeDocument(docUpdate.getDocument()));
      try {
        session.setParsedSyncDocument(this.matcherProvider.getDocumentFromString(doc.getContent(), false, true));
      } catch(Exception e){
        langNum = requestInfo.getSession().getLanguageNum(); 
        lod = requestInfo.getSession().getProtocolLOD();
        String info = "<module name=\"" + getModuleName(requestInfo.getSession().getLanguageNum()) + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, info);
        requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "Parsing updated document for the parsed synchronized document failed.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
        }
        return null;  // synchronization failed
      }
      flier.setTextModifications(requestInfo.getTextModifications());
    }
    catch(DocumentUpdateException ex){
      failed = true;
      
      if (ex.getErrorCode() == Localisation.ERROR_36_BAD_DOCUMENT) {
        requestInfo.addError(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT);
        String info;
        if (lod == Constants.PROTOCOL_LOD_V2) {
          info = "<resynchronize resource=\"" + requestInfo.getSession().getSyncDocument().getUri()
                  + "\" method=\"hard\"/>";
        } // Protocol 1.x is used
        else {
          info = "<resynchronize/>";
        }
        requestInfo.getSession().addMessageTS(info);
      }
      
      ArrayList<TextModification> failedReversedMods = ex.getReverseModifications();
      /* 
       * If exception's flag for resync is set, it's needed to inform client to make a resync
       * This is only done if client is using v1.x protocol version
       *
       * NOTE: This is special case of interruption process of text modifications when there was unable to
       * generate reverse modification, so it could not be able to insert it into failedModification list to exception
       * 
       * NOTE: Resynchronization flag can be set only for protocol 1.x
       */
      if(ex.getResyncFlag() && session.getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
        
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          String msg = "Unable to generate reverse text modification.";
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg, ex);
        }
        requestInfo.addError(lod, langNum, Localisation.ERROR_11_SYNC_ERROR_NEED_RESYNC, "<resynchronize/>");
        requestInfo.appendToReply("<resynchronize/>");
      }
      /*
       * If an exception has occured, and client is using protocol v1.x, it's needed to sent to client all failed reverse modifications
       */
      else if(failedReversedMods != null && !failedReversedMods.isEmpty() && session.getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
        Iterator<TextModification> textModIt = failedReversedMods.iterator();
        while(textModIt.hasNext()){
          TextModification tm = textModIt.next();

          //Add modification into client message
          requestInfo.addError(tm.toXMLString());
        }
      }
      /*
       * If modification has failed, and client is using protocol version 2, all already applied modifications are reversed and client is
       * informed that an error has occured
       */
      else if(ex.getErrorMessage() != null && !ex.getErrorMessage().isEmpty()){
        if (ex.getErrorCode() == Localisation.ERROR_105_MODIFICATION_SPECIFICATION) {
          String context = "<modification id=\"" + requestInfo.getLastModificationNumber() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_105_MODIFICATION_SPECIFICATION, context);
        }
        if (ex.getErrorCode() == Localisation.ERROR_33_MODULE_ERROR) {
          String context = "<module name=\"" + getModuleName(langNum) + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, context);
        }
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "An error has occured while trying to apply text modications: " + ex.getErrorMessage();
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg, ex);
        }
      }
    }
    
    if (doc != null && !failed) {
      Integer lastMod = AppBean.incrementLastDocModification(doc.getId());
      if (lastMod == null) {
        String msg = "Unable to increment text modification set ID.";
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
          Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
        }
        requestInfo.addError(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, msg);
      } else {
        flier.setTextModificationSetID(lastMod);
        AppBean.addDocModificationSet(doc.getId(), lastMod, requestInfo.getTextModifications());
      }
    }


    // If modification process was succesfull apply text modifications to another sessions
    if (!failed) {
      synchronized (AppBean.getSessions()) {
      Iterator<EditorSession> sessionsIt = AppBean.getSessions().iterator();
        while (sessionsIt.hasNext()) {  // for each session
          
          EditorSession actualSession = sessionsIt.next();

          if (session != null && flier.getCreatedInSessId() != null
              && flier.getCreatedInSessId() != actualSession.getSessionId()) {  // it is not session in flier

            AnnotDocument currDoc = actualSession.getSyncDocument();

            // Continue whether current document is not synchronized, or is not the same
            if (doc != null && currDoc != null && currDoc.getId() == doc.getId() 
              && requestInfo.getTextModifications() != null && !requestInfo.getTextModifications().isEmpty()) {  // same document

              //Prepare document for update
              DocumentUpdate actDocUpdate = new DocumentUpdate(currDoc.getContent(), actualSession);
              actDocUpdate.appendModifications(requestInfo.getTextModifications());

              try {
                actDocUpdate.updateDocument();
                currDoc.setContent(actDocUpdate.getDocumentString());
                currDoc.setModified(new Date());
                actualSession.setParsedLinDocument(Linearizer.linearizeDocument(actDocUpdate.getDocument()));
                try {
                  actualSession.setParsedSyncDocument(this.matcherProvider.getDocumentFromString(doc.getContent(), false, true));
                } catch(Exception e){
                  langNum = actualSession.getLanguageNum();
                  lod = actualSession.getProtocolLOD();
                  actualSession.addMessageTS(RequestInfo.createErrorMsg(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT));
                  String info = "";
                  if (lod == Constants.PROTOCOL_LOD_V2) {
                    info = "<resynchronize resource=\"" + actualSession.getSyncDocument().getUri()
                            + "\" method=\"hard\"/>";
                  } // Protocol 1.x is used
                  else {
                    info = "<resynchronize/>";
                  }
                  actualSession.addMessageTS(info);
                  if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
                    String msg = "Parsing updated document for the parsed synchronized document while updating other sessions failed.";
                    Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
                  }
                  return null;  // synchronization failed
                }
              } catch (DocumentUpdateException ex) {
                if (ex.getErrorCode() == Localisation.ERROR_36_BAD_DOCUMENT) {
                  langNum = actualSession.getLanguageNum();
                  lod = actualSession.getProtocolLOD();
                  actualSession.addMessageTS(RequestInfo.createErrorMsg(lod, langNum, Localisation.ERROR_36_BAD_DOCUMENT));
                }
                if (ex.getErrorCode() == Localisation.ERROR_33_MODULE_ERROR) {
                  String context = "<module name=\"" + getModuleName(langNum) + "\"/>";
                  actualSession.addMessageTS(RequestInfo.createErrorMsg(lod, langNum, Localisation.ERROR_33_MODULE_ERROR, context));
                }

                if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                  String msg = "Updating of document has failed.";
                  Logger.getLogger(CoreFuncModule.class.getName()).log(Level.ALL, msg);
                }

                String info;
                // Protocol V2 is used
                if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
                  info = "<resynchronize resource=\"" + requestInfo.getSession().getSyncDocument().getUri()
                    + "\" method=\"hard\"/>";
                }
                // Protocol 1.x is used
                else{
                  info = "<resynchronize/>";
                }
                actualSession.addMessageTS(info);
                actualSession.notifyComet();

                continue;
              }
            }  // same document
          } // it is not session in flier
        }  // for each session
      }  // synchronized
    }  // If modification process was succesfull ...

    if(doc != null) {
      if(session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2) {
        retStr = "<modificationApplied id=\"" + (lastModID + 1) + "\"/>";
      }
      // unlock for change
      AppBean.getLockMaster().getDocumentLock(doc.getId()).unlockForChange();
    }
   
    
    return retStr;
  }  // updateDocument()

  /**
   * Gets the user sources
   * 
   * @param user user
   * @return arraylist of strings with sources
   */
  static public ArrayList<String> getUserSources(User user) {
    ArrayList<String> result = new ArrayList<String>();

    if (user.getComeFrom() != null) {
      result.add(user.getComeFrom());
    }

    List<UserGroup> groups = user.getGroups();
    if (groups != null) {
      Iterator groupsIt = groups.iterator();
      while (groupsIt.hasNext()) {
        result.add(((UserGroup) groupsIt.next()).getUri());
      }
    }

    return result;
  }
  
  /**
   * Return all annotations that are related with annotations in list
   * 
   * @param annotations list of annotations to search
   * @return list of related annotations and given annotations
   */
  private ArrayList<Annotation> getRelatedAnnotations(ArrayList<Annotation> annotations){
    ArrayList<Annotation> openList = new ArrayList<Annotation>();
    ArrayList<Annotation> closeList = new ArrayList<Annotation>();
    
    if(!annotations.isEmpty())
    {
      //insert approved annotations
      openList.addAll(annotations);
      while(!openList.isEmpty()){
        //take first from open list
        Annotation first = openList.remove(0);
        //test if first from open is not in close list
        if(!closeList.contains(first)){   
          //get all pointers to first
          openList.addAll(getLinkedAnnotationsDB(first));
          if(!annotations.contains(first)){
            closeList.add(first);
          }
        }
      }

      return closeList;
    }
    
    return openList;
  }
  
  /**
   * Gets annotations for update
   * 
   * @param annotations List of Annotations
   * @param updatedAnnots List of updated Annotations
   * @return empty arraylist
   */
  private ArrayList<Annotation> getAnnotsForUpdate(ArrayList<Annotation> annotations, ArrayList<Annotation> updatedAnnots){
    ArrayList<Annotation> changedList = new ArrayList<Annotation>();

    Iterator<Annotation> annotIt = annotations.iterator();
    while(annotIt.hasNext()){
      Annotation currentAnnot = annotIt.next();      
      //get all annotations parameters that have link parameter that points to currentAnnot
      Object[] params = {"linked", currentAnnot.getId()};
      @SuppressWarnings("unchecked")
      List<LinkedAnnotationAttribute> attrList = AppBean.getPersistenceManager().queryDB("Attribute.findByLinked", params);
      if (attrList != null) {
        Iterator<LinkedAnnotationAttribute> attrIt = attrList.iterator();
        
        //go trough all results and set their values to null
        while(attrIt.hasNext()){
          
          LinkedAnnotationAttribute currentAttr = attrIt.next();
          
          //add annotation that this parameter belongs to changed array
          Annotation annotToAdd = ((BaseAttribute)currentAttr).getRefAnnotation();
          if(!updatedAnnots.contains(annotToAdd)){
            // set attribute to null
            currentAttr.setValue(null);
            updatedAnnots.add(annotToAdd);
          }else{
            // annotation is already in list
            // try to merge current annotation with changed annotation
            Annotation updatedAnnot = updatedAnnots.get(updatedAnnots.indexOf(annotToAdd));
            if(updatedAnnot.getAttributes() != null){
              // go trough all atributes of annotation that is alredy stored in updatedAnnotations list
              Iterator<BaseAttribute> updatedAnnotAttrIt = updatedAnnot.getAttributes().iterator();
              while(updatedAnnotAttrIt.hasNext()){
                BaseAttribute currAttr = updatedAnnotAttrIt.next();
                // compare by IDs
                if(currAttr.getId().equals(currentAttr.getId())){
                  // if finds corresponding attribute, set its value to null
                  currAttr.setValue(null);
                }
              }
            }
          }
        }
      }
    }
    
    //changedList = getLinkedAnnotations(changedList);
    
    return changedList;
  }

  private ArrayList<String> getAllNestedIdentificators(Annotation annot){
      ArrayList<String> result = new ArrayList<String>();
      if(annot.getAttributes() != null){
        Iterator<BaseAttribute> annotAttrIt = annot.getAttributes().iterator();
        while(annotAttrIt.hasNext()){
            BaseAttribute currentBaseAttr = annotAttrIt.next();
            if(currentBaseAttr.getNestedAnnotation() != null){
                if(!result.contains(currentBaseAttr.getNestedAnnotation().getURIV2())){
                    result.add(currentBaseAttr.getNestedAnnotation().getURIV2());
                }
            }
        }
      }
      return result;
  }
  
  /**
   * Update all annotations with relationships to given approved annotations in list.
   * 
   * @param approvedAnnotations list of approved annotations
   * @return list of related annotations and given annotations
   */
  private ArrayList<Annotation> getLinkedAnnotations(ArrayList<Annotation> approvedAnnotations){
    ArrayList<Annotation> openList = new ArrayList<Annotation>();
    ArrayList<Annotation> closeList = new ArrayList<Annotation>();
    
    if(!approvedAnnotations.isEmpty())
    {
      //insert approved annotations
      openList.addAll(approvedAnnotations);
      while(!openList.isEmpty()){
        //take first from open list
        Annotation first = openList.remove(0);
        //test if first from open is not in close list
        if(!closeList.contains(first)){   
          //get all pointers to first
          openList.addAll(getLinkedAnnotationsDB(first));
          closeList.add(first);
        }
      }

      return closeList;
    }
    
    return approvedAnnotations;
  }
  
  /**
   * Gets linked annotation attributes from db which links input annotation
   * 
   * @param annot input annotations
   * @return arraylist of linked annotations
   */
  public static ArrayList<Annotation> getLinkedAnnotationsDB(Annotation annot) {
    ArrayList<Annotation> innerAnnotationList = new ArrayList<Annotation>();
    Object[] params = {"linked", annot.getId()};
    @SuppressWarnings("unchecked")
    List<LinkedAnnotationAttribute> attrList = AppBean.getPersistenceManager().queryDB("Attribute.findByLinked", params);
    if (attrList != null) {
      Iterator<LinkedAnnotationAttribute> attrIt = attrList.iterator();

      while (attrIt.hasNext()) {
        LinkedAnnotationAttribute linkedAttr = attrIt.next();
        Annotation dbAnnot = (Annotation) AppBean.getPersistenceManager().getEntityById("Annotation", linkedAttr.getAnnotation());
        if (dbAnnot != null) {
          innerAnnotationList.add(dbAnnot);
        }
      }
    }
    return innerAnnotationList;
  }

  /**
   * Returns difference of the annotation lists ( A / B ).
   * 
   * @param annotListA List A
   * @param annotListB List B
   * @return Difference
   */
  public static ArrayList<Annotation> getDifference(ArrayList<Annotation> annotListA, ArrayList<Annotation> annotListB) {
    ArrayList<Annotation> result = new ArrayList<Annotation>();
    Iterator<Annotation> iteratorA = annotListA.iterator();
    while (iteratorA.hasNext()) {
      Annotation actualAnnot = iteratorA.next();
      Iterator<Annotation> iteratorB = annotListB.iterator();
      boolean isInB = false;
      while (iteratorB.hasNext()) {
        if (actualAnnot.getId().equals(iteratorB.next().getId())) {
          isInB = true;
        }
      }
      if(!isInB){
        result.add(actualAnnot);
      }
    }

    return result;
  }

  /**
   * Return all annotations that are related with annotations in lists for session in parameter
   * (not related only to approvedAnnot list but also to something to which is user subscribed)
   * 
   * @param approvedAnnot approved annotation list
   * @param unapprovedAnnot unapproved annotation list
   * @param session session
   * @return list of related annotations and given annotations
   */
  public static ArrayList<Annotation> getRelatedAnnotations(ArrayList<Annotation> approvedAnnot, ArrayList<Annotation> unapprovedAnnot, EditorSession session) {
    ArrayList<Annotation> result = new ArrayList<Annotation>();
    Iterator<Annotation> unapprovedIt = unapprovedAnnot.iterator();

    // we will inspect unapproved annotations one by one
    while (unapprovedIt.hasNext()) {
      // annotations that will be tested will be in this list
      ArrayList<Annotation> openList = new ArrayList<Annotation>();
      // there will be annotations after test
      ArrayList<Annotation> closedList = new ArrayList<Annotation>();
      // We will put just inspected annotation into the openList. Then it will 
      // be removed and put to the start of the closedList where it will remain.
      openList.add(unapprovedIt.next());

      // Now we will be searching approved annotation which is directly 
      // or indirectly linking inspected one.
      while (!openList.isEmpty()) {
        Annotation actualAnnot = openList.remove(0);
        closedList.add(actualAnnot);

        if (session.isSubscribed(actualAnnot, getUserSources(actualAnnot.getUser()))) {
          // We found something which is directly or indirectly linking inspected one 
          // and for which is user subscribed. We do not know whether the subscribed 
          // one is in approvedAnnot list but we need to be sure that user gets all what 
          // he need so we should approve inspected one (it is related with approved 
          // or with something other which user potentially have). 

          // The inspected annotation is inserted on the first place in the list
          // and it is considered a resulting related annotation that is somehow
          // linked by some annotation that matches the user's subscription list
          // so we add inspected one to the resulting list.
          result.add(closedList.get(0));
          // after the subscribtion status is confirmed (inspected annotation 
          // is approved) it is not necessary to inspect another related annotations 
          // which are linking inspected one and potentially can conform user's subscriptions 
          break;
        } else {
          // Get annotations which are linking actual annotation, then get annotatinos 
          // that are not in close list then in open list.
          // On the end is in annotForAdd list only annotations that linked 
          // at actual annotation and they ar not in close and open list.
          ArrayList<Annotation> annotForAdd = getDifference(getDifference(getLinkedAnnotationsDB(actualAnnot), closedList), openList);
          openList.addAll(annotForAdd);
        }
      }
    }

    if(approvedAnnot == null){
      return result;
    }
    
    approvedAnnot.addAll(result);
    return approvedAnnot;
  }

  /**
   * Checks all AnnotationLink attributes for values and updates refferences if
   * attribute value is null and tmpId value of attribute != null.
   *
   * @param annot Annotation for check.
   * @param requestInfo Informations about client request
   */
  private void updateAnnotationLinks(Annotation annot, RequestInfo requestInfo) {
    ArrayList<SuggestionLogEntry> suggested = requestInfo.getConfirmedSuggestions();

    List attr = annot.getAttributes();
    Iterator it = attr.iterator();
    while (it.hasNext()) { // for all attributes of Annotation
      BaseAttribute currAttr = (BaseAttribute) it.next();
      if (currAttr.getSimpleType().equals("AnnotationLink") && currAttr.getValue() == null) {
        String tmpId = ((LinkedAnnotationAttribute) currAttr).getTmpId();
        boolean found = false;
        if (tmpId != null) {
          Iterator<SuggestionLogEntry> suggIt = suggested.iterator();
          while (suggIt.hasNext() && !found) {
            SuggestionLogEntry curSug = suggIt.next();
            if (curSug.getTmpId().equals(tmpId)) {
              Annotation annotHit = curSug.getConfirmedVersion();
              if (annotHit != null) {
                currAttr.setValue(annotHit);
                if(annotHit != null){
                  currAttr.setAttributeType(annotHit.getAnnotType());
                }
                found = true;
              }
            }
          }
          if (found == false) { // Attribute with right tmpId wasn't found.
            it.remove();
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            if (lod < Constants.PROTOCOL_LOD_V2) {
              requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE);
            } else {
              String info = "<attribute annotationUri=\"" + annot.getURIV2() 
                          + "\" uri=\"" + currAttr.getUriInOntology() 
                          + "\" name=\"" + currAttr.getName() 
                          + "\" valueType=\"" + currAttr.getValueType() 
                          + "\" type=\"" + currAttr.getTypeUriV2() + "\"/>";
              requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
            }
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
              String msg = "Annonation link wasn't found. TmpId = " + tmpId + " .";
              Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
            }
          }
        }
      } else if (currAttr.getSimpleType().equals("NestedAnnotation") && currAttr.getValue() != null) {
        updateTmpIdRefInNested(currAttr.getNestedAnnotation(), requestInfo);
      }
    } // for all attributes of Annotation
  } // checkAnnotationLinks()

  /**
   * Recursively Checks all AnnotationLink attributes in NestedAnnotations for
   * values and updates refferences if attribute value is null and tmpId value
   * of attribute != null.
   *
   * @param nestedAnn Nested Annotation link
   * @param requestInfo Informations about client request
   */
  private static void updateTmpIdRefInNested(Annotation nestedAnn, RequestInfo requestInfo) {
    ArrayList<SuggestionLogEntry> suggested = requestInfo.getConfirmedSuggestions();

    List<BaseAttribute> attr = nestedAnn.getAttributes();
    Iterator<BaseAttribute> aIt = attr.iterator();
    while (aIt.hasNext()) {  // for each attribute
      BaseAttribute attribute = aIt.next();
      if (attribute.getSimpleType().equals("AnnotationLink")
              && ((LinkedAnnotationAttribute) attribute).getValue() == null
              && ((LinkedAnnotationAttribute) attribute).getTmpId() != null) {
        Iterator<SuggestionLogEntry> suggIt = suggested.iterator();
        String tmpId = ((LinkedAnnotationAttribute) attribute).getTmpId();
        boolean found = false;
        while (suggIt.hasNext() && !found) {
          SuggestionLogEntry curSug = suggIt.next();
          if (curSug.getTmpId().equals(tmpId)) {
            Annotation annotHit = curSug.getConfirmedVersion();
            if (annotHit != null) {
              attribute.setValue(annotHit);
              if(annotHit != null){
                attribute.setAttributeType(annotHit.getAnnotType());
              }
              found = true;
            }
          }
        }
        if (found == false) { // Attribute with right tmpId wasn't found.
          aIt.remove();
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          if (lod < Constants.PROTOCOL_LOD_V2) {
            requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE);
          } else {
            String info = "<attribute annotationUri=\"" + nestedAnn.getURIV2() 
                        + "\" uri=\"" + attribute.getUriInOntology() 
                        + "\" name=\"" + attribute.getName() 
                        + "\" valueType=\"" + attribute.getValueType() 
                        + "\" type=\"" + attribute.getTypeUriV2() + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
          }
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Annonation link wasn't found.";
            Logger.getLogger(CoreFuncModule.class.getName()).log(Level.SEVERE, msg);
          }
        }
      } else if (attribute.getSimpleType().equals("NestedAnnotation") && attribute.getNestedAnnotation() != null) {
        updateTmpIdRefInNested(attribute.getNestedAnnotation(), requestInfo);
      }
    }  // for each attribute
  } // updateTmpIdRefInNested
  
  /**
   * If document can be modified by this request, returns true, false otherwise
   * 
   * @param requestInfo Informations about client request
   * @return If document can be modified by this request, returns true, false otherwise
   */
  private boolean canBeDocumentModified(RequestInfo requestInfo) {
    if (requestInfo.getFlier() != null) {
      if (requestInfo.getFlier().getTextModifications() != null && !requestInfo.getFlier().getTextModifications().isEmpty()) {
        return true;
      }
    }
    if (requestInfo.getResyncDocContent() != null) {
      return true;
    }
    if (requestInfo.getSyncDocumentData() != null) {
      return true;
    }
    return false;
  }  // canBeDocumentModified()
  
}  // class CoreFuncModule