P2AnnotBaseProcessor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: P2AnnotBaseProcessor.java
 * Description: Abstract class provides a parser for the annotation.
 */

/**
 * @file P2AnnotBaseProcessor.java
 *
 * @brief Abstract class provides a parser for the annotation of protocol version 2.
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.PersistM;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2Trix.*;
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.User;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.bind.DatatypeConverter;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


/**
 * Abstract class provides a parser for the annotation of protocol version 2.
 *
 * @brief Abstract class provides a parser for the annotation of protocol version 2.
 * @author Martin Petr (xpetrm05)
 */
public abstract class P2AnnotBaseProcessor{
  
  /**
   * Method process annotation from given element.
   * 
   * @param annotationEl element with annotation for process
   * @param requestInfo informations about client request
   * @return annotation or null if any error occurs
   */
  public Annotation processAnnotation(Element annotationEl,RequestInfo requestInfo){
    Annotation newAnnotation = new Annotation();   
    newAnnotation.setFragments(new ArrayList<Fragment>());
    newAnnotation.setContent("");

    // get rdf:about attribute (same as uri of annotation)
    String annotUri = annotationEl.getAttribute("rdf:about");
    if(annotUri == null || annotUri.isEmpty()){
      // error - annotation without uri
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"\" invalidProperty=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Annotation is without uri.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    String annotUriPrefix = getUriType(annotUri);

    if (annotUriPrefix.equals("serv")) {
      Integer id;
      String idString = annotUri.replace(AppBean.getBaseUri() + "/serv/", "");
      try {
        id = Integer.decode(idString);
      } catch (NumberFormatException ex) {
        // error can't decode id 
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annotUri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_29_CHANGED_ANNOT_NOT_FOUND, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Can't decode annotation id. Id: " + idString;
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }

      newAnnotation.setId(id);
    } else if (annotUriPrefix.equals("temp")) {
      String idString = annotUri.replace(AppBean.getBaseUri() + "/temp/", "");
      newAnnotation.setTmpId(idString);
    } else if (annotUriPrefix.equals("sugg")) {
      String idString = annotUri.replace(AppBean.getBaseUri() + "/sugg/", "");
      newAnnotation.setTmpId(idString);
    } else {
      // bad annotation uri prefix
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad annotation uri prefix. Prefix: " + annotUriPrefix;
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    // get informations about autor
    NodeList anotatedByMsg = annotationEl.getElementsByTagName("oa:annotatedBy");
    Element anotatedByEl = (Element) anotatedByMsg.item(0);
    if(anotatedByEl != null) {
      // process autor of annotation
      User author = processAuthor(anotatedByEl, annotUri, requestInfo);
      if(author == null){
        // process of parsing author of annotation failed
        return null;
      }
      newAnnotation.setUser(author);
    }
    
    // get informations about date of creation
    NodeList annotatedAtMsg = annotationEl.getElementsByTagName("oa:annotatedAt");
    Element annotatedAtEl = (Element) annotatedAtMsg.item(0);
    if(annotatedAtEl != null) {
      // informations about time and date of creation
      Date creationDate = processCreationDate(annotatedAtEl, annotUri, requestInfo, true);
      if(creationDate == null){
        // process of parsing time and date of creation failed
        return null;
      }
      
      newAnnotation.setCreated(creationDate);
    }
    
    /*
     * Gets informations about serialization
     * 
     * Note: As server serialize annotation imediatelly after it has been processed, the same date
     * as date of creation is automatically used for serialization.
     * This is just confirmation, that client sent correct format of serialization date
     * If there is an error, client is informed about bad format of date and annotation is malformed
     */
    NodeList serializedAtMsg = annotationEl.getElementsByTagName("oa:serializedAt");
    Element serializedAtEl = (Element) serializedAtMsg.item(0);
    if(serializedAtEl != null){
      processCreationDate(serializedAtEl, annotUri, requestInfo, false);
    }
    
    // get bodies of annotation (there are type of annotation, content and attributes)
    NodeList bodiesOfAnnot = annotationEl.getElementsByTagName("oa:hasBody");
    if(bodiesOfAnnot != null){
      if(!processBodies(bodiesOfAnnot,newAnnotation,requestInfo)){
        // process of parsing bodies of annotation failed
        return null;
      }
    }
    
    // get informations about trget (there are fragments and annotated document)
    NodeList targetMsg = annotationEl.getElementsByTagName("oa:hasTarget");
    Element targetEl = (Element) targetMsg.item(0);
    if(targetEl != null) {
      if(!processTarget(targetEl,newAnnotation, requestInfo)){
        // process of parsing targets of annotation failed
        return null;
      }
    }
    
    return newAnnotation;
  }  // processAnnotation()
  
  /**
   * Method process target element of annotation.
   * 
   * @param targetEl element with target of annotation for process
   * @param annot annotation which information from target element will be set
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processTarget(Element targetEl, Annotation annot, RequestInfo requestInfo){
    
    // find composite
    NodeList fragCompositeMsg = targetEl.getElementsByTagName("oa:Composite");
    Element fragCompositeEl = (Element) fragCompositeMsg.item(0);
    if(fragCompositeEl != null) {
      // if composite process composite
      ArrayList<Fragment> fragments = processSRComposite(fragCompositeEl,annot,requestInfo);
      if(fragments != null && !fragments.isEmpty()){
        annot.setFragments(fragments);
        
        AnnotDocument doc = processHasSource(annot, fragCompositeEl,requestInfo);
        if(doc == null){
          return false;
        }
        annot.setSourceDocument(doc);
        return true;
      }else{
        return false;
      }
    }
    
    // find specificResource
    NodeList specificResourceMsg = targetEl.getElementsByTagName("oa:SpecificResource");
    Element specificResourceEl = (Element) specificResourceMsg.item(0);
    if (specificResourceEl != null) {
      // if fragment then process fragment
      Fragment frag = processSpecificResource(specificResourceEl, annot, requestInfo);
      if (frag != null) {
        ArrayList<Fragment> newFragments = new ArrayList<Fragment>();
        newFragments.add(frag);
        annot.setFragments(newFragments);
        
        AnnotDocument doc = processHasSource(annot, specificResourceEl,requestInfo);
        if(doc == null){
          return false;
        }
        annot.setSourceDocument(doc);
        return true;
      }else{
        return false;
      }
    }
    
    // if whole document make fragment for whole doc
    NodeList wholeDocMsg = targetEl.getElementsByTagName("dctypes:Text");
    Element wholeDocEl = (Element) wholeDocMsg.item(0);
    if(wholeDocEl != null) {
      
      // set document
      String documentUri = wholeDocEl.getAttribute("rdf:about");
      if(documentUri == null || documentUri.isEmpty()){
        // error - uri of document not found
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unable to find document uri (rdf:about).";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return false;
      }
      
      //check for format element
      NodeList formatMsg = targetEl.getElementsByTagName("dc:format");
      if(formatMsg.item(0) == null){
        // error - can't find trix element
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Element format in target is missing.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return false;
      }
      
      
      AnnotDocument syncDocument = requestInfo.getSession().getSyncDocument();
      AnnotDocument doc = null;
      if (syncDocument.getUri() != null && syncDocument.getUri().equals(documentUri)) {
        doc = syncDocument;
      } else {
        doc = getDocumentFromUri(documentUri, annot, requestInfo);
      }
      if(doc == null){
        return false;
      }
      
      annot.setSourceDocument(doc);
      return true;
    }
    
    return false;
  }  // processTarget()
  
  /**
   * Method process element with multiple annotated fragments of document.
   * 
   * @param compositeEl element with multiple annotated fragments for process
   * @param annot annotation which multiple fragments belongs
   * @param requestInfo informations about client request
   * @return list of fragments or null if any error occurs
   */
  private ArrayList<Fragment> processSRComposite(Element compositeEl, Annotation annot, RequestInfo requestInfo){
    ArrayList<Fragment> fragments = new ArrayList<Fragment>();
    
    NodeList itemsMsg = compositeEl.getElementsByTagName("oa:item");
    int size = itemsMsg.getLength();
    if (size > 0) {
      for (int index = 0; index < size; index++) {
        Element documentEl = (Element) itemsMsg.item(index);

        // find specificResource
        NodeList specificResourceMsg = documentEl.getElementsByTagName("oa:SpecificResource");
        Element specificResourceEl = (Element) specificResourceMsg.item(0);
        if (specificResourceEl != null) {
          // if fragment then process fragment
          Fragment frag = processSpecificResource(specificResourceEl, annot, requestInfo);
          if (frag != null) {
            fragments.add(frag);
          }
        }
      }
    } else {
      // can't find any item in composite of fragments
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_81_EMPTY_COMPOSITE, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Cant find any item in composite of fragments.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    return fragments;
  }
  
  /**
   * Method process source element (element with inforamtions about document) of 
   * annotation.
   * 
   * @param annot Annotation to which element belongs
   * @param hasSourceEl Element with source of annotation for process
   * @param requestInfo Informations about client request
   * @return Returns annotated docuemnt or null if any error occurs
   */
  private AnnotDocument processHasSource(Annotation annot, Element hasSourceEl, RequestInfo requestInfo){
    NodeList dctypesMsg = hasSourceEl.getElementsByTagName("dctypes:Text");
    Element dctypesEl = (Element) dctypesMsg.item(0);
    if (dctypesEl == null) {
      // can't find dctypes:Text element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element dctypes:Text is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    } else {
      String documentUri = dctypesEl.getAttribute("rdf:about");
      if(documentUri == null || documentUri.isEmpty()){
        // can't find document uri
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unable to find document uri.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      
      //search for format element 
      NodeList formatMsg = hasSourceEl.getElementsByTagName("dc:format");
      if(formatMsg.item(0) == null){
        // error - can't find trix element
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Element format in target - source is missing.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
      
      AnnotDocument syncDoc = requestInfo.getSession().getSyncDocument();
      if (syncDoc.getUri() != null && syncDoc.getUri().equals(documentUri)) {
        return syncDoc;
      }
      return getDocumentFromUri(documentUri, annot, requestInfo);
    }
  }
  
  /**
   * Method process specific resources of annotations and save them as fragments.
   * 
   * @param specificResourceEl element with specific resources of annotation for process
   * @param annot annotation which specific resources (fragment) belongs
   * @param requestInfo informations about client request
   * @return fragment or null if any error occurs
   */
  private Fragment processSpecificResource(Element specificResourceEl, Annotation annot, RequestInfo requestInfo){
    //check for oa:hasSelector element
    NodeList formatMsg = specificResourceEl.getElementsByTagName("oa:hasSelector");
    if(formatMsg.item(0) == null){
      // error - can't find trix element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element oa:hasSelector in target is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    // get anotated document
    Fragment newFragment = new Fragment();
    NodeList documentMsg = specificResourceEl.getElementsByTagName("oa:FragmentSelector");
    Element documentEl = (Element) documentMsg.item(0);
    newFragment.setRefAnnotation(annot);
    newFragment.setIsGood(true);
    if (documentEl == null) {
      // can't find dcterms:conformsTo element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element dcterms:conformsTo is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    } else {
      // get xpointer
      NodeList xpointerMsg = documentEl.getElementsByTagName("rdf:value");
      Element xpointerEl = (Element) xpointerMsg.item(0);
      if(xpointerEl != null) {
        String xpointer = MessageProcessor.getElementContent(xpointerEl);
        if(xpointer == null || xpointer.isEmpty()){
          // can't find xpointer value
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Cannot find xpointer value.";
            Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }
        
        // process xpointer
        if (!processXpointer(xpointer, newFragment, annot, requestInfo)) {
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Cannot process xpointer.";
            Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }
      }
    }
    
    return newFragment;
  }
  
  /**
   * Method process xpointer from given string and set informations into given 
   * fragment object.
   * 
   * @param xpointer xpointer string that will be parsed
   * @param fragment fragment that will be set
   * @param annot Annotation to which fragment belongs
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processXpointer(String xpointer, Fragment fragment, Annotation annot, RequestInfo requestInfo){
    // parse xpath  
    int xpathEndIndex = xpointer.indexOf(',');
    String xpath = xpointer.substring(0,xpathEndIndex);
    xpath = xpath.replace("xpointer(string-range(", "");
    xpath = UpdatableFragment.improveXPath(xpath);
    
    // parse text from xpointer
    int textStartIndex = xpointer.indexOf('\'');
    int textEndIndex = xpointer.lastIndexOf('\'');
    String text = xpointer.substring(textStartIndex+1, textEndIndex);
    
    // parse offset and length
    String partsList[] = xpointer.substring(textEndIndex).split(",");
    
    Integer offset;
    Integer length;
    
    try {
      offset = Integer.decode(partsList[1].trim());
      length = Integer.decode(partsList[2].replaceAll("\\)", "").trim());
    } catch (NumberFormatException ex) {
      // can't decode offset or length value
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_25_BAD_FRAGMENT, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to decode offset or length value.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    fragment.setLength(length);
    fragment.setOffset(offset);
    fragment.setAnnotatedText(text);
    fragment.setPath(xpath);

    return true;
  }
  
  /**
   * Method process element with bodies of annotation.
   * 
   * @param bodiesOfAnnot element with bodies of annotation for process
   * @param annot annotation which bodies (as fragments) belongs
   * @param requestInfo  informations about client request
   * @return false if any error occurs
   */
  private boolean processBodies(NodeList bodiesOfAnnot, Annotation annot, RequestInfo requestInfo){
    int bodiesCount = bodiesOfAnnot.getLength();
    
    if(bodiesCount == 0){
      //Annotation must have at least 1 body
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"body\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "rdf:about is not presented in body.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    // go trough all body elements
    for(int index = 0; index < bodiesCount; index++){
      Element bodyEl = (Element) bodiesOfAnnot.item(index);
      if(bodyEl != null) {
        
        // try find type of annotation element
        NodeList annotTypeMsg = bodyEl.getElementsByTagName("oa:SemanticTag");
        Element annotTypeEl = (Element) annotTypeMsg.item(0);
        if(annotTypeEl != null) {
          // process element with type of annotation
          if(!processAnnotType(annotTypeEl,annot,requestInfo)){
            // process of parsing type of annotation failed
            return false;
          }
        }
        
        // try find contents of annotation
        NodeList textContentMsg = bodyEl.getElementsByTagName("cnt:ContentAsText");
        if(textContentMsg != null && textContentMsg.getLength() > 0){
          // process contents of annotations
          if(!processAnnotContents(textContentMsg,annot,requestInfo)){
            // process of parsing contents of annotation failed
            return false;
          }
        }
      }
    }
    
    return true;
  }
  
  /**
   * Method process annotation contents element.
   * 
   * @param contentsOfAnnot element with contents of annotation for process
   * @param annot annotation which information from contents will be set
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processAnnotContents(NodeList contentsOfAnnot, Annotation annot, RequestInfo requestInfo){
    int contentsCount = contentsOfAnnot.getLength();
    
    for(int index = 0; index < contentsCount; index++){
      Element contentEl = (Element) contentsOfAnnot.item(index);

      if(contentEl != null) {
        // get content uri attribute
        String typeUriAttr = contentEl.getAttribute("rdf:about");
        if(typeUriAttr == null || typeUriAttr.isEmpty()){
          // uri of content is not presented
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"body\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
          if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "rdf:about is not presented in body.";
            Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
          }
          return false;
        }
        
        // if content is body
        if(isUriOfBody(typeUriAttr)){
          // process body of annotation
          if(!processBody(contentEl,annot,requestInfo)){
            // process of parsing body of annotation failed
            return false;
          }
        }else{
          // if content is graph of attributes of annotation
          // process attributes of annotation
          if(!processAttributesNew(contentEl,annot,requestInfo)){
              // process attributes of annotation failed
              return false;
          }
        }
      }
    }
    
    return true;
  }

  /**
   * Method process body element of annotation.
   * 
   * @param bodyEl element with body of annotation for process
   * @param annot annotation which information from body will be set
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processBody(Element bodyEl, Annotation annot,RequestInfo requestInfo){
    /** Check if type, format and chars elements are within this body */
    NodeList formatMsg = bodyEl.getElementsByTagName("dc:format");
    if(formatMsg.item(0) == null){
      // error - can't find trix element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"content\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element format is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    NodeList contentTypeMsg = bodyEl.getElementsByTagName("rdf:type");
    Element contentTypeEl = (Element) contentTypeMsg.item(0);
    if (contentTypeEl != null) {
      
      NodeList charsMsg = bodyEl.getElementsByTagName("cnt:chars");
      Element charsEl = (Element) charsMsg.item(0);
      if (charsEl != null) {
        String bodyContent = MessageProcessor.getElementContent(charsEl);
        if (bodyContent == null) {
          bodyContent = "";
        }
        annot.setContent(bodyContent);
        return true;
      } else {
        // can't find chars element
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"content\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Element chars is missing.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return false;
      }  
    } else {
      // error - can't find content type element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"content\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element content type is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
  }
  
  /**
   * Method process author of annotation.
   * 
   * @param anotatedByEl element with author of annotation for process
   * @param annotUri URI of annotation to which element belongs
   * @param requestInfo informations about client request
   * @return user or null if any error occurs
   */
  private User processAuthor(Element anotatedByEl, String annotUri, RequestInfo requestInfo){
    // get autor uri attribute
    NodeList personMsg = anotatedByEl.getElementsByTagName("foaf:Person");
    Element personEl = (Element) personMsg.item(0);
    if(personEl != null) {
      
      String authorUriAttr = personEl.getAttribute("rdf:about");
      if(authorUriAttr == null || authorUriAttr.isEmpty()){
        // uri of autor is not presented
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"author\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Uri of author is not presented.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        
        return null;
      }

      // transform uri to id
      Integer authorId;
      try {
        authorId = Integer.decode(authorUriAttr.replace(AppBean.getBaseUserUriV2(), ""));
      } catch(NumberFormatException e){
        // can't decode author id
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"author\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unable to decode author's id.";
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }

      // try find autor in DB
      PersistM persistMan = AppBean.getPersistenceManager();
      Object[] authorParams = new Object[2];
      authorParams[0] = "id";
      authorParams[1] = authorId;
      @SuppressWarnings("unchecked")
      List<User> usersList = persistMan.queryDB("User.findById", authorParams);
      if(usersList == null || usersList.isEmpty()){
        // unknown user
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"author\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unable to find author of annotation: " + authorId;
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }

      return usersList.get(0);
    }
    else{
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"author\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Missing foaf:Person element.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      
      return null;
    }
  }  // processAuthor()
  
  /**
   * Method process creation and serialization date of annotation.
   * 
   * @param annotatedAtEl element with creation date of annotation for process
   * @param annotUri URI of annotation to which element belongs
   * @param requestInfo informations about client request
   * @param created tag if its date of creation element
   * @return creation date or null if any error occurs
   */
  private Date processCreationDate(Element annotatedAtEl, String annotUri, RequestInfo requestInfo, boolean created){
    String creationDateValue = MessageProcessor.getElementContent(annotatedAtEl);
    if(creationDateValue == null || creationDateValue.isEmpty()){
      // creation date and time not found
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info, msg;
      if(created){
        info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"annotatedAt\"/>";
        msg = "Bad date and time format in annotatedAt.";
      }
      else{
        info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"serializedAt\"/>";
        msg = "Bad date and time format in serializedAt.";
      }
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    Date dateOfCreation;
    
    // try to convert string to date
    try{
      dateOfCreation = DatatypeConverter.parseDateTime(creationDateValue).getTime();
    }catch(IllegalArgumentException ex){
      // bad date time format
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info, msg;
      if(created){
        info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"annotatedAt\"/>";
        msg = "Bad date and time format in annotatedAt.";
      }
      else{
        info = "<annotation uri=\"" + annotUri + "\" invalidProperty=\"serializedAt\"/>";
        msg = "Bad date and time format in serializedAt.";
      }
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }

    return dateOfCreation;
  }
  
  /**
   * Method process type of annotation and add them into annotation.
   * 
   * @param annotTypeEl element with type of annotation for process
   * @param annot annotation which type will be set
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processAnnotType(Element annotTypeEl, Annotation annot, RequestInfo requestInfo){
    // get annotation type uri attribute
    String typeUriAttr = annotTypeEl.getAttribute("rdf:about");
    if(typeUriAttr == null || typeUriAttr.isEmpty()){
      // uri of annotation type is not presented
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"type\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Uri of annotation type is not presented.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }

      return false;
    }
 
    // try find type in DB
    PersistM persistMan = AppBean.getPersistenceManager();
    Object[] typeParams = new Object[2];
    typeParams[0] = "uri";
    typeParams[1] = typeUriAttr;
    @SuppressWarnings("unchecked")
    List<AnnotType> usersList = persistMan.queryDB("AnnotType.findByUri", typeParams);
    if(usersList == null || usersList.isEmpty()){
      if(requestInfo.getFlier().getAddedTypes() != null && !requestInfo.getFlier().getAddedTypes().isEmpty()){
          // try find type in just added types
          Iterator<AnnotType> typesIt = requestInfo.getFlier().getAddedTypes().iterator();
          while(typesIt.hasNext()){
            AnnotType currentType = typesIt.next();
            if(typeUriAttr.equals(currentType.getUri())){
                annot.setAnnotType(currentType);
                return true;
            }
          }
      }else{
        // unknown annotation type
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<annotation uri=\"" + typeUriAttr + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Unknown annotation type. Type uri: " + typeUriAttr;
          Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
        }
        return false;
      }
    }
    
    annot.setAnnotType(usersList.get(0));
    return true;
  }

  /**
   * Method finds document in server database by uri of document.
   * 
   * @param uri uri of document
   * @param annot Annotation for which we are searching target
   * @param requestInfo informations about client request
   * @return annotated document or null if document is not found
   */
  private AnnotDocument getDocumentFromUri(String uri, Annotation annot, RequestInfo requestInfo){
    Integer documentId;
    AnnotDocument document;
  
    try {
      documentId = Integer.decode(uri.replace(AppBean.getBaseDocumentUri(), ""));
    } catch (NumberFormatException ex) {
      // bad document id
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"target\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Id of document is bad.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    // get document from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = documentId;
    @SuppressWarnings("unchecked")
    List<AnnotDocument> documentsList = persistMan.queryDB("AnnotDocument.findById", params);
    if (documentsList != null && !documentsList.isEmpty()) {
      document = documentsList.get(0);
    } else {
      // can't find document
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      requestInfo.addError(lod, langNum, Localisation.ERROR_53_BAD_DOCUMENT_URI);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to find document with uri " + uri;
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    return document;
  }

  /**
   * Method determine if given uri is uri of document.
   * 
   * @param uri uri that will be tested
   * @return true if uri is uri of document
   */
  private static boolean isUriOfBody(String uri){
    if(uri.contains("#body")){
      return true;
    }
    
    return false;
  }

  /**
   * Method detects the type of annotation uri. (temp/serv/sugg)
   * 
   * @param uri uri from which method will determine type of uri
   * @return string with type of uri
   */
 protected static String getUriType(String uri){
    String parts[] = uri.split("/");
    if(parts.length > 3){
      return parts[parts.length-2];
    } 
    return null;
  }
 
 /**
   * Method that process each of triple element from user message
   * @param trixList List of trixes
   * @param requestInfo Info about clients request
   * @param annot Ref annotation
   */
 private ArrayList<P2BaseTrix> processTrixElements(NodeList trixList, RequestInfo requestInfo, Annotation annot){
    HashMap<String, P2BaseTrix> trixMap = new HashMap<String, P2BaseTrix>();
    
    // Key - attribute name | Value - linked/nested uri
    HashMap<String, ArrayList<String>> links = new HashMap<String, ArrayList<String>>();
    
    // Key - URI of nested annotation | Value - URI of parent annotation
    HashMap<String, String> nestedAnnots = new HashMap<String, String>();
    
    // Key - attribute name | Value - priority
    HashMap<String, String> priorityMap = new HashMap<String, String>();
    
    // Key - attribute name | Value - entity type
    HashMap<String, String> entityDic = new HashMap<String, String>();
    
    HashMap<String, ArrayList<P2EntityAdditionalTrix>> eadtAL = new  HashMap<String, ArrayList<P2EntityAdditionalTrix>>();
    

    
    boolean first = false, second = false, third = false;
    int trixCount = trixList.getLength();
    
    String destinationUri = null;
    String uriInOntology = null;
    String name = null;
    boolean fromOntology = false;

    //Process each of tripple
    for(int i = 0; i < trixCount; i++){
      Node trixNode = trixList.item(i);
      
      first = false;
      second = false;
      third = false;
      fromOntology = false;
      name = null;
      uriInOntology = null;
      
      for(Node node = trixNode.getFirstChild(); node != null; node = node.getNextSibling()) {
        if(!(node instanceof Element)){
          continue;
        }

        Element element = (Element) node;
        
        if(!first){
          /* Check element tag name */
          if(!element.getTagName().equals("trix:uri")){
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            
            String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"trix\"";

            requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.SEVERE, info);
            }
            return null;
          }
          
          destinationUri = MessageProcessor.getElementContent(element);
          first = true;
        }
        else if(!second){
          name = MessageProcessor.getElementContent(element);      
          if(!element.getTagName().equals("trix:uri") && !element.getTagName().equals("trix:name")){
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            
            String info = "<attribute annotationUri=\"" + destinationUri + "\" name=\"\" invalidProperty=\"designation\"/>";

            requestInfo.addError(lod, langNum, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.SEVERE, info);
            }
            return null;
          }       
    
          if(element.getTagName().equals("trix:uri")){
            fromOntology = true;
            uriInOntology = name;
            /* Obtain name from URI */
            name = name.substring(name.lastIndexOf("#")+1);
          }
          
          second = true;
        }
        /* Possible syntaxes of third trix:
         * <trix:uri> - uri entity, uri linked/nested annot, uri annot type, flag for linked/nested annot, anyAnnotation
         *              or anyEntity
         * <trix:name> - name of type of entity
         * <trix:typedLiteral> - type of attribute
         * 
         */
        else if(!third){
          if(element.getTagName().equals("trix:uri")){
            String thirdValue = MessageProcessor.getElementContent(element);
            P2BaseTrix att = null;      
            
            //If it's anyEntity or anyAnnotation
            if(thirdValue.endsWith("#anyEntity") || thirdValue.endsWith("#anyAnnotation")){
              att = new P2SimpleTrix(destinationUri);
              
              ((P2SimpleTrix)att).setTypeUri(thirdValue);
              att.setName(name);
              att.setFromOntology(fromOntology);
              att.setUriInOntology(uriInOntology);
            }
            else if(thirdValue.equals("koae:linkedAnnotation")){
              /*
               * Search if attribute with this name is not already stored in map
               * If it's there, we have not yet determined that this attribute is linked,
               * so it's needed to create specific attribute
               */
              att = trixMap.get(name);
              if(att != null){
                att = new P2LinkedTrix(att);
              }
              else{
                att = new P2LinkedTrix(destinationUri);
                att.setName(name);
                att.setFromOntology(fromOntology);
                att.setUriInOntology(uriInOntology);
              }
            }
            else if(thirdValue.equals("koae:nestedAnnotation")){
              att = trixMap.get(name);
              if(att != null){
                att = new P2NestedTrix(att);
              }
              else{
                att = new P2NestedTrix(destinationUri);
                att.setName(name);
                att.setFromOntology(fromOntology);
                att.setUriInOntology(uriInOntology);
              }
            }
            //Its uri of annot type
            else if(thirdValue.contains(AppBean.getBaseTypeUri())){
              att = trixMap.get(name);
              
              if(att == null){
                att = new P2BaseTrix(destinationUri);
                att.setName(name);
                att.setFromOntology(fromOntology);
                att.setUriInOntology(uriInOntology);
              }

              att.setAnnotType(thirdValue);
            }
            else if(thirdValue.contains("serv")
                            || thirdValue.contains("sugg")
                            || thirdValue.contains("temp")){
              // Check if destinationUri is uri of document, otherwise it's just a nestedIn links
              if(isDocumentUri(destinationUri)){
                //Search for attribute
                att = trixMap.get(name);
                if(att != null){
                  //Check if type of attribute is know at this time
                  if(att instanceof P2NestedTrix){
                    ((P2NestedTrix)att).addNestedAnnotUri(thirdValue);
                  }
                  else if(att instanceof P2LinkedTrix){
                    ((P2LinkedTrix)att).addLinkedAnnotUri(thirdValue);
                  }
                  //Type of attribute is not know at this time
                  else{
                    ArrayList<String> tmpL = links.get(name);
                    if(tmpL == null){
                      tmpL = new ArrayList<String>();
                    }
                    tmpL.add(thirdValue);
                    links.put(name, tmpL);
                    
                    first = false; second = false; 
                    continue;
                  }
                }
                //Attribute may not been created yet so its type is not known at this time
                else{
                  ArrayList<String> tmpL = links.get(name);
                  if(tmpL == null){
                    tmpL = new ArrayList<String>();
                  }
                  tmpL.add(thirdValue);
                  links.put(name, tmpL);
                  
                  first = false; second = false; 
                  continue;
                }
              }
              else{
                /* This is the case, when triple has following format:
                  * <trix:uri>{URI of nested annotation}</trix:uri>
                  * <trix:uri>koae:nestedIn</trix:uri>
                  * <trix:uri>{URI of parent annotation}</trix:uri>
                  * 
                  * We need to check, whether second trix has "koae:nestedIn", otherwise, its an error
                  */
                if(!name.equals("koae:nestedIn")){
                  int langNum = requestInfo.getSession().getLanguageNum();
                  int lod = requestInfo.getSession().getProtocolLOD();

                  String info = "<attribute annotationUri=\"" + thirdValue + "\" name=\"\" invalidProperty=\"nestedIn\"/>";

                  requestInfo.addError(lod, langNum, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, info);
                  if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                    Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.SEVERE, info);
                  }
                  return null;
                }
                nestedAnnots.put(destinationUri, thirdValue);
                first = false; second = false; 
                continue;
              }
            }
            //Its uri of entity or error 
            else{
              /* In this case, third trix may be uri of entity or corrupted nesting element, so due to this fact
               * we need to check whether attribute with this target and name has already been parsed;
               * If yes, it's an error, otherwise it's uri of entity
               */
              if(trixMap.get(name) != null){
                int langNum = requestInfo.getSession().getLanguageNum();
                int lod = requestInfo.getSession().getProtocolLOD();

                String info = "<attribute annotationUri=\"" + destinationUri + "\" name=\"" + name + "\" invalidProperty=\"nesting\"/>";

                requestInfo.addError(lod, langNum, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, info);
                if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                  Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.SEVERE, info);
                }
                return null;
              }
              else{
                att = new P2EntityTrix(destinationUri);
                ((P2EntityTrix)att).setName(name);
                ((P2EntityTrix)att).setUriInOntology(uriInOntology);
                ((P2EntityTrix)att).setEntityUri(thirdValue);
              }
            }
            
            //Save processed triple
            trixMap.put(name, att);
              
          }
          //Save entity type into dictionary
          else if(element.getTagName().equals("trix:name")){
            entityDic.put(destinationUri, MessageProcessor.getElementContent(element));
          }
          else if(element.getTagName().equals("trix:typedLiteral")){
            //If first of triple is not document uri, then this triple is entityadditional attribute
            String dataType = element.getAttribute("datatype");
            
            if(!isDocumentUri(destinationUri)){
              /* As type,name,description and imageUri are properties of entity attribute, first of all try to assign
               * this values into entity...if image or something else occurs more than once, first of them is set as property of entity
               * and all of the rest is parsed as additional attribute
               * 
               * Those properties are stored as additional attributes, so once trix is transforming into attribute, each of this values if taken,
               * and removed from additional attributes
               */
              P2EntityAdditionalTrix adt = new P2EntityAdditionalTrix();
              adt.setEntityUri(destinationUri);
              adt.setEntityAttributeName(name);
              adt.setTypeUri(dataType);
              
              if(element.getFirstChild() != null && element.getFirstChild().getNodeValue() != null){
                adt.setValue(element.getFirstChild().getNodeValue());
              }
              
              ArrayList<P2EntityAdditionalTrix> al = eadtAL.get(destinationUri);
              if(al == null){
                al = new ArrayList<P2EntityAdditionalTrix>(); 
              }
              al.add(adt);
              eadtAL.put(destinationUri, al);
            }
            else{              
              if(dataType.endsWith("#attributePriority")){
                if(element.getFirstChild() != null && element.getFirstChild().getNodeValue() != null){
                    priorityMap.put(name, element.getFirstChild().getNodeValue());
                }
              }
              else{
                P2SimpleTrix att = (P2SimpleTrix) trixMap.get(name);
                      
                if(att == null){
                  att = new P2SimpleTrix(destinationUri);
                  att.setName(name);
                  att.setUriInOntology(uriInOntology);
                  att.setTypeUri(dataType);
                }
                
                if(dataType.endsWith("#Point")){
                  parseGeoPoint(att, element);
                  trixMap.put(name, att);
                }
                else{
                  if(element.getFirstChild() != null && element.getFirstChild().getNodeValue() != null){
                    att.addValue(element.getFirstChild().getNodeValue());
                  }
                  trixMap.put(name, att);
                }
              }
            }
          }
          else{
            int langNum = requestInfo.getSession().getLanguageNum();
            int lod = requestInfo.getSession().getProtocolLOD();
            
            String info = "<attribute annotationUri=\"" + destinationUri + "\" name=\"" + name + "\" invalidProperty=\"designation\"/>";

            requestInfo.addError(lod, langNum, Localisation.ERROR_26_ATTRIBUTE_MALFORMED, info);
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.SEVERE, "Wrong tag name of third element in triple");
            }
            return null;
          }
          third = true;
        } // third
      }// inner for-cycle
    }// for-cycle
   
     
    //Iterate through processed trixes and assign remaining values
    Iterator it = trixMap.values().iterator();
    while(it.hasNext()){
      P2BaseTrix t = (P2BaseTrix)it.next();
      
      //First assign priority
      if(priorityMap.get(t.getName()) != null){
        t.setPriority(priorityMap.get(t.getName()));
      }
      
      //If attribute is type of linked, check for links
      if(t instanceof P2LinkedTrix){
        if(links.get(t.getName()) != null){
          ((P2LinkedTrix)t).addAllLinkedAnnotUris(links.get(t.getName()));
        }
      }
      
      //If attribute is type of entity, check for additional attributes and dictionary
      if(t instanceof P2EntityTrix){
        if(entityDic.get(((P2EntityTrix)t).getEntityUri()) != null){
          ((P2EntityTrix)t).setEntityType(entityDic.get(((P2EntityTrix)t).getEntityUri()));
        }
        if(eadtAL.get(((P2EntityTrix)t).getEntityUri()) != null){
          ((P2EntityTrix)t).setEntityAdditionalTrixAL(eadtAL.get(((P2EntityTrix)t).getEntityUri()));
        }
      }
      //If attribute is type of nested, check for links and references to parent annots
      else if(t instanceof P2NestedTrix){
        if(links.get(t.getName()) != null){
          ((P2NestedTrix)t).addAllNestedAnnotUris(links.get(t.getName()));
        }
        
        //As all nested annot uris got the same ref. annot, it's enough to take just first one and assign 
        // appropriate value to variable
        if(((P2NestedTrix)t).getNestedAnnotUris() != null){
          String ref = nestedAnnots.get(((P2NestedTrix)t).getNestedAnnotUris().get(0));
          ((P2NestedTrix)t).setRefAnnotUri(ref);
        }
      }
    }
   
    return new ArrayList<P2BaseTrix>(trixMap.values());
 } //processTrixElements
  
  /**
   * Process GeoPoint attribute and assign it's value into appropriate object
   * 
   * @param att Trix attribute object, into which processed value should be assigned
   * @param el Element which contains GeoPoint value
   */
  private void parseGeoPoint(P2SimpleTrix att, Element el){
    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")){
              att.addLatitude(getGeoPointNodeValue(innerNode.getFirstChild()));
          }
          else if(((Element)innerNode).getTagName().equals("geo:long")){
              att.addLongitude(getGeoPointNodeValue(innerNode.getFirstChild()));
          }
          else{
              continue;
          }
        } 
      }
    }
  }
  
 /**
   * Gets value of passed node
   *
   * @param node node whose value is going to be returned
   * @return Node value in string form 
   */
  private String getGeoPointNodeValue(Node node){
      
      for(Node n = node; n != null; n = n.getNextSibling()){
          if(n.getNodeValue() != null){
              return n.getNodeValue();
          }
      }
      return null;
  }
  
  
 /**
   * Method process attributes of annotation and add them into annotation.
   * 
   * @param attributesEl element with attributes of annotations for process
   * @param annot annotation that given attributes belongs
   * @param requestInfo informations about client request
   * @return false if any error occurs
   */
  private boolean processAttributesNew(Element attributesEl, Annotation annot, RequestInfo requestInfo){
    /**Search for rdf:type and trix:TriX elements as they has to be present within content element */
    NodeList contentTypeMsg = attributesEl.getElementsByTagName("rdf:type");
    if(contentTypeMsg.item(0) == null){
      // error - can't find content type element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"trix\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element content type is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    NodeList trixMsg = attributesEl.getElementsByTagName("trix:TriX");
    if(trixMsg.item(0) == null){
      // error - can't find trix element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"trix\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element Trix is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    NodeList formatMsg = attributesEl.getElementsByTagName("dc:format");
    if(formatMsg.item(0) == null){
      // error - can't find trix element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"trix\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element format is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
    
    
    NodeList trixGraphMsg = attributesEl.getElementsByTagName("trix:graph");
    Element trixGraphEl = (Element) trixGraphMsg.item(0);
    if(trixGraphEl != null){
      
      // go trough all triple elements
      NodeList triplesMsg = attributesEl.getElementsByTagName("trix:triple");
      
      ArrayList<P2BaseTrix> trixesList = processTrixElements(triplesMsg, requestInfo, annot);
      ArrayList<BaseAttribute> attributesList = new ArrayList<BaseAttribute>();
      
      //Error
      if(trixesList == null){
        return false;
      }
      
      Iterator<P2BaseTrix> trixesIt = trixesList.iterator();
      int counter = 0;
      while(trixesIt.hasNext()){
          ArrayList<BaseAttribute> tmpAttList = trixesIt.next().trixToAnnotAtt(annot, requestInfo, counter);
          counter++;
          if(tmpAttList == null){
              //Error
              return false;
          }
          attributesList.addAll(tmpAttList);
      }
      
      
      annot.setAttributes(attributesList);
      return true;
    }
    else{
      // error - can't find Graph element
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + annot.getURIV2() + "\" invalidProperty=\"trix\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_38_ANNOT_MALFORMED, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Element graph is missing.";
        Logger.getLogger(P2AnnotBaseProcessor.class.getName()).log(Level.ALL, msg);
      }
      return false;
    }
  }  // processAttributesNew()
  
  
  /**
   * Check if given uri is uri of document.
   * 
   * @param uri uri to check
   * @return returns true if given uri is uri of document
   */
  boolean isDocumentUri(String uri){
    if(uri.contains(AppBean.getBaseDocumentUri())){
      return true;
    }else{
      return false;
    }
  }

}  // public abstract class P2AnnotBaseProcessor