SECAPISuggestionTranslator.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: SECAPISuggestionTranslator.java
 * Description: Class provides methods for translating of suggestions from 
 *              SEC API to the objects of class Suggestion.
 */

/**
 * @file SuggestionManager.java
 *
 * @brief Methods for translating output from SEC API to the Suggestion objects
 */

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

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.comet.Linearizer;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.*;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.*;
import java.io.IOException;
import java.io.StringReader;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Class provides methods for translating of suggestions from SEC API
 * to the objects of class Suggestion.
 * 
 * @brief Methods for translating output from SEC API to the Suggestion objects
 * 
 * @author idytrych
 */
public class SECAPISuggestionTranslator {
  
  /** Separator of String values if they should be concatenated into one String attribute */
  public static final String STRING_ATT_VALUES_SEPARATOR = ", ";
  /** Separator of Text values if they should be concatenated into one Text attribute */
  public static final String TEXT_ATT_VALUES_SEPARATOR = " \n";
  /** Name of this module */
  public static final String MODULE_NAME = "SECAPISuggestionTranslator";
  
  /** Default name of attribute with latitude from SEC API */
  public static final String LATITUDE_NAME = "latitude";
  /** Default name of attribute with longitude from SEC API */
  public static final String LONGITUDE_NAME = "longitude";
  
  /* Default suggestion confidence (used if it was not set by SEC API) */
  public static final int DEFAULT_SUGGESTION_CONFIDENCE = 50;
  
  /** Default user group. */
  UserGroup userGroup;
  
  /** Default user group. */
  UserGroup defaultUserGroup;
  /** Base URI for type of annotation. */
  String baseTypeUri;
  
  /** Cache for types of annotations */
  HashMap<String,AnnotType> typesBuffer;
  
  /**
   * Set default userGroup.
   * 
   * @param userGroup User group.
   */
  public SECAPISuggestionTranslator(UserGroup userGroup) {
    this.userGroup = userGroup;
    baseTypeUri = AppBean.getBaseTypeUri();
  }
  
  /**
   * Gets alternatives from SEC API and translates them to the Suugestion objects.
   * 
   * @param requestInfo Informations about client request
   * @param SECAPIResults Results from SEC API in String
   * @param newTypes Array for adding new types of annotations
   * @param validSuggestions Alternatives is assign to one of theese suggestions
   * @return Resutns alternatives for the document
   */
  public ArrayList<Alternative> translateAlternativeFromSecApi(RequestInfo requestInfo, String SECAPIResults, ArrayList<AnnotType> newTypes, ArrayList<Suggestion> validSuggestions) {
    HashMap<Integer, ArrayList<SuggestionFragment>> sugToLinFragments = new HashMap<Integer, ArrayList<SuggestionFragment>>();
    typesBuffer = new HashMap<String, AnnotType>();
    
    // linearize given suggestions
    linearizeSuggestions(sugToLinFragments,requestInfo.getSession().getParsedSyncDocument(),validSuggestions);
    
    SECAPIResults = SECAPIResults.replace("<suggestion>",
            "<suggestion xmlns:geo=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">");
    
    // parse XML message
    Document doc = parseXml(SECAPIResults);
    if (doc == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Bad XML from SEC API: " + SECAPIResults;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;  // bad request
    }
    
    Element docEl = doc.getDocumentElement();
    HashMap<Integer,TranslateAlternativeHolder> alternatives = new HashMap<Integer,TranslateAlternativeHolder>();
    
    // process message from SEC API
    NodeList fragmentElements = docEl.getChildNodes();
    int fCount = fragmentElements.getLength();
    for (int i= 0; i < fCount; i++) {  // for each fragment from SEC API
      
      if(!(fragmentElements.item(i) instanceof Element)){
        continue;
      }
      if(!((Element) fragmentElements.item(i)).getTagName().equalsIgnoreCase("text")){
        continue;
      }
      
      Element fragmentEl = (Element) fragmentElements.item(i);
      
      TranslateAlternativeHolder newAlternative = new TranslateAlternativeHolder();
      
      // process alternative fragment from SEC API
      AlternativeFragment altFragment = processAlternativeFragment(fragmentEl);
      if(altFragment == null){
        continue; // can't process fragment
      }
      
      // proces alternative suggestions
      ArrayList<Alternative> alternativesFromSecApi = processAlternatives(requestInfo,fragmentEl,newTypes,altFragment);

      newAlternative.setUnconvertedAlternatives(alternativesFromSecApi);
      
      Alternative dummyAlternative = new Alternative();
      dummyAlternative.setId(i);
      dummyAlternative.addFragment(altFragment);
      altFragment.setRefAlternative(dummyAlternative);
      newAlternative.setDummyAlternative(dummyAlternative);
      alternatives.put(i,newAlternative);
    }
    
    // find alternatives
    findAlternativeSuggestions(alternatives,validSuggestions,sugToLinFragments);
    
    // get only new alternative suggestions
    return makeNewAlternative(requestInfo, sugToLinFragments, alternatives);
  }
  
  /** 
   * Method that process nested alternatives
   * 
   * Note: It's called recursively
   * 
   * @param atEl Attribute element
   * @param requestInfo RequestInfo
   * @param newTypes New Annotations types
   * 
   * @return Nested alternative
   */
  private Alternative processNestedAlternative(Element atEl, RequestInfo requestInfo, ArrayList<AnnotType> newTypes) {
      // process message from SEC API
    Alternative nestedAlt = null;
    NodeList fragmentElements = atEl.getChildNodes();
    int fCount = fragmentElements.getLength();
    for (int i = 0; i < fCount; i++) {  // for each fragment from SEC API

      if (!(fragmentElements.item(i) instanceof Element)) {
        continue;
      }
      if (!((Element) fragmentElements.item(i)).getTagName().equalsIgnoreCase("text")) {
        continue;
      }

      Element fragmentEl = (Element) fragmentElements.item(i);

      // process alternative fragment from SEC API
      AlternativeFragment altFragment = processAlternativeFragment(fragmentEl);
      if (altFragment == null) {
        continue; // can't process fragment
      }

      NodeList annotationElements = fragmentEl.getChildNodes();
      int aCount = annotationElements.getLength();
      int alternativeCreated = 0;

      /*
       * In case of nested, there should be always just one Annotation tag
       */
      for (int j = 0; j < aCount; j++) {  // for each annotation from SEC API
        if (alternativeCreated >= Constants.MAX_COUNT_OF_ALTERNATIVES_TO_ONE_SUGGESTION) {
          break;
        }
        if (!(annotationElements.item(j) instanceof Element)) {
          continue;
        }
        if (!((Element) annotationElements.item(j)).getTagName().equalsIgnoreCase("annotation")) {
          continue;
        }

        Element annotationEl = (Element) annotationElements.item(j);

        nestedAlt = (Alternative) createSugFromElement(requestInfo, annotationEl, newTypes, true);

        if (nestedAlt != null) {
          nestedAlt.setSourceDocument(requestInfo.getSession().getSyncDocument());
          nestedAlt.setSource(requestInfo.getSession().getSyncDocument().getUriForAnnot());
          nestedAlt.setSourceDocumentId(requestInfo.getSession().getSyncDocument().getId());
          AlternativeFragment fr = new AlternativeFragment("", altFragment.getOffset(), altFragment.getLength(), altFragment.getAnnotatedText(), null);
          fr.setRefAlternative(nestedAlt);
          nestedAlt.addFragment(fr);
        }
      }
    }
    return nestedAlt;
  }  // processNestedAlternative()

  /**
   * Method converts the raw format of alternatives from SEC Api to array of 
   * objects.
   * 
   * @param requestInfo Informations about client request
   * @param alternatvesEl Element with alternatives from SEC Api in raw format
   * @param newTypes Array for adding new types of annotations
   * @param altFragment Fragment that is assigned to all created alternatives
   * @return array of alternatives from SEC Api
   */
  private ArrayList<Alternative> processAlternatives(RequestInfo requestInfo,Element alternatvesEl, ArrayList<AnnotType> newTypes,AlternativeFragment altFragment){
    ArrayList<Alternative> result = new ArrayList<Alternative>();
    NodeList annotationElements = alternatvesEl.getChildNodes();
    int aCount = annotationElements.getLength();
    int alternativeCreated = 0;
    
    for (int j = 0; j < aCount; j++) {  // for each annotation from SEC API
      if (alternativeCreated >= Constants.MAX_COUNT_OF_ALTERNATIVES_TO_ONE_SUGGESTION) {
        break;
      }
      if(!(annotationElements.item(j) instanceof Element)){
          continue;
      }
      if(!((Element) annotationElements.item(j)).getTagName().equalsIgnoreCase("annotation")){
          continue;
      }
      
      Element annotationEl = (Element) annotationElements.item(j);

      Alternative alt = (Alternative) createSugFromElement(requestInfo, annotationEl, newTypes, true);
      if (alt != null) {
        alt.setSourceDocument(requestInfo.getSession().getSyncDocument());
        alt.setSource(requestInfo.getSession().getSyncDocument().getUriForAnnot());
        alt.setSourceDocumentId(requestInfo.getSession().getSyncDocument().getId());
        AlternativeFragment fr = new AlternativeFragment("", altFragment.getOffset(), altFragment.getLength(), altFragment.getAnnotatedText(), null);
        fr.setRefAlternative(alt);
        alt.addFragment(fr);
        result.add(alt);
      }
    }
    
    return result;
  }
  
  /** 
   * Method converts the raw format of alternatives fragments from SEC Api to array of 
   * objects.
   * 
   * @param fragmentEl Element with alternatives fragments from SEC Api in raw format
   * @return array of alternatives fragments from SEC Api
   */
  private static AlternativeFragment processAlternativeFragment(Element fragmentEl){
    String startOffsetStr = fragmentEl.getAttribute("s_offset");
    String endOffsetStr = fragmentEl.getAttribute("e_offset");
    String fragmentText = fragmentEl.getAttribute("string");

    Integer startOf;
    Integer endOf;
    try {
      startOf = Integer.parseInt(startOffsetStr);
      endOf = Integer.parseInt(endOffsetStr);
    } catch (Exception e) {
      String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
      Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
      return null;
    }
    if (startOf == null || endOf == null || startOf >= endOf) {
      String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
      Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
      return null;
    }
    
    return new AlternativeFragment("", startOf, endOf - startOf, fragmentText, null);
  }
  
  /**
   * Method creates new alternatives from SEC API message for given suggestions.
   * 
   * @param requestInfo Informations about client request
   * @param sugToLinFragments Linearized fragments of given suggestions
   * @param alternativesHolders new alternatives and alternatives from DB
   * @return array of new alternatives
   */
  private ArrayList<Alternative> makeNewAlternative(RequestInfo requestInfo,
                                                    HashMap<Integer, ArrayList<SuggestionFragment>> sugToLinFragments,
                                                    HashMap<Integer,TranslateAlternativeHolder> alternativesHolders){

    ArrayList<AlternativeFragment> allLinFragments = new ArrayList<AlternativeFragment>();
    ArrayList<Alternative> result = new ArrayList<Alternative>();
    
    /* HashMap of all alternatives which contains tmpId */
    HashMap<String, Alternative> alternativeMap = new HashMap<String, Alternative>();
    ArrayList<AlternativeAttribute> nestedLinkedList = new ArrayList<AlternativeAttribute>();

    Iterator<TranslateAlternativeHolder> secAPIAlternativesIt = alternativesHolders.values().iterator();
    while (secAPIAlternativesIt.hasNext()) {
      TranslateAlternativeHolder currentAlternativeHolder = secAPIAlternativesIt.next();
      ArrayList<Alternative> alternatives = currentAlternativeHolder.getUnconvertedAlternatives();
      ArrayList<Suggestion> suggestionsFromDB = currentAlternativeHolder.getConvertedAlternatives();

      if (currentAlternativeHolder.getDummyAlternative().getAlternativeOfSuggestion() == null) {
        Iterator<Alternative> altIt = alternatives.iterator();
        while (altIt.hasNext()) {
          Alternative tmpAlt = altIt.next();
          if(tmpAlt.getTmpId() != null && !tmpAlt.getTmpId().isEmpty()){
            alternativeMap.put(tmpAlt.getTmpId(), tmpAlt);
          }
        }
        continue;
      }

      int altCount = 0;
      if (currentAlternativeHolder.getConvertedAlternatives() != null) {
        altCount = currentAlternativeHolder.getConvertedAlternatives().size();
      }
      currentAlternativeHolder.sortUncoveredByCofidence();

      Iterator<Alternative> alternativesIt = alternatives.iterator();
      while (alternativesIt.hasNext()) {
        Alternative currentAlternative = alternativesIt.next();
        AlternativeFragment currentAltFrag = currentAlternative.getFragmentsAL().get(0);
        
        Suggestion alternativeOf = currentAlternative.getAlternativeOfSuggestion();

        if (altCount >= Constants.MAX_COUNT_OF_ALTERNATIVES_TO_ONE_SUGGESTION) {
          break;
        }

        if (!currentAlternative.contentEqualsForSec(alternativeOf, sugToLinFragments.get(alternativeOf.getId()), false)) {
          // alternative is not alternativeOf suggestion
          if (!isAlternativeInSuggestionList(suggestionsFromDB, currentAlternative, sugToLinFragments)) {
            // alternative has not been transform to suggestion yet
            allLinFragments.add(currentAltFrag);
            result.add(currentAlternative);
            altCount++;
            
            /*
             * Iterate through all alternative attributes and if attribute
             * contains some uri (either to linked or nested attribute)
             * we need to store this attribute, and once all attributes are processed,
             * search for this attribute, and assign and link to proper variable
             * 
            */
            
            Iterator<AlternativeAttribute> attIt = currentAlternative.getAttributes().iterator();
            while(attIt.hasNext()){
              AlternativeAttribute currentTmpAtt = attIt.next();
              // If its pointing to another alternative, store this attribute
              if(currentTmpAtt.getUri() != null && !currentTmpAtt.getUri().isEmpty()){
                nestedLinkedList.add(currentTmpAtt);
              }
            }
          }
        }
      }
    }
    
    /*
     * Iterate through all processed alternatives and try to find value in hashmap 
     * whose key is tmpId of current alternative 
    */
    ArrayList<AlternativeAttribute>openNestedLinkedList = nestedLinkedList;
    
    while(!openNestedLinkedList.isEmpty()){
      AlternativeAttribute tmpAtt = openNestedLinkedList.get(0);
      
      if(alternativeMap.get(tmpAtt.getUri()) != null){
        Alternative alt = alternativeMap.get(tmpAtt.getUri());
        // If it is an attribute of nestedAnnotation type, assign refAlternative to founded alternative
        // nestedInAlternative variable, and add this alternative to result list if it's not already there
        // If type of attribute is LinkedAnnotation, just make sure that this founded alternative
        // is in result list
        if(tmpAtt.getSimpleType().equalsIgnoreCase("NestedSuggestion")){
          tmpAtt.setNestedAlternative(alt);
          alt.setNestedInAlternative(tmpAtt.getRefAlternative());
        }
        else if (tmpAtt.getSimpleType().equalsIgnoreCase("SuggestionLink")){
          tmpAtt.setLinkedAlternative(alt);
        }

        if(!result.contains(alt)){
          result.add(alt);
          allLinFragments.add(alt.getFragmentsAL().get(0));
          
          //Add all nested/linked attributes to list
          Iterator<AlternativeAttribute> tmpIt = alt.getAttributes().iterator();
          while(tmpIt.hasNext()){
            AlternativeAttribute at = tmpIt.next();
            if(tmpAtt.getSimpleType().equalsIgnoreCase("NestedSuggestion") || tmpAtt.getSimpleType().equalsIgnoreCase("SuggestionLink")){
              openNestedLinkedList.add(at);
            }
          }
        }
      }
      else{
        if (!(tmpAtt.getSimpleType().equalsIgnoreCase("URI") || tmpAtt.getSimpleType().equalsIgnoreCase("Image"))) {
          tmpAtt.setUri(null);
        }
      }
      
      openNestedLinkedList.remove(tmpAtt);
    }
    
    @SuppressWarnings("unchecked") 
    ArrayList<Alternative> retList = convertLinFragments(requestInfo, result, allLinFragments, true);
    return retList;
    
  }  // makeNewAlternative()
  
  /**
   * Finds suggestions for which were alternatives sent and adds alternatives 
   * from DB.
   * 
   * @param alternatives Alternatives from SEC API
   * @param validSuggestions Alternatives is assign to one of these suggestions
   * @param sugToLinFragments Linearized fragments of given valid suggestions
   */
  private void findAlternativeSuggestions(HashMap<Integer,TranslateAlternativeHolder> alternatives, ArrayList<Suggestion> validSuggestions,HashMap<Integer, ArrayList<SuggestionFragment>> sugToLinFragments){
    
    Iterator<TranslateAlternativeHolder> alternativesFromSECIt = alternatives.values().iterator();
    while(alternativesFromSECIt.hasNext()){
      TranslateAlternativeHolder currentAlternative = alternativesFromSECIt.next();
      
      Iterator<AlternativeFragment> currentFragmentsIt = currentAlternative.getDummyAlternative().getFragmentsAL().iterator();
      while(currentFragmentsIt.hasNext()){
        AlternativeFragment currentFrag = currentFragmentsIt.next();

        // attempt to find suggestion with same part of fragment
        Suggestion alternativeOf = null;
        for (Iterator<Suggestion> sgIt = validSuggestions.iterator(); sgIt.hasNext();) {
          Suggestion sg = sgIt.next();
          if (!sugToLinFragments.containsKey(sg.getId())) {
            continue;
          }
          if (AlternativeManager.overlappingFragment(sugToLinFragments.get(sg.getId()), currentFrag.getOffset(), currentFrag.getOffset() + currentFrag.getLength())) {
            alternativeOf = sg;
            break;
          }
        }
        // main suggestion with same part of fragment was not found
        if (alternativeOf == null) {
          continue;
        }

        currentFrag.getRefAlternative().setAlternativeOfSuggestion(alternativeOf);
        // set alternative for all unconverted alternatives
        currentAlternative.setAlternativeOf(alternativeOf);

        ArrayList<Suggestion> findedSugg = new ArrayList<Suggestion>();
        // find all alternative suggestions of "alternativeOf suggestion"
        List<Suggestion> alternativeSuggestions = AlternativeManager.getOtherSuggestions(alternativeOf.getId());
        for (Iterator<Suggestion> sugIt = alternativeSuggestions.iterator(); sugIt.hasNext();) {
          Suggestion sugg = sugIt.next();
          Integer sgId = sugg.getId();
          if(!findedSugg.contains(sugg)){
            findedSugg.add(sugg);
          }
        }  
        currentAlternative.setConvertedAlternatives(findedSugg); 
      }
    }  // while(alternativesFromSECIt.
  }  // findAlternativeSuggestions()
  
  
  /**
   * Linearize fragments of given suggestions and return fragments as hash map where 
   * key is id of suggestion.
   * 
   * @param linFragmentsMap hash map where the result will be stored
   * @param doc annotated document 
   * @param suggestions suggestion which fragments will be linearize
   */
  public static void linearizeSuggestions(HashMap<Integer, ArrayList<SuggestionFragment>> linFragmentsMap, Document doc, ArrayList<Suggestion> suggestions){
    ArrayList<ArrayList<SuggestionFragment>> notConverted = new ArrayList<ArrayList<SuggestionFragment>>();
    ArrayList<SuggestionFragment> linearizedFragments;
    ArrayList<ArrayList<SuggestionFragment>> normalFragments = new ArrayList<ArrayList<SuggestionFragment>>();
    
    Iterator<Suggestion> suggestionsIt = suggestions.iterator();
    while(suggestionsIt.hasNext()){
      Suggestion currentSuggestion = suggestionsIt.next();
      normalFragments.add(currentSuggestion.getFragmentsAL());
    }
    
    // convert fragments to linearized fragments
    linearizedFragments = Linearizer.fragmentsToLinSugFragments(normalFragments,doc, notConverted, true);
    
    if(!linearizedFragments.isEmpty()){
      Iterator<SuggestionFragment> linearizedFragsIt = linearizedFragments.iterator();
      while(linearizedFragsIt.hasNext()){
        SuggestionFragment currentLinFragment = linearizedFragsIt.next();
        // suggestions for the whole document don't possess any fragment, avoid NPException
        // process regular suggestions fragments only
        if (currentLinFragment != null) {
          if(linFragmentsMap.containsKey(currentLinFragment.getRefSuggestion().getId())){
            ArrayList<SuggestionFragment> resutFragments = linFragmentsMap.get(currentLinFragment.getSuggestion());
            resutFragments.add(currentLinFragment);
          }else{
            ArrayList<SuggestionFragment> currentLinFrag = new ArrayList<SuggestionFragment>();
            currentLinFrag.add(currentLinFragment);
            linFragmentsMap.put(currentLinFragment.getRefSuggestion().getId(), currentLinFrag);
          }
        }
      }
    }
  }  // linearizeSuggestions()
  
  /**
   * Check, if alternative is in suggestion list.
   * 
   * @param suggestions Suggestion list.
   * @param alt Alternative.
   * @param sugToLinFragments HashMap with linearized fragments
   * @return Check, if alternative is in suggestion list.
   */
  private boolean isAlternativeInSuggestionList(List<Suggestion> suggestions, Alternative alt,
                    HashMap<Integer, ArrayList<SuggestionFragment>> sugToLinFragments) {
    for (Iterator<Suggestion> it = suggestions.iterator(); it.hasNext(); ) {
      Suggestion sg = it.next();
      if (alt.contentEqualsForSec(sg, sugToLinFragments.get(sg.getId()), false)) {
        return true;
      }
    }
    return false;
  }
  
  /**
   * Converts linearized fragment to normal fragment
   * 
   * @param requestInfo Informations about client request
   * @param frg Linearized fragment to convert
   * @return Returns converted fragment
   */
  private AlternativeFragment fixAlternativeFragment(RequestInfo requestInfo, AlternativeFragment frg) {
    Document doc = requestInfo.getSession().getParsedSyncDocument();
    
    // linearized fragment from SEC API to normal fragment 
    ArrayList<AlternativeFragment> input = new ArrayList<AlternativeFragment>();
    input.add(frg);
    ArrayList<ArrayList<AlternativeFragment>> badFragments = new ArrayList<ArrayList<AlternativeFragment>>();
    ArrayList<ArrayList<AlternativeFragment>> convertedFragments = Linearizer.linAltFragmentsToFragments(input, doc, badFragments);

    String info = "<module name=\"" + SECAPISuggestionTranslator.MODULE_NAME + "\"/>";
    int langNum = requestInfo.getSession().getLanguageNum();
    
    // check consistency
    if (convertedFragments == null || convertedFragments.size() != 1) {
      return null;
    }
    ArrayList<AlternativeFragment> output = convertedFragments.get(0);
    if (output.size() < 1) {
      return null;
    }
    frg = output.get(0);
    
    // normal fragment to correctly linearized fragment
    ArrayList<ArrayList<AlternativeFragment>> notConverted = new ArrayList<ArrayList<AlternativeFragment>>();
    ArrayList<ArrayList<AlternativeFragment>> comFragments = new ArrayList<ArrayList<AlternativeFragment>>();
    
    ArrayList<AlternativeFragment> input2 = new ArrayList<AlternativeFragment>();
    input2.add(frg);
    comFragments.add(input2);
    
    ArrayList<AlternativeFragment> linearizedList;
    linearizedList = Linearizer.fragmentsToLinAltFragments(comFragments,doc, notConverted, true);
    
    if (linearizedList.isEmpty()) {
      return null;
    }
    
    return linearizedList.get(0);
  }  // fixAlternativeFragment()
  
  /**
   * Gets suggestions from SEC API and translates them to the Suugestion objects.
   * 
   * @param requestInfo Informations about client request
   * @param SECAPIResults Results from SEC API in String
   * @param newTypes Array for adding new types of annotations
   * @return Resutns suggestions for the document
   */
  public ArrayList<Suggestion> translateSugFromSecApi(RequestInfo requestInfo, String SECAPIResults, ArrayList<AnnotType> newTypes) {
    ArrayList<Suggestion> result = new ArrayList<Suggestion>();
    ArrayList<SuggestionFragment> allLinFragments = new ArrayList<SuggestionFragment>();
    typesBuffer = new HashMap<String, AnnotType>();
    
    //Add geoNamespace if necessary
    SECAPIResults = SECAPIResults.replace("<suggestion>",
            "<suggestion xmlns:geo=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">");
    
    // parse XML
    Document doc = parseXml(SECAPIResults);
    if (doc == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Bad XML from SEC API: " + SECAPIResults;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;  // bad request
    }
    Element docEl = doc.getDocumentElement();
    HashMap<String, SugNestedAttribute> nestedInMap = new HashMap<String, SugNestedAttribute>();
    HashMap<String, ArrayList<SugLinkedAttribute>> linkedInMap = new HashMap<String, ArrayList<SugLinkedAttribute>>();
    
    NodeList fragmentElements = docEl.getChildNodes();
    int fCount = fragmentElements.getLength();
    for (int i= 0; i < fCount; i++) {  // for each fragment from SEC API
      
      if(!(fragmentElements.item(i) instanceof Element)){
          continue;
      }
      if(!((Element) fragmentElements.item(i)).getTagName().equalsIgnoreCase("text")){
          continue;
      }
      
      Element fragmentEl = (Element) fragmentElements.item(i);
      String startOffsetStr = fragmentEl.getAttribute("s_offset");
      String endOffsetStr = fragmentEl.getAttribute("e_offset");
      String fragmentText = fragmentEl.getAttribute("string");
      
      Integer startOf;
      Integer endOf;
      try {
        startOf = Integer.parseInt(startOffsetStr);
        endOf = Integer.parseInt(endOffsetStr);
      } catch (Exception e) {
        String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
        continue;
      }
      if (startOf == null || endOf == null || startOf >= endOf) {
        String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
        continue;
      }
      
      NodeList annotationElements = fragmentEl.getChildNodes();
      int aCount = annotationElements.getLength();
      for (int j = 0; j < aCount; j++) {  // for each annotation from SEC API
        
        if(!(annotationElements.item(j) instanceof Element)){
          continue;
        }
        if(!((Element) annotationElements.item(j)).getTagName().equalsIgnoreCase("annotation")){
            continue;
        }
          
        Element annotationEl = (Element) annotationElements.item(j);
        
        Suggestion sug = (Suggestion) createSugFromElement(requestInfo, annotationEl, newTypes, false);
        if (sug != null) {
          sug.setSourceDocument(requestInfo.getSession().getSyncDocument());
          sug.setSource(requestInfo.getSession().getSyncDocument().getUriForAnnot());
          sug.setSourceDocumentId(requestInfo.getSession().getSyncDocument().getId());
          sug.setIsFromSECAPI(true);
          if (requestInfo.getSession() != null && requestInfo.getSession().getSugRequestFlag()) {
            sug.setDisplayConfidence(true);
          }
          SuggestionFragment fr = new SuggestionFragment("", startOf, endOf - startOf, fragmentText, null);
          fr.setRefSuggestion(sug);
          sug.addFragment(fr);
          allLinFragments.add(fr);
          result.add(sug);
          
          /*
           * Iterate through all suggestion attributes and if attribute's type is nested,
           * and contains uri to suggestion, we need to store it's suggestion,
           * and once all suggestions are processed, search
           * for this suggestion, and assign to 'nestedInSuggestion' suggestion,
           * which this attribute contains
           * 
           * Similiar process is used for linked suggestions
          */
          Iterator<SugBaseAttribute> attrIt = sug.getAttributes().iterator();
          while(attrIt.hasNext()){
            SugBaseAttribute tmpAttr = attrIt.next();
            if(tmpAttr.getSimpleType().equalsIgnoreCase("NestedSuggestion")){
              if(tmpAttr.getUri() != null && !tmpAttr.getUri().isEmpty()){
                nestedInMap.put(tmpAttr.getUri(), (SugNestedAttribute)tmpAttr);
              }
            }
            else if(tmpAttr.getSimpleType().equalsIgnoreCase("SuggestionLink")){
              if(tmpAttr.getUri() != null && !tmpAttr.getUri().isEmpty()){
                ArrayList<SugLinkedAttribute> list = linkedInMap.get(tmpAttr.getUri());
                if(list == null){
                  list = new ArrayList<SugLinkedAttribute>();
                }
                list.add((SugLinkedAttribute)tmpAttr);
                linkedInMap.put(tmpAttr.getUri(), list);
              }
            }
          } //iterator
        } // if sug != null
       
      }  // for each annotation from SEC API
      
    }  // for each fragment from SEC API
    
    
    /*
     * Iterate through all processed suggestion and try to find value in hashmap 
     * whose key is tmpId of current suggestion 
    */
    Iterator<Suggestion> sugIt = result.iterator();
    while(sugIt.hasNext()){
      Suggestion s = sugIt.next();
      if(nestedInMap.get(s.getTmpId()) != null){
        s.setNestedInSuggestion(nestedInMap.get(s.getTmpId()).getRefSuggestion());
        nestedInMap.get(s.getTmpId()).setNestedSuggestion(s);
        nestedInMap.remove(s.getTmpId());
      }
      else if(linkedInMap.get(s.getTmpId()) != null){
        Iterator<SugLinkedAttribute> attIt = linkedInMap.get(s.getTmpId()).iterator();
        while(attIt.hasNext()){
          attIt.next().setLinkedSuggestion(s);
        }
        linkedInMap.remove(s.getTmpId());
      }
    }
    
    /* For all attributes which left in hash map, remove theirs uri-s */
    Iterator<SugNestedAttribute> nestedAttIt = nestedInMap.values().iterator();
    while(nestedAttIt.hasNext()){
      nestedAttIt.next().setUri(null);
    }
    
    Iterator<ArrayList<SugLinkedAttribute>> linkedALIt = linkedInMap.values().iterator();
    while(linkedALIt.hasNext()){
      Iterator<SugLinkedAttribute> linkedAttIt = linkedALIt.next().iterator();
      while(linkedAttIt.hasNext()){
        linkedAttIt.next().setUri(null);
      }
    }
    
    @SuppressWarnings("unchecked")
    ArrayList<Suggestion> retList = convertLinFragments(requestInfo, result, allLinFragments, false);
    return retList;
  }  // translateSugFromSecApi()
  
  
  /** 
   * Method that process nested suggestions
   * 
   * Note: It's called recursively
   * 
   * @param attEl Attribute element
   * @param requestInfo RequestInfo
   * @param newTypes New Annotations types
   * 
   * @return Nested suggestion
   */
  private Suggestion processNestedSugg(Element attEl, RequestInfo requestInfo, ArrayList<AnnotType> newTypes){
    Suggestion sug = null;
    NodeList fragmentElements = attEl.getChildNodes();
    int fCount = fragmentElements.getLength();
    for (int i = 0; i < fCount; i++) {  // for each fragment from SEC API

      if (!(fragmentElements.item(i) instanceof Element)) {
        continue;
      }
      if (!((Element) fragmentElements.item(i)).getTagName().equalsIgnoreCase("text")) {
        continue;
      }
      Element fragmentEl = (Element) fragmentElements.item(i);
      String startOffsetStr = fragmentEl.getAttribute("s_offset");
      String endOffsetStr = fragmentEl.getAttribute("e_offset");
      String fragmentText = fragmentEl.getAttribute("string");

      Integer startOf;
      Integer endOf;
      try {
        startOf = Integer.parseInt(startOffsetStr);
        endOf = Integer.parseInt(endOffsetStr);
      } catch (Exception e) {
        String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
        continue;
      }
      if (startOf == null || endOf == null || startOf >= endOf) {
        String msg = "Bad fragment in SEC API output: " + startOffsetStr + "," + endOffsetStr + " " + fragmentText;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
        continue;
      }

      NodeList annotationElements = fragmentEl.getChildNodes();
      int aCount = annotationElements.getLength();
      for (int j = 0; j < aCount; j++) {  // for each annotation from SEC API

        if (!(annotationElements.item(j) instanceof Element)) {
          continue;
        }
        if (!((Element) annotationElements.item(j)).getTagName().equalsIgnoreCase("annotation")) {
          continue;
        }

        Element annotationEl = (Element) annotationElements.item(j);

        sug = (Suggestion) createSugFromElement(requestInfo, annotationEl, newTypes, false);
        if (sug != null) {
          sug.setSourceDocument(requestInfo.getSession().getSyncDocument());
          sug.setSource(requestInfo.getSession().getSyncDocument().getUriForAnnot());
          sug.setSourceDocumentId(requestInfo.getSession().getSyncDocument().getId());
          sug.setIsFromSECAPI(true);
          SuggestionFragment fr = new SuggestionFragment("", startOf, endOf - startOf, fragmentText, null);
          fr.setRefSuggestion(sug);
          sug.addFragment(fr);
        }

      }  // for each annotation from SEC API
    }  // for each fragment from SEC API
    return sug;
  }  // processNestedSugg()

  /**
   * Converts linearized fragments to common fragments
   * 
   * @param requestInfo Informations about client request
   * @param result List with suggestions or alternatives to which fragments belongs
   * @param allLinFragments List of all linearized fragments to convert
   * @param useAlternatives True for work with alternatives, false otherwise
   * @return Returns list with suggestions or alternatives to which fragments 
   *         belongs with converted fragments
   */
  @SuppressWarnings("unchecked")
  private ArrayList convertLinFragments(RequestInfo requestInfo, ArrayList result, ArrayList allLinFragments, boolean useAlternatives) {
    
    // is important to sort fragments by offset and length
    try {
      Collections.sort(allLinFragments);
    } catch (Exception e) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Some fragments from SEC API was not sorted successfully.";
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
        }
        return (useAlternatives ? new ArrayList<Alternative>() : new ArrayList<Suggestion>());
    }
    
    // build new list of sorted suggestions from fragment list
    ArrayList sortedSug = (useAlternatives ? new ArrayList<Alternative>() : new ArrayList<Suggestion>());
    Iterator allInIterator = allLinFragments.iterator();
    while(allInIterator.hasNext()){
        SecFragment frag = (SecFragment) allInIterator.next();
        sortedSug.add(frag.getRefSecSuggestion());
    }
    
    // delete all suggestions with fragment from original suggestions list
    Iterator unsortedSugIt = result.iterator();
    while(unsortedSugIt.hasNext()){
        SecSuggestion actualSug = (SecSuggestion) unsortedSugIt.next();
        if(actualSug.getFragments() != null || !actualSug.getFragments().isEmpty()){
            unsortedSugIt.remove();
        }
    }
    
    // insert sorted suggestions before suggestions without fragment
    result.addAll(0, sortedSug);
    
    // list for storing of bad fragments
    ArrayList badFragments = (useAlternatives ? 
                                 new ArrayList<ArrayList<AlternativeFragment>>()
                               : new ArrayList<ArrayList<SuggestionFragment>>());
    
    ArrayList convertedFragments = (useAlternatives ?
                              Linearizer.linAltFragmentsToFragments(allLinFragments, requestInfo.getSession().getParsedSyncDocument(), badFragments)
                            : Linearizer.linSugFragmentsToFragments(allLinFragments, requestInfo.getSession().getParsedSyncDocument(), badFragments));

    String info = "<module name=\"" + SECAPISuggestionTranslator.MODULE_NAME + "\"/>";
    int langNum = requestInfo.getSession().getLanguageNum();
    
    // check consistency
    if (convertedFragments == null || convertedFragments.size() != allLinFragments.size()) {
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.getSession().addMessageTS(RequestInfo.createErrorMsg(lod, langNum, Localisation.ERROR_33_MODULE_ERROR,info));
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Some fragments from SEC API was not converted successfully.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return (useAlternatives ? new ArrayList<Alternative>() : new ArrayList<Suggestion>());
    }

    if (badFragments != null) {
      Iterator badFrIt = badFragments.iterator();
      while (badFrIt.hasNext()) {
        ArrayList badFrListForSug = (useAlternatives ? 
                                         (ArrayList<AlternativeFragment>) badFrIt.next()
                                       : (ArrayList<SuggestionFragment>) badFrIt.next());
        Iterator badFrItForSug = badFrListForSug.iterator();
        while (badFrItForSug.hasNext()) {
          SecFragment fragment = (SecFragment) badFrItForSug.next();
          String msg = "This fragment from SEC API was not converted successfully: ";
          msg = msg + " offset: " + fragment.getOffset()
                  + " length: " + fragment.getLength() + " text: " + fragment.getAnnotatedText();
          Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
        }
      }
    }
    
    // replace fragments with converted
    Iterator linFrIt = allLinFragments.iterator();
    Iterator/*<ArrayList<SuggestionFragment>>*/ newFrIt = convertedFragments.iterator();
    for (Iterator sIt = result.iterator(); sIt.hasNext();) {
      SecSuggestion sug = (SecSuggestion) sIt.next();
      // this is suggestion for the whole document, it doesn't have fragments
      if (sug.getFragments() != null && sug.getFragments().isEmpty()) {
        continue;
      }
      if (useAlternatives) {
        ((Alternative) sug).setFragments(new ArrayList<AlternativeFragment>());  // remove linearized fragments
      } else {
        ((Suggestion) sug).setFragments(new ArrayList<SuggestionFragment>());  // remove linearized fragments
      }
      SecFragment linFr = (SecFragment) linFrIt.next();
      ArrayList fragments = (ArrayList) newFrIt.next();
      for (Iterator nFrIt = fragments.iterator(); nFrIt.hasNext();) {
        SecFragment newFr = (SecFragment) nFrIt.next();
        newFr.setRefSecSuggestion(linFr.getRefSecSuggestion());
        sug.addSecFragment(newFr);  // add converted fragment
      }
    }
    return result;
  }  // convertLinFragments()
  
  /**
   * Creates suggestion object from XML element with suggestion
   * 
   * @param requestInfo Informations about client request
   * @param el XML element with suggestion
   * @param newTypes Array for adding new types of annotations
   * @param useAlternatives True for work with alternatives, false otherwise
   * @return Object with suggestion
   */
  @SuppressWarnings("unchecked")
  private SecSuggestion createSugFromElement(RequestInfo requestInfo, Element el, ArrayList<AnnotType> newTypes, boolean useAlternatives) {
    int lNum = requestInfo.getSession().getLanguageNum();
    
    String typeStr = el.getAttribute("type");
    String tmpIdStr = el.getAttribute("id");
    
    if (typeStr == null || typeStr.isEmpty()) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Suggestion from SEC API without type.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
        return null;
      }
    }
    
    String typePath = typeStr;
    Integer typeIndex = Localisation.TYPE_PATH_NUMBERS.get(typeStr);
    if (typeIndex != null) {
      typePath = Localisation.getKBStr(lNum, typeIndex);
    }
    
    NodeList attributeElements = el.getChildNodes();
    int atCount = attributeElements.getLength();
    
    boolean isCorefefence = false;
    for (int i = 0; i < atCount; i++) {  // search for coreference
      if(!(attributeElements.item(i) instanceof Element)){
          continue;
      }
      if(!((Element) attributeElements.item(i)).getTagName().equalsIgnoreCase("attribute")){
          continue;
      }
        
      Element attrEl = (Element) attributeElements.item(i);
      String nameStr = attrEl.getAttribute("name");
      if (nameStr != null && nameStr.equalsIgnoreCase("coreference")) {
        String valueStr = MessageProcessor.getElementContent(attrEl);
        if (valueStr != null) {
          Integer v = null;
          try {
            v = Integer.parseInt(valueStr);
          } catch (Exception e) {
          }
          if ((v != null && v > 0) || valueStr.equalsIgnoreCase("true")) {
            isCorefefence = true;
          }
          break;
        }
      }
    }  // search for coreference
    
    if (isCorefefence) {
      typePath = typePath + "/" + Localisation.getKBStr(lNum, Localisation.KB_COREFERENCE_TO) + typePath;
    }
    
    boolean typeCreated = false;
    ArrayList<AnnotTypeAttr> atList = new ArrayList<AnnotTypeAttr>();
    // try to find a type in the DB or newTypes array or create new one
    AnnotType annotType = findType(requestInfo, newTypes, typePath);
    if (annotType == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to obtain suggestion type";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    }
    // a type not found, new one was created
    else if (annotType.getId() == null && annotType.getAttributes().isEmpty()) {
      newTypes.addAll(SuggestionManager.breakdownType(annotType, requestInfo, newTypes));
      newTypes.add(annotType);
      typeCreated = true;
    }
    
    SecSuggestion sug = (useAlternatives ? new Alternative(annotType, "", null) : new Suggestion(annotType, "", null));
    ArrayList sugAList = (useAlternatives ? new ArrayList<AlternativeAttribute>() : new ArrayList<SugBaseAttribute>());
    
    HashMap<String, Integer> atPriorities = getPriorities(typeStr);
    HashMap<String, Integer> usedPriorities = new HashMap<String, Integer>();
    
    int pGen = 100;  // counter for generating of missing priorities
    for (int i = 0; i < atCount; i++) {  // for each attribute
      if(!(attributeElements.item(i) instanceof Element)){
          continue;
      }
      if(!((Element) attributeElements.item(i)).getTagName().equalsIgnoreCase("attribute")){
          continue;
      }
      
      
      Element attrEl = (Element) attributeElements.item(i);
      
      String nameStr = attrEl.getAttribute("name");
      if (nameStr != null && nameStr.equalsIgnoreCase("coreference")) {
        continue;  // coreference was already processed
      }
      
      if(nameStr != null && nameStr.equalsIgnoreCase("confidence")){
        // confidence is special attribute 
        String confidenceRawVal = MessageProcessor.getElementContent(attrEl);  
        Integer confidenceValue;
        try {
          confidenceValue = Integer.parseInt(confidenceRawVal);
        } catch (Exception e) {
          // error can't decode confidence
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can't decode confidence attribute from sec api. Attribute:" + confidenceRawVal;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          continue;
        }
        
        // set confidence
        if(useAlternatives){
          Alternative tmpAlt = (Alternative) sug;
          tmpAlt.setConfidence(confidenceValue);
        }else{
          Suggestion tmpSug = (Suggestion) sug;
          tmpSug.setConfidence(confidenceValue);
        }
        continue;
      }
      
      SecAttribute attr = processAttributeEl(requestInfo, attrEl, sugAList, atPriorities, usedPriorities, pGen, atList, useAlternatives, sug, newTypes);
      
      if (attr != null) {
        attr.setRefSecSuggestion(sug);
        sugAList.add(attr);
        pGen++;
      }
      
    }  // for each attribute
    
    // Check confidence and set if it is missing
    if (useAlternatives) {
      Alternative tmpAlt = (Alternative) sug;
      if (tmpAlt.getConfidence() == null) {
        tmpAlt.setConfidence(DEFAULT_SUGGESTION_CONFIDENCE);
      }
    } else {
      Suggestion tmpSug = (Suggestion) sug;
      if (tmpSug.getConfidence() == null) {
        tmpSug.setConfidence(DEFAULT_SUGGESTION_CONFIDENCE);
      }
    }
    
    // Latitude and longitude should be combined to GeoPoint (visualised on the map)
    Iterator<SecAttribute> sait = sugAList.iterator();
    SecAttribute latitude = null;
    SecAttribute longitude = null;
    Integer pri = null;
    while (sait.hasNext()) {
      SecAttribute sba = sait.next();
      if (sba.getName().equals(LATITUDE_NAME) 
          || sba.getName().equals(Localisation.getKBStr(lNum, Localisation.KB_LATITUDE))) {
        latitude = sba;
        pri = sba.getPriority();
        sait.remove();
      } else if (sba.getName().equals(LONGITUDE_NAME)
              || sba.getName().equals(Localisation.getKBStr(lNum, Localisation.KB_LONGITUDE))) {
        longitude = sba;
        if (pri == null) {
          pri = sba.getPriority();
        }
        sait.remove();
      }
    }
    SecAttribute geoAt = null;
    if (latitude != null && longitude != null) {
      try {
        BigDecimal lat = null;
        BigDecimal lon = null;
        String latStr = latitude.getStringValue();
        if (latStr != null && latStr.startsWith("\"") && latStr.endsWith("\"")) {
          latStr = latStr.substring(1,latStr.length() - 1);
        }
        String longStr = longitude.getStringValue();
        if (longStr != null && longStr.startsWith("\"") && longStr.endsWith("\"")) {
          longStr = longStr.substring(1,longStr.length() - 1);
        }
        if (latitude.getStringValue() != null && !latitude.getStringValue().equals("")) {
          lat = new BigDecimal(latStr);
        }
        if (longitude.getStringValue() != null && !longitude.getStringValue().equals("")) {
          lon = new BigDecimal(longStr);
        }
        if (latitude.getDecValue() != null) {
          lat = latitude.getDecValue();
        }
        if (longitude.getDecValue() != null) {
          lon = longitude.getDecValue();
        }
        SugBaseAttribute newSBA = new SugGeoPointAttribute(Localisation.getKBStr(lNum, Localisation.KB_GEO_LOCATION), lat, lon, null, pri);
        geoAt = (useAlternatives ? new AlternativeAttribute(newSBA) : newSBA);
        geoAt.setRefSecSuggestion(sug);
        sugAList.add(geoAt);
      } catch (NumberFormatException e) {
        if (latitude.getStringValue() != null && longitude.getStringValue() != null) {
          String stringVal = Localisation.getKBStr(lNum, Localisation.KB_LATITUDE) + ": " + latitude.getStringValue() 
            + " " + Localisation.getKBStr(lNum, Localisation.KB_LONGITUDE) + ": " + longitude.getStringValue();
          SugBaseAttribute newSBA = new SugStringAttribute(Localisation.getKBStr(lNum, Localisation.KB_GEO_LOCATION), stringVal, (Suggestion) null, pri);
          geoAt = (useAlternatives ? new AlternativeAttribute(newSBA) : newSBA);
          geoAt.setRefSecSuggestion(sug);
          sugAList.add(geoAt);
        }
      }
    } else if (latitude != null) {
      sugAList.add(latitude);
    } else if (longitude != null) {
      sugAList.add(longitude);
    }
    
    if (useAlternatives) {
      ((Alternative) sug).setAttributes(sugAList);
      ((Alternative) sug).setTmpId(tmpIdStr);
    } else {
      ((Suggestion) sug).setAttributes(sugAList);
      ((Suggestion) sug).setTmpId(tmpIdStr);
    }
    
    if (typeCreated) {
      // if new type was created, attributes should be added
      Iterator<AnnotTypeAttr> atIt = atList.iterator();
      while (atIt.hasNext()) {
        AnnotTypeAttr ata = atIt.next();
        ata.setAnnotationType(annotType);
      }
      annotType.setAttributes(atList);
    }
    
    return sug;
  }  // createSugFromElement()
  
  /**
   * Gets map with priorities of attributes of given type
   * 
   * @param name Name of type
   * @return Returns map with priorities of attributes of given type
   */
  private static HashMap<String, Integer> getPriorities(String name) {
    ArrayList<SecApiReqTypeDef> des = AppBean.getDesTypeDefinitions();
    Iterator<SecApiReqTypeDef> dIt = des.iterator();
    while (dIt.hasNext()) {
      SecApiReqTypeDef rtd = dIt.next();
      if (rtd.getTypeName().contentEquals(name)) {  // type found
        if (rtd.getPriorities() != null) {
          return rtd.getPriorities();
        }
        break;  // priorities are not available, abort search
      }
    }
    return new HashMap<String, Integer>();
  }  // getPriorities()
  
  /**
   * Creates suggestion object from XML element with attribute
   * 
   * @param requestInfo Informations about client request
   * @param sugAList List of already processed attributes (for searching of duplicities)
   * @param atEl XML element with attribute
   * @param atPriorities Array with priorities of attributes
   * @param usedPriorities Array with priorities which was already used
   * @param pGen Counter for generating of missing priorities
   * @param atList List of attributes for creation of type of annotation
   * @param useAlternatives True for work with alternatives, false otherwise
   * @param sug Suggestion to which this attribute will be added
   * @param newTypes New annotation types
   * @return Object with attribute
   */
  private SecAttribute processAttributeEl(RequestInfo requestInfo, Element atEl, 
                                                     ArrayList sugAList,
                                                     HashMap<String, Integer>atPriorities,
                                                     HashMap<String, Integer>usedPriorities,
                                                     int pGen, ArrayList<AnnotTypeAttr> atList,
                                                     boolean useAlternatives,
                                                     SecSuggestion sug,
                                                     ArrayList<AnnotType> newTypes) {
    int lNum = requestInfo.getSession().getLanguageNum();
    
    String nameStr = atEl.getAttribute("name");
    String typeStr = atEl.getAttribute("type");
    String valueStr = null;
    
    /*
     * As entite has another attributes inside, this would cause an nullpointer exception 
     */
    if(!typeStr.equalsIgnoreCase("entity")){
      valueStr = MessageProcessor.getElementContent(atEl);
    }
    
     
    if (nameStr == null || nameStr.isEmpty()) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Attribute of suggestion from SEC API without name.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    }
    if (typeStr == null || typeStr.isEmpty()) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Attribute of suggestion from SEC API without type.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    }
    
    if (typeStr.equals("url") || typeStr.equals("Url") || typeStr.equals("uri") || typeStr.equals("Uri")) {
      typeStr = "URI";  // fix case sensitivity and URL
    }
    
    String origName = nameStr;
    
    Integer nameIndex = Localisation.KB_STRINGS_INTERNAL.indexOf(nameStr);
    if (Constants.IDENTIFIER_TO_ENTITY_URI && (nameStr.equalsIgnoreCase("identifier") || nameStr.equalsIgnoreCase("URI_of_entity"))) {
      nameStr = Localisation.getKBStr(lNum, Localisation.KB_ENTITY_URI);
      if (typeStr.equals("URI") && valueStr != null && !valueStr.isEmpty()) {
        sug.setSAEntityIdentifier(valueStr);
      }
    } else if (Constants.DISPLAY_TERM_TO_NAME && nameStr.equalsIgnoreCase("display_term")) {
      nameStr = Localisation.getKBStr(lNum, Localisation.KB_PERSON_NAME);
    } else if (nameIndex > 0) {  // if it is possible, localise attribute name
      nameStr = Localisation.getKBStr(lNum, nameIndex);
    }
    
    String ucType = Character.toUpperCase(typeStr.charAt(0)) + typeStr.substring(1);
    
    if (Constants.COMPLETE_IMAGE_URI && ucType.equals("Image") && valueStr != null 
        && !valueStr.startsWith("http")) {
      valueStr = AppBean.getKBImagePrefix() + valueStr;
    }
    
    SecAttribute result = null;
    
    if (Constants.SIMPLE_TYPES.contains(ucType)) {
      if (ucType.equals("Date")) {  // date must be handled separately (ISO format)
        if (valueStr == null || valueStr.isEmpty()) {
          result = (useAlternatives ? 
                       new AlternativeAttribute(new SugDateAttribute(nameStr, null, null))
                     : new SugDateAttribute(nameStr, null, null));
        } else {
          Date dateVal = parseDate(valueStr);
          if (dateVal == null) {  // date as "1995" must be handled as String
            result = (useAlternatives ? 
                       new AlternativeAttribute(new SugStringAttribute(nameStr, valueStr, null))
                    :  new SugStringAttribute(nameStr, valueStr, null));
          } else {
            result = (useAlternatives ? 
                       new AlternativeAttribute(new SugDateAttribute(nameStr, dateVal, null))
                    :  new SugDateAttribute(nameStr, dateVal, null));
            if (useAlternatives) {
              AlternativeAttribute tmpAt = (AlternativeAttribute) result;
              tmpAt.setBoolVAlue(true);
            } else {
              SugBaseAttribute tmpAt = (SugBaseAttribute) result;
              tmpAt.setBoolVAlue(true);
            }
          }
        }
      } 
      /*
       * GeoPoint attribute
       */
      else if(ucType.equalsIgnoreCase("GeoPoint")){
        try {
          // Create proper type of attribute
          result = (useAlternatives ? 
                     new AlternativeAttribute(SugAttributeManager.createAttribute(nameStr, ucType, null))
                     :  SugAttributeManager.createAttribute(nameStr, ucType, null));
          
          //Assign value to GeoPointAttribute
          String latitude = processGeoPoint(atEl, true);
          String longitude = processGeoPoint(atEl, false);
          if (useAlternatives) {
            ((AlternativeAttribute) result).setGeoPointStringValue(latitude, longitude);
          } else {
            ((SugGeoPointAttribute) result).setStringValue(latitude, longitude);
          }
        } catch (ClassNotFoundException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unknown type of attribute of suggestion from SEC API: " + typeStr;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          return null;
        }catch (IllegalArgumentException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad value of attribute of suggestion from SEC API: " + valueStr + " (type " + typeStr + ")";
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
          }
          result = (useAlternatives ? 
                       new AlternativeAttribute(new SugStringAttribute(nameStr, valueStr, null))
                    :  new SugStringAttribute(nameStr, valueStr, null));
        }
          
      }
      /*
       * Entity Attribute
       */
      else if(ucType.equalsIgnoreCase("Entity")){
        try {
            // Create proper type of attribute
            result = (useAlternatives ? 
                        new AlternativeAttribute(SugAttributeManager.createAttribute(nameStr, ucType, null))
                        :  SugAttributeManager.createAttribute(nameStr, ucType, null));
            
          //Get all additional attributes         
          if (useAlternatives) {
            ArrayList<AltEntityAdditionalAttribute> altAddAttList;
            altAddAttList = processAltEntityAddAttributes(atEl, (AlternativeAttribute) result);
            ((AlternativeAttribute) result).setEntityAdditionalAttributes(altAddAttList);
          } else {
            ArrayList<SugEntityAdditionalAttribute> sugAddAttList;
            sugAddAttList = processSugEntityAddAttributes(atEl, (SugEntityAttribute) result);
            ((SugEntityAttribute) result).setEntityAdditionalAttributes(sugAddAttList);
          }
            
        } catch (ClassNotFoundException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unknown type of attribute of suggestion from SEC API: " + typeStr;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          return null;
        }
      }
      else {  // Other simple types
        try {
          result = (useAlternatives ? 
                       new AlternativeAttribute(SugAttributeManager.createAttribute(nameStr, ucType, null))
                    :  SugAttributeManager.createAttribute(nameStr, ucType, null));
          if (useAlternatives) {
            ((AlternativeAttribute) result).setRawValue(valueStr);
          } else {
            ((SugBaseAttribute) result).setRawValue(valueStr);
          }
        } catch (ClassNotFoundException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unknown type of attribute of suggestion from SEC API: " + typeStr;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          return null;
        } catch (IllegalArgumentException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad value of attribute of suggestion from SEC API: " + valueStr + " (type " + typeStr + ")";
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.WARNING, msg);
          }
          result = (useAlternatives ? 
                       new AlternativeAttribute(new SugStringAttribute(nameStr, valueStr, null))
                    :  new SugStringAttribute(nameStr, valueStr, null));
        }
      }
    } else {  // it is not simple
       /*
       * Linked Attribute
       */
      if (ucType.equalsIgnoreCase("LinkedAnnotation") || ucType.equalsIgnoreCase("AnnotationLink")) {
        try {
          // Create proper type of attribute
          result = (useAlternatives
                  ? new AlternativeAttribute(SugAttributeManager.createAttribute(nameStr, ucType, null))
                  : SugAttributeManager.createAttribute(nameStr, ucType, null));

          String typeName = atEl.getAttribute("annotType");
          AnnotType type = null;
          
          if (typeName != null) {
            Integer typeIndex = Localisation.TYPE_PATH_NUMBERS.get(typeStr);
            if (typeIndex != null) {
              typeName = Localisation.getKBStr(lNum, typeIndex);
            }
            type = findType(requestInfo, newTypes, typeName);
            
            if (type == null) {
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                String msg = "Unable to obtain suggestion type";
                Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
              }
              return null;
            }
            // a type not found, new one was created
            else if (type.getId() == null && type.getAttributes().isEmpty()) {
              newTypes.addAll(SuggestionManager.breakdownType(type, requestInfo, newTypes));
              newTypes.add(type);
            }
          }

          if (useAlternatives) {
              ((AlternativeAttribute) result).setAttributeType(type);
          } else {
              ((SugLinkedAttribute) result).setAttributeType(type);
          }
          
          if (valueStr != null && !valueStr.isEmpty()) {
            if (useAlternatives) {
              ((AlternativeAttribute) result).setUri(valueStr);
            } else {
              ((SugLinkedAttribute) result).setUri(valueStr);
            }
          }
        } catch (ClassNotFoundException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unknown type of attribute of suggestion from SEC API: " + typeStr;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          return null;
        }
      } 
      /*
       * Nested Attribute
       */ 
      else if (ucType.equalsIgnoreCase("NestedAnnotation")) {
        try {
          // Create proper type of attribute
          result = (useAlternatives ? 
                      new AlternativeAttribute(SugAttributeManager.createAttribute(nameStr, ucType, null))
                      : SugAttributeManager.createAttribute(nameStr, ucType, null));

          String typeName = atEl.getAttribute("annotType");
          AnnotType type = null;
          
          if (typeName != null) {
            Integer typeIndex = Localisation.TYPE_PATH_NUMBERS.get(typeStr);
            if (typeIndex != null) {
              typeName = Localisation.getKBStr(lNum, typeIndex);
            }
            type = findType(requestInfo, newTypes, typeName);
            
            if (type == null) {
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                String msg = "Unable to obtain suggestion type";
                Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
              }
              return null;
            }
            // a type not found, new one was created
            else if (type.getId() == null && type.getAttributes().isEmpty()) {
              newTypes.addAll(SuggestionManager.breakdownType(type, requestInfo, newTypes));
              newTypes.add(type);
            }
          }
                    
          if (useAlternatives) {
              ((AlternativeAttribute) result).setAttributeType(type);
          } else {
              ((SugNestedAttribute) result).setAttributeType(type);
          }
          
          String tmpUri = valueStr;
          if (valueStr.startsWith("<text")) {  // directly nested
            tmpUri = null;
          } else if (valueStr.replaceAll("[\\s\\u00A0]+$", "").contentEquals("")) {  // empty
            tmpUri = null;
          }
          if (tmpUri != null && !tmpUri.isEmpty()) {
            if (useAlternatives) {
              ((AlternativeAttribute) result).setUri(tmpUri);
            } else {
              ((SugNestedAttribute) result).setUri(tmpUri);
            }
          } else {
            //Search for a nested annotation within this attribute
            if (useAlternatives) {
              ((AlternativeAttribute) result).setNestedAlternative(processNestedAlternative(atEl, requestInfo, newTypes));
              //Assign to processed nested alternative value of 'nestedInAlternative' variable which is owner of this attribute
              ((AlternativeAttribute) result).getNestedAlternative().setNestedInAlternative((Alternative)sug);
            } else {
              ((SugNestedAttribute) result).setNestedSuggestion(processNestedSugg(atEl, requestInfo, newTypes));
              //Assign to processed nested suggestion value of 'nestedInSug' variable which is owner of this attribute
              ((SugNestedAttribute) result).getNestedSuggestion().setNestedInSuggestion((Suggestion)sug);
            }
          }

        } catch (ClassNotFoundException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unknown type of attribute of suggestion from SEC API: " + typeStr;
            Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
          }
          return null;
        }
      }
    }  // it is not simple
    
    Integer p = usedPriorities.get(origName);
    if (p == null) {
      p = atPriorities.get(origName);  // find default priority for attribute
      if (p == null) {
        p = pGen;  // use counter as backup solution
      }
    } else {  // if priority was already used
      while (usedPriorities.containsValue(p)) {        
        p++;  // increment it to do not use same priority twice
      }
    }
    if (result != null) {
      result.setPriority(p);
      usedPriorities.put(origName, p);

      AnnotTypeAttr ata = new AnnotTypeAttr(null, result.getName(), ucType, false, p);
      
      if (useAlternatives) {
        if(((AlternativeAttribute) result).getAttributeType() != null){
          ata.setAttributeType(((AlternativeAttribute) result).getAttributeType());
        }
      } else {
        if(((SugBaseAttribute)result).getAttributeType() != null){
          ata.setAttributeType(((SugBaseAttribute)result).getAttributeType());
        }
      }
      
      
      atList.add(ata);
    }
    
    return result;
  }  // processAttributeEl()
  
  /**
   * Processes element with entity additional attributes in entity in attribute of suggestion
   * 
   * @param el Element with entity additional attributes
   * @param refEntity Attribute of suggestion of type entity to which attributes belongs
   * @return List of entity additional attributes
   */
  private static ArrayList<SugEntityAdditionalAttribute> processSugEntityAddAttributes(Element el,
          SugEntityAttribute refEntity) {

    ArrayList<SugEntityAdditionalAttribute> result = new ArrayList<SugEntityAdditionalAttribute>();
    for (Node node = el.getFirstChild(); node != null; node = node.getNextSibling()) {
      if (!(node instanceof Element)) {
        continue;
      }
      if (!((Element) node).getTagName().equalsIgnoreCase("entityAttribute")) {
        continue;
      }

      String nameStr = ((Element) node).getAttribute("name");
      String typeStr = ((Element) node).getAttribute("type");
      String valueStr = MessageProcessor.getElementContent(((Element) node));

      result.add(new SugEntityAdditionalAttribute(nameStr, typeStr, valueStr, refEntity));
    }


    return result;
  }
  
  /**
   * Processes element with entity additional attributes in entity in attribute of alternative
   * 
   * @param el Element with entity additional attributes
   * @param refAltAtt Attribute of alternative of type entity to which attributes belongs
   * @return List of entity additional attributes
   */
  private static ArrayList<AltEntityAdditionalAttribute> processAltEntityAddAttributes(Element el,
                                                                  AlternativeAttribute refAltAtt) {

    ArrayList<AltEntityAdditionalAttribute> result = new ArrayList<AltEntityAdditionalAttribute>();
    for (Node node = el.getFirstChild(); node != null; node = node.getNextSibling()) {
      if (!(node instanceof Element)) {
        continue;
      }
      if (!((Element) node).getTagName().equalsIgnoreCase("entityAttribute")) {
        continue;
      }

      String nameStr = ((Element) node).getAttribute("name");
      String typeStr = ((Element) node).getAttribute("type");
      String valueStr = MessageProcessor.getElementContent(((Element) node));

      result.add(new AltEntityAdditionalAttribute(nameStr, typeStr, valueStr, refAltAtt));
    }

    return result;
  }
  
  /**
   * Gets GeoPoint value from element
   * 
   * @param el GeoPoint element
   * @param latitude Flag for getting either latitude or longitude
   * @return If flag parameter is set to true, returns latitude value, longitude otherwise
   */
  private static String processGeoPoint(Element el, boolean latitude) {

    for (Node node = el.getFirstChild(); node != null; node = node.getNextSibling()) {
      if (!(node instanceof Element)) {
        continue;
      }

      Element tmpEl = (Element) node;
      if (tmpEl.getTagName().equals("geo:Point")) {
        for (Node innerNode = tmpEl.getFirstChild(); innerNode != null; innerNode = innerNode.getNextSibling()) {
          if (!(innerNode instanceof Element)) {
            continue;
          }
          if (((Element) innerNode).getTagName().equals("geo:lat")) {
            if (latitude) {
              return getGeoPointNodeValue(innerNode.getFirstChild());
            }
          } else if (((Element) innerNode).getTagName().equals("geo:long")) {
            if (!latitude) {
              return getGeoPointNodeValue(innerNode.getFirstChild());
            }
          } else {
            continue;
          }
        }
      }
    }

    return "";
  }
  
  /**
   * Returns node value of node with GeoPoint
   * 
   * @return Returns node value
   */
  private static String getGeoPointNodeValue(Node node) {

    for (Node n = node; n != null; n = n.getNextSibling()) {
      if (n.getNodeValue() != null) {
        return n.getNodeValue();
      }
    }
    return null;
  }

  /**
   * Parses XML from the SEC API
   *
   * @param XMLString String with XML with messages from client
   * @return Parsed XML in w3c.dom.Document
   */
  private static Document parseXml(String XMLString) {
    Document dom;
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);

    try {
      DocumentBuilder db = dbf.newDocumentBuilder();
      InputSource is = new InputSource();
      is.setCharacterStream(new StringReader(XMLString));
      dom = db.parse(is);
    } catch (ParserConfigurationException pce) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "ParserConfigurationException while parsing XML from the SEC API.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg, pce);
      }
      return null;  // bad request
    } catch (SAXException se) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "SAXException while parsing XML from the SEC API.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.ALL, msg, se);
      }
      return null;
    } catch (IOException ioe) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "IOException while parsing XML from the SEC API.";
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg, ioe);
      }
      return null;
    }

    return dom;
  }  // parseXml()
  
  /**
   * Parses date from ISO format from dates.py (which is part of SEC API NER)
   * 
   * @param sDate String with date
   * @return Returns parsed date
   */
  private static Date parseDate(String sDate) {
    if (sDate == null || sDate.isEmpty()) {
      return null;
    }
    if (sDate.length() == 4 || sDate.length() == 7) {  // probably "yyyy" or "yyyy-MM"
      return null;  // partial date unsupported
    }
    if (sDate.length() < 10) {  // "yyyy-MM-dd" must have 10 characters
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Wrong date format from SEC API: " + sDate;
        Logger.getLogger(SECAPISuggestionTranslator.class.getName()).log(Level.SEVERE, msg);
      }
      return null;
    }
    int index1 = sDate.indexOf("-");
    int index2 = sDate.lastIndexOf("-");
    if (index1 == -1 || index2 == -1 || index1 == index2) {
      return null;
    }
    if (sDate.substring(index1 + 1, index2).equals("00")) {
      return null;
    }
    if (sDate.length() - index2 == 3) {
      if (sDate.substring(index2 + 1).equals("00")) {
        return null;
      }
    }
    Date date;
    try {
      date = new SimpleDateFormat("yyyy-MM-dd").parse(sDate);
    } catch (Exception e) {
      return null;
    }
    return date;
  }  // parseDate()
  
 /**
  * Searches for a type specified by the typePath and returns the type if found
  * 
  * @param requestInfo Information about a client request
  * @param newTypes A list containing newly created types
  * @param typePath A path for the type identification
  * @return Type data if found, empty data object otherwise
  */
  public AnnotType findType(RequestInfo requestInfo, ArrayList<AnnotType> newTypes, String typePath) {
    UserGroup group;
    
    if(defaultUserGroup == null){
        defaultUserGroup = requestInfo.getSession().getDefaultGroup();
        if (defaultUserGroup == null) {
          defaultUserGroup = this.userGroup;
        }
    }
    
    group = defaultUserGroup;
    
    String typeUri = baseTypeUri + "g" + group.getId() + "/" + typePath;
    
    if(typesBuffer.containsKey(typeUri)){
        return typesBuffer.get(typeUri);
    }
    
    if (newTypes != null && !newTypes.isEmpty()) { // look into the new type list
      Iterator<AnnotType> annotTypeIt = newTypes.iterator();
      while (annotTypeIt.hasNext()) {
        AnnotType aT = annotTypeIt.next();
        if (aT.getUri() != null && aT.getUri().equals(typeUri)) {
          return aT;
        }
      }
    }
    
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = typeUri;
    
    List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    
    if (tList != null && !tList.isEmpty()) {  // if type is already in the DB
      typesBuffer.put(typeUri, (AnnotType) tList.get(0));
      return (AnnotType) tList.get(0);
    }

    
    return new AnnotType(typeUri, typePath, null, group); // an empty type
  }  // findType()
  
  
  /**
   * @brief The object that hold informations ipmortant for translate of alternative 
   * from SEC Api.
   */
  private class TranslateAlternativeHolder {
    /** Dummy alternative for converting of fragment */
    private Alternative dummyAlternative;
    /** Array of unconverted alternatives from SEC API */
    private ArrayList<Alternative> unconvertedAlternatives;
    /** Array of converted alternative suggestions from DB */
    private ArrayList<Suggestion> convertedAlternatives;

    /**
     * Gets dummy alternative for converting of fragment.
     * 
     * @return dummy alternative for converting of fragment
     */
    public Alternative getDummyAlternative() {
      return dummyAlternative;
    }

    /**
     * Sets dummy alternative for converting of fragment.
     * 
     * @param dummyAlternative dummy alternative for converting of fragment.
     */
    public void setDummyAlternative(Alternative dummyAlternative) {
      this.dummyAlternative = dummyAlternative;
    }

    /**
     * Gets array of unconverted alternatives from SEC API.
     * 
     * @return array of unconverted alternatives from SEC API
     */
    public ArrayList<Alternative> getUnconvertedAlternatives() {
      return unconvertedAlternatives;
    }

    /**
     * Sets array of unconverted alternatives from SEC API.
     * 
     * @param unconvertedAlternatives array of unconverted alternatives from SEC API
     */
    public void setUnconvertedAlternatives(ArrayList<Alternative> unconvertedAlternatives) {
      this.unconvertedAlternatives = unconvertedAlternatives;
    }

    /**
     * Gets array of converted alternative suggestions from DB.
     * 
     * @return array of converted alternative suggestions from DB
     */
    public ArrayList<Suggestion> getConvertedAlternatives() {
      return convertedAlternatives;
    }

    /**
     * Sets array of converted alternative suggestions from DB.
     * 
     * @param convertedAlternatives array of converted alternative suggestions from DB
     */
    public void setConvertedAlternatives(ArrayList<Suggestion> convertedAlternatives) {
      this.convertedAlternatives = convertedAlternatives;
    }
    
    /**
     * Sets alternative of paramether for each unconverted alternative.
     * 
     * @param alternativeOf suggestion that will be set as main suggestion
     */
    public void setAlternativeOf(Suggestion alternativeOf){
      if(unconvertedAlternatives != null && !unconvertedAlternatives.isEmpty()){
        Iterator<Alternative> unconvertedIt = unconvertedAlternatives.iterator();
        while(unconvertedIt.hasNext()){
          unconvertedIt.next().setAlternativeOfSuggestion(alternativeOf);  
        }
      }
    }
    
    /**
     * Method sorts array of uncovered alternatives.
     */
    public void sortUncoveredByCofidence() {
      Collections.sort(unconvertedAlternatives, new ConfidenceComparator());
    }

    /**
     * @brief The object implements comparator of Alternative objects that are
     * compared by confidence (from highest to lowest confidence).
     */
    public class ConfidenceComparator implements Comparator<Alternative> {

      @Override
      public int compare(Alternative o1, Alternative o2) {
        int result = o1.getConfidence().compareTo(o2.getConfidence());
        if (result == 0) {
          return result;
        } else {
          return (result * (-1));
        }
      }
    } // public class ConfidenceComparator
    
  } // private class TranslateAlternativeHolder
  
}  // public class SECAPISuggestionTranslator