EditorSession.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: EditorSession.java
 * Description: Class with informations about client (annotations editor) session
 */

/**
 * @file EditorSession.java
 *
 * @brief Informations about client session
 */

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

import com.sun.grizzly.comet.CometContext;
import com.sun.grizzly.comet.CometEngine;
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.AnnotCometServlet.AnnotHandler;
import cz.vutbr.fit.knot.annotations.entity.*;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.Suggestion;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.Query;
import org.w3c.dom.Document;

/**
 * Class with informations about client (annotations editor) session
 *
 * @brief Informations about client session
 * @author idytrych
 */
public class EditorSession {

  /** Id of session*/
  private long sessionId;
  /** User logged in this session */
  private User user = null;
  /** Communication protocol version */
  private String protocolVersion;
  /** List of subscribed sources */
  private ArrayList<SubscribedSource> subscribedSources;
  /** List of unsubscribed sources (Black List) */
  private ArrayList<SubscribedSource> unsubscribedSources;
  /** Fragments to which are to be suggested annotations */
  private ArrayList<Fragment> suggestionsFr;
  /** Annotation types to be suggested (list with filters) */
  private ArrayList<String> suggestionsTypes;
  /** List of queried annotation types */
  private ArrayList<String> queriedTypes;
  /** Synchronized document */
  private AnnotDocument syncDocument = null;
  /** Linearized synchronized document */
  private String parsedLinDocument = null;
  /** Indicator of linearization */
  private boolean linearization = false;
  /** Language to use in server */
  private String language = "eng";
  /** Number of language to use in server */
  private int languageNum = Localisation.LANGUAGE_ENG;
  /** List with attributes which should be filtered out */
  private ArrayList<String> attFilter;
  /** 
   * Should be negative feedback updated for suggestions refused by same 
   * fragment as some confirmed have? If it will be updated and we have 
   * two suggestions on same fragment and same two suggestions on more 
   * same fragments, confirmation on one of them refuses second one from 
   * all other fragments. 
   */
  private boolean updateNegFeedbackForRefusedBySame = false;
  /**
   * Should be other similar (same annotated text and URI of entity) 
   * suggestions in same part of document confirmed?
   */
  private boolean enableUpdatePositiveFeedback = false;
  /**
   * Should be alternatives automatically activated?
   */
  private boolean autoActivateAlternatives = false;
  /** String with messages to be sent via comet */
  private String messagesTSVC = "";
  /** Cache for annotation suggestions */
  private ArrayList<SuggestionLogEntry> suggestionsCache;
  /** Time stamp that indicate last activity time of session */
  private long lastActivityTime;
  /** Time stamp that indicate last confirm time of session */
  private long lastConfirmTime;
  /** Array of IDs of suggestions which was sent to client (client's cache) */
  private volatile ArrayList<Integer> sendedSuggestions;
  /** Comet handler associated with this session */
  private AnnotCometServlet.AnnotHandler cometHandler = null;
  /** Comet context associated with this session */
  private String cometContext = null;
  /** List of subscribed subscriptions */
  private ArrayList<Subscription> subscribeList = null;
  /** Parsed synchronized document */
  private Document parsedSyncDocument = null;
  /** Flag which denotes that suggestions was requested so an empty diff cannot be omitted. */
  private Boolean sugRequestFlag = false;
  /** Should be confidence displayed for suggestions */
  private boolean displaySugConfidence = true;
  /** Is KB_Ref mode on? */
  private boolean KBRefMode = false;
  
  /** Minimal confidence used to filtrate suggestions */
  private Integer minConfidence;
  /** Minimal level of confidence to auto confirm suggestion */
  private Integer autoConfirm;
  /** Are variables dependent on document ID initialized? */
  private Boolean docIDdependentVariablesInitialized = false;

  /**
   * Constructor of reference objects for searching purposes - no initialization
   * needed
   */
  public EditorSession(long sessId) {
    sessionId = sessId;
  }

  /**
   * Constructor - sets the session id to new generated value and initialize
   * variables
   */
  public EditorSession(String protocolVersion) {
    sessionId = AppBean.getNextSessId();
    this.protocolVersion = protocolVersion;
    subscribedSources = new ArrayList<SubscribedSource>();
    unsubscribedSources = new ArrayList<SubscribedSource>();
    queriedTypes = new ArrayList<String>();
    this.suggestionsFr = new ArrayList<Fragment>();
    suggestionsCache = new ArrayList<SuggestionLogEntry>();
    sendedSuggestions = new ArrayList<Integer>();
    suggestionsTypes = new ArrayList<String>();
    attFilter = new ArrayList<String>();
  }

  /**
   * Gets id of this session
   *
   * @return Returns id of this session
   */
  public long getSessionId() {
    return sessionId;
  }

  /**
   * Gets agreed communication protocol version
   *
   * @return Returns communication protocol version
   */
  public String getProtocolVersion() {
    return protocolVersion;
  }

  /**
   * Sets agreed communication protocol version
   *
   * @param protocolVersion Communication protocol version
   */
  public void setProtocolVersion(String protocolVersion) {
    this.protocolVersion = protocolVersion;
  }

  /**
   * Gets protocol level of development. Higher level activates newer functions.
   *
   * @return Protocol level of development (1 for protocol v. 1.0)
   */
  public int getProtocolLOD() {
    if (protocolVersion.equals("1.0")){
      return Constants.PROTOCOL_LOD_V1; 
    }
    if (protocolVersion.equals("2.0")){
        return Constants.PROTOCOL_LOD_V2;
    }
    
    if (protocolVersion.charAt(0) == '2'){
      return Constants.PROTOCOL_LOD_V2;
    }
    else{
      return Constants.PROTOCOL_LOD_V1_1;
    }
  }

  /**
   * Gets appropriate version of namespaces based on protocol LOD
   *
   * @return Appropriate version of namespaces based on protocol LOD
   */
  public int getNamespacesLOD(){
    int protocolVer = this.getProtocolLOD();

    if(protocolVer < Constants.PROTOCOL_LOD_V2){
      return Constants.NAMESPACES_LOD_V1;
    }
    else{
      return Constants.NAMESPACES_LOD_V2;
    }
  }

  /**
   * Gets list of fragments to which are to be suggested annotations
   *
   * @return Returns list of fragments to which are to be suggested annotations
   */
  public ArrayList<Fragment> getSuggestionsFr() {
    return suggestionsFr;
  }

  /**
   * Sets list of fragments to which are to be suggested annotations
   *
   * @param suggestionsFr List of fragments to which are to be suggested annotations
   */
  public void setSuggestionsFr(ArrayList<Fragment> suggestionsFr) {
    this.suggestionsFr = suggestionsFr;
  }

  /**
   * Adds fragment to which are to be suggested annotations to the list
   *
   * @param suggestionsFr Fragment to which are to be suggested annotations
   */
  public void addSuggestionsFr(Fragment suggestionsFr) {
    this.suggestionsFr.add(suggestionsFr);
  }

  /**
   * Adds source of annotations to list of subscribed sources
   *
   * @param source Source of annotations to be added
   */
  public void addSource(SubscribedSource source) {
    subscribedSources.add(source);
  }

  /**
   * Removes source of annotations from list of subscribed sources
   *
   * @param source Source of annotations to be removed
   */
  public void removeSource(SubscribedSource source) {
    subscribedSources.remove(source);
  }

  /**
   * Check whether source of annotations is in the list of subscribed sources
   *
   * @param source Source of annotations to be searched
   * @return If source is in the list, returns true, false otherwise
   */
  public boolean containsSource(SubscribedSource source) {
    return subscribedSources.contains(source);
  }

  /**
   * Adds unsubscribed source of annotation to list of unsubscribed sources (black list)
   *
   * @param source Unsubscribed source of annotations to be added
   */
  public void addUnsubscribeSource(SubscribedSource source){
      unsubscribedSources.add(source);
  }

  /**
   * Removes unsubscribed source of annotation from list of unsubscribed sources (black list)
   *
   * @param source Unsubscribed source of annotations to be removed
   */
  public void removeUnsubscribeSource(SubscribedSource source){
      unsubscribedSources.remove(source);
  }
  /**
   * Check whether source of annotations is in the list of unsubscribed sources
   *
   * @param source Source of annotations to be searched in the list of unsubscribed
   * @return If source is found, returns true, otherwise return false
   */
  public boolean containsUnsubscribedSource(SubscribedSource source){
     return unsubscribedSources.contains(source);
  }

  /**
   * Gets queried types of annotations (list of strings with filters which was used)
   *
   * @return Returns queried types of annotations (list of strings with filters which was used)
   */
  public ArrayList<String> getQueriedTypes() {
    return queriedTypes;
  }

  /**
   * Sets queried types of annotations (list of strings with filters which was used)
   *
   * @param queriedTypes Queried types of annotations (list of strings with filters which was used)
   */
  public void setQueriedTypes(ArrayList<String> queriedTypes) {
    this.queriedTypes = queriedTypes;
  }

  /**
   * Adds queried type(s) of annotations to the list (string with filter)
   *
   * @param queriedType Queried type(s) of annotations to the list (string with filter)
   */
  public void addQueriedTypes(String queriedType) {
    this.queriedTypes.add(queriedType);
  }

  /**
   * Gets time stamp of activity time of session
   *
   * @return Returns time stamp of activity time of session
   */
  public long getLastActivityTime() {
    return lastActivityTime;
  }

  /**
   * Sets time stamp of activity time of session
   *
   * @param lastActivityTime time stamp of activity time of session
   */
  public void setLastActivityTime(long lastActivityTime) {
    this.lastActivityTime = lastActivityTime;
  }

  /**
   * Gets time stamp of confirm time of session
   *
   * @return Returns time stamp of confirm time of session
   */
  public long getLastConfirmTime() {
    return lastConfirmTime;
  }

  /**
   * Sets time stamp of confirm time of session
   *
   * @param lastConfirmTime Time stamp of confirm time of session
   */
  public void setLastConfirmTime(long lastConfirmTime) {
    this.lastConfirmTime = lastConfirmTime;
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation.
   *
   * @param annot Checked annotation
   * @param testDoc If matching of document must be checked then true, false otherwise
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribed(Annotation annot, boolean testDoc) {
    return isSubscribed(annot, null, true);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation.
   *
   * @param annot Checked annotation
   * @param sources List of sources to which annotation belongs to
   * @param testDoc If matching of document must be checked then true, false otherwise
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribed(Annotation annot, ArrayList<String> sources, boolean testDoc) {
    if (testDoc) {
      if (syncDocument == null) {
        return false;
      }
      if (!syncDocument.equals(annot.getSourceDocument())) {
        return false;
      }
    }
    return isSubscribed(annot, sources);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation. User groups of annotation author are taken into account.
   *
   * @param annot Checked annotation
   * @param testDoc If matching of document must be checked then true, false otherwise
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribedWG(Annotation annot, boolean testDoc) {
    ArrayList<String> sources = new ArrayList<String>();
    return isSubscribedWG(annot, sources, true);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation. User groups of annotation author are taken into account.
   *
   * @param annot Checked annotation
   * @param sources List of sources to which annotation belongs to
   * @param testDoc If matching of document must be checked then true, false otherwise
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribedWG(Annotation annot, ArrayList<String> sources, boolean testDoc) {
    if (testDoc) {
      if (syncDocument == null) {
        return false;
      }
      if (!syncDocument.equals(annot.getSourceDocument())) {
        return false;
      }
    }
    return isSubscribedWG(annot, sources);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation.
   *
   * @param annot Checked annotation
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribed(Annotation annot) {
    return isSubscribed(annot, null);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation. User groups of annotation author are taken into account.
   *
   * @param annot Checked annotation
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribedWG(Annotation annot) {
    ArrayList<String> sources = new ArrayList<String>();
    return isSubscribedWG(annot, sources);
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation. User groups of annotation author are taken into account.
   *
   * @param annot Checked annotation
   * @param sources List of sources to which annotation belongs to
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribedWG(Annotation annot, ArrayList<String> sources) {
    if (annot.getUser() != null) {
      Iterator<UserGroup> gIter = annot.getUser().getGroups().iterator();
      while (gIter.hasNext()) {
        UserGroup userGroup = gIter.next();
        sources.add(AppBean.getBaseGroupUri() + userGroup.getId());
      }
    }
    return isSubscribed(annot, sources);
  }

  /**
   * Method sets comet context for this session.
   *
   * @param cometContext string with comet context
   */
  public void setCometContext(String cometContext) {
    this.cometContext = cometContext;
  }

  /**
   * Method sets handler to comet that belongs to session.
   *
   * @param cometHandler comet handler for this session
   */
  public void setCometHandler(AnnotHandler cometHandler) {
    this.cometHandler = cometHandler;
  }

  /**
   * Method gets comet context for this session.
   *
   * @return Returns comet context for this session.
   */
  public String getCometContext() {
    return this.cometContext;
  }

  /**
   * Method gets handler to comet that belongs to session.
   *
   * @return Returns comet handler for this session
   */
  public AnnotHandler getCometHandler() {
    return this.cometHandler;
  }
  
  /**
   * Method provides asynchronous sending messages trough comet channel. Basically
   * send notify to comet engine and that wake comet for this session.
   */
  public void notifyComet(){
    if(cometHandler != null && cometContext != null){
      CometEngine engine = CometEngine.getEngine();
      CometContext<?> context = engine.getCometContext(cometContext);
      try{
        context.notify(null,cometHandler);
      }
      catch(Exception e){
        String msg = "Can't notify comet.";
        Logger.getLogger(EditorSession.class.getName()).log(Level.ALL, msg);
      }
    }
  }

  /**
   * The method finds the corresponding subscriptions for submitted type of
   * annotation, users and resources. 
  * 
   * @param list List of subscribed or unsubscribed annotations
   * @param annot Annotation from which Identification of user (URI or address) will be get
   * @param type Annotation type for which method searching for a record annotation type
   * @param sources List of sources to which annotation belongs to
   * @return Returns list of SubscribedSources that corresponds with type of annotation
   */
  static public ArrayList<SubscribedSource> listOfMatches(ArrayList<SubscribedSource> list, Annotation annot, AnnotType type, ArrayList<String> sources) {
   ArrayList<SubscribedSource> resultList = new ArrayList<SubscribedSource>();
   if(list == null){
     return resultList;
   }
   ListIterator<SubscribedSource> iter = list.listIterator();
   SubscribedSource subS = null;

   try{

    if (sources != null) {
      if (!sources.isEmpty()) {
        ListIterator<String> sIter = sources.listIterator();
        String source = null;
        while (sIter.hasNext()) {
          source = sIter.next();
          iter = list.listIterator();
          while (iter.hasNext()) {
            subS = iter.next();
            if (subS.matches(type.getUri(), annot.getUser().getURI(), source) || subS.matches(type.getUri(), annot.getUser().getURIV2(), source)) {
              resultList.add(subS);
            }
          }
        }
      } else {
        while (iter.hasNext()) {
          subS = iter.next();
          if (subS.matches(type.getUri(), annot.getUser().getURI(), null) || subS.matches(type.getUri(), annot.getUser().getURIV2(), null)) {
            resultList.add(subS);
          }
        }
      }
    } else {
      while (iter.hasNext()) {
        subS = iter.next();
        if (subS.matches(type.getUri(), annot.getUser().getURI(), null) || subS.matches(type.getUri(), annot.getUser().getURIV2(), null)) {
          resultList.add(subS);
        }
      }
    }
    // For clients with bad protocol or for unknown user
    iter = list.listIterator();
    if (sources != null) {
      if (!sources.isEmpty()) {
        ListIterator<String> sIter = sources.listIterator();
        String source = null;
        while (sIter.hasNext()) {
          source = sIter.next();
          iter = list.listIterator();
          while (iter.hasNext()) {
            subS = iter.next();
            if (subS.matches(type.getUri(), annot.getAuthorAddress(), source)) {
              resultList.add(subS);
            }
          }
        }
      } else {
        while (iter.hasNext()) {
          subS = iter.next();
          if (subS.matches(type.getUri(), annot.getAuthorAddress(), null)) {
            resultList.add(subS);
          }
        }
      }
    } else {
      while (iter.hasNext()) {
        subS = iter.next();
        if (subS.matches(type.getUri(), annot.getAuthorAddress(), null)) {
          resultList.add(subS);
        }
      }
    }

   } catch(Exception e) {
      throw new NullPointerException("NullPointerException was occurs in EditorSessionModule, while trying to find corresponding subscriptions");
    }
    return resultList;
  } // listOfMatches()

  /**
   * Checks whether list contain subscribed (or unsubscribed) source rule  other
   * then "hungry type" rule (rule where type isn't fill).
   *
   * @param list List of subscribed sources (rules)
   * @return Returns true if found other rule then "hungry type" rule otherwise return false
   */
  static public boolean containTypeRule(ArrayList<SubscribedSource> list){

    ListIterator<SubscribedSource> iter = list.listIterator();

    while(iter.hasNext()){
      SubscribedSource actualSource = iter.next();
      if(actualSource.getType() != null)
      {
        if((!actualSource.getType().startsWith("*"))){
          return true;
        }
      }
    }

    return false;
  }

  /**
   * Checks whether list contain subscribed (or unsubscribed) source rule  other
   * then "hungry user" rule (rule where user isn't fill).
   *
   * @param list List of subscribed sources (rules)
   * @return Returns true if found other rule then "hungry user" rule otherwise return false
   */
  static public boolean containUserRule(ArrayList<SubscribedSource> list)
  {
    ListIterator<SubscribedSource> iter = list.listIterator();

    while(iter.hasNext()){
      SubscribedSource actualSource = iter.next();

      if(actualSource.getUser() != null){
        return true;
      }
    }

    return false;
  }

  /**
   * Checks whether list contain subscribed (or unsubscribed) source rule  other
   * then "hungry source" rule (rule where source isn't fill).
   *
   * @param list List of subscribed sources (rules)
   * @return Returns true if found other rule then "hungry source" rule otherwhise retrun false
   */
  static public boolean containSourceRule(ArrayList<SubscribedSource> list)
  {
    ListIterator<SubscribedSource> iter = list.listIterator();

    while(iter.hasNext()){
      SubscribedSource actualSource = iter.next();

      if(actualSource.getUri() != null){
        return true;
      }
    }

    return false;
  }

  /** 
   * Method finds every rule for all given annotations type ancestors and returns if is subscribed or unsubscribed.
   * 
   * @param rootType type where will checking begin
   * @param annot annotation that is checked
   * @param sources sources for current user
   * @param unsubResult list of found unsubscribed rules
   * @param subResult list of found subscribed files
   * @return value that represent if is current annotation subscribed unsubscribed or method don't find any rule
   */
  private int checkBranch(AnnotType rootType, Annotation annot, ArrayList<String> sources,
          ArrayList<SubscribedSource> unsubResult, ArrayList<SubscribedSource> subResult){

    AnnotType actualType = rootType;

    while(actualType != null) //climb tree of types from nod to root
    {
      int ancestorsCount = actualType.getAncestorTypes().size();

      if(ancestorsCount <= 1){

        // check if is current type type of annotation in unsubscribed list
        unsubResult.clear();
        unsubResult.addAll(listOfMatches(unsubscribedSources,annot,actualType,sources));

        // or in subscribed list
        subResult.clear();
        subResult.addAll(listOfMatches(subscribedSources,annot,actualType,sources));

        if(!subResult.isEmpty() && containTypeRule(subResult)){
          return Constants.SUBSCRIBED; // if was type found in subscribed then return true
        }else{
          if(!unsubResult.isEmpty() && containTypeRule(unsubResult)){
            return Constants.UNSUBSCRIBED; // if was type of annotation found in unsubscribed then return false
          }
        }

        actualType = actualType.getAncestorType();
      }else{
        Iterator<AnnotType> typeIt = actualType.getAncestorTypes().iterator();
        int resultsArray[] = new int [ancestorsCount];
        boolean unsubscribedOccur = false;

        for(int i = 0;typeIt.hasNext();i++){
          resultsArray[i] = checkBranch(typeIt.next(),annot,sources,unsubResult,subResult);
          if(resultsArray[i] == Constants.SUBSCRIBED) return Constants.SUBSCRIBED;
          if(resultsArray[i] == Constants.UNSUBSCRIBED) unsubscribedOccur = true;
        }

        if(unsubscribedOccur) return Constants.UNSUBSCRIBED;
        else return Constants.NOTHING;
      }
    }
    return Constants.NOTHING;
  }

  /**
   * Checks whether editor connected to this session is subscribed to get given
   * annotation.
   *
   * @param annot Checked annotation
   * @param sources List of sources to which annotation belongs to
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  public boolean isSubscribed(Annotation annot, ArrayList<String> sources) {

    AnnotType type = annot.getAnnotType();

    ArrayList<SubscribedSource> unsubResult = new ArrayList<SubscribedSource>();
    ArrayList<SubscribedSource> subResult = new ArrayList<SubscribedSource>();

    switch(checkBranch(annot.getAnnotType(),annot,sources,unsubResult,subResult)){
      case Constants.SUBSCRIBED: return true;
      case Constants.UNSUBSCRIBED: return false;
      default:
    }

    //if there occured only hungry subscriptions

    if(!subResult.isEmpty() || !unsubResult.isEmpty())
    {
      if(containUserRule(subResult)){
        return true;
      }
      if(containUserRule(unsubResult)){
        return false;
      }
      if(containSourceRule(subResult)){
        return true;
      }
      if(containSourceRule(unsubResult)){
        return false;
      }
    }

    return false;
  } // isSubscribed()

  /**
   * Gets list of subscribed sources
   *
   * @return List of subscribed sources
   */
  public ArrayList<SubscribedSource> getSubscribedSources() {
    return subscribedSources;
  }

  /**
   * Gets user logged in this session
   *
   * @return Returns user logged in this session
   */
  public User getUser() {
    return user;
  }

  /**
   * Sets user logged in this session
   *
   * @param user User logged in this session
   */
  public void setUser(User user) {
    this.user = user;
  }

  /**
   * Gets synchronized document
   *
   * @return Returns synchronized document
   */
  public AnnotDocument getSyncDocument() {
    return syncDocument;
  }

  /**
   * Sets synchronized document
   *
   * @param syncDocument Synchronized document
   */
  public void setSyncDocument(AnnotDocument syncDocument) {
    this.docIDdependentVariablesInitialized = false;
    if(this.syncDocument != null && this.syncDocument.getId() != null){
      AppBean.decrementDocumentUsage(this.syncDocument.getId());
    }
    if (syncDocument != null && syncDocument.getId() != null) {
      this.docIDdependentVariablesInitialized = true;
      if(AppBean.getDocumentUsage(syncDocument.getId()) == 0){
        AppBean.removePossibleModificationSets(syncDocument.getId());
        AppBean.initLastDocModification(syncDocument.getId());
      }
      AppBean.incrementDocumentUsage(syncDocument.getId());
    }
    this.syncDocument = syncDocument;
  }
    
  /**
   * If we synchronize a new document then
   * we dont have doc.id when we first call setSyncDocument 
   */
  public void initDocumentUsageAndTMNumber(){
    if (!docIDdependentVariablesInitialized && 
            syncDocument != null && syncDocument.getId() != null) 
    {
      if(AppBean.getDocumentUsage(syncDocument.getId()) == 0){
        AppBean.removePossibleModificationSets(syncDocument.getId());
        AppBean.initLastDocModification(syncDocument.getId());
      }
      AppBean.incrementDocumentUsage(syncDocument.getId());
    }
  }

  /**
   * Returns status of linearization
   *
   * @return If linearization is enabled, returns true, false otherwise
   */
  public boolean isLinearization() {
    return linearization;
  }

  /**
   * Sets linearization
   *
   * @param linearization If linearization is enabled then true, false otherwise
   */
  public void setLinearization(boolean linearization) {
    this.linearization = linearization;
  }

  public ArrayList<String> getSuggestionsTypes() {
    return suggestionsTypes;
  }

  public void setSuggestionsTypes(ArrayList<String> suggestionsTypes) {
    this.suggestionsTypes = suggestionsTypes;
  }
  
  public void addSuggestionType(String suggestionsType){
    if(this.suggestionsTypes == null){
      this.suggestionsTypes = new ArrayList<String>();
    }
    
    this.suggestionsTypes.add(suggestionsType);
  }
  
  public void clearSuggestionsTypes(){
    if(this.suggestionsTypes == null){
      this.suggestionsTypes = new ArrayList<String>();
    }
    
    this.suggestionsTypes.clear();
  }
  
  public boolean isSuggestionType(){
    if(this.suggestionsTypes == null){
      this.suggestionsTypes = new ArrayList<String>();
    }
    
    return this.suggestionsTypes.isEmpty();
  }
  
  /**
   * Sets parsed synchronized document
   * 
   * @param doc New document
   */
  public void setParsedSyncDocument(Document doc) {
    this.parsedSyncDocument = doc;
  }

  /**
   * Gets parsed synchronized document
   *
   * @return Returns parsed synchronized document
   */
  public Document getParsedSyncDocument() {
    return this.parsedSyncDocument;
  }

  /**
   * Gets parsed linearized document
   *
   * @return Returns parsed linearized document
   */
  public String getParsedLinDocument() {
    return parsedLinDocument;
  }

  /**
   * Gets content of cache for annotation suggestions
   *
   * @return Returns content of cache for annotation suggestions
   */
  public ArrayList<SuggestionLogEntry> getSuggestionsCache() {
    return suggestionsCache;
  }

  /**
   * Sets content of cache for annotation suggestions
   *
   * @param suggestionsCache Content of cache for annotation suggestions
   */
  public void setSuggestionsCache(ArrayList<SuggestionLogEntry> suggestionsCache) {
    this.suggestionsCache = suggestionsCache;
  }

  /**
   * Sets parsed linearized document
   *
   * @param parsedLinDocument Parsed linearized document
   */
  public void setParsedLinDocument(String parsedLinDocument) {
    this.parsedLinDocument = parsedLinDocument;
  }

  /**
   * Gets string with messages to be sent via comet
   *
   * @return Returns string with messages to be sent via comet
   */
  public String getMessagesTSVC() {
    return messagesTSVC;
  }

  /**
   * Sets string with messages to be sent via comet
   *
   * @param messagesTSVC String with messages to be sent via comet
   */
  public void setMessagesTSVC(String messagesTSVC) {
    this.messagesTSVC = messagesTSVC;
  }
  
  /**
   * Returns true if this session contaions any messages for send via coment
   * 
   * @return is messages string not empty?
   */
  public boolean hasMessagesTSVC() {
    if(this.messagesTSVC != null){
      return !this.messagesTSVC.isEmpty();
    }
    return false;
  }

  /**
   * Gets and cleans string with messages to be sent via comet
   *
   * @return Returns string with messages to be sent via comet
   */
  public synchronized String getAndCleanMessages() {
    String retStr = messagesTSVC;
    messagesTSVC = "";
    return retStr;
  }

  /**
   * Adds message to string with messages to be sent via comet
   *
   * @param message Message to be sent via comet
   */
  public synchronized void addMessageTS(String message) {
    messagesTSVC = messagesTSVC + message;
  }

  /**
   * Gets list of subscriptions.
   * 
   * @return list of subscriptions
   */
  public ArrayList<Subscription> getSubscribeList() {
    return subscribeList;
  }

  /**
   * Sets list of subscriptions.
   * 
   * @param subscribeList list of subscriptions
   */
  public void setSubscribeList(ArrayList<Subscription> subscribeList) {
    this.subscribeList = subscribeList;
  }
  
  
  /**
   * Remove subscription from subscribe list.
   * 
   * @param subscription subscription to delete
   */
  public void deleteFromSubscribeList(Subscription subscription){
    if(this.subscribeList != null && !subscribeList.isEmpty()){
      Iterator<Subscription> subscribeListIt = subscribeList.iterator();
      while(subscribeListIt.hasNext()){
        if(subscription.getId() != null && subscription.equals(subscribeListIt.next())){
          subscribeListIt.remove();
          return;
        }
      }
    }
  }
  
  
  /**
   * Add subscription to subscribe list.
   * 
   * @param subscription subscription to add
   */
  public void addToSubscribeList(Subscription subscription){
    if(this.subscribeList != null){
      if(!isInSubscribeList(subscription)){
        this.subscribeList.add(subscription);
      }
    }else{
      this.subscribeList = new ArrayList<Subscription>();
      this.subscribeList.add(subscription);
    }
  }
  
  /**
   * Gets subscription from subscribe list by id.
   * 
   * @param id id of searched subscription
   */
  public Subscription getSubscriptionFromList(Integer id){
    if(this.subscribeList != null && !subscribeList.isEmpty()){
      Iterator<Subscription> subscribeListIt = subscribeList.iterator();
      while(subscribeListIt.hasNext()){
        Subscription currentSubscription = subscribeListIt.next();
        if(currentSubscription.getId().equals(id)){
          return currentSubscription;
        }
      }
    }
    
    return null;
  }
  
  
  /**
   * Tests if given subscription is already in list.
   * 
   * @param subscription searched subscription
   * 
   * @return true if subscription is already in list, false otherwise
   */
  public boolean isInSubscribeList(Subscription subscription){
    if(this.subscribeList != null && !subscribeList.isEmpty()){
      Iterator<Subscription> subscribeListIt = subscribeList.iterator();
      while(subscribeListIt.hasNext()){
        if(subscription.getId() != null && subscription.getId().equals(subscribeListIt.next().getId())){
          return true;
        }
      }
    }
    return false;
  }
  
  /**
   * Removes subscription sources from subscribe and unsubscribe list.
   * 
   * @param subscription subscriprion which source will be remove from list
   */
  public void deleteFromSubscribes(Subscription subscription){    
    // delete positive sources from session
    ArrayList<SubscribedSource> sourcePosList = subscription.getSourcesAsSubSource(true);
    if(sourcePosList != null && !sourcePosList.isEmpty()){
      Iterator<SubscribedSource> posSourcesIt = sourcePosList.iterator();
      while(posSourcesIt.hasNext()){
        SubscribedSource currentSource = posSourcesIt.next();
        findSubscriptionAndDelete(getSubscribedSources(),currentSource);
      }
    }

    // delete negative sources from session
    ArrayList<SubscribedSource> sourceNegList = subscription.getSourcesAsSubSource(false);
    if(sourceNegList != null && !sourceNegList.isEmpty()){
      Iterator<SubscribedSource> negSourcesIt = sourceNegList.iterator();
      while(negSourcesIt.hasNext()){
        SubscribedSource currentSource = negSourcesIt.next();
        findSubscriptionAndDelete(getSubscribedSources(),currentSource);
      }
    }
  }
  
  /**
   * Adds subscription sources to subscribe and unsubscribe list.
   * 
   * @param subscription subscriprion which source will be add to list
   */
  public void addToSubscribes(Subscription subscription){
    // add positive sources to session
    ArrayList<SubscribedSource> sourcePosList = subscription.getSourcesAsSubSource(true);
    if(sourcePosList != null && !sourcePosList.isEmpty()){
      Iterator<SubscribedSource> posSourcesIt = sourcePosList.iterator();
      while(posSourcesIt.hasNext()){
        SubscribedSource currentSource = posSourcesIt.next();
        addSource(currentSource);
      }
    }

    // add negative sources to session
    ArrayList<SubscribedSource> sourceNegList = subscription.getSourcesAsSubSource(false);
    if(sourceNegList != null && !sourceNegList.isEmpty()){
      Iterator<SubscribedSource> negSourcesIt = sourceNegList.iterator();
      while(negSourcesIt.hasNext()){
        SubscribedSource currentSource = negSourcesIt.next();
        addUnsubscribeSource(currentSource);
      }
    }
  }
  
  /**
   * Finds subscription source in subscribed or unsubscribed list and remove it.
   * 
   * @param sources list where method will be search for subscription source
   * @param subSource subscription source that will be delete from list
   */
  private void findSubscriptionAndDelete(ArrayList<SubscribedSource> sources, SubscribedSource subSource){
    if(sources != null && !sources.isEmpty()){
      Iterator<SubscribedSource> sourcesIt = sources.iterator();
      while(sourcesIt.hasNext()){
        SubscribedSource actualSource = sourcesIt.next();
        boolean isTypeEqual = false;
        boolean isUriEqual = false;
        boolean isSourceEqual = false;
        
        if((actualSource.getType() != null && subSource.getType() != null) &&
           (actualSource.getType().equals(subSource.getType()))){
          isTypeEqual = true;
        }else if((actualSource.getType() == null && subSource.getType() == null) ){
          isTypeEqual = true;
        }
        
        if((actualSource.getUri() != null && subSource.getUri() != null) &&
           (actualSource.getUri().equals(subSource.getUri()))){
          isUriEqual = true;
        }else if((actualSource.getUri() == null && subSource.getUri() == null) ){
          isUriEqual = true;
        }
        
        if((actualSource.getUser() != null && subSource.getUser() != null) &&
           (actualSource.getUser().equals(subSource.getUser()))){
          isSourceEqual = true;
        }else if((actualSource.getUser() == null && subSource.getUser() == null) ){
          isSourceEqual = true;
        }
        
        if(isTypeEqual && isUriEqual && isSourceEqual){
          sourcesIt.remove();
          return;
        }
      }
    }
  }

  /**
   * Gets user settings for logged in user from database
   *
   * @return Returns list of parameters of user settings or null, if nobody logged in
   */
  public ArrayList<Settings> getSettings() {
    if (this.user == null) {
      return null;
    }
    PersistM pm = AppBean.getPersistenceManager();
    ArrayList<Settings> settings = new ArrayList<Settings>();
    Object[] params = new Object[2];
    params[0] = "userId";
    params[1] = this.user.getId();
    
    @SuppressWarnings("unchecked")
    List<Settings> sList = pm.queryDB("Settings.findByUser", params);
    if (sList != null && !sList.isEmpty()) {
      Iterator<Settings> sIterator = sList.iterator();
      while (sIterator.hasNext()) {
        settings.add(sIterator.next());
      }
    }
    return settings;
  }

  /**
   * Gets list with names of attributes which should be filtered out
   * 
   * @return Returns list with names of attributes which should be filtered out
   */
  public ArrayList<String> getAttFilter() {
    if (attFilter == null) {
      attFilter = new ArrayList<String>();
    }
    if (!attFilter.contains(Constants.UPDATABLE_AN_AT_NAME)) {
      attFilter.add(Constants.UPDATABLE_AN_AT_NAME);
    }
    return attFilter;
  }

  /**
   * Sets list with names of attributes which should be filtered out
   * 
   * @param attFilter List with names of attributes which should be filtered out
   */
  public void setAttFilter(ArrayList<String> attFilter) {
    this.attFilter = attFilter;
  }
  
  /**
   * Actualizes attribute filter from user's settings
   */
  public void actualizeAttFilter() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings attFilterParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_ATT_FILTER;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      attFilterParam = (Settings) sList.get(0);
    }
    if (attFilterParam != null) {
      String attFilterParamStr = attFilterParam.getValue();
      if (attFilterParamStr != null && !attFilterParamStr.isEmpty()) {
        String[] splitted = attFilterParamStr.split(",");
        attFilter = new ArrayList<String>(Arrays.asList(splitted));
      } else {
        attFilter = new ArrayList<String>();
      }
    }
  }  // actualizeAttFilter()
  
  /**
   * Actualizes all cached settings
   */
  public void actualizeAllCachedSettings() {
    actualizeLanguage();
    actualizeAttFilter();
    actualizeNegFeedbackSetting();
    actualizeEnableUpdatePositiveFeedback();
    actualizeAutoAltSetting();
    actualizeDisplaySugConfidence();
    actualizeKBRefMode();
  }

  /**
   * Actualizes whether negative feedback should updated for suggestions refused 
   * by same fragment as some confirmed have.
   */
  public void actualizeNegFeedbackSetting() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings negFeedParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_UPDATE_NEG_FEEDBACK_FOR_REFUSED_BY_SAME;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      negFeedParam = (Settings) sList.get(0);
    } else {
      updateNegFeedbackForRefusedBySame = false;
    }
    if (negFeedParam != null) {
      String negFeedParamStr = negFeedParam.getValue();
      if (negFeedParamStr != null && !negFeedParamStr.isEmpty()) {
        if (negFeedParamStr.contentEquals("1") || negFeedParamStr.equalsIgnoreCase("true")) {
          updateNegFeedbackForRefusedBySame = true;
        } else {
          updateNegFeedbackForRefusedBySame = false;
        }
      } else {
        updateNegFeedbackForRefusedBySame = false;
      }
    } else {
      updateNegFeedbackForRefusedBySame = false;
    }
  }  // actualizeNegFeedbackSetting()
  
  /**
   * Should be negative feedback updated for suggestions refused by same 
   * fragment as some confirmed have?
   * 
   * @return Returns whether negative feedback should updated for suggestions 
   *         refused by same fragment as some confirmed have.
   */
  public boolean getUpdateNegFeedbackForRefusedBySame() {
    return updateNegFeedbackForRefusedBySame;
  }

  /**
   * Sets whether negative feedback should updated for suggestions refused 
   * by same fragment as some confirmed have.
   * 
   * @param updateNegFeedbackForRefusedBySame Should be negative feedback updated 
   *                                          for suggestions refused by same 
   *                                          fragment as some confirmed have?
   */
  public void setUpdateNegFeedbackForRefusedBySame(boolean updateNegFeedbackForRefusedBySame) {
    this.updateNegFeedbackForRefusedBySame = updateNegFeedbackForRefusedBySame;
  }
  
  /**
   * Actualizes whether alternatives should be automatically activated
   */
  public void actualizeAutoAltSetting() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings negFeedParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_AUTO_ALTERNATIVES;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      negFeedParam = (Settings) sList.get(0);
    } else {
      autoActivateAlternatives = false;
    }
    if (negFeedParam != null) {
      String negFeedParamStr = negFeedParam.getValue();
      if (negFeedParamStr != null && !negFeedParamStr.isEmpty()) {
        if (negFeedParamStr.contentEquals("1") || negFeedParamStr.equalsIgnoreCase("true")) {
          autoActivateAlternatives = true;
        } else {
          autoActivateAlternatives = false;
        }
      } else {
        autoActivateAlternatives = false;
      }
    } else {
      autoActivateAlternatives = false;
    }
  }  // actualizeAutoAltSetting()
  
  /**
   * Should be alternatives automatically activated?
   * 
   * @return Returns whether alternatives should be automatically activated
   */
  public boolean getAutoActivateAlternatives() {
    return autoActivateAlternatives;
  }

  /**
   * Sets whether alternatives should be automatically activated
   * 
   * @param autoActivateAlternatives Should be alternatives automatically activated?
   */
  public void setAutoActivateAlternatives(boolean autoActivateAlternatives) {
    this.autoActivateAlternatives = autoActivateAlternatives;
  }
  
  /**
   * Actualizes whether other similar (same annotated text and URI of entity) 
   * suggestions in same part of document should be confirmed
   */
  public void actualizeEnableUpdatePositiveFeedback() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings posFeedParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_ENABLE_UPDATE_POSITIVE_FEEDBACK;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      posFeedParam = (Settings) sList.get(0);
    } else {
      enableUpdatePositiveFeedback = false;
    }
    if (posFeedParam != null) {
      String posFeedParamStr = posFeedParam.getValue();
      if (posFeedParamStr != null && !posFeedParamStr.isEmpty()) {
        if (posFeedParamStr.contentEquals("1") || posFeedParamStr.equalsIgnoreCase("true")) {
          enableUpdatePositiveFeedback = true;
        } else {
          enableUpdatePositiveFeedback = false;
        }
      } else {
        enableUpdatePositiveFeedback = false;
      }
    } else {
      enableUpdatePositiveFeedback = false;
    }
  }  // actualizeEnableUpdatePositiveFeedback()
  
  /**
   * Should be other similar (same annotated text and URI of entity) 
   * suggestions in same part of document confirmed?
   * 
   * @return Returns whether other similar (same annotated text and URI of entity) 
   *         suggestions in same part of document should be confirmed
   */
  public boolean getEnableUpdatePositiveFeedback() {
    return enableUpdatePositiveFeedback;
  }

  /**
   * Sets whether other similar (same annotated text and URI of entity) 
   * suggestions in same part of document should be confirmed
   * 
   * @param enableUpdatePositiveFeedback Should be other similar (same 
   *                                     annotated text and URI of entity) 
   *                                     suggestions in same part of document 
   *                                     confirmed?
   */
  public void setEnableUpdatePositiveFeedback(boolean enableUpdatePositiveFeedback) {
    this.enableUpdatePositiveFeedback = enableUpdatePositiveFeedback;
  }
  
  /**
   * Get language used in this session
   *
   * @return Returns language used in this session
   */
  public String getLanguage() {
    return language;
  }

  /**
   * Get number of language used in this session
   *
   * @return Returns number of language used in this session
   */
  public int getLanguageNum() {
    return languageNum;
  }

  /**
   * Set language for this session. If language code is not found, language
   * is set to English.
   *
   * @param language Language code according to ISO 639-2
   * @return If succeed and language code is found, returns true, false otherwise
   */
  public boolean setLanguage(String language) {
    int lNum = Localisation.LANGUAGE_CODES.indexOf(language);
    if (lNum < 0) {
      this.language = "eng";
      this.languageNum = Localisation.LANGUAGE_ENG;
      return true;
    }
    this.language = language;
    this.languageNum = lNum;
    return false;
  }

  /**
   * Actualize language settings from database
   *
   * @return If succeed, returns true, false otherwise
   */
  public boolean actualizeLanguage() {
    if (this.user == null) {
      return true;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings langParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_SERVER_LANGUAGE;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      langParam = (Settings) sList.get(0);
    } else {
      return true;
    }
    return setLanguage(langParam.getValue());
  }

  /**
   * Refreshes informations about user from DB
   */
  public void refreshUser() {
    if (user != null) {
      User u = (User) AppBean.getPersistenceManager().getEntityById("User", user.getId());
      if (u != null) {
        user = u;
      }
    }
  }  // refreshUser()

  /**
   * Gets default group of logged in user from database.
   * If according user settings parameter is correctly set, it will be used.
   * If parameter is not set, first group of this user fetched from database
   * will be returned.
   *
   * @return Default group of logged in user
   */
  public UserGroup getDefaultGroup() {
    UserGroup retGroup = null;
    if (user == null) {
      return null;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings langParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_DEFAULT_GROUP;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    Settings groupParam = null;
    if (sList != null && !sList.isEmpty()) {
      groupParam = (Settings) sList.get(0);
    }
    if (groupParam != null) {
      String grStr = groupParam.getValue();
      if (grStr != null && !grStr.isEmpty()) {
        grStr = grStr.replace(AppBean.getBaseGroupUri(), "");
        Integer grId = null;
        try {
          grId = Integer.parseInt(grStr);
        } catch (NumberFormatException nfe) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "NumberFormatException in getDefaultGroup.";
            Logger.getLogger(EditorSession.class.getName()).log(Level.ALL, msg);
          }
          grId = null;
        }
        if (grId != null) {
          UserGroup cmpG = new UserGroup(grId);
          List<UserGroup> groupList = user.getGroups();
          int index = groupList.indexOf(cmpG);
          if (index >= 0) {
            retGroup = groupList.get(index);
          }
        }
      }
    }
    if (retGroup == null) {
      if (!user.getGroups().isEmpty()) {
        Iterator<UserGroup> grIt = user.getGroups().iterator();
        while (grIt.hasNext() && retGroup == null) {
          UserGroup gr = grIt.next();
          retGroup = gr;
        }
      }
    }
    return retGroup;
  }  // getDefaultGroup()
  
  /***************************************
   * Suggestion
   ***************************************/
  
  /**
   * Sets minimal confidence 
   *  
   * @param minConfidence Number of minimal confidence
   */
  public void setMinConfidence(Integer minConfidence){
    this.minConfidence = minConfidence;
  }

  /**
   * Gets number of minimal confidence
   *
   * @return number of minimal confidence
   */
  public Integer getMinConfidence(){
    return minConfidence;
  }

  /**
   * Gets minimal level of confidence to auto confirm suggestion
   * 
   * @return Returns minimal level of confidence to auto confirm suggestion
   */
  public Integer getAutoConfirm() {
    return autoConfirm;
  }

  /**
   * Sets minimal level of confidence to auto confirm suggestion
   * 
   * @param autoConfirm Minimal level of confidence to auto confirm suggestion
   */
  public void setAutoConfirm(Integer autoConfirm) {
    this.autoConfirm = autoConfirm;
  }

  /**
   * Sets array of sent suggestions (client's cache)
   * 
   * @param sugArray New array of sent suggestions
   */
  public void setSendedSugg(ArrayList<Integer> sugArray){
    synchronized (this) {
      sendedSuggestions = new ArrayList<Integer>();
      sendedSuggestions.addAll(sugArray);
    }
  }
  
  /**
   * Adds suggestion to the array of sent suggestions (client's cache)
   * 
   * @param suggestion Suggestion to add
   */
  public void addSendedSugg(Suggestion suggestion){
    synchronized (sendedSuggestions) {
      if (!sendedSuggestions.contains(suggestion.getId())) {
        sendedSuggestions.add(suggestion.getId());
      }
    }
  }
  
  /**
   * Adds array of suggestions to the array of sent suggestions (client's cache)
   * 
   * @param sugArray Array of suggestions to add
   */
  public void addSendedSugg(ArrayList<Suggestion> sugArray){
    synchronized (sendedSuggestions) {
      if (!sendedSuggestions.isEmpty()) {
        Iterator<Suggestion> sugArrayIt = sugArray.iterator();
        while (sugArrayIt.hasNext()) {
          addSendedSugg(sugArrayIt.next());
        }
      } else {
        Iterator<Suggestion> sugArrayIt = sugArray.iterator();
        while (sugArrayIt.hasNext()) {
          sendedSuggestions.add(sugArrayIt.next().getId());
        }
      }
    }
  }
  
  /**
   * Removes suggestion from the array of sended suggestions (client's cache)
   * 
   * @param suggestion Suggestion to remove
   */
  public void deleteSendedSugg(Suggestion suggestion){
    synchronized (sendedSuggestions) {
      sendedSuggestions.remove(suggestion.getId());
    }
  }
  
  /**
   * Removes suggestions from the array of sended suggestions (client's cache)
   * 
   * @param sugArray Array of suggestions to remove
   */
  public void deleteSendedSugg(ArrayList<Suggestion> sugArray){
    synchronized (sendedSuggestions) {
      if (!sendedSuggestions.isEmpty()) {
        Iterator<Suggestion> sugArrayIt = sugArray.iterator();
        while (sugArrayIt.hasNext()) {
          deleteSendedSugg(sugArrayIt.next());
        }
      }
    }
  }
  
  /**
   * Differences array of suggestions with array of sent ones and return these 
   * suggestions which are not in sent
   * 
   * @param sugArray Array to differences
   * @return Returns suggestions which are not in sent
   */
  public ArrayList<Suggestion> diffSendedSug(ArrayList<Suggestion> sugArray){
    synchronized (sendedSuggestions) {
      ArrayList<Suggestion> result = new ArrayList<Suggestion>(sugArray.size());
      Iterator<Suggestion> sugArrayIt = sugArray.iterator();
      while (sugArrayIt.hasNext()) {
        Suggestion actualSugg = sugArrayIt.next();
        if (!sendedSuggestions.contains(actualSugg.getId())) {
          result.add(actualSugg);
        }
      }
      return result;
    }
  }
  
  /**
   * Differences array of suggestions with array of sent ones and return these 
   * suggestions which are in sent
   * 
   * @param sugArray Array to differences
   * @return Returns suggestions which are in sent
   */
  public ArrayList<Suggestion> haveSendedSug(ArrayList<Suggestion> sugArray){
    synchronized (sendedSuggestions) {
      ArrayList<Suggestion> result = new ArrayList<Suggestion>(sugArray.size());
      Iterator<Suggestion> sugArrayIt = sugArray.iterator();
      while (sugArrayIt.hasNext()) {
        Suggestion actualSugg = sugArrayIt.next();
        if (sendedSuggestions.contains(actualSugg.getId())) {
          result.add(actualSugg);
        }
      }
      return result;
    }
  }
  
  /**
   * Differences array of suggestions with array of sent ones and return these 
   * suggestions which are in sent but not in given array
   * 
   * @param sugArray Array to differences
   * @return Returns suggestions which are in sent but not in given array
   */
  public ArrayList<Integer> diffStoredSug(ArrayList<Suggestion> sugArray){
    synchronized (sendedSuggestions) {
      ArrayList<Integer> result = new ArrayList<Integer>(sugArray.size());
      Iterator<Integer> sugArrayIdIt = sendedSuggestions.iterator();
      while (sugArrayIdIt.hasNext()) {
        Integer actualSuggId = sugArrayIdIt.next();
        Iterator<Suggestion> sugArrayIt = sugArray.iterator();
        boolean founded = false;
        while (sugArrayIt.hasNext()) {
          Suggestion actualSugg = sugArrayIt.next();
          if (actualSugg.getId().equals(actualSuggId)) {
            founded = true;
            break;
          }
        }

        if (!founded) {
          result.add(actualSuggId);
        }
      }
      return result;
    }
  }
  
  /**
   * Tries to find an ID of the suggestion in the sendedSuggestions array and
   * returns the result of the search as a boolean value
   * 
   * @param suggID ID of the suggestion that we are searching for
   * @return True if the suggestion ID is contained, false otherwise
   */
  public boolean isSuggInSendedSuggestions(Integer suggID) {
    synchronized (sendedSuggestions) {
      if (sendedSuggestions.indexOf(suggID) >= 0) {
        return true;
      }
      return false;
    }
  }

  /**
   * Gets array of sent suggestions IDs (client's cache)
   * 
   * @return Returns array of sent suggestions IDs
   */
  public ArrayList<Integer> getSendedSuggestions() {
    return sendedSuggestions;
  }
  
  /**
   * Get all sent suggestions.
   * 
   * @return Returns list of sent suggestions
   */
  public ArrayList<Suggestion> getWholeSendedSuggestions() {
    synchronized (this) {
      ArrayList<Suggestion> suggestions = new ArrayList<Suggestion>();
      
      Iterator<Integer> it = sendedSuggestions.iterator();
      while(it.hasNext()){
        Query query = AppBean.getPersistenceManager().getEM().createNamedQuery("Suggestion.findById");
        query.setParameter("id", it.next());
        List sList = query.getResultList();
        if (sList != null && !sList.isEmpty()) {
          suggestions.add((Suggestion) sList.get(0));
        }
      }
      return suggestions;
    }
  }
  
  /**
   * Get sended suggestion.
   * 
   * @return Returns sended suggestion
   */
  public Suggestion getWholeSendedSuggestion(Integer id) {
    Query query = AppBean.getPersistenceManager().getEM().createNamedQuery("Suggestion.findById");
    query.setParameter("id", id);
    List sList = query.getResultList();
    if (sList != null && !sList.isEmpty()) {
      return (Suggestion) sList.get(0);
    }
    return null;
  }

  /**
   * Returns whether suggestions was requested so an empty diff cannot be omitted.
   * 
   * @return Returns whether suggestions was requested so an empty diff cannot be omitted
   */
  public synchronized Boolean getSugRequestFlag() {
    return sugRequestFlag;
  }

  /**
   * Sets whether suggestions was requested so an empty diff cannot be omitted.
   * 
   * @param sugRequestFlag Was suggestions requested (can be empty diff omitted)?
   */
  public synchronized void setSugRequestFlag(Boolean sugRequestFlag) {
    this.sugRequestFlag = sugRequestFlag;
  }

  /**
   * Returns whether confidence should be displayed for suggestions
   * 
   * @return Returns whether confidence should be displayed for suggestions
   */
  public boolean getDisplaySugConfidence() {
    return displaySugConfidence;
  }

  /**
   * Sets whether confidence should be displayed for suggestions
   * 
   * @param displaySugConfidence Should be confidence displayed for suggestions?
   */
  public void setDisplaySugConfidence(boolean displaySugConfidence) {
    this.displaySugConfidence = displaySugConfidence;
  }
  
  /**
   * Actualizes whether confidence should be displayed for suggestions
   */
  public void actualizeDisplaySugConfidence() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings posFeedParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_DISPLAY_SUG_CONFIDENCE;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      posFeedParam = (Settings) sList.get(0);
    } else {
      displaySugConfidence = true;
    }
    if (posFeedParam != null) {
      String posFeedParamStr = posFeedParam.getValue();
      if (posFeedParamStr != null && !posFeedParamStr.isEmpty()) {
        if (posFeedParamStr.contentEquals("1") || posFeedParamStr.equalsIgnoreCase("true")) {
          displaySugConfidence = true;
        } else {
          displaySugConfidence = false;
        }
      } else {
        displaySugConfidence = false;
      }
    } else {
      displaySugConfidence = true;
    }
  }  // actualizeDisplaySugConfidence()

  /**
   * Gets whether KB_Ref mode is on
   * 
   * @return Returns whether KB_Ref mode is on
   */
  public boolean getKBRefMode() {
    return KBRefMode;
  }

  /**
   * Sets whether KB_Ref mode is on
   * 
   * @param KBRefMode Is KB_Ref mode on?
   */
  public void setKBRefMode(boolean KBRefMode) {
    this.KBRefMode = KBRefMode;
  }
  
  /**
   * Actualizes whether KB_Ref mode is on
   */
  public void actualizeKBRefMode() {
    if (this.user == null) {
      return;
    }
    PersistM pm = AppBean.getPersistenceManager();
    Settings kRMParam = null;
    Object[] params = new Object[4];
    params[0] = "userId";
    params[1] = this.user.getId();
    params[2] = "name";
    params[3] = Constants.SETTINGS_PARAM_KB_REF_MODE;
    List sList = pm.queryDB("Settings.findByUserAndName", params);
    if (sList != null && !sList.isEmpty()) {
      kRMParam = (Settings) sList.get(0);
    } else {
      KBRefMode = false;
    }
    if (kRMParam != null) {
      String kRMParamStr = kRMParam.getValue();
      if (kRMParamStr != null && !kRMParamStr.isEmpty()) {
        if (kRMParamStr.contentEquals("1") || kRMParamStr.equalsIgnoreCase("true")) {
          KBRefMode = true;
        } else {
          KBRefMode = false;
        }
      } else {
        KBRefMode = false;
      }
    } else {
      KBRefMode = false;
    }
  }  // actualizeKBRefMode()
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same id.
   *
   * @param obj Object to compare with
   * @return If object is same type and have same id, returns true, false otherwise
   */
  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final EditorSession other = (EditorSession) obj;
    if (this.sessionId != other.sessionId) {
      return false;
    }
    return true;
  }

  /**
   * Returns hash code of this object. Hash is based on sessionID.
   * 
   * @return Hash code
   */
  @Override
  public int hashCode() {
    int hash = 3;
    hash = 89 * hash + (int) (this.sessionId ^ (this.sessionId >>> 32));
    return hash;
  }

}  // class EditorSession