P2SuggestionProcessor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Jaroslav Dytrych, Martin Petr
 * File: P2SuggestionProcessor.java
 * Description: Class which process XML elements with messages related 
 *              to suggestions in 4A protocol v 2.0
 */

/**
 * @file P2SuggestionProcessor.java
 *
 * @brief Class which process messages related to suggestions in protocol v 2.0
 */
package cz.vutbr.fit.knot.annotations.comet.protocolV2_0;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.PersistM;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.SuggestionLogEntry;
import static cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2AnnotBaseProcessor.getUriType;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.Fragment;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.BooleanAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.LinkedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.NestedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SECAPISuggestionTranslator;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.Suggestion;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionFeedback;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionManager;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugAttributeManager;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugBaseAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugLinkedAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugNestedAttribute;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

/**
 * Class which process XML elements with messages related to suggestions 
 * in 4A protocol v 2.0
 * 
 * @brief Class which process messages related to suggestions in protocol v 2.0
 * @author Martin Petr, Jaroslav Dytrych
 */
public class P2SuggestionProcessor extends P2AnnotBaseProcessor {
  
  /**
   * Method for processing of message with query for suggestions
   * 
   * @param suggQueryEl Element with message
   * @param requestInfo Informations about client request
   */
  public void processSuggestionQuery(Element suggQueryEl, RequestInfo requestInfo) {
    // get minimal confidence attribute
    String minConfidenceStr = suggQueryEl.getAttribute("minConfidence");
    if(minConfidenceStr == null || minConfidenceStr.isEmpty()){
      // error - minimal confidence attribute is required
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_95_MISSING_CONFIDENCE);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't found minimal confidence attribute in request.";
        Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
      }
    }
    
    // convert to string with value to intege
    Integer minConfidence;
    try{
      minConfidence = Integer.parseInt(minConfidenceStr);
    } catch(NumberFormatException ex){
      // error - bad format of minimal confidence
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_95_MISSING_CONFIDENCE);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't decode minConfidence value. Value is: " + minConfidenceStr;
        Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    Integer autoConfirm = null;
    // get autoconfirm attribute
    String autoConfirmStr = suggQueryEl.getAttribute("autoConfirm");
    if (autoConfirmStr != null && !autoConfirmStr.isEmpty()) {
      try {
        autoConfirm = Integer.parseInt(autoConfirmStr);
      } catch (NumberFormatException ex) {
        // error - bad format of autoConfirm
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        requestInfo.addError(lod, langNum, Localisation.ERROR_107_BAD_AUTOCONFIRM);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Can't decode autoConfirm value. Value is: " + autoConfirmStr;
          Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
    }
    
    ArrayList<Fragment> fragments = new ArrayList<Fragment>();
    NodeList fragmentsElems = suggQueryEl.getElementsByTagName("fragments");
    Element fragmentsEl = (Element) fragmentsElems.item(0);
    if(fragmentsEl != null) {
      // fragments are presented
      fragments = processSuggFragments(fragmentsEl,requestInfo);
      if(fragments == null || fragments.isEmpty()){
        // error occured (error message is printed by processSuggFragments())
        return;
      }
    } else {  // fragments element is not presented, create special fragment for whole document
      fragments.add(new Fragment("", null, null));
    }
    
    ArrayList<String> typesUris = null;
    NodeList suggTypesElems = suggQueryEl.getElementsByTagName("types");
    Element suggTypesEl = (Element) suggTypesElems.item(0);
    if(suggTypesEl != null) {
      typesUris = processSuggTypes(suggTypesEl,requestInfo);
      if(typesUris == null || typesUris.isEmpty()){
        // error occured (error message is printed by processSuggTypes())
        return;
      }
    }
    
    if(autoConfirm == null){
        requestInfo.setAutoconfirmRequested(false);
    }else{
        requestInfo.setAutoconfirmRequested(true);
    }
    
    requestInfo.getSession().setAutoConfirm(autoConfirm);
    requestInfo.getSession().setMinConfidence(minConfidence);
    requestInfo.getSession().setSuggestionsFr(fragments);
    requestInfo.getSession().setSuggestionsTypes(typesUris);
    requestInfo.setSuggFragmentChanged(true);
    if (requestInfo.getSession() != null) {
      requestInfo.getSession().setSugRequestFlag(Boolean.TRUE);
    }
    
    if (autoConfirm != null && autoConfirm > 0 && autoConfirm <= 100) {  // reasonable is 1 - 100%
      processSuggestionAutoConfirm(autoConfirm, requestInfo);
    }
  }  // processSuggestionQuery()
  
  /**
   * Method for processing of message with confirmation of suggestions
   * 
   * @param suggConfirmEl Element with message
   * @param requestInfo Informations about client request
   */
  public void processSuggestionConfirm(Element suggConfirmEl, RequestInfo requestInfo) {
    ArrayList<Suggestion> allSuggest;
    if (requestInfo.getSession().getDefaultGroup() == null) {
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, requestInfo.getSession().getLanguageNum(), Localisation.ERROR_97_NOT_IN_GROUP);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "User is not in any group.";
        Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.SEVERE, msg);
      }
      return;
    } else {  // if user is in any group
      allSuggest = SuggestionManager.getSuggestionsFromDB(requestInfo.getSession().getSyncDocument().getId());
      ArrayList<Suggestion> updatedSuggs = new ArrayList<Suggestion>();
      ArrayList<Suggestion> removedSug = getSuggestionWithoutFeedback(requestInfo, allSuggest, updatedSuggs);
      ArrayList<Suggestion> rSug = SuggestionManager.getNestedSuggFromToDelete(allSuggest, removedSug);
      updatedSuggs.addAll(cutRefusedSuggLinks(allSuggest, rSug));
      
      // now we should have same list of Suggestions as in SuggestionManager 
      // so we know, what client see
      
    }  // if user is in any group
    
    
    // get all confirmed suggestion
    NodeList confirmedElems = suggConfirmEl.getElementsByTagName("suggestion");
    HashMap<String,Annotation> confirmedSuggestions = new HashMap<String,Annotation>();
    ArrayList<Annotation> annotList = new ArrayList<Annotation>();
    
    for(int index = 0; index < confirmedElems.getLength(); index ++){
      Element suggEl = (Element) confirmedElems.item(index);
      if(suggEl != null){

        String suggModified = suggEl.getAttribute("modified");
        if (suggModified == null && suggModified.isEmpty()) {
          //error - can't find information about modification in suggestion
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String suggUri = suggEl.getAttribute("uri");
          if (suggUri == null) {
            NodeList annotsElems = suggEl.getElementsByTagName("oa:Annotation");
            Element annotEl = (Element) annotsElems.item(0);
            if (annotEl != null) {
               suggUri = annotEl.getAttribute("rdf:about");
            }
          }
          if (suggUri == null) {
            suggUri = "";
          }
          String info = "<suggestion uri=\"" + suggUri + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_28_BAD_CONFIRM, info);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can't find information about modification in suggestion. Suggestion is not comfirmed. Index: " + Integer.toString(index);
            Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
          }
          continue;
        }
        
        boolean modified = Boolean.valueOf(suggModified);
        
        SuggestionLogEntry logEntry;
        
        if (modified) {
          NodeList annotsElems = suggEl.getElementsByTagName("oa:Annotation");
          Element annotEl = (Element) annotsElems.item(0);
          if (annotEl != null) {
            Annotation newAnnotation = processAnnotation(annotEl, requestInfo);
            if (newAnnotation != null) {
              // here I have annotation
              String idString = newAnnotation.getTmpId();

              logEntry = new SuggestionLogEntry(idString);
              logEntry.setConfirmedVersion(newAnnotation);
              requestInfo.getFlier().AddAddedAnnotation(newAnnotation);
              logEntry.setConfirmMethod(Constants.CONFIRMED_MANUALLY_EDITED);
              
              confirmedSuggestions.put(newAnnotation.getTmpId(),newAnnotation);
              annotList.add(newAnnotation);
              
            } else {
              // can't parse annotation
              return;
            }
          } else {
            // error - there MUST be an annotation
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String suggUri = suggEl.getAttribute("uri");
            if (suggUri == null) {
              suggUri = "";
            }
            String info = "<suggestion uri=\"" + suggUri + "\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_103_MISSING_MODIFIED_SUG, info);
            if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "There isn't oa:Annotation element in suggestion element of suggestion confirmation.";
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
            return;
          }
        } else {
          String suggUri = suggEl.getAttribute("uri");
          if(suggUri == null && suggUri.isEmpty()){
            //error - can't find uri of confirmed suggestion
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            String info = "<suggestion uri=\"\"/>";
            requestInfo.addError(lod, langNum, Localisation.ERROR_28_BAD_CONFIRM, info);
            if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Can't find URI of confirmed suggestion. URI of confirmed suggestion is required.";
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
            return;
          }
          
          String idString = suggUri.replace(AppBean.getBaseUri() + "/sugg/","");
          logEntry = new SuggestionLogEntry(idString);
          logEntry.setConfirmMethod(Constants.CONFIRMED_MANUALLY);
        }
        
        // find suggestion
         
        if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
          Integer id = null;
          try {
            id = Integer.parseInt(logEntry.getTmpId());
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "The ID of the confirmed suggestion is not a number: " + logEntry.getTmpId();
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
          // ID was parsed successfuly and the ID is contained within sended suggestions
          if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {

            Suggestion sended = SuggestionManager.getSuggestionFromList(id, allSuggest);
            if (sended == null) {
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                String msg = "Unable to confirm suggestion with id = " + id + ". Suggestion with this id is not found in sended suggestions list.";
                Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
              }
              continue;  // not found - imposssible to confirm
            }

            Annotation sendedSug = new Annotation();
            sendedSug.setTmpId(logEntry.getTmpId());
            sendedSug.updateWithSuggestion(sended);
            sendedSug.setUser(requestInfo.getSession().getUser());
            sendedSug.setAuthorIdStr(requestInfo.getSession().getUser().getURIV2());
            sendedSug.setAuthorAddress(requestInfo.getSession().getUser().getEmail());
            sendedSug.setAuthorName(requestInfo.getSession().getUser().getName());
            sendedSug.setCreated(new Date());
            // set informations about confirmation
            confirmedSuggestions.put(sended.getURIV2(), sendedSug);
            annotList.add(sendedSug);
            if (logEntry.getConfirmedVersion() == null) {
              logEntry.setConfirmedVersion(sendedSug);
              requestInfo.getFlier().AddAddedAnnotation(sendedSug);
            }
            if (!modified && requestInfo.getSession().getKBRefMode()) {
              BaseAttribute uAAt = new BooleanAttribute(Constants.UPDATABLE_AN_AT_NAME, true, sendedSug);
              sendedSug.getAttributes().add(uAAt);
            }
            logEntry.setSuggestion(sendedSug);
            // add to list of confirmed suggestions
            if (!requestInfo.getConfirmedSuggestions().contains(logEntry)) {
              requestInfo.addConfirmedSuggestion(logEntry);
            }
          } else { // the suggestion's not been found
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Suggestion with the following ID not found: " + logEntry.getTmpId();
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
        }
      }
    }
    connectAnnotations(annotList,confirmedSuggestions,requestInfo);
    
    if (requestInfo.getSession().getEnableUpdatePositiveFeedback()) {
      updatePositiveFeedback(requestInfo);
    }
  }  // processSuggestionConfirm()
  
  /**
   * Method for updating positive feedback
   * Automatically cnfirms other similar (same annotated text and URI of entity) 
   * suggestions in the same part of document.
   * 
   * @param requestInfo Informations about client request
   * @return Automatically onfirmed suggestions
   */
  private ArrayList<SuggestionLogEntry> updatePositiveFeedback(RequestInfo requestInfo) {
    ArrayList<SuggestionLogEntry> suggLog = requestInfo.getConfirmedSuggestions();
    Integer groupId = requestInfo.getSession().getDefaultGroup().getId();

    ArrayList<SuggestionLogEntry> addToLog = new ArrayList<SuggestionLogEntry>();
    
    ArrayList<Suggestion> allSugg = requestInfo.getSession().getWholeSendedSuggestions();
    if (allSugg != null && !allSugg.isEmpty()) {  // if there are some sended suggestions
      HashMap<Integer, ArrayList<SuggestionFragment>> sugToLinFragments = new HashMap<Integer, ArrayList<SuggestionFragment>>();
      SECAPISuggestionTranslator.linearizeSuggestions(sugToLinFragments, requestInfo.getSession().getParsedSyncDocument(), allSugg);
      ArrayList<Integer> separators = findSeparators(requestInfo.getSession().getParsedLinDocument());
      int docLength = requestInfo.getSession().getParsedLinDocument().length();
      
      Iterator<SuggestionLogEntry> confSugIt = suggLog.iterator();
      while (confSugIt.hasNext()) {  // for each confirmed suggestion
        SuggestionLogEntry confSugLogEntry = confSugIt.next();

        // get confirmed suggestion's annotated text
        Integer confirmedSuggestionId = Integer.parseInt(confSugLogEntry.getTmpId());
        Suggestion confirmedSuggestion = getSuggestionFromDB(confirmedSuggestionId);
        ArrayList<SuggestionFragment> suggFragList = confirmedSuggestion.getFragmentsAL();
        AnnotType confirmedSuggType = confirmedSuggestion.getAnnotType();

        // get confirmedURI
        String confirmedURI = confirmedSuggestion.getSAEntityIdentifier();
        if (confirmedURI != null && !confirmedURI.isEmpty()) {  // if there is URI of Entity
          if (suggFragList != null && !suggFragList.isEmpty()) {  // if suggestion have at least one fragment
            if (suggFragList.size() >= 2) {
              Collections.sort(suggFragList, new SuggestionFragmentComp());
            }
            
            // find separators for current suggestion
            int leftSep = 0;
            int rightSep = docLength;
            Integer curOffset = null;
            ArrayList<SuggestionFragment> frags = sugToLinFragments.get(confirmedSuggestionId);
            SuggestionFragment frag;
            if (frags != null && !frags.isEmpty()) {
              frag = frags.get(0);
            } else {
              frag = null;  // no fragments - maybe it is for whole document
            }
            if (frag != null) {
              curOffset = frag.getOffset();
              Iterator<Integer> sepIt = separators.iterator();
              while (sepIt.hasNext()) {
                Integer s = sepIt.next();
                if (s < curOffset && leftSep < s) {
                  leftSep = s;
                }
                if (s > curOffset && s < rightSep) {
                  rightSep = s;
                }
              }
            }
            
            Iterator<Suggestion> allSuggIt = allSugg.iterator();
            while (allSuggIt.hasNext()) {  // for each sended suggestion
              Suggestion actualSugg = allSuggIt.next();
              
              // Find offset for comparison with separators
              frags = sugToLinFragments.get(actualSugg.getId());
              if (frags != null && !frags.isEmpty()) {
                frag = frags.get(0);
              } else {
                frag = null;
              }
              if (frag != null) {
                curOffset = frag.getOffset();
              } else {
                curOffset = null;
              }
              
              // condition to ensure that sugg. are the same type and sugg. with the same id will be skipped 
              Integer actualSuggId = actualSugg.getId();
              AnnotType actualSuggType = actualSugg.getAnnotType();
              String actualURI = actualSugg.getSAEntityIdentifier();
              if (actualSuggId != null && confirmedSuggestionId != null && !actualSuggId.equals(confirmedSuggestionId)
                      && actualSuggType != null && confirmedSuggType != null && actualSuggType.equals(confirmedSuggType)
                      && actualURI != null && confirmedURI.equals(actualURI)) {
                // if it is not same suggestion but have same type and SEC API Entity URI
                ArrayList<SuggestionFragment> tmpFragList = actualSugg.getFragmentsAL();
                if (tmpFragList.size() >= 2) {
                  Collections.sort(tmpFragList, new SuggestionFragmentComp());
                }
                // check whether both suggestion fragment lists have the same amount of fragments
                if (tmpFragList.size() == suggFragList.size()) {
                  Iterator<SuggestionFragment> tmpFragListIt = tmpFragList.iterator();
                  Iterator<SuggestionFragment> suggFragListIt = suggFragList.iterator();
                  Boolean errFlag = false;
                  // condition to check if !tmpFragList.isEmpty() is not needed
                  while (tmpFragListIt.hasNext()) {
                    // same annotated text
                    SuggestionFragment tmpFrag1 = tmpFragListIt.next();
                    SuggestionFragment tmpFrag2 = suggFragListIt.next();
                    if (!(tmpFrag1.getAnnotatedText()).equals(tmpFrag2.getAnnotatedText())) {
                      errFlag = true;
                      break;
                    }
                    // different path and offset
                    String path1 = tmpFrag1.getPath();
                    String path2 = tmpFrag2.getPath();
                    if (path1 != null && path2 != null && path1.equals(path2)) {
                      Integer offset1 = tmpFrag1.getOffset();
                      Integer offset2 = tmpFrag2.getOffset();
                      if (offset1 != null && offset2 != null && offset1.equals(offset2)) {
                        errFlag = true;
                        break;
                      }
                    }
                  }
                  if (curOffset != null) {
                    if (curOffset < leftSep || curOffset > rightSep) {
                      errFlag = true;  // out of borders given by separators
                    }
                  }
                  if (haveNestedOrLinked(actualSugg)) {
                    errFlag = true;  // this feature is not allowed if there are nested or linked attributes
                  }
                  if (!errFlag) {
                    SuggestionLogEntry tmpLogEntry = new SuggestionLogEntry((actualSugg.getId()).toString());
                    Annotation sendedSug = new Annotation();
                    sendedSug.setTmpId(tmpLogEntry.getTmpId());
                    sendedSug.updateWithSuggestion(actualSugg);
                    sendedSug.setUser(requestInfo.getSession().getUser());
                    sendedSug.setAuthorIdStr(requestInfo.getSession().getUser().getURIV2());
                    sendedSug.setAuthorAddress(requestInfo.getSession().getUser().getEmail());
                    sendedSug.setAuthorName(requestInfo.getSession().getUser().getName());
                    sendedSug.setCreated(new Date());
                    tmpLogEntry.setConfirmedVersion(sendedSug);
                    tmpLogEntry.setConfirmMethod(Constants.CONFIRMED_AUTOMATICALLY);
                    addToLog.add(tmpLogEntry);
                    requestInfo.getFlier().AddAddedAnnotation(sendedSug);
                    requestInfo.addAutoconfirmedSuggestion(tmpLogEntry);
                  }
                }
              } // if it is not same suggestion but have same type and SEC API Entity URI
            }  // for each sended suggestion
          }  // if suggestion have at least one fragment
        }  // if there is URI of Entity
      }  // for each confirmed suggestion
    }  // if there are some sended suggestions
    
    suggLog.addAll(addToLog);  // add additional suggestions found
    
    return addToLog;
  }  // updatePositiveFeedback()
  
  /**
   * Method loads suggestion specified by id from the database.
   * 
   * @param id id that specify suggestions
   * @return querried suggestion or null if suggestion isn't found
   */
  public static Suggestion getSuggestionFromDB(Integer id){
    Object[] params = {"id",id};
    @SuppressWarnings("unchecked")
    List<Suggestion> suggestionList = AppBean.getPersistenceManager().queryDB("Suggestion.findById",params);
    if(suggestionList != null && !suggestionList.isEmpty()){
      return suggestionList.get(0);
    }
    
    return null;
  }
  
  /**
   * Class which implements Comparator to sort arrayList of SuggestionFragment alphabetically
   * 
   * @brief Class which implements Comparator to sort arrayList of SuggestionFragment alphabetically
   */
  class SuggestionFragmentComp implements java.util.Comparator<SuggestionFragment>{

    /**
     * Compares two fragments according to offset and length
     * 
     * @param frag1 First fragment
     * @param frag2 Second fragment
     * @return Returns a negative integer, zero, or a positive integer as first 
     *         fragment is less than, equal to, or greater than the second fragment. 
     */
    @Override
    public int compare(SuggestionFragment frag1, SuggestionFragment frag2){
      return (frag1.getAnnotatedText()).compareTo(frag2.getAnnotatedText());
    }
  }
  
  /**
   * Finds offsets of all ocurrences of refuse border separator in linearized 
   * document (separators are defined in Constants)
   * 
   * @param doc Linearized document
   * @return Returns offsets of separators
   */
  private static ArrayList<Integer> findSeparators(String doc) {
    ArrayList<Integer> result = new ArrayList<Integer>();
    Iterator<String> sepIt = Constants.REFUSE_BORDER_SEPARATOR.iterator();
    while (sepIt.hasNext()) {
      String sep = sepIt.next();
      int offset = doc.indexOf(sep);
      while (offset >= 0) {
        result.add(offset);
        offset = doc.indexOf(sep, offset + 1);
      }
    }
    Collections.sort(result);
    return result;
  }  // findSeparators()
  
  /**
   * Checks whether suggestion have some linked or nested attributes
   * 
   * @param sug Suggestion to check
   * @return Returns whether suggestion have some linked or nested attributes
   */
  private boolean haveNestedOrLinked(Suggestion sug) {
    if (sug.getAttributes() == null) {
      return false;
    }
    Iterator<SugBaseAttribute> sAttIt = sug.getAttributes().iterator();
    while (sAttIt.hasNext()) {
      SugBaseAttribute at = sAttIt.next();
      if (at instanceof SugLinkedAttribute || at instanceof SugNestedAttribute) {
        return true;
      }
      if (at.getSimpleType() != null && (at.getSimpleType().equalsIgnoreCase("linkedSuggestion") 
          || at.getSimpleType().equalsIgnoreCase("nestedSuggestion") 
          || at.getSimpleType().equalsIgnoreCase("linkedAnnotation") 
          || at.getSimpleType().equalsIgnoreCase("nestedAnnotation"))) {
        // it is possible that instance is not good so it is better to do second check
        return true;
      }
    }
    
    return false;
  }  // haveNestedOrLinked()
  
  /**
   * Process request to automatically confirm the suggestions (part of request 
   * for suggestions)
   * 
   * Dependencies with lower confidence are also confirmed!
   * 
   * @param minConfidence Minimal confidence to automatically confirm suggestion
   * @param requestInfo Informations about client request
   */
  public void processSuggestionAutoConfirm(Integer minConfidence,RequestInfo requestInfo){
    if (requestInfo.getSession().getDefaultGroup() == null) {
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, requestInfo.getSession().getLanguageNum(), Localisation.ERROR_97_NOT_IN_GROUP);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "User is not in any group.";
        Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.SEVERE, msg);
      }
      return;
    }

    EditorSession session = requestInfo.getSession();
    
    ArrayList<Suggestion> allSuggest = SuggestionManager.getSuggestionsFromDB(requestInfo.getSession().getSyncDocument().getId());
    if (allSuggest == null || allSuggest.isEmpty()) {
      // Error - suggestions are not ready (it is necessary to try it later)
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_101_SUGGESTIONR_NOT_READY);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Suggestions are not ready (it is necessary to try it later).";
        Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    ArrayList<Suggestion> filteredSuggest = new ArrayList<Suggestion>(allSuggest);
    SuggestionManager.filtrateSuggestions(requestInfo, session, filteredSuggest);
    ArrayList<Suggestion> shouldHave = SuggestionManager.addAllDependencies(filteredSuggest, allSuggest);
    ArrayList<Suggestion> updatedSuggs = new ArrayList<Suggestion>();
    ArrayList<Suggestion> removedSug = getSuggestionWithoutFeedback(requestInfo, shouldHave, updatedSuggs);
    ArrayList<Suggestion> rSug = SuggestionManager.getNestedSuggFromToDelete(shouldHave, removedSug);
    updatedSuggs.addAll(cutRefusedSuggLinks(shouldHave, rSug));
    ArrayList<AnnotType> newTypes = new ArrayList<AnnotType>();
    SuggestionManager.checkTypes(session, shouldHave, newTypes, true);
    SuggestionManager.persistTypes(newTypes);
    // message with types
    String msgTypes = SuggestionManager.printTypes(requestInfo, session, newTypes);
    // send types to others
    SuggestionManager.sendToOthers(requestInfo, msgTypes);
    
    // Here we should have list of suugestions which client can get according to 
    // just received request
      
    // get IDs of all confirmed suggestions
    ArrayList<Suggestion> allConfSugs = new ArrayList<Suggestion>();

    Iterator<Suggestion> shouldHaveIt = shouldHave.iterator();
    while (shouldHaveIt.hasNext()) {
      Suggestion sug = shouldHaveIt.next();
      if (sug == null) {
        continue;
      }
      if (sug.getConfidence() < minConfidence) {
        continue;
      }
      allConfSugs.add(sug);
    }
    
    // Add dependencies with lower confidence
    allConfSugs = SuggestionManager.addAllDependencies(allConfSugs, shouldHave);

    HashMap<String,Annotation> confirmedSuggestions = new HashMap<String,Annotation>();
    ArrayList<Annotation> annotList = new ArrayList<Annotation>();

    Iterator<Suggestion> confSugIt = allConfSugs.iterator();
    while (confSugIt.hasNext()) {
      Suggestion sended = confSugIt.next();
      Integer id = sended.getId();
      String idString = id.toString();
              
      SuggestionLogEntry logEntry = new SuggestionLogEntry(idString);
      logEntry.setConfirmMethod(Constants.CONFIRMED_AUTOMATICALLY);

      Annotation sendedSug = new Annotation();
      sendedSug.setTmpId(logEntry.getTmpId());
      sendedSug.updateWithSuggestion(sended);
      sendedSug.setUser(requestInfo.getSession().getUser());
      sendedSug.setAuthorIdStr(requestInfo.getSession().getUser().getURIV2());
      sendedSug.setAuthorAddress(requestInfo.getSession().getUser().getEmail());
      sendedSug.setAuthorName(requestInfo.getSession().getUser().getName());
      sendedSug.setCreated(new Date());
      // set informations about confirmation
      confirmedSuggestions.put(sended.getURIV2(), sendedSug);
      annotList.add(sendedSug);
      if (logEntry.getConfirmedVersion() == null) {
        logEntry.setConfirmedVersion(sendedSug);
        requestInfo.getFlier().AddAddedAnnotation(sendedSug);
      }
      if (requestInfo.getSession().getKBRefMode()) {
        BaseAttribute uAAt = new BooleanAttribute(Constants.UPDATABLE_AN_AT_NAME, true, sendedSug);
        sendedSug.getAttributes().add(uAAt);
      }
      logEntry.setSuggestion(sendedSug);
      // add to list of confirmed suggestions
      if (!requestInfo.getConfirmedSuggestions().contains(logEntry)) {
        requestInfo.addConfirmedSuggestion(logEntry);
        requestInfo.addAutoconfirmedSuggestion(logEntry);
      }
    }
    connectAnnotations(annotList, confirmedSuggestions,requestInfo);
    
  }  // processSuggestionAutoConfirm()
  
  /**
   * Method which reconstruct links between annotation objects (references 
   * to appropriate objects) using URIs in attributes. For example if there 
   * is link to another annotation but only URI of annotation is set 
   * in the attribute, it will set also reference to linked annotation. 
   * It also reconstruct both sides of nesting relation.
   * 
   * @param annotsToConnect List of annotation in which links should be reconstructed.
   * @param tmpIdMap Map with mapping of URIs to objects
   * @param requestInfo Informations about client request
   */
  private void connectAnnotations(ArrayList<Annotation> annotsToConnect, HashMap<String, Annotation> tmpIdMap, RequestInfo requestInfo) {
    Iterator<Annotation> connectIt = annotsToConnect.iterator();
    while (connectIt.hasNext()) {  // for each annotation in the list

      // go trough all added annotations
      Annotation actualAnnot = connectIt.next();
      if (actualAnnot.getAttributes() != null) {  // if annotation have some attributes

        // go tough all attributes
        Iterator<BaseAttribute> attributesIt = actualAnnot.getAttributes().iterator();
        while (attributesIt.hasNext()) {  // for each attribute

          // try find nested or linked attribute
          BaseAttribute actualAttribute = attributesIt.next();
          if ((actualAttribute instanceof LinkedAnnotationAttribute)) {  // if it is link to annotation
            if (actualAttribute.getUri() != null && !actualAttribute.getUri().isEmpty()) {
              // try find annotation uri in just added annotations

              String annotUri = actualAttribute.getUri();
              String uriType = getUriType(annotUri);

              if (uriType.equals("sugg")) {
                Annotation findedAnnot = tmpIdMap.get(actualAttribute.getUri());
                if (findedAnnot != null) {
                  ((LinkedAnnotationAttribute) actualAttribute).setValue(findedAnnot);
                }
              } else if (uriType.equals("serv")) {
                Integer id = null;
                String idString = annotUri.replace(AppBean.getBaseUri() + "/serv/", "");
                try {
                  id = Integer.decode(idString);
                } catch (NumberFormatException ex) {
                  // error - cant decode id
                  int langNum = requestInfo.getSession().getLanguageNum();
                  int lod = requestInfo.getSession().getProtocolLOD();
                  String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2() 
                        + "\" uri=\"" + actualAttribute.getUriInOntology() 
                        + "\" name=\"" + actualAttribute.getName() 
                        + "\" valueType=\"" + actualAttribute.getValueType() 
                        + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                  requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                  if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                    String msg = "Can't decode suggestion id. Id value: " + idString;
                    Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
                  }
                  continue;
                }
                
                PersistM persistMan = AppBean.getPersistenceManager();

                Object[] annotParams = new Object[2];
                annotParams[0] = "id";
                annotParams[1] = id;

                @SuppressWarnings("unchecked")
                List<Annotation> annotList = persistMan.queryDB("Annotation.findById", annotParams);
                if (annotList == null || annotList.isEmpty()) {
                  //error - cant find linked annot in DB
                  int langNum = requestInfo.getSession().getLanguageNum();
                  int lod = requestInfo.getSession().getProtocolLOD();
                  String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2()
                          + "\" uri=\"" + actualAttribute.getUriInOntology()
                          + "\" name=\"" + actualAttribute.getName()
                          + "\" valueType=\"" + actualAttribute.getValueType()
                          + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                  requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                  if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                    String msg = "Can't find linked annot in DB. Id value: " + idString;
                    Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
                  }
                  continue;
                }

                LinkedAnnotationAttribute actualLinked = (LinkedAnnotationAttribute) actualAttribute;
                actualLinked.setValue(annotList.get(0));
                actualLinked.setAttributeType(annotList.get(0).getAnnotType());
              }
            }
          }  // if it is link to annotation


          if ((actualAttribute instanceof NestedAnnotationAttribute)) {
            NestedAnnotationAttribute nestedAttr = (NestedAnnotationAttribute) actualAttribute;
            if (actualAttribute.getUri() != null && !actualAttribute.getUri().isEmpty()) {
              // try find annotation uri in just added annotations
              Annotation findedAnnot = tmpIdMap.get(actualAttribute.getUri());
              nestedAttr.setValue(findedAnnot);
              findedAnnot.setNestedInAnnot(nestedAttr.getRefAnnotation());
            }
          }
        }  // for each attribute
      }  // if annotation have some attributes
    }  // for each annotation in the list
  }  // connectAnnotations()
  
  /**
   * Method for processing of message with refusing of suggestions
   * 
   * @param suggRefuseEl Element with message
   * @param requestInfo Informations about client request
   */
  public void processSuggestionRefuse(Element suggRefuseEl, RequestInfo requestInfo) {
    // get all refused suggestion
    NodeList refusedElems = suggRefuseEl.getElementsByTagName("suggestion");
    
    for(int index = 0; index < refusedElems.getLength(); index ++){  // for each refused
      Element suggEl = (Element) refusedElems.item(index);
      if(suggEl != null){
        String suggUri = suggEl.getAttribute("uri");
        if(suggUri == null && suggUri.isEmpty()){
          //error - can't find uri of refused suggestion
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<suggestion uri=\"\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_28_BAD_CONFIRM, info); 
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can't find uri of refused annotation suggestion.";
            Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
          }
          continue;
        }

        String idString = suggUri.replace(AppBean.getBaseUri() + "/sugg/","");
        SuggestionLogEntry logEntry = new SuggestionLogEntry(idString);
        logEntry.setRefuseMethod(Constants.REFUSED_MANUALLY);

        // find suggested annotation in list of suggestions
         if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
          Integer id = null;
          try {
            id = Integer.parseInt(idString);
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "The ID of the refused suggestion is not a number: " + idString;
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
          // ID was parsed successfuly and the ID is contained within sended suggestions
          if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {
            Annotation refused = new Annotation();
            refused.updateWithSuggestion(requestInfo.getSession().getWholeSendedSuggestion(id));
            logEntry.setSuggestion(refused);
          }
        } else { // the suggestion's not been found
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Suggestion with the following ID not found: " + idString;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          continue;
        }

        requestInfo.addRefusedSuggestion(logEntry);
      }
    }  // for each refused
    
    requestInfo.getOrigRefusedSuggestions().addAll(requestInfo.getRefusedSuggestions());
  }  // processSuggestionRefuse()
  
  /**
   * Method for processing of message with request for alternatives
   * 
   * @param getAltEl Element with message
   * @param requestInfo Informations about client request
   */
  public void processGetAlternatives(Element getAltEl, RequestInfo requestInfo) {
    // get all suggestions
    NodeList getAltElems = getAltEl.getElementsByTagName("suggestion");
    
    for(int index = 0; index < getAltElems.getLength(); index ++){  // for each suggestion
      Element suggEl = (Element) getAltElems.item(index);
      if(suggEl != null){
        String suggUri = suggEl.getAttribute("uri");
        if(suggUri == null && suggUri.isEmpty()){
          //error - can't find uri of suggestion
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          // There can be some message for client in the future but now it is not needed
          // requestInfo.addError(lod, langNum, Localisation., info); 
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can't find uri of suggestion.";
            Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
          }
          continue;
        }

        String idString = suggUri.replace(AppBean.getBaseUri() + "/sugg/","");

        // find suggested annotation in list of suggestions
         if (requestInfo.getSession().getSendedSuggestions() != null && !requestInfo.getSession().getSendedSuggestions().isEmpty()) {
          Integer id = null;
          try {
            id = Integer.parseInt(idString);
          } catch (NumberFormatException nfe) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "The ID of the suggestion is not a number: " + idString;
              Logger.getLogger(P2SuggestionProcessor.class.getName()).log(Level.ALL, msg);
            }
          }
          // ID was parsed successfuly and the ID is contained within sended suggestions
          if (id != null && requestInfo.getSession().isSuggInSendedSuggestions(id)) {
            requestInfo.addSugToAlternativesRequestedFor(requestInfo.getSession().getWholeSendedSuggestion(id));
          }
        } else { // the suggestion's not been found
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Suggestion with the following ID was not found: " + idString;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          continue;
        }
      }
    }  // for each suggestion
  }  // processGetAlternatives()
  
  /**
   * Processes elements with fragments for which annotations should be suggested
   * 
   * @param fragmentsEl Elements with fragments
   * @param requestInfo Informations about client request
   * @return Returns list of processed fragments
   */
  private ArrayList<Fragment> processSuggFragments(Element fragmentsEl, RequestInfo requestInfo){
    // get all fragment nodes
    NodeList fragmentElems = fragmentsEl.getElementsByTagName("fragment");
    ArrayList<Fragment> resultsFragments = new ArrayList<Fragment>(fragmentElems.getLength());
    
    // go trough all fragment elements
    for(int index = 0; index < fragmentElems.getLength(); index++){
      Element currentFragmentsEl = (Element) fragmentElems.item(0);
      if(currentFragmentsEl != null){
        Fragment newFragment = new Fragment();

        // get XPath attribute (required)
        String xPathString = currentFragmentsEl.getAttribute("path");
        if(xPathString == null || xPathString.isEmpty()){
          // error - XPath attribute is required in attribute element
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          requestInfo.addError(lod, langNum, Localisation.ERROR_8_SUG_FRAGMENT);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "XPath attribute is required in suggestion request fragment element.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
        }

        // get offset attribute
        Integer offset;
        String attributeString = currentFragmentsEl.getAttribute("offset");
        if (attributeString == null || attributeString.isEmpty()) {
          offset = null;
        } else {
          try {
            offset = Integer.parseInt(attributeString);
          } catch (NumberFormatException ex) {
            // error - bad format of fragment offset
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            requestInfo.addError(lod, langNum, Localisation.ERROR_8_SUG_FRAGMENT);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Can't decode fragment offset. Value of offset: " + attributeString;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
            return null;
          }
        }

        Integer length;
        String lengthString = currentFragmentsEl.getAttribute("length");
        if(lengthString == null || lengthString.isEmpty()){
          length = null;
        }else{
          try {
            length = Integer.parseInt(lengthString);
          } catch (NumberFormatException ex) {
            // error - bad format of length offset
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            requestInfo.addError(lod, langNum, Localisation.ERROR_8_SUG_FRAGMENT);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
              String msg = "Can't decode fragment length. Value of length: " + lengthString;
              Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
            }
            return null;
          }
        }

        // improve XPath to be usable
        String sPath = UpdatableFragment.improveXPath(xPathString);
        // create object with fragment
        newFragment = new Fragment(sPath, offset, length);
        // add new fragment
        resultsFragments.add(newFragment);
      }
    }
    return resultsFragments;
  }  // processSuggFragments()
  
  /**
   * Processes elements with types of annotations which should be suggested
   * 
   * @param typesEl Elements with types
   * @param requestInfo Informations about client request
   * @return Returns list of URIs of types
   */
  private ArrayList<String> processSuggTypes(Element typesEl, RequestInfo requestInfo) {
    // get all annotation types
    NodeList annotTypeElems = typesEl.getElementsByTagName("type");
    ArrayList<String> resultsAnnotType = new ArrayList<String>(annotTypeElems.getLength());
    
    // go trough all annotation types elements
    for (int index = 0; index < annotTypeElems.getLength(); index++) {
      Element currentAnnotTypesEl = (Element) annotTypeElems.item(0);
      if (currentAnnotTypesEl != null) {
        // get uri of annotation type uri (required)
        String typeUriString = currentAnnotTypesEl.getAttribute("uri");
        if (typeUriString == null || typeUriString.isEmpty()) {
          // error - annotation type uri is required
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type uri=\"\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_40_BAD_SUGG_TYPE, info);  
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Annotation type uri is required.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }

        // find annotation type in DB
        PersistM persistMan = AppBean.getPersistenceManager();

        Object[] params = new Object[2];
        params[0] = "uri";
        params[1] = typeUriString;
        
        @SuppressWarnings("unchecked")
        List<AnnotType> annotTypeList = persistMan.queryDB("AnnotType.findByUri", params);
        if(annotTypeList != null && !annotTypeList.isEmpty()){
          resultsAnnotType.add(typeUriString);
        }else{
          // error - can't find annotation type of suggestion request
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type uri=\"" + typeUriString + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_40_BAD_SUGG_TYPE, info); 
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can't find annotation type of suggestion request. Type uri: " + typeUriString;
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }   
      }
    }
    
    return resultsAnnotType;
  }  // processSuggTypes()
  
    
  /**
   * Removes suggestions with feedback from the list and replaces all references 
   * to them by annotations from feedback (for negative feedback by null).
   * 
   * @param requestInfo Informations about client request
   * @param list List of suggestions
   * @param modified List to which modified suggestions will be added
   * @return Removed suggestions from list.
   */
  private ArrayList<Suggestion> getSuggestionWithoutFeedback(RequestInfo requestInfo, ArrayList<Suggestion> list, ArrayList<Suggestion> modified) {
    ArrayList<Suggestion> removedSuggestions = new ArrayList<Suggestion>();
    UserGroup defGroup = requestInfo.getSession().getDefaultGroup();
    int defaultUserGroupID = defGroup.getId();

    List<SuggestionFeedback> feedList = SuggestionManager.getFeedbackFromDB(requestInfo.getSession().getSyncDocument().getId(), defaultUserGroupID);
    ArrayList<SuggestionFeedback> feedListOtherGroups = new ArrayList<SuggestionFeedback>();
    
    if (requestInfo.getSession().getUser() != null) {
      Iterator<UserGroup> allUserGroups = requestInfo.getSession().getUser().getGroupsAL().iterator();
      while(allUserGroups.hasNext()){
        UserGroup group = allUserGroups.next();
        if(group.getId() != defaultUserGroupID){
           List<SuggestionFeedback> feed = SuggestionManager.getFeedbackFromDB(requestInfo.getSession().getSyncDocument().getId(), group.getId());
           feedListOtherGroups.addAll(feed);
        }
      }
    }
    
    // delete suggestions with positiveFeedback in default group
    for (Iterator<SuggestionFeedback> it = feedList.iterator(); it.hasNext();) {
      SuggestionFeedback fb = it.next();
      if (fb.getSuggestion() == null) {
        continue;
      }
      Suggestion sgFromList = SuggestionManager.getSuggestionFromList(fb.getSuggestion().getId(), list);
      if (sgFromList != null) { // suggestion was found
        feedbackChangeRef(list, sgFromList, modified, fb, removedSuggestions);
      }
    }
    
    // delete suggestions with positiveFeedback in other group
    for (Iterator<SuggestionFeedback> it = feedListOtherGroups.iterator(); it.hasNext();) {
      SuggestionFeedback fb = it.next();
      if (fb.getSuggestion() == null) {
        continue;
      }
      Suggestion sgFromList = SuggestionManager.getSuggestionFromList(fb.getSuggestion().getId(), list);
      if (sgFromList != null) { // suggestion was found
        feedbackChangeRef(list, sgFromList, modified, fb, removedSuggestions);
      }
    }
    
    return removedSuggestions;
  }  // getSuggestionWithoutFeedback()
  
  /**
   * Adds links in suggestion to modified suggs
   * 
   * @param list List of suggestions
   * @param sgFromList Suggestion to check for links
   * @param modified List to which modified suggestions will be added
   * @param fb feedback for this suggestion
   * @param removedSuggestions Removed suggestions from list.
   */
  private void feedbackChangeRef(ArrayList<Suggestion> list, 
          Suggestion sgFromList, ArrayList<Suggestion> modified, SuggestionFeedback fb,
          ArrayList<Suggestion> removedSuggestions)
  {
    for (Iterator<Suggestion> itList = list.iterator(); itList.hasNext(); ) {
      Suggestion sg = itList.next();
      List atrs = sg.getAttributes();
      // iterate in all atributes
      for (Iterator it2 = atrs.iterator(); it2.hasNext();) {
        Object obj = (Object) it2.next();
        Object value = null;
        if (obj instanceof SugLinkedAttribute) {
          value = ((SugLinkedAttribute) obj).getValue();
        }
        if (obj instanceof SugNestedAttribute) {
          value = ((SugNestedAttribute) obj).getValue();
        }
        if (value instanceof Suggestion) {
          if (((Suggestion) value).equals(sgFromList)) {
            if (obj instanceof SugLinkedAttribute) {
              ((SugLinkedAttribute) obj).setValue(fb.getAnnot());
              if (fb.getAnnot() != null) {
                ((SugLinkedAttribute) obj).setUri(fb.getAnnot().getURIV2());
              } else {
                ((SugLinkedAttribute) obj).setUri(null);
              }
              if (modified != null && !modified.contains(sg)) {
                modified.add(sg);
              }
            }
            if (obj instanceof SugNestedAttribute) {
              ((SugNestedAttribute) obj).setValue(fb.getAnnot());
              if (fb.getAnnot() != null) {
                ((SugNestedAttribute) obj).setUri(fb.getAnnot().getURIV2());
              } else {
                ((SugNestedAttribute) obj).setUri(null);
              }
              if (modified != null && !modified.contains(sg)) {
                modified.add(sg);
              }
            }
          }
        }
      }
    }
    list.remove(sgFromList);
    removedSuggestions.add(sgFromList);
  }
  
  /**
   * Method sets the rejected references to null and return changed suggestions.
   * 
   * @param userSuggestions list of filtered suggestions
   * @param refusedSuggestions list of refused suggestions by users
   * @return changed suggestions
   */
  private ArrayList<Suggestion> cutRefusedSuggLinks(ArrayList<Suggestion> userSuggestions, ArrayList<Suggestion> refusedSuggestions){
    ArrayList<Suggestion> changedSuggestions = new ArrayList<Suggestion>();
    if(userSuggestions != null && !userSuggestions.isEmpty() && refusedSuggestions != null && !refusedSuggestions.isEmpty()){
      Iterator<Suggestion> userSuggIt = userSuggestions.iterator();
      while(userSuggIt.hasNext()){
        Suggestion actualSugg = userSuggIt.next();
        List attrList = actualSugg.getAttributes();
        Iterator attrListIt = attrList.iterator();
        // Go trough all attributes of suggestion
        while(attrListIt.hasNext()){
          Object actualObject = (Object) attrListIt.next();
          // Search for suggestion link
          if(actualObject instanceof SugLinkedAttribute){
            SugLinkedAttribute actualLink = (SugLinkedAttribute)actualObject;
            if(actualLink.getValue() != null && actualLink.getValue() instanceof Suggestion){
              Iterator<Suggestion> refSugIterator = refusedSuggestions.iterator();
              while(refSugIterator.hasNext()){
                // Check if linked suggestion parameter points to refused suggestion
                if(((Suggestion)actualLink.getValue()).getId().equals(refSugIterator.next().getId())){
                  // Then set link to null (cut off refused suggestion)
                  actualLink.setValue(null);
                  actualLink.setUri(null);
                  if(!changedSuggestions.contains(actualSugg)){
                    changedSuggestions.add(actualSugg);
                  }
                }
              } // while(refSugIterator.hasNext())
            } // ... instanceof Suggestion){
          } // if(actualObject instanceof SugLinkedAttribute
          else if(actualObject instanceof SugNestedAttribute){
            SugNestedAttribute actualLink = (SugNestedAttribute)actualObject;
            if(actualLink.getValue() != null && actualLink.getValue() instanceof Suggestion){
              Iterator<Suggestion> refSugIterator = refusedSuggestions.iterator();
              while(refSugIterator.hasNext()){
                // Check if nested suggestion parameter points to refused suggestion
                if(((Suggestion)actualLink.getValue()).getId().equals(refSugIterator.next().getId())){
                  // Then set link to null (cut off refused suggestion)
                  actualLink.setValue(null);
                  actualLink.setUri(null);
                  if(!changedSuggestions.contains(actualSugg)){
                    changedSuggestions.add(actualSugg);
                  }
                }
              } // while(refSugIterator.hasNext())
            } // ... instanceof Suggestion){
          } // if(actualObject instanceof SugNestedAttribute
        } // while(attrListIt.hasNext())
      } // while(userSuggIt.hasNext())
    } //  if(userSuggestions != null && ... 
    return changedSuggestions;
  }  // cutRefusedSuggLinks()
  
}  // public class P2SuggestionProcessor