P2AnnotTypeProcessor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: P2AnnotTypeProcessor.java
 * Description: Class which parses and process XML with messages with types for 
 * protocol version 2.
 */

/**
 * @file P2AnnotTypeProcessor.java
 *
 * @brief Class which parses and process XML with messages with types for 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.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.document.Pair;
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 java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

/**
 * Class which parses and process XML with messages with types for protocol
 * version 2.
 *
 * @brief Class which parses and process XML with messages with types for protocol
 * version 2
 * @author Martin Petr (xpetrm05)
 */
public class P2AnnotTypeProcessor {
  /** Informations about client request */
  private RequestInfo requestInfo;
  /** List of new annotations without founded ancestors */
  private ArrayList<Pair<String,AnnotType>> ancestorPair;
  /** List of new annotations without founded direct ancestors */
  private ArrayList<Pair<String,AnnotType>> direcAncestorPair;
  
  /**
   * Constructor
   */
  public P2AnnotTypeProcessor() {
    ancestorPair = new ArrayList<Pair<String,AnnotType>>();
    direcAncestorPair = new ArrayList<Pair<String,AnnotType>>();
  }
  
  /**
   * Entry method for processing types for add.
   * 
   * @param typesElement element with types for add
   * @param requestInfo informations about client request
   */
  public void procesTypesAdd(Element typesElement,RequestInfo requestInfo){
    this.requestInfo = requestInfo;
    procesAnnotTypes(typesElement,requestInfo,false);
  }
  
  /**
   * Entry method for processing types for remove.
   * 
   * @param typesElement element with types for remove
   * @param requestInfo informations about client request
   */
  public void procesTypesRemove(Element typesElement,RequestInfo requestInfo){
    this.requestInfo = requestInfo;
    procesDeleteTypes(typesElement,requestInfo);
  }
  
  /**
   * Entry method for processing types for change.
   * 
   * @param typesElement element with types for change
   * @param requestInfo informations about client request
   */
  public void procesTypesChange(Element typesElement,RequestInfo requestInfo){
    this.requestInfo = requestInfo;
    procesAnnotTypes(typesElement,requestInfo,true);
  }
  
  /**
   * Entry method for processing types guery.
   * 
   * @param typesQueryElement element with types guery
   * @param requestInfo informations about client request
   */
  public void procesTypeQuery(Element typesQueryElement,RequestInfo requestInfo){
    String uriAttr = typesQueryElement.getAttribute("uri");
    if(uriAttr == null || uriAttr.isEmpty()){
      uriAttr = "*";
    }
   
    EditorSession session = requestInfo.getSession();
    requestInfo.addQueryTypes(uriAttr);
    // Remember queries for later sending the types changes
    if (session.getQueriedTypes() != null && !session.getQueriedTypes().contains(uriAttr)) {
      session.addQueriedTypes(uriAttr);
    }
  }
  
  /**
   * Method process element with types for add or update.
   * 
   * @param typesElement element with types for add or update
   * @param requestInfo informations about client request
   * @param update if true proces types for update if is false process types for add
   */
  private void procesAnnotTypes(Element typesElement,RequestInfo requestInfo, boolean update){
    NodeList typesMsg = typesElement.getElementsByTagName("type");
    int typesCount = typesMsg.getLength();
    
    for(int index = 0; index < typesCount; index++){
      Element modifyTypesEl = (Element) typesMsg.item(index);
      if(modifyTypesEl != null) {
        procesAnnotType(modifyTypesEl,requestInfo,update);
      }
    }
    
    if(update){
      setMissingAncestors(requestInfo.getFlier().getEditedTypes(),requestInfo);
      setMissingDirectAncestors(requestInfo.getFlier().getEditedTypes(),requestInfo);
      checkAncestors(requestInfo.getFlier().getEditedTypes(),requestInfo);
    }else{
      setMissingAncestors(requestInfo.getFlier().getAddedTypes(),requestInfo);
      setMissingDirectAncestors(requestInfo.getFlier().getAddedTypes(),requestInfo);
      checkAncestors(requestInfo.getFlier().getAddedTypes(),requestInfo);
    }
    
    
    this.direcAncestorPair.clear();
    this.ancestorPair.clear();
  }
  
  /**
   * Method process element with type for add or update.
   * 
   * @param typeElement element with type for add or update
   * @param requestInfo informations about client request
   * @param update if true proces type for update if is false process types for add
   */
  private void procesAnnotType(Element typeElement,RequestInfo requestInfo, boolean update){
    AnnotType type = new AnnotType();
    AnnotType typeForChange = null;
    PersistM persistMan = AppBean.getPersistenceManager();

    // get name attribute
    String nameAttr = typeElement.getAttribute("name");
    if(nameAttr == null){
      nameAttr = "";
    }
    
    // get uri attribute
    String uriAttr = typeElement.getAttribute("uri");
    if(uriAttr == null){
      uriAttr = "";
    }
    
    // get groupUri attribute
    String groupUriAttr = typeElement.getAttribute("groupUri");
    if(groupUriAttr == null){
      groupUriAttr = "";
    }
    
    // get uri in ontology attribute
    String ontologyUriAttr = typeElement.getAttribute("ontologyUri");
    if(ontologyUriAttr == null){
      ontologyUriAttr = "";
    }
    
    // get restrictedAttributes attribute
    String restrictedAttributesAttr = typeElement.getAttribute("restrictedAttributes");
    if(restrictedAttributesAttr == null){
      restrictedAttributesAttr = "";
    }
    
    // test if all required informations are presented
    if (nameAttr.isEmpty()) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"name\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Empty required attribute of add type of annotation.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    if (uriAttr.isEmpty()) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Empty required attribute of add type of annotation.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // Check ancestor in URI
    String foundAncUri = "";
    // get string with name of type and names of his ancestors from URI
    String namesStr = uriAttr.replace(AppBean.getBaseTypeUri(), "");
    String[] namesArr = namesStr.split("/");
    ArrayList<String> names = new ArrayList<String>(Arrays.asList(namesArr));
    int nSize = names.size();  // compute number of names
    if (nSize > 2) {  // if there is more then name of type and id of group
      // get URI of ancestor type
      // prevUri = uri of type without "/" and name
      foundAncUri = uriAttr.substring(0, uriAttr.lastIndexOf("/"));
    }  // if there is more then name of type and id of group
    
    
    if (groupUriAttr.isEmpty()) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"groupUri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Empty required attribute of add type of annotation.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    if (restrictedAttributesAttr.isEmpty()) {
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"restrictedAttributes\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Empty required attribute of add type of annotation.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // test if group exist
    Integer groupId = null;
    try{
       groupId = Integer.decode(groupUriAttr.replace(AppBean.getBaseGroupUri(), ""));
    } catch(NumberFormatException e){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"groupUri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't decode group id.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    Object[] groupParams = new Object[2];
    groupParams[0] = "id";
    groupParams[1] = groupId;
    @SuppressWarnings("unchecked")
    List<UserGroup> groupsList = persistMan.queryDB("UserGroup.findById", groupParams);
    if(groupsList == null || groupsList.isEmpty()){
      // if grup was not found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
              + "uri=\"" + uriAttr + "\" "
              + "invalidAttribute=\"groupUri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Can't find group with id:" + groupId.toString();
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // test if type is already in DB
    Object[] typeParams = new Object[4];
    typeParams[0] = "uri";
    typeParams[1] = uriAttr;
    typeParams[2] = "groupId";
    typeParams[3] = groupId;
    @SuppressWarnings("unchecked")
    List<AnnotType> typesList = persistMan.queryDB("AnnotType.findByUriAndGroup", typeParams);
    
    if (typesList != null && !typesList.isEmpty() && !update) {
      // if annotation type was found and it is not update - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" uri=\"" + uriAttr + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_49_DUPLICIT_TYPE, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Attempt to create of duplicit type of annotation; uri: " + uriAttr;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    } else if ((typesList == null || typesList.isEmpty()) && update) {
      // if it is update request and annotation type was not found - error
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" uri=\"" + uriAttr + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unknown type of annotation for update: uri: " + uriAttr;
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    if(update){
      typeForChange = typesList.get(0);
    }
    
    // get ancestors
    ArrayList<AnnotType> ancestors = new ArrayList<AnnotType>();
    AnnotType primaryAncestor = null;
    NodeList ancestorsMsg = typeElement.getElementsByTagName("directAncestors");
    Element ancestorsEl = (Element) ancestorsMsg.item(0);
    
    if (ancestorsEl != null) {
      String primaryAncestorUri = ancestorsEl.getAttribute("primary");
      if (primaryAncestorUri != null && !primaryAncestorUri.isEmpty()) {
        primaryAncestor = getAncestor(nameAttr, uriAttr, primaryAncestorUri);
        if (primaryAncestor == null) {
          this.direcAncestorPair.add(new Pair<String, AnnotType>(primaryAncestorUri, type));
        }
        if (!primaryAncestorUri.equals(foundAncUri)) {
          // We must handle it as wrong URI as primary ancestor is different here
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + nameAttr + "\" "
                  + "uri=\"" + uriAttr + "\" "
                  + "invalidAttribute=\"uri\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "URI of added type of annotation contains wrong ancestor.";
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }
          return;
        }
      } else if (!foundAncUri.isEmpty()) {  // if ancestor is missing but was found in URI
        // We must handle it as wrong URI as ancestor was not declared
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + nameAttr + "\" "
                    + "uri=\"" + uriAttr + "\" "
                    + "invalidAttribute=\"uri\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "URI of added type of annotation contains missing ancestor.";
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
      
      NodeList ancestorMsg = ancestorsEl.getElementsByTagName("ancestor");
      int ancestorsCount = ancestorMsg.getLength();
      for(int index = 0; index < ancestorsCount; index++){
        Element ancestorEl = (Element) ancestorMsg.item(index);
        String currentAncestorUri = processAncestors(nameAttr, uriAttr, ancestorEl);
        AnnotType currentAncestor = getAncestor(nameAttr, uriAttr, currentAncestorUri);
        if (currentAncestor != null) {
          ancestors.add(currentAncestor);
        } else {
          this.ancestorPair.add(new Pair<String, AnnotType>(currentAncestorUri, type));
        }
      }
    } else if (!foundAncUri.isEmpty()) {  // if ancestor is missing but was found in URI
      // We must handle it as wrong URI as ancestor was not declared
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + nameAttr + "\" "
                  + "uri=\"" + uriAttr + "\" "
                  + "invalidAttribute=\"uri\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "URI of added type of annotation contains missing ancestor.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }

    // process comment
    String comment = null;
    NodeList commentNL = typeElement.getElementsByTagName("comment");
    if (commentNL.getLength() != 0) {
      for(int index = 0; index < commentNL.getLength(); index ++){
        Element commentEl = (Element) commentNL.item(index);
        if(commentEl.getParentNode().getNodeName().equals(typeElement.getNodeName())){
          comment = MessageProcessor.getElementContent(commentEl);
        }
      }
    }
    
    if(update){
      // test for forbidden changes
      if(!typeForChange.getName().equals(nameAttr)){
        // forbidden operation change name - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + typeForChange.getName() 
                    + "\" uri=\"" + typeForChange.getUri() 
                    + "\" invalidAttribute=\"name\"/>";
        String msg = "Attempt to change name of the type of annotation: " 
                     + typeForChange.getName() + " - " + nameAttr;
        requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) { 
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
      
      if(!typeForChange.getGroup().getUri().equals(groupUriAttr)){
        // forbidden operation change group - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + typeForChange.getName() 
                    + "\" uri=\"" + typeForChange.getUri() 
                    + "\" invalidAttribute=\"groupUri\"/>";
        String msg = "Attempt to change group of the type of annotation.";
        requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
      
      if(((typeForChange.getAncestorType() == null && primaryAncestor != null) || 
              (typeForChange.getAncestorType() != null && primaryAncestor != null)) &&
              !(typeForChange.getAncestorType().equals(primaryAncestor))){
        // forbidden operation change ancestor - error
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + typeForChange.getName() 
                    + "\" uri=\"" + typeForChange.getUri() 
                    + "\" invalidAttribute=\"ancestor\"/>";
        String msg = "Attempt to change ancestor type of annotation.";
        requestInfo.addError(lod, langNum, Localisation.ERROR_20_TYPE_NAME_MODIFY, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
        return;
      }
      
      type.setId(typeForChange.getId());
    }
    // set group that type belongs
    type.setGroup(groupsList.get(0));
    // set restricted attributes
    if(restrictedAttributesAttr.equalsIgnoreCase("true")){
      type.setRestrictedAtt(true);
    }else{
      type.setRestrictedAtt(false);
    }
    // set name of type
    type.setName(nameAttr);
    // set uri of type
    type.setUri(uriAttr);
    // set uri in ontology
    type.setUriInOntology(ontologyUriAttr);

    // set ancestors
    type.setAncestorType(primaryAncestor);
    type.setAncestorTypes(ancestors);

    // set commentary
    type.setComment(comment);
    
    // get atrributes
    ArrayList<AnnotTypeAttr> attributes = new ArrayList<AnnotTypeAttr>();
    NodeList attributesMsg = typeElement.getElementsByTagName("attributes");
    Element attributesEl = (Element) attributesMsg.item(0);
    if(attributesEl != null){
      NodeList attributeMsg = attributesEl.getElementsByTagName("attribute");
      int attributesCount = attributeMsg.getLength();
      for(int index = 0; index < attributesCount; index++){
        Element attributeEl = (Element) attributeMsg.item(index);
        AnnotTypeAttr currentAttr = processTypeAttribute(attributeEl,type);
        if (currentAttr != null) {
          attributes.add(currentAttr);
        } else {
          // type don't have any attributes
          return;
        }
      }
    }
    
    // set attributes 
    type.setAttributes(attributes);
    
    if (update) {
      requestInfo.getFlier().AddEditedType(type);
    } else {
      requestInfo.getFlier().AddAddedType(type);
    }
  }  // procesAnnotType()
  
  /**
   * Method gets ancestor of annotation type from DB.
   * 
   * @param name name of type for which we are searching ancestor
   * @param typeUri uri of type for which we are searching ancestor
   * @param uri uri of ancestor of annotation type
   * @return annotation type object from DB or null if not found
   */
  private AnnotType getAncestor(String name, String typeUri, String uri){
    AnnotType ancestor = null;
    
    // query database for ancestor
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = uri;
    
    PersistM persistMan = AppBean.getPersistenceManager();
    @SuppressWarnings("unchecked")
    List <AnnotType>aList = persistMan.queryDB("AnnotType.findByUri", params);
    if (aList != null && !aList.isEmpty()) {  
      // if ancestor was found
      ancestor = aList.get(0);
    } else {  // if ancestor was not found
      // it possibly can be new type
      Iterator<AnnotType> atIter = (Iterator<AnnotType>) requestInfo.getFlier().getAddedTypes().iterator();
      while(atIter.hasNext() && ancestor == null) {  // look over just added types
        AnnotType addedT = atIter.next();
        if (addedT.getUri().equals(uri)) {  // if type was found
          ancestor = addedT;
        }
      }
      
      if(ancestor == null) {  // if ancestor is not new type
        // unknown ancestor
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + name 
                    + "\" uri=\"" + typeUri + "\" ancestor=\"" + uri + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Unknown annotation type ancestor with uri:" + uri + "";
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
        return null;
      }
    }
    
    return ancestor;
  }
  
  /**
   * Method process element with ancestor of annotation type.
   * 
   * @param name Name of type of annotation to which ancestors should be assigned
   * @param uri URI of type of annotation to which ancestors should be assigned
   * @param ancestorEl element with type for add or update
   * @return uri of ancestor of annotation type
   */
  private String processAncestors(String name, String uri, Element ancestorEl){
    String uriAttr = ancestorEl.getAttribute("uri");
    if(uriAttr == null || uriAttr.isEmpty()){
      int langNum = requestInfo.getSession().getLanguageNum();        
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + name 
                  + "\" uri=\"" + uri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_55_TYPE_ANCESTORS_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Bad ancestor type in new type of annotation.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    return uriAttr;
  }
  
  /**
   * Method process element with attribute of annotation type.
   * 
   * @param attributeEl element with attribute of annotation type
   * @param annotType Type of annotation to which this attribute belongs
   * @return attribute of annotation type
   */
  private AnnotTypeAttr processTypeAttribute(Element attributeEl, AnnotType annotType){
    AnnotTypeAttr newAttr = null;
    Boolean isRequired = false;
    
    // get type attribute
    String typeAttr = attributeEl.getAttribute("type");
    if(typeAttr == null){
      typeAttr = "";
    }
    
    // get name attribute
    String nameAttr = attributeEl.getAttribute("name");
    if(nameAttr == null){
      nameAttr = "";
    }
    
    // get type attribute
    String typeUriAttr = attributeEl.getAttribute("typeUri");
    if(typeUriAttr == null){
      typeUriAttr = "";
    }
    
    // get uri in ontology attribute
    String ontologyUriAttr = attributeEl.getAttribute("ontologyUri");
    if(ontologyUriAttr == null){
      ontologyUriAttr = "";
    }
    
    // get required attribute
    String requiredAttr = attributeEl.getAttribute("required");
    if(requiredAttr == null){
      requiredAttr = "";
    }
    if(requiredAttr.equalsIgnoreCase("true")){
      isRequired = true;
    }
    
    // test if all required attributes are presented
    if(nameAttr.isEmpty()){
      // missing name, uri of attribute type or information if attribute is required
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<attribute typeName=\"" + annotType.getName() + "\" "
                  + "typeUri=\"" + annotType.getUri() + "\" "
                  + "name=\"" + nameAttr + "\" "
                  + "ontologyUri=\"" + ontologyUriAttr + "\" "
                  + "invalidAttribute=\"name\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_17_TYPE_ATTRIBUTES_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Missing name, type uri or required attribute.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    if(typeUriAttr.isEmpty()){
      // missing name, uri of attribute type or information if attribute is required
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<attribute typeName=\"" + annotType.getName() + "\" "
                  + "typeUri=\"" + annotType.getUri() + "\" "
                  + "name=\"" + nameAttr + "\" "
                  + "ontologyUri=\"" + ontologyUriAttr + "\" "
                  + "invalidAttribute=\"type\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_17_TYPE_ATTRIBUTES_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Missing name, type uri or required attribute.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    if (requiredAttr.isEmpty()) {
      // missing name, uri of attribute type or information if attribute is required
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<attribute typeName=\"" + annotType.getName() + "\" "
                  + "typeUri=\"" + annotType.getUri() + "\" "
                  + "name=\"" + nameAttr + "\" "
                  + "ontologyUri=\"" + ontologyUriAttr + "\" "
                  + "invalidAttribute=\"required\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_17_TYPE_ATTRIBUTES_MALFORMED, info);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Missing name, type uri or required attribute.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    // get comment
    String comment = null;
    NodeList commentMsg = attributeEl.getElementsByTagName("comment");
    Element commentEl = (Element) commentMsg.item(0);
    if(commentEl != null){
      comment = MessageProcessor.getElementContent(commentEl);
    }
    
    // find type
    if (Constants.SIMPLE_TYPES_URI_V2.contains(typeUriAttr)) {  // if it's simple type
      // create object with attribute of type of annotation
      String typeName = Constants.SIMPLE_TYPES_NAMES_V2.get(Constants.SIMPLE_TYPES_URI_V2.indexOf(typeUriAttr));
      newAttr = new AnnotTypeAttr(annotType, nameAttr, typeName, isRequired);
      // set comment
      newAttr.setComment(comment);
      // set uri in ontology
      newAttr.setUriInOntology(ontologyUriAttr);

      if (containsAttrName(annotType, nameAttr)) {  // if it is duplicit attribute
        // duplicit attribute
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<attribute typeName=\"" + annotType.getName() 
                    + "\" typeUri=\"" + annotType.getUri() 
                    + "\" name=\"" + nameAttr 
                    + "\" ontologyUri=\"" + ontologyUriAttr + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_92_DUPLICIT_ATTRIBUTE_OF_TYPE, info);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Duplicit attribute of the type of annotation.";
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }

        return null;
      }
    } else {  // if it is structured type
      // if it's structured type query database for type of attribute (type of annotation)
      Object[] typeParams = new Object[2];
      typeParams[0] = "uri";
      typeParams[1] = typeUriAttr;
      PersistM persistMan = AppBean.getPersistenceManager();
      List tList = persistMan.queryDB("AnnotType.findByUri", typeParams);
      if (tList != null && !tList.isEmpty()) { 
        // if type was found
        AnnotType attrStructType = (AnnotType) tList.get(0);
        // create object with attribute of type of annotation
        newAttr = new AnnotTypeAttr(annotType, nameAttr, attrStructType, isRequired);
        // set comment
        newAttr.setComment(comment);
        // set uri in ontology
        newAttr.setUriInOntology(ontologyUriAttr);
      
        // set information about type
        if(typeAttr.equals("linked")){
          newAttr.setSimpleType("annotationLink");
        }else if(typeAttr.equals("nested")){
          newAttr.setSimpleType("nestedAnnotation");
        }
        
        if (containsAttrName(annotType,nameAttr)) {  
          // duplicit attribute
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<attribute typeName=\"" + annotType.getName() 
                    + "\" typeUri=\"" + annotType.getUri() 
                    + "\" name=\"" + nameAttr 
                    + "\" ontologyUri=\"" + ontologyUriAttr + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_92_DUPLICIT_ATTRIBUTE_OF_TYPE, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Duplicit attribute of the type of annotation.";
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }
      } else {
        // try find annotation type in added types
        ArrayList<AnnotType> addedTypes =  requestInfo.getFlier().getAddedTypes();
        if(addedTypes != null && !addedTypes.isEmpty()){
          Iterator<AnnotType> addedTypesIt = addedTypes.iterator();
          while(addedTypesIt.hasNext()){
            AnnotType actualType = addedTypesIt.next();
            if(actualType.getUri().equals(typeUriAttr)){
              // create object with attribute of type of annotation
              newAttr = new AnnotTypeAttr(annotType, nameAttr, actualType, isRequired);
              // set comment
              newAttr.setComment(comment);
              
              // set information about type
              if(typeAttr.equals("linked")){
                newAttr.setSimpleType("annotationLink");
              }else if(typeAttr.equals("nested")){
                newAttr.setSimpleType("nestedAnnotation");
              }
               
              if (containsAttrName(annotType,nameAttr)) {  
                // duplicit attribute
                int langNum = requestInfo.getSession().getLanguageNum();
                int lod = requestInfo.getSession().getProtocolLOD();
                String info = "<attribute typeName=\"" + annotType.getName() 
                    + "\" typeUri=\"" + annotType.getUri() 
                    + "\" name=\"" + nameAttr 
                    + "\" ontologyUri=\"" + ontologyUriAttr + "\"/>";
                requestInfo.addError(lod, langNum, Localisation.ERROR_92_DUPLICIT_ATTRIBUTE_OF_TYPE, info);
                if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                  String msg = "Duplicit attribute of the type of annotation.";
                  Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
                }
                return null;
              }
            }
          }
        } else {
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          // if type was not found - error
          String info = "<attribute typeName=\"" + annotType.getName() + "\" "
                  + "typeUri=\"" + annotType.getUri() + "\" "
                  + "name=\"" + nameAttr + "\" "
                  + "ontologyUri=\"" + ontologyUriAttr + "\" "
                  + "invalidAttribute=\"typeUri\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_17_TYPE_ATTRIBUTES_MALFORMED, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Unknown structured type of attribute of the type of annotation: " + typeUriAttr;
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        }
      }
    }  // if it is structured type
    
    return newAttr;
  }  // processTypeAttribute()
  
  /**
   * Method process element with annotation types to delete.
   * 
   * @param typeElement element with annotation types to delete
   * @param requestInfo informations about client request
   */
  private void procesDeleteTypes(Element typeElement,RequestInfo requestInfo){
    NodeList typesMsgs = typeElement.getElementsByTagName("type");
    int typesListSize = typesMsgs.getLength();
    for(int index = 0; index < typesListSize; index ++){
      Element currentTypeEl = (Element) typesMsgs.item(index);
      procesDeleteAnnotType(currentTypeEl,requestInfo);
    }
  }
  
  /**
   * Method process element with annotation type to delete.
   * 
   * @param typeElement element with annotation type to delete
   * @param requestInfo informations about client request
   */
  private void procesDeleteAnnotType(Element typeElement,RequestInfo requestInfo){
    // search for annotation type uri
    String typeUri = typeElement.getAttribute("uri");
    if(typeUri == null || typeUri.isEmpty()){
      // nothing to delete
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type uri=\"" + typeUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Attempt to remove type of annotation without uri.";
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      
      return;
    }
    
    // try to find annotation type by its uri
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = typeUri;
    @SuppressWarnings("unchecked")
    List<AnnotType> typesList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    if(typesList == null || typesList.isEmpty()){
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type uri=\"" + typeUri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Attempt to remove unknown type of annotation: " + typeUri;
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      }
      return;
    }
    
    // query database for annotations of this type
    AnnotType dType = (AnnotType) typesList.get(0);
    params[0] = "type";
    params[1] = dType.getId();
    List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
    if(aList != null && !aList.isEmpty()) {  
      // ifannotations was found then it is forbidden operation beaciuse is used by some annotation
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<type name=\"" + dType.getName() + "\" uri=\"" + dType.getUri() + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_47_USED_TYPE_DEL, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Attempt to delete used type of annotation: " + typeUri;
        Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
      } 
    } else { 
      // ifannotations of this type was not found query database for subtypes of this type of annotation
      params[0] = "ancestor";
      params[1] = dType.getId();
      List aTList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
      if(aTList != null && !aTList.isEmpty()) {  
        // ifsubtypes was found then it is forbidden operation
        int langNum = requestInfo.getSession().getLanguageNum();
        int lod = requestInfo.getSession().getProtocolLOD();
        String info = "<type name=\"" + dType.getName() + "\" uri=\"" + dType.getUri() + "\"/>";
        requestInfo.addError(lod, langNum, Localisation.ERROR_51_TYPE_W_SUBTYPE_DEL, info);
        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Attempt to delete type of annotation with subtypes: " + typeUri;
          Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
        }
      } else {  
        // ifsubtypes was not found add type to list of removed types in flier
        requestInfo.getFlier().AddRemovedType(dType);  
      }
    }  // ifannotations of this type was not found
  }  // procesDeleteAnnotType()
  
  /**
   * Method check if annotation type have attribute with specific name.
   * 
   * @param annotType type in which method will seek
   * @param name name of attribute which method will seek
   * @return true if corresponding attribute is found
   */
  private boolean containsAttrName(AnnotType annotType, String name){
    if(annotType.getAttributes() != null){
      Iterator<AnnotTypeAttr> attrsIt = annotType.getAttributes().iterator();
      while(attrsIt.hasNext()){
        if(attrsIt.next().getName().equals(name)){
          return true;
        }
      }
    }
    
    return false;
  }
  
  /**
   * The method finds the ancestors of a new types which don't have the 
   * ancestors yet (they are in the same request probably). This covers 
   * only the types which had the ancestors filled out in the serialized form.
   * 
   * @param types all new types
   * @param requestInfo informations about client request
   */
  private void setMissingAncestors(ArrayList<AnnotType> types, RequestInfo requestInfo){
    if(types != null){
      Iterator<Pair<String,AnnotType>> ancestIt = this.ancestorPair.iterator();
      while(ancestIt.hasNext()){
        Pair<String,AnnotType> actualPair = ancestIt.next();
        AnnotType findedAncestor = findTypeByUri(types,actualPair.left);
        if(findedAncestor == null){
          // cant find ancestor
          int langNum = requestInfo.getSession().getLanguageNum();        
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + actualPair.right.getName() 
                  + "\" uri=\"" + actualPair.right.getUri() + "\" ancestor=\"" + actualPair.left + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad ancestor type in new type of annotation: " + actualPair.left;
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }

          deleteTypeByUri(types,actualPair.right.getUri());
          ancestIt.remove();
          continue;
        }

        AnnotType actualType = actualPair.right;
        actualType.addAncestorType(findedAncestor);
        ancestIt.remove();
      }
    }
  }
  
  /**
   * The method finds the direct ancestor of a new types which don't have the 
   * direct ancestors yet (they are in the same request probably). This covers 
   * only the types which had the ancestors filled out in the serialized form.
   * 
   * @param types all new types
   * @param requestInfo informations about client request
   */
  private void setMissingDirectAncestors(ArrayList<AnnotType> types, RequestInfo requestInfo){
    if(types != null){
      // go trough all types without ancestor
      Iterator<Pair<String,AnnotType>> ancestIt = this.direcAncestorPair.iterator();
      while(ancestIt.hasNext()){
        Pair<String,AnnotType> actualPair = ancestIt.next();
        AnnotType findedAncestor = findTypeByUri(types,actualPair.left);
        if(findedAncestor == null){
          // cant find ancestor
          int langNum = requestInfo.getSession().getLanguageNum();        
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<type name=\"" + actualPair.right.getName() 
                  + "\" uri=\"" + actualPair.right.getUri() + "\" ancestor=\"" + actualPair.left + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_19_TYPE_UNKNOWN, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Bad ancestor type in new type of annotation: " + actualPair.left;
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }

          deleteTypeByUri(types,actualPair.right.getUri());
          ancestIt.remove();
          continue;
        }

        AnnotType actualType = actualPair.right;
        actualType.setAncestorType(findedAncestor);
        ancestIt.remove();
      }
    }
  }
  
  /**
   * Find type of annotation in the list
   * 
   * @param types List of types of annotation
   * @param uri Uri of type of annotation which should be found
   * @return If it was found returns given type, null otherwise
   */
  AnnotType findTypeByUri(ArrayList<AnnotType> types, String uri){
    Iterator<AnnotType> typesIt = types.iterator();
    while(typesIt.hasNext()){
      AnnotType actualType = typesIt.next();
      if(actualType.getUri().equals(uri)){
        return actualType;
      }
    }
    return null;
  }
  
  /**
   * Removes type with given URI from list
   * 
   * @param types List of types
   * @param uri URI of type which should be removed from the list
   */
  void deleteTypeByUri(ArrayList<AnnotType> types, String uri){
    Iterator<AnnotType> typesIt = types.iterator();
    while(typesIt.hasNext()){
      AnnotType actualType = typesIt.next();
      if(actualType.getUri().equals(uri)){
        typesIt.remove();
        return;
      }
    }
  }
  
  /**
   * Consistency check for primary ancestor and list of ancestors
   * 
   * @param types List with types to check
   * @param requestInfo Informations about client request
   */
  private void checkAncestors(ArrayList<AnnotType> types, RequestInfo requestInfo){
    if(types != null){
      Iterator<AnnotType> typesIt = types.iterator();
      while(typesIt.hasNext()){
        AnnotType actualType = typesIt.next();
        if (actualType.getAncestorType() == null && (actualType.getAncestorTypesAL() != null && !actualType.getAncestorTypesAL().isEmpty())) {
          // error - primary ancestor is not choosed but there are some ancestors
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String context = "<type name=\"" + actualType.getName() + "\" uri=\"" + actualType.getUri() + "\" invalidAttribute=\"directAncestors\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_16_TYPE_MALFORMED,context);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Primary ancestor not choosed.";
            Logger.getLogger(P2AnnotTypeProcessor.class.getName()).log(Level.ALL, msg);
          }

          typesIt.remove();
        } else if (actualType.getAncestorType() != null && (actualType.getAncestorTypesAL() == null || actualType.getAncestorTypesAL().isEmpty())) {
          // there is primary ancestor but list of ancestors is empty
          if (actualType.getAncestorTypesAL() == null) {
            actualType.setAncestorTypes(new ArrayList<AnnotType>());
          }
          actualType.addAncestorType(actualType.getAncestorType());
        } else if (actualType.getAncestorType() != null) {
          if (!actualType.getAncestorTypesAL().contains(actualType.getAncestorType())) {
            actualType.addAncestorType(actualType.getAncestorType());
          }
        }
      }
    }
  }  // checkAncestors()
  
  /**
   * Search for type in DB and currently added types which are stored in flier
   * @param uri Uri of annotation type
   * @param typesFromFlier ArrayList of annotation types, which have been recently added
   * @return 
   */
  public static AnnotType searchAnnotType(String uri, ArrayList<AnnotType> typesFromFlier){
        if(typesFromFlier != null){
        Iterator<AnnotType> annotTypeIt = typesFromFlier.iterator();
            while(annotTypeIt.hasNext()){
                AnnotType tmpType = annotTypeIt.next();
                if(tmpType.getUri() != null && tmpType.getUri().equals(uri)){
                    return tmpType;
                }
            }
        }


        PersistM persistMan = AppBean.getPersistenceManager();
        Object[] typeParams = new Object[2];

        typeParams[0] = "uri";
        typeParams[1] = uri;

        @SuppressWarnings("unchecked")
        List<AnnotType> attrsList = persistMan.queryDB("AnnotType.findByUri", typeParams);
        if(attrsList == null || attrsList.isEmpty()){
            return null;
        }

        return attrsList.get(0);
    }
  
}  // public class P2AnnotTypeProcessor