StoryscopeInterfaceSender.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: StoryscopeInterfaceSender.java
 * Description: Class represent thread of Storyscope Interface that sends 
 *              messages to StoryScopes
 */

/**
 * @file StoryscopeInterfaceSender.java
 *
 * @brief Class represent thread of Storyscope Interface that sends messages to StoryScopes
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Linearizer;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.SubscribedSource;
import cz.vutbr.fit.knot.annotations.comet.Util;
import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.Fragment;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.LinkedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.NestedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.modules.CoreFuncModule;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Document;

/**
 * Class that represents a thread that sends annotations from all documents 
 * according to the rules composed of Subscribed and unsubscribed sources, types 
 * and users.
 *
 * @brief Class represent thread of Storyscope Interface that sends messages to StoryScopes
 * @author Martin Petr (xpetrm05)
 */
public class StoryscopeInterfaceSender extends Thread {
  
  /** List of avaibel StoryScopes */
  private List<StoryScope> storyScopes; 
  /** Object with informations about current request  */
  private RequestInfo requestInfo;
  /** Array of added annotations to send to Storyscope */
  ArrayList<Annotation> addedAnnotations;
  /** Array of edited annotations to send to Storyscope */
  ArrayList<Annotation> editedAnnotations;
  /** Array of removed annotations to send to Storyscope */
  ArrayList<Annotation> removedAnnotations;
  /** Indicates if this code will be started as module (in therad) or not */
  boolean runAsModule;
  /** Pattern of response from StoryScope*/
  private static final String answerTemplate = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ok/>";
  
  /**
   * Constructor
   * 
   * @param requestInfo informations about current request
   */
  public StoryscopeInterfaceSender(RequestInfo requestInfo){
    super("StoryscopeInterfaceSender");
    runAsModule = true;
    this.requestInfo = requestInfo;
    addedAnnotations = requestInfo.getFlier().getAddedAnnotations();
    if(addedAnnotations == null){
      addedAnnotations = new ArrayList<Annotation>();
    }
    
    editedAnnotations = requestInfo.getFlier().getEditedAnnotations();
    if(editedAnnotations == null){
      editedAnnotations = new ArrayList<Annotation>();
    }
    
    removedAnnotations = requestInfo.getFlier().getRemovedAnnotations();
    if(removedAnnotations == null){
      removedAnnotations = new ArrayList<Annotation>();
    }
  }

  /**
   * Constructor (not run in thread).
   * 
   * @param name of thread
   */
  public StoryscopeInterfaceSender(String name) {
    super(name);
    runAsModule = false;
    addedAnnotations = new ArrayList<Annotation>();
    editedAnnotations = new ArrayList<Annotation>();
    removedAnnotations = new ArrayList<Annotation>();
  }

  /**
   * Gets array of added annotations to send to Storyscope
   * 
   * @return array of added annotations
   */
  public ArrayList<Annotation> getAddedAnnotations() {
    return addedAnnotations;
  }

  /**
   * Sets array of added annotations to send to Storyscope
   * 
   * @param addedAnnotations array of added annotations to send to Storyscope
   */
  public void setAddedAnnotations(ArrayList<Annotation> addedAnnotations) {
    this.addedAnnotations = addedAnnotations;
  }

  /**
   * Gets array of edited annotations to send to Storyscope
   * 
   * @return array of edited annotations
   */
  public ArrayList<Annotation> getEditedAnnotations() {
    return editedAnnotations;
  }

  /**
   * Sets array of edited annotations to send to Storyscope
   * 
   * @param editedAnnotations array of edited annotations to send to Storyscope
   */
  public void setEditedAnnotations(ArrayList<Annotation> editedAnnotations) {
    this.editedAnnotations = editedAnnotations;
  }

  /**
   * Gets array of removed annotations to send to Storyscope
   * 
   * @return array of removed annotations
   */
  public ArrayList<Annotation> getRemovedAnnotations() {
    return removedAnnotations;
  }

  /**
   * Sets array of removed annotations to send to Storyscope
   * 
   * @param removedAnnotations array of removed annotations to send to Storyscope
   */
  public void setRemovedAnnotations(ArrayList<Annotation> removedAnnotations) {
    this.removedAnnotations = removedAnnotations;
  }
  
  /**
   * Method locks documents for read and run main method.
   * 
   */
  @Override
  public void run(){
    //lock document for change
    if (requestInfo.getSession() == null || requestInfo.getSession().getSyncDocument() == null) {
      return;
    }
    
    AnnotDocument doc = requestInfo.getSession().getSyncDocument();
    
    if(doc != null){
      while(true){
        if(AppBean.getLockMaster().getDocumentLock(doc.getId()).lockForRead()){
          break;
        }
      }
    }
    
    try{
      startModule();
    }
    
    catch(Exception ex){
      // unlock document for change
      if(doc != null){
        AppBean.getLockMaster().getDocumentLock(doc.getId()).unlockForRead();
      }
    } 
    
    finally{
      // unlock document for change
      if(doc != null){
        AppBean.getLockMaster().getDocumentLock(doc.getId()).unlockForRead();
      }
    }
  }
  
  /**
   * Method check added, edited and deleted annotations and set them to configured 
   * StoryScopes. If is StoryScope unreachable, method save its messages and 
   * send them when will be reachable.
   */
  void startModule(){
    //body of new thread
    @SuppressWarnings("unchecked")
    List<StoryScope> tmpList = AppBean.getPersistenceManager().getEntitiesByName("StoryScope");
    storyScopes = tmpList;
    
    if(storyScopes != null){   
      Iterator<StoryScope> ssListIterator = storyScopes.iterator();
      
      while(ssListIterator.hasNext()){  // for each StoryScope
        StoryScope actualStoryScope = ssListIterator.next();
        ArrayList<SubscribedSource> subscribedList = actualStoryScope.getSubscribedList();
        ArrayList<SubscribedSource> unsubscribedList = actualStoryScope.getUnsubscribedList();
        
        //processing annotations that was added 
        ArrayList<Annotation> refusedAnnotations = new ArrayList<Annotation>();
        ArrayList<Annotation> acceptedAnnotations = new ArrayList<Annotation>();
        Iterator addAnnotIterator = addedAnnotations.iterator();
        //go trough all added annotations
        while(addAnnotIterator.hasNext()){
          Annotation actualAnnotation = (Annotation)addAnnotIterator.next();
          //and test they for subscription
          if(isSubscribed(actualAnnotation,unsubscribedList,subscribedList, CoreFuncModule.getUserSources(actualAnnotation.getUser()))){
            acceptedAnnotations.add(actualAnnotation);
          }else{
            refusedAnnotations.add(actualAnnotation);
          }
        }
              
        //for unaccdepted and accepted annotation must be checked if they are link with other annotation
        acceptedAnnotations = getRelatedAnnotations(acceptedAnnotations,refusedAnnotations,subscribedList,unsubscribedList);
        ArrayList<String> addMessage = new ArrayList<String>();
        Iterator<Annotation> acceptedIterator = acceptedAnnotations.iterator();
        while(acceptedIterator.hasNext())
        {
          addMessage.add(AnnotationToXMLStringL(acceptedIterator.next(), requestInfo.getSession().getParsedSyncDocument()));
        }
        
        //processing annotations that was changed or auto updated
        //this part of code add auto updated annotations
        //at first checks if flier have some auto updated anotations
        if(runAsModule && requestInfo.getFlier().getAutoUpdatedAnnotations()!=null){
          //if is edited annotations array list empty
          if(editedAnnotations == null){ 
            //simply add all auto updated annotations
            editedAnnotations = requestInfo.getFlier().getAutoUpdatedAnnotations();
          }else{
            //if edited annotations array list have some annotations
            Iterator<Annotation> autoUpdatedIter = requestInfo.getFlier().getAutoUpdatedAnnotations().iterator();
            
            //check if edited annotations don't contains same annotation that is in auto updated annotations array list
            while(autoUpdatedIter.hasNext()){
              Annotation actualAnnotation = autoUpdatedIter.next();
              if(!editedAnnotations.contains(actualAnnotation)){
                //add only different annotations
                editedAnnotations.add(actualAnnotation);
              }
            }
          }
        }
        
        refusedAnnotations = new ArrayList<Annotation>();
        acceptedAnnotations = new ArrayList<Annotation>();
        Iterator editedAnnotIterator = editedAnnotations.iterator();
        //go trough all changed annotations
        while(editedAnnotIterator.hasNext()){
          Annotation actualAnnotation = (Annotation)editedAnnotIterator.next();
          //and test they for subscription
          if(isSubscribed(actualAnnotation,unsubscribedList,subscribedList,CoreFuncModule.getUserSources(actualAnnotation.getUser()))){
            acceptedAnnotations.add(actualAnnotation);
          }else{
            refusedAnnotations.add(actualAnnotation);
          }
        }
        
        //for unaccdepted and accepted annotation must be checked if they are link with other annotation
        acceptedAnnotations = getRelatedAnnotations(acceptedAnnotations,refusedAnnotations,subscribedList,unsubscribedList);
        ArrayList<String> editedMessage = new ArrayList<String>();
        acceptedIterator = acceptedAnnotations.iterator();
        while(acceptedIterator.hasNext())
        {
          editedMessage.add(AnnotationToXMLStringL(acceptedIterator.next(), requestInfo.getSession().getParsedSyncDocument()));
        }
        
        //processing annotations that was deleted
        refusedAnnotations = new ArrayList<Annotation>();
        acceptedAnnotations = new ArrayList<Annotation>();
        Iterator removedAnnotIterator = removedAnnotations.iterator();
        //go trough all deleted annotations
        while(removedAnnotIterator.hasNext()){
          Annotation actualAnnotation = (Annotation)removedAnnotIterator.next();
          //and test they for subscription
          if(isSubscribed(actualAnnotation,unsubscribedList,subscribedList,CoreFuncModule.getUserSources(actualAnnotation.getUser()))){
            acceptedAnnotations.add(actualAnnotation);
          }else{
            refusedAnnotations.add(actualAnnotation);
          }
        }
        
        //for unaccdepted and accepted annotation must be checked if they are link with other annotation
        acceptedAnnotations = getRelatedAnnotations(acceptedAnnotations,refusedAnnotations,subscribedList,unsubscribedList);
        ArrayList<String> removedMessage = new ArrayList<String>();
        acceptedIterator = acceptedAnnotations.iterator();
        while(acceptedIterator.hasNext())
        {
          removedMessage.add(AnnotationToXMLStringL(acceptedIterator.next(), requestInfo.getSession().getParsedSyncDocument()));
        }
        
        //if there are messages for sent
        if(!addMessage.isEmpty() || !editedMessage.isEmpty() || !removedMessage.isEmpty())
        {
          String message = "<add>" + actualStoryScope.getMessagesAdd() + StoryScope.messagesToString(addMessage) + "</add>"
                  + "<change>" + actualStoryScope.getMessagesChange() + StoryScope.messagesToString(editedMessage) + "</change>"
                  + "<remove>" + actualStoryScope.getMessagesDelete() + StoryScope.messagesToString(removedMessage) + "</remove>";
          
          String data = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
                + "<messages xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\""
                + " xmlns:geo=\"http://www.w3.org/2003/01/geo/wgs84_pos#\""
                + " xmlns:a=\"http://knot.fit.vutbr.cz/annotations/AnnotXMLSchema\">\n"
                + "<annotations>" 
                + message
                + "</annotations>"
                + "</messages>";
          //try to send message for actual StroySpace
          if(!sendAndCheck(actualStoryScope, data)){
            //new annotations must be sent wether error occurs
            actualStoryScope.addSavedMessages(addMessage, SavedMessage.MESSAGE_ADD);
            actualStoryScope.addSavedMessages(editedMessage, SavedMessage.MESSAGE_CHANGE);
            actualStoryScope.addSavedMessages(removedMessage, SavedMessage.MESSAGE_DELETE);
          }else{
            actualStoryScope.deleteMessages();
          }
        }
      }  // // for each StoryScope
    }  // if(storyScopes != null
  }  // startModule()
  
  /**
   * Method sends a message for each StoryScope in list and check if the StoryScope 
   * sent correct answer.
   *
   * @param storyScope StoryScopes whose message will be sent.
   * @param data Data to send
   */
  private boolean sendAndCheck(StoryScope storyScope, String data){
    String answer = new String();
    
    try{
      String postMessage = "xml=" + URLEncoder.encode(data,"UTF-8");

      URL clientUrl = new URL(storyScope.getClientURL());
      URLConnection clientConnection = clientUrl.openConnection();
      clientConnection.setDoOutput(true);

      OutputStreamWriter dataWriter = new OutputStreamWriter(clientConnection.getOutputStream());
      dataWriter.write(postMessage);
      dataWriter.close();

      BufferedReader recivedData = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
      String line;
      while ((line = recivedData.readLine()) != null) {
          answer += line;
      }
      recivedData.close();
    }

    catch(Exception e){
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Unable to send data to StoryScope with name: " + storyScope.getName() + ".";
        Logger.getLogger(StoryscopeInterfaceSender.class.getName()).log(Level.SEVERE, msg);
        return false;
      }
    }

    if(!answer.equalsIgnoreCase(answerTemplate)){
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "A confirmation message from StoryScope with name: " + storyScope.getName() + " not match. Message content:" + answer;
        Logger.getLogger(StoryscopeInterfaceSender.class.getName()).log(Level.SEVERE, msg);
        return false;
      }
    }
    
    return true;
  }  // sendAndCheck()
  
  /** 
   * Method finds every rule for all given annotation's type ancestors and returns 
   * if is subscribed or unsubscribed.
   * 
   * @param rootType type where will checking begin
   * @param annot annotation that is checked
   * @param unsubscribedSources unsubscribed sources for current user
   * @param subscribedSources subscribed sources for current user
   * @param sources sources for current user
   * @param unsubResult list of finded unsubscribed rules
   * @param subResult list of finded 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<SubscribedSource> unsubscribedSources, 
            ArrayList<SubscribedSource> subscribedSources,ArrayList<String> sources,ArrayList<SubscribedSource> unsubResult, 
            ArrayList<SubscribedSource> subResult){ //sorry for this :-(
    
    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(EditorSession.listOfMatches(unsubscribedSources,annot,actualType,sources));

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

        if(!subResult.isEmpty() && EditorSession.containTypeRule(subResult)){
          return Constants.SUBSCRIBED; // if was type found in subscribed then return true
        }else{
          if(!unsubResult.isEmpty() && EditorSession.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,unsubscribedSources,subscribedSources,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; 
  }
  
  /**
   * Method will check if the given annotation meets the criteria for sending to 
   * StoryScope
   *
   * @param annot Checked annotation
   * @param unsubscribedSources list of unsubscribed sources
   * @param subscribedSources list of subscribed sources
   * @param sources List of sources to which annotation belongs to
   * @return If annotation matches to subscriptions, returns true, false otherwise
   */
  private boolean isSubscribed(Annotation annot,ArrayList<SubscribedSource> unsubscribedSources, ArrayList<SubscribedSource> subscribedSources, ArrayList<String> sources) {
    
    ArrayList<SubscribedSource> unsubResult = new ArrayList<SubscribedSource>();
    ArrayList<SubscribedSource> subResult = new ArrayList<SubscribedSource>();

    switch(checkBranch(annot.getAnnotType(),annot,unsubscribedSources,subscribedSources,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(EditorSession.containUserRule(subResult)){
        return true;
      }
      if(EditorSession.containUserRule(unsubResult)){
        return false;
      }
      if(EditorSession.containSourceRule(subResult)){
        return true;
      }
      if(EditorSession.containSourceRule(unsubResult)){
        return false;
      }
    }

    return false;
  } // isSubscribed()
  
  /**
   * Method returns all linked annotations of this annotation.
   * 
   * @param annot annotation which will be processed
   * @return list of annotations that are linked with this annotation
   */
  private ArrayList<Annotation> getLinkedAnnotations(Annotation annot){
    ArrayList<Annotation> innerAnnotationList = new ArrayList<Annotation>();
    Iterator <BaseAttribute> attrIt = annot.getAttributes().iterator();
    
    while(attrIt.hasNext()){
      BaseAttribute attrTmp = attrIt.next();
      if(attrTmp instanceof LinkedAnnotationAttribute)
      {
        //here are only linked annotations
        LinkedAnnotationAttribute linkedAttr = (LinkedAnnotationAttribute)attrTmp;
        innerAnnotationList.add((Annotation)linkedAttr.getValue());
      }
    } 
    
    return innerAnnotationList;
  }
  
  /**
   * Method returns all annotations that are link annotation given as parameter.
   * 
   * @param annot annotation which will be processed
   * @return list of annotations that links this anotation
   */
  private ArrayList<Annotation> getLinkedAnnotationsDB(Annotation annot){
    ArrayList<Annotation> innerAnnotationList = new ArrayList<Annotation>();
    Object[] params = {"linked",annot.getId()};
    @SuppressWarnings("unchecked")
    List <LinkedAnnotationAttribute> attrList = AppBean.getPersistenceManager().queryDB("Attribute.findByLinked", params);
    if(attrList != null)
    {
      Iterator <LinkedAnnotationAttribute> attrIt = attrList.iterator();

      while(attrIt.hasNext()){
        LinkedAnnotationAttribute linkedAttr = attrIt.next();
        Annotation dbAnnot = (Annotation)AppBean.getPersistenceManager().getEntityById("Annotation", linkedAttr.getAnnotation());
        if(dbAnnot != null){
          innerAnnotationList.add(dbAnnot);
        }
      }
    }
    return innerAnnotationList;
  }
  
  /**
   * Method check if annotation have any linked type parameter and all this parameters 
   * add to list with secondaryAnnotList. But check if isn't inside main or secondary 
   * annotations list before add it.
   *
   * @param mainAnnotList array list of approved annotations 
   * @param secondaryAnnotList secondary list of approved annotations
   * @param annot annotatihon thats linked type attributes will be add to list
   * @return return list thats contain secodary annotation list and linked type annotations from annotation
   */
  private ArrayList<Annotation> decomposeLinked(ArrayList<Annotation> mainAnnotList, ArrayList<Annotation> secondaryAnnotList, Annotation annot){  
    Iterator<Annotation> innerIt = getLinkedAnnotations(annot).iterator();
     
    found : while(innerIt.hasNext()){
      Annotation actualAnnot = innerIt.next();
      //as first, go trough main annotations (approved annotations)
      Iterator<Annotation> mainIt = mainAnnotList.iterator();
      while(mainIt.hasNext()){
        //check if current annotation from linked is in main annotations list
        Annotation approvedAnnot = mainIt.next();
        if(approvedAnnot.getId() == actualAnnot.getId()){
          continue found;
        }
      }
      
      //as second, go trough secondary annotations (approved annotations)
      Iterator<Annotation> secondIt = secondaryAnnotList.iterator();
      while(secondIt.hasNext()){
        //check if current annotation from linked is in secondary annotations list
        Annotation approvedAnnot = secondIt.next();
        if(approvedAnnot.getId() == actualAnnot.getId()){
          continue found;
        }
      }
      secondaryAnnotList.add(actualAnnot);
    }
    
    return secondaryAnnotList;
  }
  
  /**
   * Method checks if approved and unapproved annotations have linked type attributes
   * when there are any, add annotations that are linked with approved or if they are
   * subscribed.
   *
   * @param approvedAnnot annotations that are approved (they are subscribed) 
   * @param unapprovedAnnot annotations that are unapproved (others annotations)
   * @param subscribed list of subscribed sources for current StoryScope
   * @param unsubscribed list of unsubscribed sources for current StoryScope
   * @return approved annotations and added annotations together in one list
   */
  private ArrayList<Annotation> getRelatedAnnotations(ArrayList<Annotation> approvedAnnot, 
                                      ArrayList<Annotation> unapprovedAnnot,
                                      ArrayList<SubscribedSource> subscribed,
                                      ArrayList<SubscribedSource> unsubscribed){
    
    ArrayList<Annotation> secondaryApproved = getRelatedAnnots(approvedAnnot,unapprovedAnnot,subscribed,unsubscribed);
    Iterator<Annotation> secApprovedIt = secondaryApproved.iterator();
    ArrayList<Annotation> addedAnnotations = new ArrayList<Annotation>();
    
    while(secApprovedIt.hasNext()){
      //annotations that will be tested will be in this list
      ArrayList<Annotation> openList = new ArrayList<Annotation>();
      //there will be annotations after test
      ArrayList<Annotation> closeList = new ArrayList<Annotation>();
      openList.add(secApprovedIt.next());
      while(!openList.isEmpty()){
        Annotation actualAnnot = openList.remove(0);
        closeList.add(actualAnnot);
        
        ArrayList<Annotation> links = getLinkedAnnotations(actualAnnot);
        if(links != null) links.addAll(getLinkedAnnotationsDB(actualAnnot));
        else links = getLinkedAnnotationsDB(actualAnnot);
        if(links != null){
          Iterator<Annotation> linksIt = links.iterator();
          while(linksIt.hasNext()){
            Annotation actualLink = linksIt.next();
            if(!openList.contains(actualLink) && !closeList.contains(actualLink)){
              openList.add(actualLink);
              if(!addedAnnotations.contains(actualLink) && !approvedAnnot.contains(actualLink))
              {
                addedAnnotations.add(actualLink);
              }
            }
          }
        }

      }
    }
    
    if(approvedAnnot == null){
      return addedAnnotations;
    }
    
    approvedAnnot.addAll(addedAnnotations);
    return approvedAnnot;
  }
  
  /**
   * Method gets related annotations that links given annotation.
   * 
   * @param approvedAnnot list od approved annotations 
   * @param unapprovedAnnot list of unapproved annotations
   * @param subscribed subecribed rules
   * @param unsubscribed unsubscribed rules
   * @return list of realted annotations
   */
  public ArrayList<Annotation> getRelatedAnnots(ArrayList<Annotation> approvedAnnot, 
                                      ArrayList<Annotation> unapprovedAnnot, 
                                      ArrayList<SubscribedSource> subscribed,
                                      ArrayList<SubscribedSource> unsubscribed) {
    ArrayList<Annotation> result = new ArrayList<Annotation>();
    Iterator<Annotation> unapprovedIt = unapprovedAnnot.iterator();

    while (unapprovedIt.hasNext()) {
      //annotations that will be tested will be in this list
      ArrayList<Annotation> openList = new ArrayList<Annotation>();
      //there will be annotations after test
      ArrayList<Annotation> closeList = new ArrayList<Annotation>();
      openList.add(unapprovedIt.next());

      while (!openList.isEmpty()) {
        Annotation actualAnnot = openList.remove(0);
        closeList.add(actualAnnot);

        if (isSubscribed(actualAnnot, unsubscribed, subscribed, CoreFuncModule.getUserSources(actualAnnot.getUser()))) {
          result.add(actualAnnot);
        } else {
          //get annotations which linked actual annotation, then get annotatinos that are not in close list then in open list
          //on the end is in annotForAdd list only annotations that linked at actual annotation and they ar not in close and open list
          ArrayList<Annotation> annotForAdd = CoreFuncModule.getDifference(CoreFuncModule.getDifference(CoreFuncModule.getLinkedAnnotationsDB(actualAnnot), closeList), openList);
          openList.addAll(annotForAdd);
        }
      }
    }

    if(approvedAnnot == null){
      return result;
    }
    
    approvedAnnot.addAll(result);
    return approvedAnnot;
  }
  
  /**
   * Method finds all ancestors of type annotation of annotation given as attribute.
   * 
   * @param annot annotation which will be processed
   * @return string with uri of all ancestors of annotation's type
   */
  String AnnotationTypeAncestors(Annotation annot){
    StringBuilder result = new StringBuilder();
    ArrayList<AnnotType> openList = new ArrayList<AnnotType>();
    ArrayList<AnnotType> closeList = new ArrayList<AnnotType>();
    
    openList.add(annot.getAnnotType());
    while(!openList.isEmpty()){
      AnnotType actualAnnot = openList.remove(0);
      if(!closeList.contains(actualAnnot)){
        closeList.add(actualAnnot);
        result.append("<ancestorType uri=\"").append(actualAnnot.getUri()).append("\"/>");
        openList.addAll(actualAnnot.getAncestorTypes());
      }
    }
    
    return result.toString();
  }
  
  /**
   *  Info:
   *  Methods below are copied from Annotations, they are modified, because modifed 
   *  protocol is used between Storyscope Interface and SEC Client.
   */
  
  /**
   * Returns serialized and linearized informations about annotation in XML
   *
   * @param annot annotation that will be represented by XML
   * @param doc anotated document
   * @return Returns serialized informations about annotation in XML
   */
  public String AnnotationToXMLStringL(Annotation annot,Document doc) {
    String authorAttr = "";
    if (annot.getAuthorName() != null) {
      authorAttr = authorAttr + " name=\"" + annot.getAuthorName() + "\"";
    }
    if (annot.getAuthorAddress() != null) {
      authorAttr = authorAttr + " address=\"" + annot.getAuthorAddress() + "\"";
    }
    String aboutStr = "";
    if (annot.getId() != null) {
      aboutStr = AppBean.getBaseAnnotUri() + annot.getId();
    }
    
    String OntologyUri = "";
    if(annot.getAnnotType().getUriInOntology() != null){
      OntologyUri = " ontologyUri=\"" + annot.getAnnotType().getUriInOntology() + "\"";
    }
     
    String typeComment = new String();
    String tmpComent = "";
    
    if(annot.getAnnotType().getComment() != null){
      tmpComent = annot.getAnnotType().getComment();
    }
    
    if(annot.getAnnotType().getComment() != null)
    {
        typeComment = "<comment><![CDATA["
        + annot.getAnnotType().getComment()
        + "]]></comment>";
    }
    
    return "<annotation>"
        + "<rdf:Description rdf:about=\"" + aboutStr + "\">"
          + "<rdf:type rdf:resource=\"" + annot.getAnnotType().getUri() + OntologyUri + "\">"
          + "<ancestorsList>"
          + AnnotationTypeAncestors(annot)
          + "</ancestorsList>"
          + typeComment
          + "</rdf:type>"
          + "<a:dateTime rdf:value=\"" + Util.toRFC3339Date(annot.getCreated()) + "\" />"
          + "<a:author id=\"" + annot.getAuthorIdStr() + "\"" + authorAttr + "/>"
          + "<a:source rdf:resource=\"" + annot.getSource() + "\" uri=\"" + annot.getSourceDocument().getUri() +"\"/>"
          + fragmentsToXMLStringL(annot,doc)
          + "<a:content>"
          + "<![CDATA["
          + annot.getContent()
          + "]]>"
          + "</a:content>"
          + attributesToXMLStringL(annot,true, false, doc)
        + "</rdf:Description>"
        + "</annotation>";
  }  // toXMLString()
  
  /**
   * Returns serialized and linearized informations about annotated fragments in XML
   *
   * @param annot annotation which fragments should be serialized
   * @param doc document tahat fragments belongs
   * @return Returns serialized informations about annotated fragments in XML
   */
  public String fragmentsToXMLStringL(Annotation annot, Document doc) {
    String LinearizedFragments = "";
    ArrayList<ArrayList<Fragment>> notConverted = new ArrayList<ArrayList<Fragment>>();
    ArrayList<ArrayList<Fragment>> comFragments = new ArrayList<ArrayList<Fragment>>();
    comFragments.add(new ArrayList<Fragment>());
    Iterator<Fragment> convIt = annot.getFragments().iterator();
    while(convIt.hasNext()){
      comFragments.get(0).add(convIt.next());
    }
    
    ArrayList<Fragment> linearizedList;
    linearizedList = Linearizer.fragmentsToLinFragments(comFragments,doc, notConverted, false);
    
    if (notConverted != null) {
      Iterator<ArrayList<Fragment>> badFrIt = notConverted.iterator();
      while (badFrIt.hasNext()) {
        ArrayList<Fragment> badFrListForAnnot = badFrIt.next();
        Iterator<Fragment> badFrItForAnnot = badFrListForAnnot.iterator();
        while (badFrItForAnnot.hasNext()) {
          Fragment fragment = badFrItForAnnot.next();
          String msg = "This fragment was not linearized successfully: ";
          msg = msg + " offset: " + fragment.getOffset()
                  + " length: " + fragment.getLength() + " text: " + fragment.getAnnotatedText();
          Logger.getLogger(StoryscopeInterfaceSender.class.getName()).log(Level.SEVERE, msg);
        }
      }
    }
    
    Iterator<Fragment> fragIt = linearizedList.iterator();
    Fragment fr;
    while (fragIt.hasNext()) {
      fr = fragIt.next();
      if(fr != null)
      {
        LinearizedFragments += fr.toXMLString();
      }
    }
    return LinearizedFragments;
  }
  
  /**
   * Returns serialized informations about annotation attributes in XML
   *
   * @param annot Annotation which attributes should be serialized
   * @param proto11 If true, protocol version is greather then 1.0
   * @param tmpIdForNested If true, nested annotations will have attribute tmpId
   * @param doc Annotated document
   * @return Returns serialized informations about annotation attributes in XML
   */
  public String attributesToXMLStringL(Annotation annot, boolean proto11, boolean tmpIdForNested, Document doc) {
    String attrString = "";
    Iterator<BaseAttribute> attrIt = annot.getAttributes().iterator();
    BaseAttribute attr;
    while (attrIt.hasNext()) {
      attr = attrIt.next();
      if(attr instanceof NestedAnnotationAttribute){
        Annotation nestedAnnot = ((NestedAnnotationAttribute)attr).getNestedAnnotation();
        if(nestedAnnot != null){
          attrString += "<a:attribute name=\"" + attr.getName() + "\" type=\"nestedAnnotation\" "
            + "tmpId=\"" + nestedAnnot.getTmpId() + "\">";
          attrString += AnnotationToXMLStringL(nestedAnnot,doc);
          
          if(attr.getComment() != null){
            attrString += "<a:comment> <![CDATA[" + attr.getComment() + "]]></a:comment>";
          }
          attrString += "</a:attribute>";
        }
      }else{
        attrString += attr.toXMLString(proto11, tmpIdForNested, true);
      }
    }
    return attrString;
  }
}  // public class StoryscopeInterfaceSender