UploadOntology.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: UploadOntology.java
 * Description: Backbean for page for uploading ontology
 */

/**
 * @file UploadOntology.java
 *
 * @brief Backbean for page for uploading ontology
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
import cz.vutbr.fit.knot.annotations.comet.ResponseCreator;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.TypeAttrOnto;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import org.apache.commons.io.IOUtils;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import org.semanticweb.owlapi.apibinding.OWLManager;
import org.semanticweb.owlapi.model.ClassExpressionType;
import org.semanticweb.owlapi.model.OWLAnnotation;
import org.semanticweb.owlapi.model.OWLAnnotationProperty;
import org.semanticweb.owlapi.model.OWLAnnotationPropertyDomainAxiom;
import org.semanticweb.owlapi.model.OWLAnnotationPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLAnnotationValue;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.model.OWLDataFactory;
import org.semanticweb.owlapi.model.OWLDataProperty;
import org.semanticweb.owlapi.model.OWLDataPropertyExpression;
import org.semanticweb.owlapi.model.OWLDataRange;
import org.semanticweb.owlapi.model.OWLEquivalentClassesAxiom;
import org.semanticweb.owlapi.model.OWLIndividual;
import org.semanticweb.owlapi.model.OWLLiteral;
import org.semanticweb.owlapi.model.OWLNamedIndividual;
import org.semanticweb.owlapi.model.OWLObjectIntersectionOf;
import org.semanticweb.owlapi.model.OWLObjectOneOf;
import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLObjectPropertyDomainAxiom;
import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;
import org.semanticweb.owlapi.model.OWLObjectPropertyRangeAxiom;
import org.semanticweb.owlapi.model.OWLObjectUnionOf;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.OWLOntologyManager;
import org.semanticweb.owlapi.model.OWLSubAnnotationPropertyOfAxiom;
import org.semanticweb.owlapi.model.OWLSubObjectPropertyOfAxiom;
import org.semanticweb.owlapi.util.OWLOntologyWalker;
import org.semanticweb.owlapi.util.OWLOntologyWalkerVisitor;
import uk.ac.manchester.cs.owl.owlapi.OWLDatatypeImpl;

/**
 * Backbean for page for uploading ontology
 *
 * @brief Backbean for for page for uploading ontology
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class UploadOntology implements Serializable {
  /**
   * Error message displayed in form
   */
  private String errorMessage = "";
  /**
   * Success message displayed in form
   */
  private String successMessage = "";
  /**
   * Uploading indicator
   */
  private Boolean ontologyUploaded = false;
  /**
   * Uploaded file
   */
  private UploadedFile uploadedFile = null;
  /**
   * File name
   */
  private String fileName;
  /**
   * User group in which uploaded types will be shared
   */
  private String uGroup;
  /**
   * Selected import method
   */
  private int iMethod = 0;
  /**
   * Count of recursive call in inverse property processing.
   */
  private int recursiveInverseCount = 0;
  /**
   * Import method 0: If type already exists, error.
   */
  public static final int METHOD_0_ERROR = 0;
  /**
   * Import method 1: If type already exists, use it (do not create or update).
   */
  public static final int METHOD_1_USE = 1;
  /**
   * Import method 0: If type already exists, update it.
   */
  public static final int METHOD_2_UPDATE = 2;
  /**
   * Import language
   */
  private String importLang;
  /**
   * Language number
   */
  private int lNum;
  
  
  
  
  // <editor-fold defaultstate="collapsed" desc="helper classes">

  // <editor-fold defaultstate="collapsed" desc="BooleanHolder">
  /**
   * Class for boolean reference pass.
   * 
   * @brief Class for boolean reference pass.
   * @author Marek Kopecky
   */
  private static class BooleanHolder {
    /** Value */
    boolean value;
    /**
     * Constructor
     */
    public BooleanHolder() {
      value = false;
    }
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="AnnotTypeInfo">
  /**
   * Class for additional information about AnnotType.
   * 
   * @brief Class for additional information about AnnotType.
   * @author Marek Kopecky
   */
  public class AnnotTypeInfo {
    
    /** URI of type origin */
    public String originUri;
    /** Corrected URI */
    public String correctedUri;
    /** Was it object (individual)? */
    public boolean wasObject;
    /** Was it anonymous class? */
    public boolean wasAnonymous;
    /** Class in OWL */
    public OWLClass owlClass;
    /** Set of disjoint ones */
    public Set<String> disjointWithSet;
    
    /**
     * Construtor
     * 
     * @param originUri URI of type origin
     * @param correctedUri Corrected URI
     * @param owlClass OWL class
     * @param wasObject True, if it was object (individual), false otherwise
     * @param wasAnonymous True, if it was oanonymous class, false otherwise
     */
    public AnnotTypeInfo(String originUri, String correctedUri, OWLClass owlClass, boolean wasObject, boolean wasAnonymous) {
      this.correctedUri = correctedUri;
      this.originUri = originUri;
      this.owlClass = owlClass;
      this.wasObject = wasObject;
      this.wasAnonymous = wasAnonymous;
      this.disjointWithSet = new HashSet<String>();
    }
    
    /**
     * Constructor
     * 
     * @param originUri URI of type origin
     * @param correctedUri Corrected URI
     * @param owlClass OWL class
     */
    public AnnotTypeInfo(String originUri, String correctedUri, OWLClass owlClass) {
      this(originUri, correctedUri, owlClass, true, false);
    }
    
    /**
     * Constructor
     * 
     * @param originUri URI of type origin
     * @param owlClass OWL class 
     */
    public AnnotTypeInfo(String originUri, OWLClass owlClass) {
      this(originUri, originUri, owlClass,  true, false);
    }
  }  // public class AnnotTypeInfo
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="PropertyReference class">
  /**
   * Class with reference to OWLObjectProperty or OWLDataProperty.
   * 
   * @brief Class with reference to OWLObjectProperty or OWLDataProperty.
   * @author Marek Kopecky
   */
  private static class PropertyReference {
    private OWLObjectProperty objectProperty;
    private OWLDataProperty dataProperty;
    
    /**
     * Constructor for objectProperty.
     * @param objectProperty 
     */
    public PropertyReference(OWLObjectProperty objectProperty) {
      this.objectProperty = objectProperty;
      this.dataProperty = null;
    }
    
    /**
     * Constructor for dataProperty.
     * @param dataProperty 
     */
    public PropertyReference(OWLDataProperty dataProperty) {
      this.objectProperty = null;
      this.dataProperty = dataProperty;
    }
    
    /**
     * Constructor for rdf:property.
     */
    public PropertyReference() {
      this.objectProperty = null;
      this.dataProperty = null;
    }
    
    public OWLObjectProperty getObjectProperty() {
      return objectProperty;
    }
    
    public OWLDataProperty getDataProperty() {
      return dataProperty;
    }
  }
  // </editor-fold>
  
  // </editor-fold>


  
  
  // <editor-fold defaultstate="collapsed" desc="Helper functions">

  /**
   * Delete name in URI if anonymous property.
   * Old anonymous uri type example: http://www.co-ode.org/ontologies/pizza/pizza2.owl#genid4 to http://www.co-ode.org/ontologies/pizza/pizza2.owl#
   * 
   * @param originURI Original URI
   * @param isAnonymous Output parameter - if anonymous, it will be set to true, false otherwise
   * @return Returns URI without name
   */
  private String deleteNameInURIIfAnonymousProperty(String originURI, BooleanHolder isAnonymous) {
    isAnonymous.value = false;
    // new anonymous URI type 
    if (originURI.startsWith("_:genid")) {
      String endOfUrl;
      try {
        endOfUrl = originURI.substring(7);
      } catch (Exception e) { // substring error
        return originURI;
      }
      if (OWLVisitorForRestrictionData.tryParseInt(endOfUrl)) {
        isAnonymous.value = true;
        return AppBean.getBaseUri() + "#";
      }
    }
    
    // old anonymous URI type
    int anonymousStartName = originURI.lastIndexOf("#genid");
    // property is not anonymous
    if (anonymousStartName == -1) {
      return originURI;
    }
    if (!OWLVisitorForRestrictionData.tryParseInt(originURI.substring(anonymousStartName + 6))) {
      return originURI;
    }
    isAnonymous.value = true;
    return originURI.substring(0, anonymousStartName + 1);
  }
 
  /**
   * Delete name in URI
   * 
   * @param originURI
   * @return Uri without name
   */
  private String deleteNameInURI(String originURI) {
    int startName = originURI.lastIndexOf("#");
    // property is not anonymous
    if (startName == -1) {
      return originURI;
    }
    return originURI.substring(0, startName + 1);
  }
  
  /**
   * Return argument with first upper character.
   * @param str Original string.
   * @return Argument with first upper character.
   */
  private String upperFirstChar(String str) {
    return str.substring(0, 1).toUpperCase() + str.substring(1);
  }
  
  /**
   * Rename uri to acceptable format, if its class is annonymous
   * 
   * @param uri Original uri
   * @param isAnnonymous Function set value of this object.
   * @return Corrected uri
   */
  private String renameIfAnonymous(String uri, BooleanHolder isAnnonymous) {
    isAnnonymous.value = false;
    if (uri.startsWith("http://org.semanticweb.owlapi/error#Error")) { // anonymous class
      isAnnonymous.value = true;
      return AppBean.getBaseOntoUploadUri() + "anonymous#classgenid" + uri.substring(41);
    }
    return uri; // named class
  }
  
  /**
   * Rename uri to acceptable format, if its class is annonymous
   * 
   * @param uri Original uri
   * @return Corrected uri
   */
  private String renameIfAnonymous(String uri) {
    return renameIfAnonymous(uri, new BooleanHolder()); // named class
  }
  
  /**
   * Get class name from URI.
   * 
   * @param uri
   * @return Name 
   */
  public static String getNameFromURI(String uri) {
    int startIndex = uri.indexOf("#"); // uri specified by owl file
    if (startIndex == -1) { // uri not specified by owl file
      startIndex = uri.lastIndexOf("/"); // if -1, uri is damaged
    }
    return uri.substring(++startIndex);
  }
  
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="createAnnotTypeFromIndividual">
  /**
   * Create AnnotType object from OWL object (individual).
   * 
   * @param oModel Ontology model
   * @param oFactory Ontology factory
   * @param newTypes List with new (imported) types of annotations
   * @param newTypesMap Map with new (imported) types of annotations
   * @param newTypesMapInfo Map with information about element in newTypesMap
   * @param userGroup User group in which uploaded types will be shared
   * @param individual Individual
   * @param name Individual name.
   * @param anonymousIndividualCount Count of parsed anonymous individuals.
   * @return New count of parsed anonymous individuals.
   */
  private int createAnnotTypeFromIndividual(OWLOntology oModel, OWLDataFactory oFactory, ArrayList<AnnotType> newTypes, Map<String, AnnotType> newTypesMap, Map<String, AnnotTypeInfo> newTypesMapInfo, UserGroup userGroup, OWLIndividual individual, String name, int anonymousIndividualCount) {
    String individualUri = individual.toStringID();
    String individualCorrectUri = individualUri;
    if (individual.isAnonymous()) {
      int indexSharp = individualCorrectUri.indexOf("#");
      if (indexSharp == -1) { // anonymous individual should be in form ...#genidx
        if (!individualCorrectUri.startsWith("_:genid")) {
          return anonymousIndividualCount;
        }
        individualCorrectUri = AppBean.getBaseUri() + "#Specific" + name + ++anonymousIndividualCount;
      } else { // old type of anonymous object (owl:individual) uri
        int indexHttp = individualCorrectUri.indexOf("http://");
        if (indexHttp == -1) { // anonymous individual should be in form http://...
          return anonymousIndividualCount;
        }
        individualCorrectUri = individualCorrectUri.substring(indexHttp, indexSharp+1) + "Specific" + name + ++anonymousIndividualCount;
      }
    }


    String individualName = getNameFromURI(individualCorrectUri);  // get class name
    AnnotType individualType = new AnnotType(null, individualName, null, userGroup);
    individualType.setUriInOntology(individualCorrectUri);
    AnnotTypeInfo individualInfo = new AnnotTypeInfo(individualUri, individualCorrectUri, null, true, individual.isAnonymous());
    if (newTypesMap.containsKey(individualCorrectUri)) {  // duplicit class
      errorMessage = errorMessage + MessageProvider.getMessage("duplicitClassFound") + ": " + individualName + "<br/>";
      return anonymousIndividualCount;
    }

    String comment = "";
    if (!individual.isAnonymous()) {
      try { // asOWLNamedIndividual function can throw exception, but should not (because individual is not anonymous
        comment = getComments(oFactory, individual.asOWLNamedIndividual().getAnnotations(oModel));
      } catch (Exception e) {}
    }
    if (!comment.isEmpty()) {
      individualType.setComment(comment);
    }
    newTypes.add(individualType);
    newTypesMap.put(individualCorrectUri, individualType);
    newTypesMapInfo.put(individualUri, individualInfo);
    return anonymousIndividualCount;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="processModelPhase1">
  /**
   * Processing of ontology model - phase 1:
   * - get classes and create types of annotations
   * 
   * @param oModel Ontology model
   * @param oFactory Ontology factory
   * @param newTypes List with new (imported) types of annotations
   * @param newTypesMap Map with new (imported) types of annotations
   * @param userGroup User group in which uploaded types will be shared
   * @param newTypesMapInfo Map with information about element in newTypesMap
   * @return If error occurred, returns true, false otherwise
   */
  private boolean processModelPhase1(OWLOntology oModel, OWLDataFactory oFactory, ArrayList<AnnotType> newTypes, Map<String, AnnotType> newTypesMap, UserGroup userGroup, Map<String, AnnotTypeInfo> newTypesMapInfo) {
    // We must create all types firstly and then add attributes and new URIs
    for (OWLClass ontClass : oModel.getClassesInSignature()) { // for all classes
      String uri = ontClass.toStringID();  // get class uri

      BooleanHolder isAnnonymous = new BooleanHolder();
      uri = renameIfAnonymous(uri, isAnnonymous); // rename uri to acceptable format, if its class is annonymous
      String name = getNameFromURI(uri);  // get class name
      AnnotTypeInfo info = new AnnotTypeInfo(ontClass.toStringID(), uri,
              ontClass, false, (name.isEmpty() ? true : isAnnonymous.value));
      AnnotType type = new AnnotType(null, name, null, userGroup);
      type.setUriInOntology(uri);
      if (newTypesMap.containsKey(uri)) {  // duplicit class
        errorMessage = errorMessage + MessageProvider.getMessage("duplicitClassFound") + ": " + name + "<br/>";
        continue;
      }
      if (Constants.RESTRICT_TYPES_IMPORTED_FROM_ONTO) {  // attributes restriction
        type.setRestrictedAtt(true);
      }
      newTypesMapInfo.put(ontClass.toStringID(), info);
      newTypes.add(type);
      newTypesMap.put(uri, type);
      Set<OWLIndividual> classIndividuals = ontClass.getIndividuals(oModel);
      int anonymousIndividualCount = 0;
      for (OWLIndividual individual : classIndividuals) {
        anonymousIndividualCount = createAnnotTypeFromIndividual(oModel, oFactory, newTypes,
                newTypesMap, newTypesMapInfo, userGroup, individual, name, anonymousIndividualCount);
      }
    }
    return false;
  }  // processModelPhase1()
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="ProcessPropertyFunctions">
  
  // <editor-fold defaultstate="collapsed" desc="noRangePropertyProcess">
  /**
   * Add attribute with no object (no range) to AnnotType.
   * 
   * @param type AnnotType object.
   * @param prName Property name.
   * @param prUri Property URI.
   * @param comment Property comment.
   */
  private void noRangePropertyProcess(AnnotType type, String prName, String prUri, String comment) {
    Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
    boolean aFound = false;
    while (atrIt.hasNext()) {  // check whether is not already presented
      AnnotTypeAttr aTA = atrIt.next();
      if (aTA.getName().equals(prName)) {
        aFound = true;
      }
    }
    if (!aFound) {  // if attribute is not presented, add it
      AnnotTypeAttr attr = new AnnotTypeAttr(type, prName, "AnyAnnotation", false);
      attr.setUriInOntology(prUri);
      if (!comment.isEmpty()) {
        attr.setComment(comment);
      }
      type.getAttributes().add(attr);
    }
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="getStringTypeFromOntologyURI">
  /**
   * Convert datatype URI in ontology to datatype name, used in this server.
   * 
   * @param stringURI Datatype URI in ontology.
   * @param generateError If true, then generate error, when URI is not corrected.
   * @param isRequired This function set this value to true, if attribute should be required.
   * @return Datatype name in server.
   */
  private String getStringTypeFromOntologyURI(String stringURI, boolean generateError, BooleanHolder isRequired) {
    isRequired.value = false;
    String stringType = "";
    if (stringURI.contains("XMLSchema#string")) {
      stringType = "String";
    } else if (stringURI.contains("XMLSchema#anyURI")) {
      stringType = "URI";
    } else if (stringURI.contains("XMLSchema#float") || stringURI.contains("XMLSchema#double")) {
      stringType = "Decimal";
    } else if (stringURI.contains("XMLSchema#dateTime")) {
      stringType = "DateTime";
    } else if (stringURI.contains("XMLSchema#decimal")) {
      stringType = "Decimal";
    } else if (stringURI.contains("XMLSchema#date")
            || stringURI.contains("XMLSchema#gYearMonth")
            || stringURI.contains("XMLSchema#gYear")
            || stringURI.contains("XMLSchema#gDay")
            || stringURI.contains("XMLSchema#gMonth")
            || stringURI.contains("XMLSchema#gMonthDay")) {
      stringType = "Date";
    } else if (stringURI.contains("XMLSchema#time")) {
      stringType = "Time";
    } else if (stringURI.contains("XMLSchema#boolean")) {
      stringType = "Boolean";
    } else if (stringURI.contains("XMLSchema#integer")
            || stringURI.contains("XMLSchema#long")
            || stringURI.contains("XMLSchema#int")
            || stringURI.contains("XMLSchema#short")
            || stringURI.contains("XMLSchema#byte")
            || stringURI.contains("XMLSchema#nonPositiveInteger")
            || stringURI.contains("XMLSchema#negativeInteger")
            || stringURI.contains("XMLSchema#nonNegativeInteger")
            || stringURI.contains("XMLSchema#positiveInteger")
            || stringURI.contains("XMLSchema#unsignedLong")
            || stringURI.contains("XMLSchema#unsignedInt")
            || stringURI.contains("XMLSchema#unsignedShort")
            || stringURI.contains("XMLSchema#unsignedByte")) {  // integer derivatives
      stringType = "Integer";
    } else if (stringURI.contains("XMLSchema#normalizedString")
            || stringURI.contains("XMLSchema#token")
            || stringURI.contains("XMLSchema#language")
            || stringURI.contains("XMLSchema#QName")
            || stringURI.contains("XMLSchema#NOTATION")
            || stringURI.contains("XMLSchema#ID")
            || stringURI.contains("XMLSchema#ENTITY")
            || stringURI.contains("XMLSchema#ENTITIES")
            || stringURI.contains("XMLSchema#IDREF")
            || stringURI.contains("XMLSchema#IDREFS")
            || stringURI.contains("XMLSchema#Name")
            || stringURI.contains("XMLSchema#NCName")) {  // string derivatives
      stringType = "String";
    } else if (stringURI.contains("XMLSchema#NMTOKEN")
            || stringURI.contains("XMLSchema#NMTOKENS")) {
      stringType = "String";
      isRequired.value = true;
    } else if (stringURI.contains("XMLSchema#base64Binary")
            || stringURI.contains("XMLSchema#hexBinary")) {  // Binary
      stringType = "Binary";
    } else if (stringURI.contains("XMLSchema#duration")) {  // duration
      stringType = "Duration";
    } else {  // unsupported (so far)
      if (generateError) {
        errorMessage = errorMessage + MessageProvider.getMessage("unsupportedLiteralDatatype1")
              + stringURI + MessageProvider.getMessage("unsupportedLiteralDatatype2") + "<br/>";
      }
    }
    return stringType;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="getStringTypeFromOntologyURI">
  /**
   * Add property to AnnotType object in newTypesMap.
   * 
   * @param prUri Property URI in ontology.
   * @param propertyReference Reference to The OWL API structure for this property.
   * @param comment Comment.
   * @param subjectSetClassURI Set of subject URI.
   * @param objectSetClassURI Set of object URI.
   * @param newTypesMap Map with new (imported) types of annotations
   * @param newTypesMapInfo Information about newNewTypesMap
   * @param ontoAttrs List with attributes of unknown types of annotations
   * @param userGroup User group in which uploaded types will be shared
   * @param superPropertiesStringSet Set of super properties.
   * @param inversePropertiesID Set of inverse properties URI.
   * @param oModel Ontology model
   */
  private void processProperties(String prUri, PropertyReference propertyReference, String comment, 
          HashSet<String> subjectSetClassURI, HashSet<String> objectSetClassURI,
          Map<String, AnnotType> newTypesMap,
          Map<String, AnnotTypeInfo> newTypesMapInfo, ArrayList<TypeAttrOnto> ontoAttrs,
          UserGroup userGroup, Set<String> superPropertiesStringSet,
          Set<String> inversePropertiesID, OWLOntology oModel) { 
      if (prUri == null) { // fatal error, The OWL API generate URI and name if it is not set normally
        errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + "<br/>";
        return;
      }
      BooleanHolder anonymousProperty = new BooleanHolder();
      prUri = deleteNameInURIIfAnonymousProperty(prUri, anonymousProperty);
      
      // if anonymous, generate new name
      if (anonymousProperty.value) {
        if (!inversePropertiesID.isEmpty()) {
          anonymousProperty.value = false;
          Iterator<String> itr = inversePropertiesID.iterator();
          String firstInverseProperty = itr.next();
          prUri += "not" + upperFirstChar(firstInverseProperty);
        } else {
          if (superPropertiesStringSet.isEmpty()) {
            prUri += "has";
          } else {
            Iterator<String> itr = superPropertiesStringSet.iterator();
            String ancestor = itr.next();
            prUri += getNameFromURI(ancestor) + "Has";
          }
        }
      }
      
      // property name
      String prName = getNameFromURI(prUri);  // predicate name
      if (prName.isEmpty()) { // generate name for anonymous property
        errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + "<br/>";
        return;
      }
      
      // add information about property type to comment (transitive, reflexive, functional, etc.)
      comment = procesSpecialPropertyType(comment, propertyReference, objectSetClassURI.size(), prName, oModel);
      
      
      // attribute without subject
      if (subjectSetClassURI.isEmpty()) { 
        processPropertyWS(prUri, prName, comment, objectSetClassURI, userGroup, ontoAttrs, newTypesMap, anonymousProperty.value);
        return;
      }
        
      for (String subjectUri : subjectSetClassURI) { // for all domain in property
        AnnotTypeInfo info = newTypesMapInfo.get(subjectUri);
        if (info == null) {
          errorMessage = errorMessage + MessageProvider.getMessage("badClassInOntology") + ": " + subjectUri + "<br/>";
          continue;  // unknown subject - property can't be processed
        }
        AnnotType type = newTypesMap.get(info.correctedUri);  // get type created for this class
        if (type == null) {
          errorMessage = errorMessage + MessageProvider.getMessage("badClassInOntology") + ": " + subjectUri + "<br/>";
          continue;  // unknown subject - property can't be processed
        }
        String subjectName = getNameFromURI(subjectUri);
        
        // no range in property (no object) or rdf-schema#Literal in range in owl:ObjectProperty
        if (objectSetClassURI.isEmpty()) { 
          if (!anonymousProperty.value) { // any usefull information
            noRangePropertyProcess(type, prName, prUri, comment);
          }
          continue;
        }
        
        for (String objUri : objectSetClassURI) { // rdfs:range = object
          String objName = getNameFromURI(objUri);
          String newPrUri = prUri;
          String newPrName = prName;
          if (!anonymousProperty.value) {
            if (objectSetClassURI.size() != 1) {
              newPrUri += "." + objName;
              newPrName += "." + objName;
            }
          } else { // appending of object name 
            String objNameUpperFirstChar = upperFirstChar(objName);
            newPrUri += objNameUpperFirstChar;
            newPrName += objNameUpperFirstChar;
          }
          if (objUri.endsWith("rdf-schema#Literal")) { 
            if (!anonymousProperty.value) { // any usefull information
              noRangePropertyProcess(type, prName, prUri, comment);
            }
            continue;
          }
          AnnotTypeInfo pInfo = newTypesMapInfo.get(objUri);
          AnnotType pType = null;
          if (pInfo != null) {
            pType = newTypesMap.get(pInfo.correctedUri);
          }
          if (pType != null && pInfo != null) {  // if type was found
            Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
            boolean aFound = false;
            while (atrIt.hasNext()) {  // check whether is not already presented
              AnnotTypeAttr aTA = atrIt.next();
              if (aTA.getName().equals(newPrName)) {
                aFound = true;
              }
            }
            if (!aFound) {  // if attribute is not presented, add it
              AnnotTypeAttr attr = new AnnotTypeAttr(type, newPrName, pType, false);
              attr.setUriInOntology(newPrUri);
              if (comment != null) {
                if (!comment.isEmpty()) {
                    attr.setComment(comment);
                }
              }
              type.getAttributes().add(attr);
            }
          } else {
            if (objUri.contains("XMLSchema#")) {
                BooleanHolder isRequired = new BooleanHolder();
                String simpleType = getStringTypeFromOntologyURI(objUri, true, isRequired);
                if (simpleType.isEmpty()) {
                  continue;
                }
                AnnotTypeAttr attr = new AnnotTypeAttr(type, newPrName, simpleType, isRequired.value);
                attr.setUriInOntology(newPrUri);
                if (!comment.isEmpty()) {
                  attr.setComment(comment);
                }
                // WARNING: Value (variable objString) discarded - there is no place for it!
                Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
                boolean aFound = false;
                while (atrIt.hasNext()) {  // check whether is not already presented
                  AnnotTypeAttr aTA = atrIt.next();
                  if (aTA.getName().equals(prName)) {
                    aFound = true;
                  }
                }
                if (!aFound) {  // if it is not already presented
                  type.getAttributes().add(attr);
                }
            } else {
              errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + ": " + prUri + "<br/>";
            }
            continue;
          }
        }
      }
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="addSuperPropertiesToComment">
  /**
   * Add information about superProperties to comment of property.
   * @param propertyURI Property URI.
   * @param comment Origin comment.
   * @param superClasses Set of super classes URI.
   * @return New comment.
   */
  private String addSuperPropertiesToComment(String propertyURI, String comment, Set<String> superClasses) {
    for (String superClass : superClasses) {
      if (superClass.equals(propertyURI)) {
        continue;
      }
      BooleanHolder isAnonymous = new BooleanHolder();
      deleteNameInURIIfAnonymousProperty(superClass, isAnonymous);
      if (isAnonymous.value) { // information about anonymous property was skipped
        continue;
      }
      comment = prepareCommentToAdding(comment);
      comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SUB_PROPERTY_COMMENT_1) + 
                 getNameFromURI(superClass) + 
                 TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SUB_PROPERTY_COMMENT_2);
    }
    return comment;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="addSuperObjectPropertiesToSet">
  /**
   * This function is for OWLObjectProperty.
   * It create set of superProperties URI.
   * 
   * @param propertyURI Property URI.
   * @param superProperties Set of superProperties as OWLObjectPropertyExpression.
   * @param superClasses Set of superProperties as String (URI).
   */
  private void addSuperObjectPropertiesToSet(String propertyURI, 
          Set<OWLObjectPropertyExpression> superProperties,
          Set<String> superClasses) {
    for (OWLObjectPropertyExpression superProperty : superProperties) {
      String property;
      try {
        property = superProperty.asOWLObjectProperty().toStringID();
        if (propertyURI.equals(property)) {
          continue;
        }
        superClasses.add(property);
      } catch (Exception e) {
        continue;
      }
    }
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="addSuperDataPropertiesToSet">
  /**
   * This function is for OWLDatatypeProperty.
   * It create set of superProperties URI.
   * 
   * @param propertyURI Property URI.
   * @param superProperties Set of superProperties as OWLObjectPropertyExpression.
   * @param superClasses Set of superProperties as String (URI).
   */
  private void addSuperDataPropertiesToSet(String propertyURI, 
          Set<OWLDataPropertyExpression> superProperties,
          Set<String> superClasses) {
    for (OWLDataPropertyExpression superProperty : superProperties) {
      String property;
      try {
        property = superProperty.asOWLDataProperty().toStringID();
        if (propertyURI.equals(property)) {
          continue;
        }
        superClasses.add(property);
      } catch (Exception e) {
        continue;
      }
    }
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="prepareCommentToAdding">
  /**
   * Prepare comment string to add another comment.
   * @param comment Origin comment.
   * @return New comment.
   */
  private String prepareCommentToAdding(String comment) {
    if (comment == null) {
      comment = "";
    }
    if (!comment.isEmpty()) {
      comment += "\n";
    }
    return comment;
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="editCommentBaseOnType">
  /**
   * Add property type information to property comment.
   * For example, type can be "reflexive", "functional", etc.
   * 
   * @param originalComment Original comment.
   * @param action If true, property is of selected type.
   * @param objectCount Count of property object.
   * @param propertyName Property name.
   * @param oneComment Text to comment, if property has one object.
   * @param moreComment1 First text to comment, if property has more objects.
   * @param moreComment2 Second text to comment, if property has more objects
   * @return New comment.
   */
  private String editCommentBaseOnType(String originalComment, boolean action, int objectCount,
                  String propertyName, String oneComment, 
                  String moreComment1, String moreComment2) {
    if (!action) {
      return originalComment;
    }
    originalComment = prepareCommentToAdding(originalComment);
    if (objectCount > 1) {
      originalComment += moreComment1 + propertyName + moreComment2;
    } else {
      originalComment += oneComment;
    }
    return originalComment;
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="procesSpecialPropertyType">
  /**
   * Add information about all types to property comment.
   * @param comment Original comment.
   * @param propertyReference Reference to The OWL API structure for this property.
   * @param objectCount Count of property object.
   * @param newPropertyName Property name.
   * @param oModel Ontology model.
   * @return New comment.
   */
  private String procesSpecialPropertyType(String comment, PropertyReference propertyReference, int objectCount, String newPropertyName, OWLOntology oModel) {
    try {
      OWLDataProperty dataProperty = propertyReference.getDataProperty();
      OWLObjectProperty objectProperty = propertyReference.getObjectProperty();

      if (dataProperty != null) {
        comment = editCommentBaseOnType(comment, dataProperty.isFunctional(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_2));
      } else if (objectProperty != null) {
        comment = editCommentBaseOnType(comment, objectProperty.isFunctional(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isAsymmetric(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ASSYMETRIC_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ASSYMETRIC_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ASSYMETRIC_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isInverseFunctional(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INVERSE_FUNCTIONAL_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INVERSE_FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INVERSE_FUNCTIONAL_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isIrreflexive(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.IRREFLEXIVE_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.IRREFLEXIVE_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.IRREFLEXIVE_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isReflexive(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.REFLEXIVE_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.REFLEXIVE_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.REFLEXIVE_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isSymmetric(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SYMETRIC_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SYMETRIC_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SYMETRIC_PROPERTY_MORE_OBJECT_COMMENT_2));
        comment = editCommentBaseOnType(comment, objectProperty.isTransitive(oModel), objectCount,
                    newPropertyName, TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.TRANSITIVE_PROPERTY_ONE_OBJECT_COMMENT), 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.TRANSITIVE_PROPERTY_MORE_OBJECT_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.TRANSITIVE_PROPERTY_MORE_OBJECT_COMMENT_2));
      }
    } catch (Exception e) {}
    return comment;
  }
  // </editor-fold>

  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="getComments">
  /**
   * Get comments from annotationSet (annotation of OWL Class).
   * 
   * @param oFactory Ontology factory
   * @param annotationSet Set of annotation of OWL Class.
   * @return Comment.
   */
  private String getComments( OWLDataFactory oFactory, Set<OWLAnnotation> annotationSet) {
      String comment = "";
      for (OWLAnnotation propertyAnnotation : annotationSet) {    
        OWLAnnotationProperty propertyType = propertyAnnotation.getProperty();  
        OWLAnnotationValue value = propertyAnnotation.getValue();
        
        if (value instanceof OWLLiteral) {
          OWLLiteral literalValue = (OWLLiteral) value;  
          // RDFS Comment
          literalValue.getObjectPropertiesInSignature();
          if (propertyType.equals(oFactory.getRDFSComment())) {
            String commentValue = literalValue.getLiteral();
            if (!comment.isEmpty()) {
              comment = comment + " \n" + commentValue.trim();
            } else {
              comment = commentValue.trim();
            }
            continue;
          }
        }
      }
      return comment;
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="processOWLClassExpression">
  /**
   * Get all class URI from OWLClassExpression.
   * This function is used for get subject (domain) and object (range) from property.
   * 
   * @param oModel Ontology model.
   * @param exp OWLClassExpression value.
   * @return Set of class URI
   */
  private HashSet<String> processOWLClassExpression(OWLOntology oModel, OWLClassExpression exp) {
      HashSet<String> set = new HashSet<String>();
      try { // cast can throw exception, but should not (try is used just to be sure)
        if (exp.getClassExpressionType().equals(ClassExpressionType.OWL_CLASS)) {
            set.add(exp.asOWLClass().toStringID());
        }
        else if (exp.getClassExpressionType().equals(ClassExpressionType.OBJECT_UNION_OF)) {
            Set<OWLClass> classSet = ((OWLObjectUnionOf) exp).getClassesInSignature();
            for (OWLClass cls : classSet) {
                set.add(cls.toStringID());
            }
        }
      } catch (Exception e) {}
      return set;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="process inverse property">
  /**
   * Get inverse ane equivalent properties of property. Recursive function.
   * Property or expression argument should be null.
   * 
   * @param processedProperty URI of properties, that has been already processed.
   * @param property Property object.
   * @param expression Expression object.
   * @param oModel Ontology model
   * @param inversePropertyURI Set of inverse properties URI
   * @param equivalentPropertyURI Set of equivalent properties URI
   */
  private void getInverseEquivalentPropertyUri(Set<String> processedProperty,
          OWLObjectProperty property, OWLObjectPropertyExpression expression, 
          OWLOntology oModel, Set<OWLObjectPropertyExpression> inversePropertyURI,
          Set<OWLObjectPropertyExpression> equivalentPropertyURI) {
    // security condition
    recursiveInverseCount++;
    if (recursiveInverseCount > 5000) {
      return;
    }
    
    Set<OWLObjectPropertyExpression> inverses;
    Set<OWLObjectPropertyExpression> equivalents;
    if (property != null) {
      property.getInverseProperty().getRanges(oModel).toString();
      inverses = property.getInverses(oModel);
      equivalents = property.getEquivalentProperties(oModel);
    } else {
      if (expression == null) { // fatal error
        return;
      }
      inverses = expression.getInverses(oModel);
      equivalents = expression.getEquivalentProperties(oModel);
    }
    
    for (OWLObjectPropertyExpression propertyExpression : inverses) {
      if (processedProperty.contains(propertyExpression.toString())) {
        continue;
      }
      processedProperty.add(propertyExpression.toString());
      inversePropertyURI.add(propertyExpression);
      getInverseEquivalentPropertyUri(processedProperty, null, propertyExpression, oModel,
              equivalentPropertyURI, inversePropertyURI);
    }
    for (OWLObjectPropertyExpression propertyExpression : equivalents) {
      if (processedProperty.contains(propertyExpression.toString())) {
        continue;
      }
      //System.out.println(propertyExpression.toString());
      processedProperty.add(propertyExpression.toString());
      equivalentPropertyURI.add(propertyExpression);
      getInverseEquivalentPropertyUri(processedProperty, null, propertyExpression, oModel,
              inversePropertyURI, equivalentPropertyURI);
    }
  }
  
  /**
   * 
   * @param oModel Ontology model
   * @param property Property object
   * @param objectSetExpression Set of object class expression
   * @param subjectSetExpression Set of subject class expression
   * @param inversePropertiesStringSet Set of inverse properties URI. This set is fill with data up in this function.
   */
  private void processInverseProperty(OWLOntology oModel, OWLObjectProperty property,
                 Set<OWLClassExpression> objectSetExpression,
                 Set<OWLClassExpression> subjectSetExpression,
                 Set<String> inversePropertiesStringSet) {
    try {
      recursiveInverseCount = 0;
      Set<OWLObjectPropertyExpression> inverseSet = new HashSet<OWLObjectPropertyExpression>();
      Set<OWLObjectPropertyExpression> equivalentSet = new HashSet<OWLObjectPropertyExpression>();
      getInverseEquivalentPropertyUri(new HashSet<String>(), property, null, oModel, inverseSet, equivalentSet);
      // detect all inverse properties and get subject or object from them
      for (OWLObjectPropertyExpression propertyExpression : inverseSet) { 
        if (!propertyExpression.isAnonymous()) { // name of anonymous property is useless
          String inversePropertyNameID = propertyExpression.getNamedProperty().toStringID();
          inversePropertiesStringSet.add(inversePropertyNameID);
        } else { // anonymous property, but The OWL API didn't generate anonymous name in form genidX (where X is unique number)
          BooleanHolder isAnonymousByName = new BooleanHolder();
          deleteNameInURIIfAnonymousProperty(propertyExpression.toString(), isAnonymousByName);
          if (!isAnonymousByName.value) {
            isAnonymousByName.value = true;
          }
        }
        if (subjectSetExpression.isEmpty()) {
          subjectSetExpression.addAll(propertyExpression.getRanges(oModel));
        }
        if (objectSetExpression.isEmpty()) {
          objectSetExpression.addAll(propertyExpression.getDomains(oModel));
        }
      }
      // attempt to get object and subject from equivalent property
      for (OWLObjectPropertyExpression propertyExpression : equivalentSet) { 
        // not equivalent class
        if (propertyExpression.toString().startsWith("InverseOf") || !propertyExpression.toString().startsWith("<")) {
            continue;
        }
        // this class is skipped
        if (!propertyExpression.isAnonymous()) {
          if (propertyExpression.getNamedProperty().toStringID().equalsIgnoreCase(property.toStringID())) {
            continue;
          }
        }
        if (subjectSetExpression.isEmpty()) {
          subjectSetExpression.addAll(propertyExpression.getDomains(oModel));
        }
        if (objectSetExpression.isEmpty()) {
          objectSetExpression.addAll(propertyExpression.getRanges(oModel));
        }
      }
    } catch (Exception e) {}
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="processSuperClass">
  /**
   * Get super classes URI of OWL class.
   * 
   * @param oModel Ontology model
   * @param ontClass Class object
   * @return List of super classes URI.
   */
  private LinkedList<String> processSuperClass(OWLOntology oModel, OWLClass ontClass) {
    LinkedList<String> allAncestorList = new LinkedList<String>();
    try { // cast can throw exception, but should not (try is used just to be sure)
      OWLClass actualClass = ontClass;
      while (true) {
        Set<OWLClassExpression> ancestorSet = actualClass.getSuperClasses(oModel);
        Iterator<OWLClassExpression> ancestorIt = ancestorSet.iterator();
        if (!ancestorIt.hasNext()) { // any ancestor found
          break;
        }
        OWLClassExpression ancestor = ancestorIt.next();
        String ancestorString = ancestor.asOWLClass().toStringID();
        actualClass = ancestor.asOWLClass();
        if (allAncestorList.contains(ancestorString)) {
          break;
        }
        allAncestorList.addLast(ancestorString);
      }
    } catch (Exception e) {}
    return allAncestorList;
  }
  
  /**
   * Add list of super-classes to AnnotType object.
   * 
   * @param newTypes List with new (imported) types of annotations
   * @param newTypesMap Map with new (imported) types of annotations
   * @param userGroup User group in which uploaded types will be shared
   * @param type AnnotType object.
   * @param superClasses  List of super classes URI. This list is fill up in this function.
   */
  private void addSuperClassesToAnnotType(ArrayList<AnnotType> newTypes, Map<String, AnnotType> newTypesMap, UserGroup userGroup, AnnotType type, List<String> superClasses) {
      Iterator<String> superClassesIt = superClasses.iterator();
      while (superClassesIt.hasNext()) { 
        String parentUri = renameIfAnonymous(superClassesIt.next());
        AnnotType aType = newTypesMap.get(parentUri);
        if (aType != null) {  // if ancestor was found
          type.addAncestorType(aType);
        } else {
          if (!parentUri.equals("http://www.w3.org/2002/07/owl#Thing")) {
            errorMessage = errorMessage + MessageProvider.getMessage("badSuperclassInOntology") + ": " + parentUri + "<br/>";
          } else {  // if it is Thing
            if (!newTypesMap.containsKey(parentUri)) {  // if Thing not presented
              // Create Thing
              AnnotType thing = new AnnotType(null, "Thing", null, userGroup);
              thing.setUri(thing.getGeneratedURI());
              thing.setUriInOntology(parentUri);
              newTypesMap.put(parentUri, thing);
              newTypes.add(thing);
              aType = thing;
              type.addAncestorType(aType);
            }
          }  // if it is Thing  
        }
      }
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="processRdfPropertyAxioms">
  /**
   * Process set of OWL Axiom and get subject, object and ancestor for rdf:property element.
   * 
   * @param objectSetClassURI Set of object URI string.
   * @param subjectSetClassURI Set of subject URI string.
   * @param ancestorSetClassURI Set of ancestor URI string.
   * @param allAxioms Set of all axiom to selected property.
   * @return Count of unsupported axioms.
   */
  private int processRdfPropertyAxioms(HashSet<String> objectSetClassURI,
                HashSet<String> subjectSetClassURI,
                HashSet<String> ancestorSetClassURI,
                Set<OWLAxiom> allAxioms) {
    int anotherAxioms = 0;
    for (OWLAxiom ax : allAxioms) {
      if (ax.getAxiomType().getName().equals("AnnotationPropertyRangeOf") &&
          ax instanceof OWLAnnotationPropertyRangeAxiom) {
        OWLAnnotationPropertyRangeAxiom range = (OWLAnnotationPropertyRangeAxiom) ax;
        objectSetClassURI.add(range.getRange().toString());
      } else if (ax.getAxiomType().getName().equals("AnnotationPropertyDomain") &&
                 ax instanceof OWLAnnotationPropertyDomainAxiom) {
        OWLAnnotationPropertyDomainAxiom domain = (OWLAnnotationPropertyDomainAxiom) ax;
        subjectSetClassURI.add(domain.getDomain().toString());
      } else if (ax.getAxiomType().getName().equals("SubAnnotationPropertyOf") &&
                 ax instanceof OWLSubAnnotationPropertyOfAxiom) {
        try { // cast can throw exception, but should not (try is used just to be sure)
          OWLSubAnnotationPropertyOfAxiom ancestor = (OWLSubAnnotationPropertyOfAxiom) ax;
          OWLAnnotationProperty ancestorProperty = ancestor.getSuperProperty();
          if (ancestorProperty.isOWLObjectProperty()) {
            ancestorSetClassURI.add(ancestorProperty.asOWLObjectProperty().toStringID());
          } else {
            ancestorSetClassURI.add(ancestorProperty.getIRI().toString());
          }
        } catch (Exception e) {}
      } 
      else if (ax.getAxiomType().getName().equals("AnnotationAssertion")) {
        anotherAxioms++;
        continue; // elements like this: <test:whatever rdf:resource="#aaa"/> in class tag is processed in another place
      } else { 
        anotherAxioms++;  
      }
    }
    return anotherAxioms;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="processPropertyWS">
  /**
   * Process property without subject
   * - creates attribute of unknown type of annotation
   * 
   * @param prUri Property URI in ontology
   * @param prName Name of property to process
   * @param comment Comment of property to process
   * @param objectSetClassURI Set of object URI.
   * @param userGroup User group in which uploaded types will be shared
   * @param ontoAttrs List with attributes of unknown types of annotations
   * @param newTypesMap Map with new (imported) types of annotations
   * @param isAnonymous True if it is anonymous, false otherwise
   */
  private void processPropertyWS(String prUri, String prName, String comment, HashSet<String> objectSetClassURI, UserGroup userGroup, ArrayList<TypeAttrOnto> ontoAttrs, Map<String, AnnotType> newTypesMap, boolean isAnonymous) {
    Iterator<String> it = objectSetClassURI.iterator();
    while (it.hasNext()) {
      String objectURI = it.next();
      if (objectURI.endsWith("rdf-schema#Literal")) { 
        it.remove();
      }
    }
      if (objectSetClassURI.isEmpty()) {
        if (isAnonymous) {
          return;
        }
        Iterator<TypeAttrOnto> atrIt = ontoAttrs.iterator();
        boolean aFound = false;
        while (atrIt.hasNext()) {  // check whether is not already presented
          TypeAttrOnto aTA = atrIt.next();
          if (aTA.getName().equals(prName)) {
            aFound = true;
          }
        }
        if (!aFound) {  // if attribute is not presented, add it
          TypeAttrOnto attr = new TypeAttrOnto(userGroup, prName, "AnyAnnotation");
          attr.setUriInOntology(prUri);
          if (!comment.isEmpty()) {
            attr.setComment(comment);
          }
          ontoAttrs.add(attr);
        }
        return;
      }

      if (prName.equals("subClassOf")) { // if object is superclass
        errorMessage = errorMessage + MessageProvider.getMessage("badSuperclassInOntology") + "<br/>";
        return;
      } 
      
      // for all objects
      for (String objUri : objectSetClassURI) {
        String newPrName = prName;
        String newPrUri = prUri;
        // update property name
        if (!isAnonymous) {
          if (objectSetClassURI.size() > 1) {
            String objName = getNameFromURI(objUri);
            newPrName += "." + objName;
            newPrUri += "." + objName;
          }
        } else { // is anonymous
          String objName = upperFirstChar(getNameFromURI(objUri));
          newPrName += objName;
          newPrUri += objName;
        }
        AnnotType pType = newTypesMap.get(objUri);
        if (pType != null) {  // if type was found
          Iterator<TypeAttrOnto> atrIt = ontoAttrs.iterator();
          boolean aFound = false;
          while (atrIt.hasNext()) {  // check whether is not already presented
            TypeAttrOnto aTA = atrIt.next();
            if (aTA.getName().equals(newPrName)) {
              aFound = true;
            }
          }
          if (!aFound) {  // if attribute is not presented, add it
            TypeAttrOnto attr = new TypeAttrOnto(userGroup, newPrName, pType);
            attr.setUriInOntology(newPrUri);
            if (!comment.isEmpty()) {
              attr.setComment(comment);
            }
            ontoAttrs.add(attr);
          }
        } else {
            
            if (objUri.contains("XMLSchema#")) {
                BooleanHolder isRequired = new BooleanHolder(); // not used here
                String simpleType = getStringTypeFromOntologyURI(objUri, true, isRequired);
                if (simpleType.isEmpty()) {
                    return;
                }
                Iterator<TypeAttrOnto> atrIt = ontoAttrs.iterator();
                boolean aFound = false;
                while (atrIt.hasNext()) {  // check whether is not already presented
                  TypeAttrOnto aTA = atrIt.next();
                  if (aTA.getName().equals(newPrName)) {
                    aFound = true;
                  }
                }
                if (!aFound) {  // if attribute is not presented, add it
                  TypeAttrOnto attr = new TypeAttrOnto(userGroup, newPrName, simpleType);
                  attr.setUriInOntology(newPrUri);
                  if (!comment.isEmpty()) {
                    attr.setComment(comment);
                  }
                  ontoAttrs.add(attr);
                }
            } else {
              errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + ": " + prUri + "<br/>";
              return;
            }
        }
      }
  }  // processPropertyWS()
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="getOntoPropertyMayMove">
  /**
   * Find properties in ontoAttrs, if found, remove from ontoAttrs and add to ontoAttrsDeleted
   * This is for restriction in anonymous class.
   * 
   * @param propertyURI Uri of property in restriction.
   * @param ontoAttrs List with attributes of unknown types of annotations
   * @param ontoAttrsDeleted List with attributes of known types of annotations (types are known from restriction in anonymous class)
   * @return If found, all properties in set, else null.
   */
  private ArrayList<TypeAttrOnto> getOntoPropertyMayMove(String propertyURI, ArrayList<TypeAttrOnto> ontoAttrs,
                          ArrayList<TypeAttrOnto> ontoAttrsDeleted) {
    Iterator<TypeAttrOnto> it = ontoAttrs.iterator();
    ArrayList<TypeAttrOnto> ontoList = new ArrayList<TypeAttrOnto>();
    boolean ontoAtrFound = false;
    TypeAttrOnto ontoAtr;
    while (it.hasNext()) {
      ontoAtr = it.next();
      String uri = ontoAtr.getUriInOntology();
      if (uri.startsWith(propertyURI + ".") || uri.equalsIgnoreCase(propertyURI)) {
        ontoAtrFound = true;
        it.remove();
        ontoAttrsDeleted.add(ontoAtr);
        ontoList.add(ontoAtr);
      }
    }
    if (ontoAtrFound) {
      return ontoList;
    }
    // try to found in ontoAttrsDeleted
    it = ontoAttrsDeleted.iterator();
    while (it.hasNext()) {
      ontoAtr = it.next();
      if (ontoAtr.getUriInOntology().startsWith(propertyURI + ".") ||
          ontoAtr.getUriInOntology().equalsIgnoreCase(propertyURI)) {
        ontoAtrFound = true;
        ontoList.add(ontoAtr);
      }
    }
    if (ontoAtrFound) {
      return ontoList;
    }
    // nothing found
    return null;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="addPropertyInAnonymousClassFromCardinalityRestriction">
  /**
   * Add property to anonymous class. Property is marked only in restriction.
   * 
   * @param ontoAttrs List with attributes of unknown types of annotations
   * @param ontoAttrsDeleted List with attributes of known types of annotations (types are known from restriction in anonymous class)
   * @param data Information about restriction.
   * @param typeURI Subject class URI.
   * @param newTypesMap Map with new (imported) types of annotations
   * @param newTypesMapInfo Map with informations about new (imported) types of annotations
   * @param oModel Ontology model
   * @param userGroup User group in which uploaded types will be shared
   * @return Count of new atributes.
   */
  private int addPropertyInAnonymousClassFromCardinalityRestriction(ArrayList<TypeAttrOnto> ontoAttrs,
                  ArrayList<TypeAttrOnto> ontoAttrsDeleted, OWLVisitorForRestrictionData.CardinalityData data,
                  String typeURI, Map<String, AnnotType> newTypesMap, 
                  Map<String, AnnotTypeInfo> newTypesMapInfo, OWLOntology oModel, UserGroup userGroup) {
      int counter = 0;
      // try to get object from ontoAttrs
      ArrayList<TypeAttrOnto> ontoAtrList = getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
      HashSet<String> subjectSetClassURI = new HashSet<String>();
      subjectSetClassURI.add(typeURI);
      if (ontoAtrList != null) {
        for (TypeAttrOnto oAtr : ontoAtrList) {
          HashSet<String> objectSetClassURI = new HashSet<String>();
          if (oAtr.getAttributeType() != null) {
            objectSetClassURI.add(oAtr.getAttributeType().getUriInOntology());
          }
          String comment = oAtr.getComment();
          processProperties(oAtr.getUriInOntology(), new PropertyReference(),
            (comment == null ? "" : comment), subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
            userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
          counter++;
        }
      } else { // unknown object, we set object from someValue-restriction (best information, that we have)
        HashSet<String> objectSetClassURI = new HashSet<String>();
        processProperties(data.propertyURI, new PropertyReference(),
          "", subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
          userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
        counter++;
      }
      return counter;
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="getNewNameForAnonymousClass">
  /**
   * Create new name for anonymous class.
   * 
   * @param info AnnotTypeInfo object for class
   * @param type AnnotType object for class
   * @return New name
   */
  private String getNewNameForAnonymousClass(AnnotTypeInfo info, AnnotType type) {
    String URIWithoutName = deleteNameInURI(info.correctedUri);
    String newName = "";
    
    // get suitable label (if any)
    boolean isSuitableLabel = false; // The OWL API error
    boolean onlyLabel = false;
    if (isSuitableLabel && info.disjointWithSet.isEmpty() && type.getAttributes().isEmpty() && isSuitableLabel) {
      onlyLabel = true;
    }
    
    
    boolean firstPart = true;
    // add information about ancestor to name
    boolean ancestorInName = false;
    AnnotType ancestorType = type.getAncestorType();
    if (ancestorType != null && !onlyLabel) {
      if (info.disjointWithSet.isEmpty() && type.getAttributes().isEmpty()) {
        newName += "specific" + upperFirstChar(ancestorType.getName());
      } else {
        newName += ancestorType.getName();
      }
      ancestorInName = true;
      firstPart = false;
    }
    // add information about disjointClasses to name
    int disjointClassesCount = 0;
    for (String disjointClass : info.disjointWithSet) {
      if (firstPart) {
        newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.DISJOINT_WITH_ANONYMOUS_NAME_FIRST);
        firstPart = false;
      } else {
        newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.DISJOINT_WITH_ANONYMOUS_NAME);
      }
      newName += upperFirstChar(getNameFromURI(disjointClass));
      disjointClassesCount++;
      if (disjointClassesCount >= 5) {
        break;
      }
    }
    // add information about attributes to name
    if (info.disjointWithSet.isEmpty()) {
      int attributesCount = type.getAttributes().size();
      for (Object atrObj : type.getAttributes()) {
        if (!(atrObj instanceof AnnotTypeAttr)) {
          continue;
        }
        AnnotTypeAttr atr = (AnnotTypeAttr) atrObj;
        if (ancestorInName) {
          if (attributesCount == 1) {
            newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ATTRIBUTE_WITH_ANONYMOUS_NAME_FIRST_AFTER);
          } else {
            newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ATTRIBUTES_WITH_ANONYMOUS_NAME_FIRST_AFTER);
          }
          ancestorInName = false;
        } else if (firstPart) {
          if (attributesCount == 1) {
            newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ATTRIBUTE_WITH_ANONYMOUS_NAME_FIRST);
          } else {
            newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ATTRIBUTES_WITH_ANONYMOUS_NAME_FIRST);
          }
          firstPart = false;
        } else {
          newName += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.ATTRIBUTES_WITH_ANONYMOUS_NAME);
        }
        newName += upperFirstChar(atr.getName());
      }
    }
    
    if (!newName.isEmpty()) {
      return URIWithoutName + newName;
    }
    return info.correctedUri; //we don't know any information, final name will be genidX (where X is unique number)
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="processing of collection information">

  // <editor-fold defaultstate="collapsed" desc="processOWLClassExpressionIntersectionOfOneOf">
  /**
   * Get oneOf and intersectionOf classes URI from OWLClassExpression.
   * 
   * @param exp OWLClassExpression value.
   * @param intersectionOfSet This function add URI of class to this set.
   * @param oneOfSet This function add URI of class to this set.
   */
  private void processOWLClassExpressionIntersectionOfOneOf(OWLClassExpression exp,
          HashSet<String> intersectionOfSet, HashSet<String> oneOfSet) {
    try { // cast can throw exception, but should not (try is used just to be sure)
      if (exp.getClassExpressionType().equals(ClassExpressionType.OBJECT_ONE_OF)) {
        Set<OWLNamedIndividual> classSet = ((OWLObjectOneOf) exp).getIndividualsInSignature();
        for (OWLNamedIndividual individual : classSet) {
            oneOfSet.add(individual.toStringID());
        }
      }
      else if (exp.getClassExpressionType().equals(ClassExpressionType.OBJECT_INTERSECTION_OF)) {
        Set<OWLClass> classSet = ((OWLObjectIntersectionOf) exp).getClassesInSignature();
        for (OWLClass cls : classSet) {
            intersectionOfSet.add(cls.toStringID());
        }
      }
    } catch (Exception e) {}
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="addInfoAboutCollectionToComment">
  /**
   * Add information about oneOf, unionOf and intersectionOf to comment
   * 
   * @param type Information about type.
   * @param setOfURI This class is in collection.
   * @param commentStr1 1. constant to comment.
   * @param commentStr2 2. constant to comment.
   * @param commentStr3 3. constant to comment.
   */
  private void addInfoAboutCollectionToComment(AnnotType type, HashSet<String> setOfURI,
          String commentStr1, String commentStr2, String commentStr3) {
    if (setOfURI.size() > 1) {
      String comment = prepareCommentToAdding(type.getComment());
      comment += commentStr1;
      boolean first = true;
      for (String cls : setOfURI) {
        if (first) {
          first = false;
        } else {
          comment += commentStr2;
        }
        comment += getNameFromURI(cls);
      }
      comment += commentStr3;
      type.setComment(comment);
    }
  }
  // </editor-fold>
  
  // <editor-fold defaultstate="collapsed" desc="processUnionOfOneOfIntersectionOf">
  /**
   * Get axiom of class about unionOf, oneOf and intersectionOf elements and add it to comment.
   * 
   * @param ontClass OWL class
   * @param type Information about type
   * @param oModel Ontology model
   */
  private void processUnionOfOneOfIntersectionOf(OWLClass ontClass, AnnotType type, OWLOntology oModel) {
    HashSet<String> unionOfClasses = new HashSet<String>(); 
    for (OWLAxiom axiom : ontClass.getReferencingAxioms(oModel)) {
      if (axiom instanceof OWLEquivalentClassesAxiom) {
        try { // cast can throw exception, but should not (try is used just to be sure)
          OWLEquivalentClassesAxiom equivalentAxiom = (OWLEquivalentClassesAxiom) axiom;
          Set<OWLClassExpression> equivalentClasses = equivalentAxiom.getClassExpressions();
          // one of equivalent class is not this class, than bad axiom founded
          boolean classFound = false;
          for (OWLClassExpression exp : equivalentClasses) {
            if (exp.getClassExpressionType().equals(ClassExpressionType.OWL_CLASS)) {
              if (exp.asOWLClass().toStringID().equals(ontClass.toStringID())) {
                classFound = true;
              }
            }
          }
          if (!classFound) {
            continue;
          }
          // proces collection
          for (OWLClassExpression exp : equivalentClasses) {
            // unionOf
            HashSet<String> classes = processOWLClassExpression(oModel, exp);
            if (classes.contains(ontClass.toStringID())) { // axiom contains ontClass URI too
              classes.remove(ontClass.toStringID());
            }
            unionOfClasses.addAll(classes);
            // intersectionOf and oneOf
            HashSet<String> intersectionOfSet = new HashSet<String>();
            HashSet<String> oneOfSet = new HashSet<String>();
            processOWLClassExpressionIntersectionOfOneOf(exp, intersectionOfSet, oneOfSet);
            // add information of intersectionOf to comment
            addInfoAboutCollectionToComment(type, intersectionOfSet,
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INTERSECTION_OF_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INTERSECTION_OF_COMMENT_2),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.INTERSECTION_OF_COMMENT_3));
            // add information of oneOf to comment
            // OWL object is represented by AnnotType too (as well as OWL class)
            addInfoAboutCollectionToComment(type, oneOfSet,
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_1),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_2),
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_3));
          }
        } catch (Exception e) {}
      }
    }
    // add information to comments
    addInfoAboutCollectionToComment(type, unionOfClasses,
            TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_1),
            TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_2),
            TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.UNION_OF_COMMENT_3));
  }
  // </editor-fold>
  
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="processModelPhase2">
  /**
   * Processing of ontology model - phase 2:
   * - get properties and create attributes of types of annotations
   * - assign ancestors and primary ancestors to types of annotations
   * 
   * @param oModel Ontology model
   * @param oFactory Ontology factory
   * @param newTypes List with new (imported) types of annotations
   * @param newTypesMap Map with new (imported) types of annotations
   * @param newTypesMapInfo Information about newNewTypesMap
   * @param ontoAttrs List with attributes of unknown types of annotations
   * @param userGroup User group in which uploaded types will be shared
   * @return If error occurred, returns true, false otherwise
   */
  private boolean processModelPhase2(OWLOntology oModel, OWLDataFactory oFactory,
          ArrayList<AnnotType> newTypes, Map<String, AnnotType> newTypesMap,
          Map<String, AnnotTypeInfo> newTypesMapInfo, ArrayList<TypeAttrOnto> ontoAttrs,
          UserGroup userGroup) {
 
    HashMap<String, HashSet<String>> objectMap  = new HashMap<String, HashSet<String>>();
    HashMap<String, HashSet<String>> subjectMap = new HashMap<String, HashSet<String>>();
    HashMap<String, HashSet<String>> ancestorMap = new HashMap<String, HashSet<String>>();
    
    // <editor-fold defaultstate="collapsed" desc="rdf:Property note object and subject">
    for (OWLAnnotationProperty property : oModel.getAnnotationPropertiesInSignature()) {
      String prUri = property.toStringID();  // URI
      if (prUri.contains("rdf-schema#")) { // for example http://www.w3.org/2000/01/rdf-schema#comment, it is getting by another way
        continue;
      }
      
      // definition of subejct and object
      HashSet<String> objectSetClassURI = new HashSet<String>(); // range
      HashSet<String> subjectSetClassURI = new HashSet<String>(); // domain
      HashSet<String> ancestorSetClassURI = new HashSet<String>();
      Set<OWLAxiom> allAxioms = property.getReferencingAxioms(oModel);
      int anotherAxioms = processRdfPropertyAxioms(objectSetClassURI, subjectSetClassURI, ancestorSetClassURI, allAxioms);

      if (subjectSetClassURI.isEmpty() && objectSetClassURI.isEmpty() && anotherAxioms != 0) {
          continue;
      }
      
      objectMap.put(prUri, objectSetClassURI);
      subjectMap.put(prUri, subjectSetClassURI);
      ancestorMap.put(prUri, ancestorSetClassURI);
    }
    // </editor-fold>
    
    
    // <editor-fold defaultstate="collapsed" desc="get owl:ObjectProperty">
    // generate map of all properties
    HashSet<String> ObjectAndDataPropertiesMap = new HashSet<String>();
    for (OWLObjectProperty property : oModel.getObjectPropertiesInSignature()) {
        ObjectAndDataPropertiesMap.add(property.toStringID());
    }
    // process all properties
    for (OWLObjectProperty property : oModel.getObjectPropertiesInSignature()) {
      String prUri = property.toStringID();  // URI
      
      // set of ancestors
      Set<OWLObjectPropertyExpression> superProperties = property.getSuperProperties(oModel);
      
      // definition of subejct and object
      Set<OWLClassExpression> objectSetExpression = property.getRanges(oModel);
      Set<OWLClassExpression> subjectSetExpression = property.getDomains(oModel);
      
      // anonymous property (property.isAnonymous() don't work correctly), another detection of anonymous property
      if (objectSetExpression.isEmpty() && subjectSetExpression.isEmpty() && prUri.indexOf("genid") != -1) { // previous two function don't work correctly for anonymous properties
        Set<OWLAxiom> axioms = property.getReferencingAxioms(oModel);
        for (OWLAxiom axiom : axioms) {
          String axiomName = axiom.getAxiomType().getName();
          if (axiomName.equals("ObjectPropertyRange") &&
              axiom instanceof OWLObjectPropertyRangeAxiom) {
            OWLObjectPropertyRangeAxiom range = (OWLObjectPropertyRangeAxiom) axiom;
            objectSetExpression.add(range.getRange());
          }
          if (axiomName.equals("ObjectPropertyDomain") &&
              axiom instanceof OWLObjectPropertyDomainAxiom) {
            OWLObjectPropertyDomainAxiom domain = (OWLObjectPropertyDomainAxiom) axiom;
            subjectSetExpression.add(domain.getDomain());
          }
          if (axiomName.equals("SubObjectPropertyOf") &&
              axiom instanceof OWLSubObjectPropertyOfAxiom) {
            try { 
              OWLSubObjectPropertyOfAxiom subProperty = (OWLSubObjectPropertyOfAxiom) axiom;
              if (!subProperty.getSuperProperty().asOWLObjectProperty().toStringID().equals(prUri)) {
                superProperties.add(subProperty.getSuperProperty());
              }
            } catch (Exception e) {
              continue; // not Object Property
            }
          }
        }
      }
      
      Set<String> superPropertiesStringSet = new HashSet<String>();
      addSuperObjectPropertiesToSet(prUri, superProperties, superPropertiesStringSet);
      
      Set<String> inversePropertiesID = new HashSet<String>();
      // get object and subject from inverse properties
      processInverseProperty(oModel, property, objectSetExpression, subjectSetExpression, inversePropertiesID);
      
      // get list of objectClass and subjectClass
      HashSet<String> objectSetClassURI = new HashSet<String>();
      for (OWLClassExpression exp : objectSetExpression) {
          objectSetClassURI.addAll(processOWLClassExpression(oModel, exp));
      }
      HashSet<String> subjectSetClassURI = new HashSet<String>();
      for (OWLClassExpression exp : subjectSetExpression) {
          subjectSetClassURI.addAll(processOWLClassExpression(oModel, exp));
      }
      
      // add object and subject from annotation property (for rdf:proprety elements)
      boolean addObjectFromAnnotationProperty = objectSetClassURI.isEmpty();
      if (objectSetClassURI.size() == 1) {
        Iterator<String> it = objectSetClassURI.iterator();
        if (it.next().endsWith("rdf-schema#Literal")) {
          addObjectFromAnnotationProperty = true;
        }
      }
      boolean addSubjectFromAnnotationProperty = subjectSetClassURI.isEmpty();
      if (subjectSetClassURI.size() == 1) {
        Iterator<String> it = subjectSetClassURI.iterator();
        if (it.next().endsWith("rdf-schema#Literal")) {
          addSubjectFromAnnotationProperty = true;
        }
      }
      if (addObjectFromAnnotationProperty) {
        if (objectMap.containsKey(prUri)) {
          objectSetClassURI.addAll(objectMap.get(prUri));
        }
      }
      if (addSubjectFromAnnotationProperty) {
        if (subjectMap.containsKey(prUri)) {
          subjectSetClassURI.addAll(subjectMap.get(prUri));
        }
      }
      if (superPropertiesStringSet.isEmpty()) {
        if (ancestorMap.containsKey(prUri)) {
          superPropertiesStringSet.addAll(ancestorMap.get(prUri));
        }
      }
      
      String comment = getComments(oFactory, property.getAnnotations(oModel));
      comment = addSuperPropertiesToComment(prUri, comment, superPropertiesStringSet);
      
      PropertyReference propertyReference = new PropertyReference(property);
      processProperties(prUri, propertyReference, comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs, userGroup, superPropertiesStringSet, inversePropertiesID, oModel);
    }
    // </editor-fold>
    
    
    // <editor-fold defaultstate="collapsed" desc="DatatypeProperty">
    for (OWLDataProperty dataProperty : oModel.getDataPropertiesInSignature()) {
        ObjectAndDataPropertiesMap.add(dataProperty.toStringID());
    }
    for (OWLDataProperty dataProperty : oModel.getDataPropertiesInSignature()) {
      String prUri = dataProperty.toStringID();
      Set<OWLDataRange> rangeSet = dataProperty.getRanges(oModel);
      Set<OWLClassExpression> subjectSet = dataProperty.getDomains(oModel);
      
      // get URIs
      HashSet<String> subjectSetClassURI = new HashSet<String>();
      for (OWLClassExpression exp : subjectSet) {
          subjectSetClassURI.addAll(processOWLClassExpression(oModel, exp));
      }
      HashSet<String> objectSetClassURI = new HashSet<String>();
      for (OWLDataRange range : rangeSet) {
        if (range instanceof OWLDatatypeImpl) {
          OWLDatatypeImpl concreteRange = (OWLDatatypeImpl) range;
          objectSetClassURI.add(concreteRange.getIRI().toString());
        }
      }
      
      Set<OWLDataPropertyExpression> superProperties = dataProperty.getSuperProperties(oModel);
      
      //get comments
      Set<String> superPropertiesStringSet = new HashSet<String>();
      addSuperDataPropertiesToSet(prUri, superProperties, superPropertiesStringSet);
      
      // add object and subject from annotation property (for rdf:proprety elements)
      boolean addObjectFromAnnotationProperty = objectSetClassURI.isEmpty();
      if (objectSetClassURI.size() == 1) {
        Iterator<String> it = objectSetClassURI.iterator();
        if (it.next().endsWith("rdf-schema#Literal")) {
          addObjectFromAnnotationProperty = true;
        }
      }
      boolean addSubjectFromAnnotationProperty = subjectSetClassURI.isEmpty();
      if (subjectSetClassURI.size() == 1) {
        Iterator<String> it = subjectSetClassURI.iterator();
        if (it.next().endsWith("rdf-schema#Literal")) {
          addSubjectFromAnnotationProperty = true;
        }
      }
      if (addObjectFromAnnotationProperty) {
        if (objectMap.containsKey(prUri)) {
          objectSetClassURI.addAll(objectMap.get(prUri));
        }
      }
      if (addSubjectFromAnnotationProperty) {
        if (subjectMap.containsKey(prUri)) {
          subjectSetClassURI.addAll(subjectMap.get(prUri));
        }
      }
      if (superPropertiesStringSet.isEmpty()) {
        if (ancestorMap.containsKey(prUri)) {
          superPropertiesStringSet.addAll(ancestorMap.get(prUri));
        }
      }
      
      String comment = getComments(oFactory, dataProperty.getAnnotations(oModel));
      comment = addSuperPropertiesToComment(prUri, comment, superPropertiesStringSet);
      
      // inverse property is not allowed in datatypeProeprty
      processProperties(prUri, new PropertyReference(dataProperty), comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs, userGroup, superPropertiesStringSet, new HashSet<String>(), oModel);
    }
        
    // </editor-fold>
    
    
    // <editor-fold defaultstate="collapsed" desc="get rdf:Property">
    for (OWLAnnotationProperty property : oModel.getAnnotationPropertiesInSignature()) {
      String prUri = property.toStringID();  // URI
      if (prUri.contains("rdf-schema#")) { // for example http://www.w3.org/2000/01/rdf-schema#comment, it is getting by another way
        continue;
      }     
      
      // definition of subejct and object

      HashSet<String> objectSetClassURI = new HashSet<String>(); // range
      HashSet<String> subjectSetClassURI = new HashSet<String>(); // domain
      HashSet<String> ancestorSetClassURI = new HashSet<String>();
      Set<OWLAxiom> allAxioms = property.getReferencingAxioms(oModel);
      int anotherAxioms = processRdfPropertyAxioms(objectSetClassURI, subjectSetClassURI, ancestorSetClassURI, allAxioms);

      //ObjectPropertiesMap.get(prUri).getRanges(oModel).toString();
      if (ObjectAndDataPropertiesMap.contains(prUri)) { // property is owl:ObjectProperty, not rdf:Property
        continue;
      }
      if (subjectSetClassURI.isEmpty() && objectSetClassURI.isEmpty() && anotherAxioms != 0) {
          continue;
      }
      
      String comment = getComments(oFactory, property.getAnnotations(oModel));
      comment = addSuperPropertiesToComment(property.toStringID(), comment, ancestorSetClassURI);
      
      // inverse property can't be defined in rdf:Property
      processProperties(prUri, new PropertyReference(), comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs, userGroup, ancestorSetClassURI, new HashSet<String>(), oModel);
    }
    
    // </editor-fold>
    
    // Set of annotation property URIs
    Set<String> annotationPropertyURIs = new HashSet<String>();
    Set<OWLAnnotationProperty> annotationProperty = oModel.getAnnotationPropertiesInSignature();
    for (OWLAnnotationProperty anotProp : annotationProperty) {
      String anotPropURI = anotProp.toStringID();
      annotationPropertyURIs.add(anotPropURI);
      // <editor-fold defaultstate="collapsed" desc="process comment in annonymous class">
      // attempt of avoid of The OWL API bug
      /*if (anotPropURI.equalsIgnoreCase("http://www.w3.org/2000/01/rdf-schema#comment")) {
        for (OWLAxiom ax : anotProp.getReferencingAxioms(oModel)) {
          if (ax.getAxiomType().toString().equals("AnnotationAssertion")) {
            try {
              OWLAnnotationAssertionAxiom anAx = (OWLAnnotationAssertionAxiom) ax;
              String subject = anAx.getSubject().toString();
              // The OWL API bug (URI of subject is little diferent than URI of anonymous class)
              subject = "http://org.semanticweb.owlapi/error#Error" + subject.substring(7);
              if (newTypesMapInfo.containsKey(subject)) {
                AnnotTypeInfo info = newTypesMapInfo.get(subject);
                if (info.wasAnonymous) {
                  OWLAnnotationValue val = anAx.getValue();
                  if (val instanceof OWLLiteral) {
                    AnnotType typeForComment = newTypesMap.get(info.correctedUri);
                    String comment = typeForComment.getComment();
                    comment = prepareCommentToAdding(comment);
                    comment += ((OWLLiteral) val).getLiteral();
                    typeForComment.setComment(comment);
                  }
                }
              };
              anAx.getSubject().toString();
            } catch (Exception e) {}
            ax.getClassesInSignature();
          }
        }
      }*/
      // </editor-fold>
    }
      
    // create attributes in all classes
    for (OWLClass ontClass : oModel.getClassesInSignature()) { // for all classes
      String uri = ontClass.toStringID();  // get class uri
      AnnotTypeInfo info = newTypesMapInfo.get(uri);
      if (info == null) {
        continue;
      }
      uri = info.correctedUri; // rename uri to acceptable format, if its class is annonymous
      String name = getNameFromURI(uri);  // get class name
      AnnotType type = newTypesMap.get(uri);  // get type created for this class
      if (type == null) {
        errorMessage = MessageProvider.getMessage("unknownOntologyError");
        return true;
      }
      
      // <editor-fold defaultstate="collapsed" desc="process complementOf classes">
      for (OWLClassExpression clsExp : ontClass.getEquivalentClasses(oModel)) {
        if (clsExp.toString().startsWith("ObjectComplementOf")) {
          try {
            if (!clsExp.getComplementNNF().asOWLClass().isAnonymous()) {
              String newComment = TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.COMPLEMENT_OF_COMMENT_1) + 
                      getNameFromURI(clsExp.getComplementNNF().asOWLClass().toStringID()) + 
                      TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.COMPLEMENT_OF_COMMENT_2);
              String comment = prepareCommentToAdding(type.getComment());
              type.setComment(comment + newComment);
            }
          } catch (Exception e) {
            // complement is not Class
          }
        }
        clsExp.toString();
      }
      // </editor-fold>
      
      // <editor-fold defaultstate="collapsed" desc="process superclasses">
      LinkedList<String> superClasses = processSuperClass(oModel, ontClass);
      addSuperClassesToAnnotType(newTypes, newTypesMap, userGroup, type, superClasses);
      
      // assign primary ancestor
      if (!type.getAncestorTypes().isEmpty()) {
        AnnotType anc = type.getAncestorTypes().get(0);
        type.setAncestorType(anc);
      }
      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="process superclasses to individuals">
      superClasses.addFirst(uri);
      Set<OWLIndividual> classIndividuals = ontClass.getIndividuals(oModel);
      for (OWLIndividual individual : classIndividuals) {
        AnnotTypeInfo individualInfo = newTypesMapInfo.get(individual.toStringID());
        if (individualInfo == null) { // fatal error
          continue;
        }
        AnnotType individualType = newTypesMap.get(individualInfo.correctedUri); // correctedUri is renamed, if individual is annonymous
        if (individualType == null) {
          errorMessage = MessageProvider.getMessage("unknownOntologyError");
          return true;
        }
        addSuperClassesToAnnotType(newTypes, newTypesMap, userGroup, individualType, superClasses);
        // assign primary ancestor
        if (!individualType.getAncestorTypes().isEmpty()) {
          AnnotType anc = individualType.getAncestorTypes().get(0);
          individualType.setAncestorType(anc);
        }
      }
      // </editor-fold>
      
      
      // <editor-fold defaultstate="collapsed" desc="process disjoint classes">
      Set<OWLClassExpression> disjointClasses = ontClass.getDisjointClasses(oModel);
      HashSet<String> disjointClassesURI = new HashSet<String>();
      for (OWLClassExpression exp : disjointClasses) {
        disjointClassesURI.addAll(processOWLClassExpression(oModel, exp));
      }
      for (String disjointClass : disjointClassesURI) {
        BooleanHolder isAnonymous = new BooleanHolder();
        renameIfAnonymous(disjointClass, isAnonymous);
        if (isAnonymous.value) { // comment or name of anonymous class will be confusing
          continue;
        }
        String newComment = TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.DISJOINT_WITH_COMMENT_1) + getNameFromURI(disjointClass) + 
                TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.DISJOINT_WITH_COMMENT_2);
        String comment = prepareCommentToAdding(type.getComment());
        type.setComment(comment + newComment);
        if (info.wasAnonymous) {
          info.disjointWithSet.add(disjointClass);
        }
      }
      // </editor-fold>
      
      processUnionOfOneOfIntersectionOf(ontClass, type, oModel);
      
      // get properties
      for (OWLAnnotation statement : ontClass.getAnnotations(oModel)) {
        // get informations about object
        OWLAnnotationValue object = statement.getValue();
        String objUri;
        String objString;
        OWLAnnotationProperty property = statement.getProperty();
        
        // RDFS isDefinedBy
        if (property.equals(oFactory.getRDFSIsDefinedBy())) {
          // Not usable (object is only URI which can't be used separately)
          // IsDefinedBy value is mostly in Class URI too
          continue;
        }
         
        // <editor-fold defaultstate="collapsed" desc="Literal (comment and label)">
        if (object instanceof OWLLiteral) {
          OWLLiteral objLiteral = (OWLLiteral) object;
          
          // RDFS Comment
          if (property.equals(oFactory.getRDFSComment())) {
            objString = objLiteral.getLiteral();
            String comment = prepareCommentToAdding(type.getComment());
            type.setComment(comment + objString.trim());
            continue;
          }
          
          // RDFS Label
          if (property.equals(oFactory.getRDFSLabel())) {
            objString = objLiteral.getLiteral();
            String comment = prepareCommentToAdding(type.getComment());
            type.setComment(comment + 
                    TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.LABEL_COMMENT_1) + objString.trim()
                  + TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.LABEL_COMMENT_2));
            continue;
          }
          
          // test datatype in class
          if (annotationPropertyURIs.contains(property.toStringID())) {
              String objLitS = objLiteral.toString();
              int index = objLitS.lastIndexOf(":");
              if (index != -1) {
                BooleanHolder isRequired = new BooleanHolder();
                String simpleType = getStringTypeFromOntologyURI("XMLSchema#" + objLitS.substring(index+1), false, isRequired);
                if (!simpleType.isEmpty()) {
                    String newPrUri = property.toStringID();
                    String prName = getNameFromURI(newPrUri);
                    AnnotTypeAttr attr = new AnnotTypeAttr(type, prName, simpleType, isRequired.value);
                    attr.setUriInOntology(newPrUri);
                    // WARNING: Value (variable objString) discarded - there is no place for it!
                    Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
                    boolean aFound = false;
                    while (atrIt.hasNext()) {  // check whether is not already presented
                      AnnotTypeAttr aTA = atrIt.next();
                      if (aTA.getName().equals(prName)) {
                        aFound = true;
                      }
                    }
                    if (!aFound) {  // if it is not already presented
                      type.getAttributes().add(attr);
                    }
                    continue;
                }
              }
          }
        }
        // </editor-fold>
        
        // <editor-fold defaultstate="collapsed" desc="object property in class">
        objUri = object.toString();
        String prUri = property.toStringID();
        String prName = getNameFromURI(prUri);
        if (prName.isEmpty()) {
            errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + "<br/>";
            continue;
        }
        // property
        if (prUri.indexOf("http://www.w3.org/2000/01/rdf-schema") == -1) {
          AnnotType pType = newTypesMap.get(objUri);
          if (pType == null && objUri.startsWith("\"") && objUri.endsWith("\"") && objUri.length() > 2) {
              String nUri = objUri.substring(1, objUri.length() - 1);
              pType = newTypesMap.get(nUri);
          }
          if (pType != null) {  // if type was found
            AnnotTypeAttr attr = new AnnotTypeAttr(type, prName, pType, false);
            attr.setUriInOntology(prUri);
            Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
            boolean aFound = false;
            while (atrIt.hasNext()) {  // check whether is not already presented
              AnnotTypeAttr aTA = atrIt.next();
              if (aTA.getName().equals(attr.getName())) {
                aFound = true;
                break;
              }
            }
            if (!aFound) {  // if attribute is not presented, add it
              type.getAttributes().add(attr);
            }
          } else {
            errorMessage = errorMessage + MessageProvider.getMessage("badPropertyFound") + "<br/>";
            continue;
          }
        } else { // rdf element
          if (prName.equalsIgnoreCase("seeAlso")) {
            if (!objUri.isEmpty()) {
              String comment = prepareCommentToAdding(type.getComment());
              type.setComment(comment + 
                      TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SEE_ALSO_COMMENT) + objUri.trim());
            }
          }
        }
        // </editor-fold>
        
      } // end get properties
    } // end all classes
    
    
    // <editor-fold defaultstate="collapsed" desc="restrictions">
    try {
      OWLOntologyWalker walker = new OWLOntologyWalker(Collections.singleton(oModel));
      OWLVisitorForRestrictionData visitor = new OWLVisitorForRestrictionData(walker);
      // Now ask the walker to walk over the ontology structure
      OWLOntologyWalkerVisitor baseVisitor = (OWLOntologyWalkerVisitor) visitor;
      walker.walkStructure(baseVisitor);
      // atributes, that was associated to anonymous class becauseof restriction in this class
      ArrayList<TypeAttrOnto> ontoAttrsDeleted = new ArrayList<TypeAttrOnto>();


      // <editor-fold defaultstate="collapsed" desc="minCardinality">
      Set<OWLVisitorForRestrictionData.CardinalityData> minCardinalityData = visitor.getMinCardinalityData();
      for (OWLVisitorForRestrictionData.CardinalityData data : minCardinalityData) {
        if (data.cardinality == 0) { // this is default behaviour, no need to do some changes
          continue;
        }

        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, how many object property has
          int counter = 0;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              counter++;
            }
          }
          if (counter == 0){ // add property
            counter = addPropertyInAnonymousClassFromCardinalityRestriction(ontoAttrs,
                  ontoAttrsDeleted, data,
                  typeInfo.originUri, newTypesMap, newTypesMapInfo, oModel, userGroup);
          }
          // set information to property
          atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              String comment = atr.getComment();
              if (comment == null) {
                comment = "";
              }
              if (!comment.isEmpty()) {
                comment = prepareCommentToAdding(comment);;
              }
              // property has one object, AnnotTypeAttr has URI in format "property"
              if (counter == 1) {
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MIN_CARDINALITY_ONE_OBJECT_COMMENT_1) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MIN_CARDINALITY_ONE_OBJECT_COMMENT_2);
                atr.setRequired(true);
              } else { // property has more objects, AnnotTypeAttr has URI in format "property.object"
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MIN_CARDINALITY_MORE_OBJECT_COMMENT_1) + getNameFromURI(data.propertyURI)
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MIN_CARDINALITY_MORE_OBJECT_COMMENT_2) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MIN_CARDINALITY_MORE_OBJECT_COMMENT_3);
              }
              atr.setComment(comment);
            }
          }
        }
      }

      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="maxCardinality">
      Set<OWLVisitorForRestrictionData.CardinalityData> maxCardinalityData = visitor.getMaxCardinalityData();
      for (OWLVisitorForRestrictionData.CardinalityData data : maxCardinalityData) {
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, how many object property has
          int counter = 0;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              counter++;
            }
          }
          if (counter == 0){ // add property
            counter = addPropertyInAnonymousClassFromCardinalityRestriction(ontoAttrs,
                  ontoAttrsDeleted, data,
                  typeInfo.originUri, newTypesMap, newTypesMapInfo, oModel, userGroup);
          }
          // set information to property
          atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              if (data.cardinality == 0) { // property is useless
                atrIt.remove();
                continue;
              }
              String comment = atr.getComment();
              comment = prepareCommentToAdding(comment);
              // property has one object, AnnotTypeAttr has URI in format "property"
              if (counter == 1) {
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MAX_CARDINALITY_ONE_OBJECT_COMMENT_1) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MAX_CARDINALITY_ONE_OBJECT_COMMENT_2);
              } else { // property has more objects, AnnotTypeAttr has URI in format "property.object"
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MAX_CARDINALITY_MORE_OBJECT_COMMENT_1) + getNameFromURI(data.propertyURI)
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MAX_CARDINALITY_MORE_OBJECT_COMMENT_2) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.MAX_CARDINALITY_MORE_OBJECT_COMMENT_3);
              }
              atr.setComment(comment);
            }
          }
        }
      }

      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="exactCardinality">
      Set<OWLVisitorForRestrictionData.CardinalityData> exactCardinalityData = visitor.getCardinalityData();
      for (OWLVisitorForRestrictionData.CardinalityData data : exactCardinalityData) {
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, how many object property has
          int counter = 0;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              counter++;
            }
          }
          if (counter == 0){ // add property
            counter = addPropertyInAnonymousClassFromCardinalityRestriction(ontoAttrs,
                  ontoAttrsDeleted, data,
                  typeInfo.originUri, newTypesMap, newTypesMapInfo, oModel, userGroup);
          }
          // set information to property
          atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              if (data.cardinality == 0) { // property is useless
                atrIt.remove();
                continue;
              }
              String comment = atr.getComment();
              comment = prepareCommentToAdding(comment);
              // property has one object, AnnotTypeAttr has URI in format "property"
              if (counter == 1) {
                atr.setRequired(true);
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.EXACT_CARDINALITY_ONE_OBJECT_COMMENT_1) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.EXACT_CARDINALITY_ONE_OBJECT_COMMENT_2);
              } else { // property has more objects, AnnotTypeAttr has URI in format "property.object"
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.EXACT_CARDINALITY_MORE_OBJECT_COMMENT_1) + getNameFromURI(data.propertyURI)
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.EXACT_CARDINALITY_MORE_OBJECT_COMMENT_2) + data.cardinality
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.EXACT_CARDINALITY_MORE_OBJECT_COMMENT_3);
              }
              atr.setComment(comment);
            }
          }
        }
      }

      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="someValuesFrom">
      Set<OWLVisitorForRestrictionData.ValueData> someValuesFromData = visitor.getSomeValuesFromData();
      for (OWLVisitorForRestrictionData.ValueData data : someValuesFromData) {
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, how many object property has
          int counter = 0;
          boolean onePropertyFromManyFound = false; // if more AnnotTypeAttr from properties are presented, one may have object from restriction
          AnnotTypeAttr foundedProperty = null;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              counter++;
              String propertyObjectUri = atr.getAttributeType().getUriInOntology(); // uri of object of property
              if (data.valueURI.equals(propertyObjectUri)) {
                onePropertyFromManyFound = true;
                foundedProperty = atr;
              }
            }
          }
          if (counter == 0) {
            if (!typeInfo.wasAnonymous) { // named class (unexcepted behaviour)
              continue;
            } else {
              // try to get object from ontoAttrs
              ArrayList<TypeAttrOnto> ontoAtrList = getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
              HashSet<String> subjectSetClassURI = new HashSet<String>();
              subjectSetClassURI.add(typeInfo.originUri);
              if (ontoAtrList != null) {
                for (TypeAttrOnto oAtr : ontoAtrList) {
                  HashSet<String> objectSetClassURI = new HashSet<String>();
                  if (oAtr.getAttributeType() != null) {
                    objectSetClassURI.add(oAtr.getAttributeType().getUriInOntology());
                  } else {
                    objectSetClassURI.add(data.valueURI);
                  }
                  String comment = oAtr.getComment();
                  processProperties(oAtr.getUriInOntology(), new PropertyReference(),
                    (comment == null ? "" : comment), subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
                    userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
                }
              } else { // unknown object, we set object from someValue-restriction (best information, that we have)
                HashSet<String> objectSetClassURI = new HashSet<String>();
                objectSetClassURI.add(data.valueURI);
                processProperties(data.propertyURI, new PropertyReference(),
                  "", subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
                  userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
                continue; // information of this restriction is not nessesery to add to comment
              }
            }
          }
          // correcting of properties
          atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              String comment = atr.getComment();
              comment = prepareCommentToAdding(comment);
              // property has one object, AnnotTypeAttr has URI in format "property"
              if (counter == 1) {
                comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_ONE_OBJECT_COMMENT_1) + getNameFromURI(data.valueURI)
                        +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_ONE_OBJECT_COMMENT_2);
                atr.setRequired(true);
              } else { // property has more objects, AnnotTypeAttr has URI in format "property.object"
                if (!onePropertyFromManyFound) {
                  comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_1) + getNameFromURI(data.propertyURI)
                          +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_2) + getNameFromURI(data.valueURI)
                          +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_3);
                } else {
                  if (atr == foundedProperty) {
                    comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_1) + getNameFromURI(data.propertyURI)
                            +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_2) + getNameFromURI(data.valueURI)
                            +  TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.SOME_VALUES_FROM_MORE_OBJECT_COMMENT_3);
                    atr.setRequired(true);
                  }
                }
              }
              atr.setComment(comment);
            }
          }
        }
      }

      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="allValuesFrom">
      Set<OWLVisitorForRestrictionData.ValueData> allValuesFromData = visitor.getAllValuesFromData();
      for (OWLVisitorForRestrictionData.ValueData data : allValuesFromData) {
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, if object has property
          boolean propertyFound = false;
          AnnotTypeAttr annotTypeAttr = null;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              // remove all AnnotTypeAttr, except first one
              if (propertyFound) {
                atrIt.remove();
              } else {
                propertyFound = true;
                annotTypeAttr = atr;
              }
            }
          }
          if (propertyFound) {
            // find new attributeType
            AnnotType attributeType = newTypesMap.get(data.valueURI);
            if (attributeType == null) { // bad constraints found
              continue;
            }
            // set information to property
            annotTypeAttr.setUriInOntology(data.propertyURI);
            annotTypeAttr.setName(getNameFromURI(data.propertyURI));
            annotTypeAttr.setAttributeType(attributeType);
            annotTypeAttr.setSimpleType(null);
          } else { // create atribute
              ArrayList<TypeAttrOnto> ontoAtrList = getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
              HashSet<String> subjectSetClassURI = new HashSet<String>();
              subjectSetClassURI.add(typeInfo.originUri);
              HashSet<String> objectSetClassURI = new HashSet<String>();
              objectSetClassURI.add(data.valueURI);
              String comment = (ontoAtrList.isEmpty() ? "" : ontoAtrList.iterator().next().getComment());
              processProperties(data.propertyURI, new PropertyReference(),
                  comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
                  userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
          }
        }
      }
      // </editor-fold>

      // <editor-fold defaultstate="collapsed" desc="hasValue">
      Set<OWLVisitorForRestrictionData.HasValueData> hasValueData = visitor.getHasValueData();
      for (OWLVisitorForRestrictionData.HasValueData data : hasValueData) {
        if (data.individual.isAnonymous()) { // any object can be here
          continue;
        }
        AnnotTypeInfo infoType = newTypesMapInfo.get(data.classURI);
        if (infoType == null) {
          continue;
        }
        if (infoType.wasObject) { // object should be instance of class, not instance of another object
          continue;
        }
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, if object has property
          boolean propertyFound = false;
          AnnotTypeAttr annotTypeAttr = null;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI)) {
              // remove all AnnotTypeAttr, except first one
              if (propertyFound) {
                atrIt.remove();
              } else {
                propertyFound = true;
                annotTypeAttr = atr;
              }
            }
          }
          // find object
          AnnotType objectType = newTypesMap.get(data.valueURI);
          // <editor-fold defaultstate="collapsed" desc="confirm finding object">
          boolean selectedObjectFound = false;
          if (objectType != null) {
            AnnotTypeInfo objectInfo = newTypesMapInfo.get(data.valueURI);
            if (objectInfo == null) { // bad restriction in ontology error
              errorMessage += MessageProvider.getMessage("unknownOntologyError") + "<br/>";
              continue;
            }
            selectedObjectFound = true;
          }
          if (!selectedObjectFound) { // if object wasn't found, create it
            // create AnnotType from object
            createAnnotTypeFromIndividual(oModel, oFactory, newTypes,
                  newTypesMap, newTypesMapInfo, userGroup, data.individual, type.getName(), 0);
            // specification of ancestors
            AnnotType individualType = newTypesMap.get(data.valueURI); // created in last command
            if (individualType == null) {
              errorMessage = MessageProvider.getMessage("unknownOntologyError");
              return true;
            }
            LinkedList<String> superClasses = processSuperClass(oModel, infoType.owlClass);
            superClasses.addFirst(infoType.correctedUri);
            addSuperClassesToAnnotType(newTypes, newTypesMap, userGroup, individualType, superClasses);
            // assign primary ancestor
            if (!type.getAncestorTypes().isEmpty()) {
              AnnotType anc = individualType.getAncestorTypes().get(0);
              individualType.setAncestorType(anc);
            }
            objectType = individualType;
          }
          // </editor-fold>
          if (propertyFound) {
            // set information to property
            annotTypeAttr.setUriInOntology(data.propertyURI);
            annotTypeAttr.setName(getNameFromURI(data.propertyURI));
            annotTypeAttr.setAttributeType(objectType);
            annotTypeAttr.setSimpleType(null);
          } else { // create atribut
              ArrayList<TypeAttrOnto> ontoAtrList = getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
              HashSet<String> subjectSetClassURI = new HashSet<String>();
              subjectSetClassURI.add(typeInfo.originUri);
              HashSet<String> objectSetClassURI = new HashSet<String>();
              objectSetClassURI.add(data.valueURI);
              String comment = (ontoAtrList.isEmpty() ? "" : ontoAtrList.iterator().next().getComment());
              processProperties(data.propertyURI, new PropertyReference(),
                  comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
                  userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
          }
        }
      }
      // </editor-fold>
    
      // <editor-fold defaultstate="collapsed" desc="hasSelf">
      Set<OWLVisitorForRestrictionData.ValueData> hasSelfData = visitor.getHasSelfData();
      for (OWLVisitorForRestrictionData.ValueData data : hasSelfData) {
        AnnotTypeInfo infoType = newTypesMapInfo.get(data.classURI);
        if (infoType == null) {
          continue;
        }
        if (infoType.wasObject) { // object should be instance of class, not instance of another object
          continue;
        }
        AnnotTypeInfo typeInfo = newTypesMapInfo.get(data.classURI);
        if (typeInfo == null) {
          continue;
        }
        AnnotType type = newTypesMap.get(typeInfo.correctedUri);
        if (type != null) { // type was found
          // determinate, if object has property
          boolean propertyFound = false;
          AnnotTypeAttr annotTypeAttr = null;
          Iterator<AnnotTypeAttr> atrIt = type.getAttributes().iterator();
          while (atrIt.hasNext()) {  // check whether is not already presented
            AnnotTypeAttr atr = atrIt.next();
            if (atr.getUriInOntology().startsWith(data.propertyURI + ".") ||
                atr.getUriInOntology().equalsIgnoreCase(data.propertyURI) ||
                atr.getName().equalsIgnoreCase(getNameFromURI(data.propertyURI))) {
              // remove all AnnotTypeAttr, except first one
              if (propertyFound) {
                atrIt.remove();
              } else {
                propertyFound = true;
                annotTypeAttr = atr;
              }
            }
          }
          if (propertyFound) {
            // set information to property (set specific object)
            getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
            annotTypeAttr.setAttributeType(type);
            annotTypeAttr.setSimpleType(null);
            String comment = annotTypeAttr.getComment();
            comment = prepareCommentToAdding(comment);
            comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.HAS_SELF_COMMENT);
            annotTypeAttr.setComment(comment);
          } else { // create atribut
              ArrayList<TypeAttrOnto> ontoAtrList = getOntoPropertyMayMove(data.propertyURI, ontoAttrs, ontoAttrsDeleted);
              HashSet<String> subjectSetClassURI = new HashSet<String>();
              subjectSetClassURI.add(typeInfo.originUri);
              HashSet<String> objectSetClassURI = new HashSet<String>();
              objectSetClassURI.add(typeInfo.originUri);
              String comment = (ontoAtrList.isEmpty() ? "" : ontoAtrList.iterator().next().getComment());
              comment = prepareCommentToAdding(comment);
              comment += TextsFromOWLConstants.getOWLString(lNum,TextsFromOWLConstants.HAS_SELF_COMMENT);
              processProperties(data.propertyURI, new PropertyReference(),
                  comment, subjectSetClassURI, objectSetClassURI, newTypesMap, newTypesMapInfo, ontoAttrs,
                  userGroup, new HashSet<String>(), new HashSet<String>(), oModel);
          }
        }
      }
      // </editor-fold>
    } catch (Exception e) {  }
    // </editor-fold>

    
    // <editor-fold defaultstate="collapsed" desc="create name for anonymous class">
    // create name for anonymous class
    for (OWLClass ontClass : oModel.getClassesInSignature()) { // for all classes
      String uri = ontClass.toStringID();  // get class uri
      AnnotTypeInfo info = newTypesMapInfo.get(uri);
      if (info == null) {
        continue;
      }
      if (!info.wasAnonymous) {
        continue;
      }
      uri = info.correctedUri; // rename uri to acceptable format, if its class is annonymous
      String name = getNameFromURI(uri);  // get class name
      AnnotType type = newTypesMap.get(uri);  // get type created for this class
      if (type == null) {
        errorMessage = MessageProvider.getMessage("unknownOntologyError");
        return true;
      }
      String newURI = getNewNameForAnonymousClass(info, type);
      String newName = getNameFromURI(newURI);
      type.setUriInOntology(newURI);
      type.setName(newName);
      newTypesMap.remove(uri);
      newTypesMap.put(newURI, type);
    }
    // </editor-fold>
    
    
    return false;
  }  // processModelPhase2()

  // </editor-fold>
  
  
  
  // <editor-fold defaultstate="collapsed" desc="btnUploadAction">
  /**
   * Action listener for upload button
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnUploadAction() {
    
    ontologyUploaded = true;
    
    errorMessage = "";
    successMessage = "";
    lNum = Localisation.LANGUAGE_CZE;

    if (uGroup.isEmpty()) {
      errorMessage = MessageProvider.getMessage("groupMustBeSet");
      return null;
    }
    // query database for user group
    Object[] params = new Object[2];  // parameters for database query
    params[0] = "name";
    params[1] = uGroup;
    List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findByName", params);
    UserGroup userGroup = null;
    if (gList != null && !gList.isEmpty()) {  // if group was found
      userGroup = (UserGroup) gList.get(0);
    } else {
      errorMessage = MessageProvider.getMessage("unknownGroup");
      return null;
    }

    // Informations about uploaded file
    // String fileType = uploadedFile.getContentType();
    // String fileNameStr = uploadedFile.getName();
    // Long fileSize = uploadedFile.getSize();  // bytes

    if (uploadedFile == null) {
      errorMessage = MessageProvider.getMessage("uploadingError");
      return null;
    }
    
    // Create writer with file data
    StringWriter fWriter = new StringWriter();
    try {
      IOUtils.copy(uploadedFile.getInputStream(), fWriter);
    } catch (IOException ex) {
      errorMessage = MessageProvider.getMessage("uploadingError");
      return null;
    }

    // Create input streams with file data
    InputStream is = null;
    try {
      is = new ByteArrayInputStream(fWriter.toString().getBytes("UTF-8")); 
    } catch (UnsupportedEncodingException ex) {
      errorMessage = MessageProvider.getMessage("uploadingError");
      return null;
    }

        // Create ontology model
    OWLOntologyManager oManager = OWLManager.createOWLOntologyManager();
    OWLDataFactory oFactory = OWLManager.getOWLDataFactory();
    OWLOntology oModel;
    try {
        oModel = oManager.loadOntologyFromOntologyDocument(is);
    } catch (OWLOntologyCreationException ex) {
      errorMessage = errorMessage + MessageProvider.getMessage("unknownOntologyError") + "<br/>";
      return null;
    }
    
    if (importLang != null && Localisation.LANGUAGE_CODES.contains(importLang)) {
      lNum = Localisation.LANGUAGE_CODES.indexOf(importLang);
    } else if (importLang != null && !importLang.isEmpty()) {
      errorMessage = errorMessage + MessageProvider.getMessage("unknownImportLanguage") + "<br/>";
      return null;
    }
    
    // load imported models - The OWL API do it automatically in contrast to JENA

    // list of new types
    ArrayList<AnnotType> newTypes = new ArrayList<AnnotType>();

    // map of new types
    Map<String, AnnotType> newTypesMap = new HashMap<String, AnnotType>();

    // list with attributes of unknown types of annotations
    ArrayList<TypeAttrOnto> ontoAttrs = new ArrayList<TypeAttrOnto>();

    // list with helper information to AnnotType
    Map<String, AnnotTypeInfo> newTypesMapInfo = new HashMap<String, AnnotTypeInfo>();
    
    // get classes and create types of annotations
    if (processModelPhase1(oModel, oFactory, newTypes, newTypesMap, userGroup, newTypesMapInfo)) {
      return null;  // error occurred
    }

    // get properties, create attributes of types of annotations and assign
    // ancestors and primary ancestors to types of annotations
    if (processModelPhase2(oModel, oFactory, newTypes, newTypesMap, newTypesMapInfo, ontoAttrs, userGroup)) {
      return null;  // error occurred
    }
    
    // generate URIs
    for (Iterator<AnnotType> ntIt = newTypes.iterator(); ntIt.hasNext();) {
      AnnotType type = ntIt.next();
      String uri = type.getGeneratedURI();
      type.setUri(uri);
    }
    
    // types of annotations to update
    List<AnnotType> tToUpdate = new ArrayList<AnnotType>();  // old types to update

    // check whether some type is not exists in database
    boolean duplicitTypeFound = false;
    for (Iterator<AnnotType> ntIt = newTypes.iterator(); ntIt.hasNext();) {
      AnnotType type = ntIt.next();
      params[0] = "uri";
      params[1] = type.getUri();
      List tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
      if (tList != null && !tList.isEmpty()) {  // if type was found
        AnnotType typeInDB = (AnnotType) tList.get(0);
        if (iMethod == METHOD_0_ERROR) {
          errorMessage = errorMessage + MessageProvider.getMessage("typeAlreadyExists1") 
                       + type.getUri() + MessageProvider.getMessage("typeAlreadyExists2") + "<br/>";
        } else if (iMethod == METHOD_1_USE) {  // method 1 (use old one)
          for (Iterator<AnnotType> ntIt2 = newTypes.iterator(); ntIt2.hasNext();) {  // replace in others
            AnnotType t2 = ntIt2.next();
            if (t2.getAncestorType() != null && t2.getAncestorType().getUri().equals(type.getUri())) {
              t2.setAncestorType(typeInDB);  // replace ancestor
            }
            List<AnnotType> nAnc = new ArrayList<AnnotType>();  // new list
            for (Iterator t2AIt = t2.getAncestorTypes().iterator(); t2AIt.hasNext();) {
              AnnotType t2A = (AnnotType) t2AIt.next();
              if (t2A.getUri() != null && t2A.getUri().equals(type.getUri())) {
                nAnc.add(typeInDB);
              } else {
                nAnc.add(t2A);
              }
            }
            t2.setAncestorTypes(nAnc);  // replace list of ancestors
            for (Iterator t2AtIt = t2.getAttributes().iterator(); t2AtIt.hasNext();) {
              AnnotTypeAttr t2At = (AnnotTypeAttr)t2AtIt.next();
              if (t2At.getAttributeType() != null && t2At.getAttributeType().getUri().equals(type.getUri())) {
                t2At.setAttributeType(typeInDB);
              }
            }
          }  // replace in others
          ntIt.remove();  // remove type (old will be used)
        } else if (iMethod == METHOD_2_UPDATE) {  // method 2
          // update old type
          typeInDB.setAncestorType(type.getAncestorType());
          typeInDB.setAncestorTypes(type.getAncestorTypes());
          typeInDB.setAttributes(new ArrayList<AnnotTypeAttr>(type.getAttributes()));
          typeInDB.setComment(type.getComment());
          typeInDB.setRestrictedAtt(type.getRestrictedAtt());
          typeInDB.setUriInOntology(type.getUriInOntology());
                    
          for (Iterator<AnnotType> ntIt2 = newTypes.iterator(); ntIt2.hasNext();) {  // replace in others
            AnnotType t2 = ntIt2.next();
            if (t2.getAncestorType() != null && t2.getAncestorType().getUri().equals(type.getUri())) {
              t2.setAncestorType(typeInDB);  // replace ancestor
            }
            List<AnnotType> nAnc = new ArrayList<AnnotType>();  // new list
            for (Iterator t2AIt = t2.getAncestorTypes().iterator(); t2AIt.hasNext();) {
              AnnotType t2A = (AnnotType) t2AIt.next();
              if (t2A.getUri() != null && t2A.getUri().equals(type.getUri())) {
                nAnc.add(typeInDB);
              } else {
                nAnc.add(t2A);
              }
            }
            t2.setAncestorTypes(nAnc);  // replace list of ancestors
            for (Iterator t2AtIt = t2.getAttributes().iterator(); t2AtIt.hasNext();) {
              AnnotTypeAttr t2At = (AnnotTypeAttr)t2AtIt.next();
              if (t2At.getAttributeType() != null && t2At.getAttributeType().getUri().equals(type.getUri())) {
                t2At.setAttributeType(typeInDB);
              }
            }
          }  // replace in others

          tToUpdate.add(typeInDB);
          ntIt.remove();  // remove type (old will be used)
        } else {  // unknown method
          errorMessage = errorMessage + MessageProvider.getMessage("typeAlreadyExists1")
                       + type.getUri() + MessageProvider.getMessage("typeAlreadyExists2") + "<br/>";
          return null;
        }
        duplicitTypeFound = true;
      }  // if type was found
    }  // check whether some type is not exists in database

    if (duplicitTypeFound) {  // if some duplicit type found
      if (iMethod == METHOD_0_ERROR) {
        return null;
      }
    }

    // attributes from ontology to update
    List<TypeAttrOnto> aToUpdate = new ArrayList<TypeAttrOnto>();
    
    // check whether some attribute is not exists in database
    boolean duplicitAttributeFound = false;
    for (Iterator<TypeAttrOnto> aFOIt = ontoAttrs.iterator(); aFOIt.hasNext();) {
      TypeAttrOnto aFO = aFOIt.next();
      Object[] params2 = new Object[4];  // parameters for database query
      params2[0] = "name";
      params2[1] = aFO.getName();
      params2[2] = "groupId";
      params2[3] = aFO.getGroup().getId();
      List aList = AppBean.getPersistenceManager().queryDB("TypeAttrOnto.findByNameAndGroup", params2);
      if (aList != null && !aList.isEmpty()) {  // if attribute was found
        TypeAttrOnto attrInDB = (TypeAttrOnto) aList.get(0);
        if (iMethod == METHOD_0_ERROR) {
          errorMessage = errorMessage + MessageProvider.getMessage("attributeAlreadyExists1") 
                       + aFO.getName() + MessageProvider.getMessage("attributeAlreadyExists2") + "<br/>";
        } else if (iMethod == METHOD_1_USE) {  // method 1 (use old one)
          aFOIt.remove();
        } else if (iMethod == METHOD_2_UPDATE) {  // method 2
          // update old attribute
          attrInDB.setSimpleType(aFO.getSimpleType());
          attrInDB.setAttributeType(aFO.getAttributeType());
          attrInDB.setComment(aFO.getComment());
          attrInDB.setUriInOntology(aFO.getUriInOntology());
          
          aToUpdate.add(attrInDB);  // add to list
          aFOIt.remove();
        }
        duplicitTypeFound = true;
      }  // if attribute was found
    }  // check whether some attribute is not exists in database

    if (duplicitAttributeFound) {  // if some duplicit attribute found
      if (iMethod == METHOD_0_ERROR) {
        return null;
      }
    }

    // persist types to database
    // Relations with existing types can't be saved if it is not update (TODO: Is it needed? If yes, complete it.)
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    try {
      transaction.begin();

      // create list without attributes and ansestors and map with types and ancestors
      ArrayList<AnnotType> nTWA = new ArrayList<AnnotType>();
      Map<String, AnnotType> nTMap = new HashMap<String, AnnotType>();
      for (Iterator<AnnotType> ntIt = newTypes.iterator(); ntIt.hasNext();) {
        AnnotType type = ntIt.next();
        AnnotType nT = new AnnotType(type.getUri(), type.getName(), type.getAncestorType(), type.getGroup());
        nT.setAncestorTypes(type.getAncestorTypes());
        nT.setAttributes(new ArrayList<AnnotTypeAttr>(type.getAttributes()));
        nT.setRestrictedAtt(type.getRestrictedAtt());
        nT.setUriInOntology(type.getUriInOntology());
        nT.setComment(type.getComment());
        type.setAncestorType(null);
        type.setAncestorTypes(new ArrayList<AnnotType>());
        type.setAttributes(new ArrayList<AnnotTypeAttr>());
        nTWA.add(type);
        nTMap.put(type.getUri(), nT);
      }
      
      // merge types without attributes and create map with merged types
      ArrayList<AnnotType> mergedTypes = new ArrayList<AnnotType>();
      Map<String, AnnotType> mTypesMap = new HashMap<String, AnnotType>();
      for (Iterator<AnnotType> nTWAIt = nTWA.iterator(); nTWAIt.hasNext();) {
        AnnotType type = nTWAIt.next();
        type = em.merge(type);
        mergedTypes.add(type);
        mTypesMap.put(type.getUri(), type);
      }

      // fix, add and merge attributes and ancestors
      for (Iterator<AnnotType> mIt = mergedTypes.iterator(); mIt.hasNext();) {
        AnnotType mType = mIt.next();
        AnnotType oType = nTMap.get(mType.getUri());  // get original type
        
        // attributes
        List<AnnotTypeAttr> aList = oType.getAttributes();
        for (Iterator<AnnotTypeAttr> aIt = aList.iterator(); aIt.hasNext();) {
          AnnotTypeAttr aTA = aIt.next();
          AnnotType aTAAT = aTA.getAttributeType();
          if (aTAAT != null) {  // if it is structured attribute
            // replace type with merged one
            AnnotType rType = mTypesMap.get(aTAAT.getUri());
            if (rType == null) {  // it is not new type, it is in database
              rType = queryType(aTAAT.getUri(), em);
            }
            aTA.setAttributeType(rType);
          }
          // fix back reference to annotation type
          aTA.setAnnotationType(mTypesMap.get(aTA.getAnnotationType().getUri()));
        }
        mType.setAttributes(new ArrayList<AnnotTypeAttr>(aList));
        
        // primary ancestor
        if (oType.getAncestorType() != null) {
          // replace type with merged one
          AnnotType rType = mTypesMap.get(oType.getAncestorType().getUri());
          if (rType == null) {  // it is not new type, it is in database
            rType = queryType(oType.getAncestorType().getUri(), em);
          }
          mType.setAncestorType(rType);
        }

        // ancestors
        ArrayList<AnnotType> newAncestors = new ArrayList<AnnotType>();
        for (Iterator<AnnotType> ancIt = oType.getAncestorTypes().iterator(); ancIt.hasNext();) {
          AnnotType ancType = ancIt.next();
          AnnotType mAnc = mTypesMap.get(ancType.getUri());
          if (mAnc == null) {  // it is not new type, it is in database
            mAnc = queryType(ancType.getUri(), em);
          }
          if(!newAncestors.contains(mAnc)){
            newAncestors.add(mAnc);
          }
        }
        mType.setAncestorTypes(newAncestors);
                
        mType = em.merge(mType);
      }  // fix, add and merge attributes and ancestors

      // merge updated types
      for (Iterator<AnnotType> tTUIt = tToUpdate.iterator(); tTUIt.hasNext();) {
        AnnotType type = tTUIt.next();
        AnnotType pType = queryType(type.getUri(), em);
        // update informations
        pType.setComment(type.getComment());
        pType.setRestrictedAtt(type.getRestrictedAtt());
        pType.setUriInOntology(type.getUriInOntology());
        
        Iterator<AnnotTypeAttr> attrIter = pType.getAttributes().iterator();
        Iterator<AnnotTypeAttr> newAttrIter = type.getAttributes().iterator();
        while (attrIter.hasNext()) {  // update attributes
          AnnotTypeAttr attr = attrIter.next();
          if (!newAttrIter.hasNext()) {
            em.remove(attr);
          } else {
            AnnotTypeAttr newAttr = newAttrIter.next();
            attr.setSimpleType(newAttr.getSimpleType());
            if (newAttr.getAttributeType() != null) {
              attr.setAttributeType(queryType(newAttr.getAttributeType().getUri(), em));
            } else {
              attr.setAttributeType(null);
            }
            attr.setName(newAttr.getName());
            attr.setComment(newAttr.getComment());
            attr.setRequired(newAttr.getRequired());
            attr.setUriInOntology(newAttr.getUriInOntology());
          }
        }  // update attributes
        // append new attributes
        while (newAttrIter.hasNext()) {
          AnnotTypeAttr nA = newAttrIter.next();
          if (nA.getAttributeType() != null) {
            nA.setAttributeType(queryType(nA.getAttributeType().getUri(), em));
          }
          nA.setAnnotationType(pType);
          pType.getAttributes().add(nA);
        }

        // update ancestors
        List<AnnotType> newAnc = new ArrayList<AnnotType>();
        for (Iterator<AnnotType> aIt = type.getAncestorTypes().iterator(); aIt.hasNext();) {
          AnnotType aT = aIt.next();
          newAnc.add(queryType(aT.getUri(), em));
        }
        pType.setAncestorTypes(newAnc);

        // update primary ancestor
        if (type.getAncestorType() != null) {
          pType.setAncestorType(queryType(type.getAncestorType().getUri(), em));
        } else {
          pType.setAncestorType(null);
        }
      }  // merge updated types
      
      // Persist attributes of unknown types of annotations
      for (Iterator<TypeAttrOnto> oAIt = ontoAttrs.iterator(); oAIt.hasNext();) {
        TypeAttrOnto attr = oAIt.next();
        // fix references
        if (attr.getAttributeType() != null) {
          AnnotType aT = mTypesMap.get(attr.getAttributeType().getUri());
          attr.setAttributeType(aT);
        }
        // merge
        em.merge(attr);
      }
      
      // Update existing attributes of unknown types of annotations
      for (Iterator<TypeAttrOnto> aFOIt = aToUpdate.iterator(); aFOIt.hasNext();) {
        TypeAttrOnto aFO = aFOIt.next();
        if (aFO.getAttributeType() != null) {
            aFO.setAttributeType(queryType(aFO.getAttributeType().getUri(), em));
        }
        em.merge(aFO);
      }  // Update existing attributes of unknown types of annotations

      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      errorMessage = errorMessage + MessageProvider.getMessage("typePersistingError") + "<br/>";
      return null;
    } finally {
      em.close();
    }
    
    // prepare messages for connected clients
    ResponseCreator rc = AppBean.getResponseCreator();
    synchronized(AppBean.getSessions()){
      Iterator<EditorSession> sesIt = AppBean.getSessions().iterator();
      while (sesIt.hasNext()) {  // for each client
        EditorSession es = sesIt.next();
        Flier flier = new Flier();
        // create list of added types
        for (Iterator<AnnotType> atIt = newTypes.iterator(); atIt.hasNext();) {
          AnnotType at = atIt.next();
          flier.AddAddedType(at);
        }
        // create list of changed types
        for (Iterator<AnnotType> atIt = tToUpdate.iterator(); atIt.hasNext();) {
          AnnotType at = atIt.next();
          flier.AddEditedType(at);
        }
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }  // for each client
    }
    
    // display message about success
    successMessage = MessageProvider.getMessage("uploadSuccessfull");

    return null;
  }  // btnUploadAction()
  // </editor-fold>

  
  // <editor-fold defaultstate="collapsed" desc="queryType">
  /**
   * Query database for type of annotation
   *
   * @param uri URI of type of annotation
   * @param em Entity manager
   * @return Returns type of annotation with given URI
   * @throws RuntimeException If type of annotation was not found, throws exception
   */
  private static AnnotType queryType(String uri, EntityManager em) throws RuntimeException {
    AnnotType annotType = null;
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = uri;
    Query q = em.createNamedQuery("AnnotType.findByUri");
    for (int p = 0; p < params.length; p = p + 2) {
      q.setParameter((String) params[p], params[p + 1]);
    }
    List aList = q.getResultList();
    if (aList != null && !aList.isEmpty()) {  // if type was found
      annotType = (AnnotType) aList.get(0);
    } else {  // if type was not found (merge failed)
      throw new RuntimeException("New type not found!");
    }
    return annotType;
  }  // queryType()
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="btnCancelAction">
  /**
   * Action listener for cancel button
   *
   * @return Returns page outcome (null to stay here)
   */
  public String btnCancelAction() {
    return null;
  }
  // </editor-fold>

  // <editor-fold defaultstate="collapsed" desc="get and set function">
  /**
   * Gets uploaded file
   *
   * @return Returns uploaded file
   */
  public UploadedFile getUploadedFile() {
    return uploadedFile;
  }

  /**
   * Sets uploaded file
   *
   * @param uploadedFile Uploaded file
   */
  public void setUploadedFile(UploadedFile uploadedFile) {
    this.uploadedFile = uploadedFile;
  }

  /**
   * Gets uploaded file name
   * 
   * @return Returns uploaded file name
   */
  public String getFileName() {
    return fileName;
  }

  /**
   * Gets error message displayed in form
   *
   * @return Returns error message displayed in form
   */
  public String getErrorMessage() {
    return errorMessage;
  }

  /**
   * Sets error message to be displayed in form
   *
   * @param errorMessage Error message to be displayed in form
   */
  public void setErrorMessage(String errorMessage) {
    this.errorMessage = errorMessage;
  }

  /**
   * Gets uploading indicator
   *
   * @return Returns uploading indicator
   */
  public Boolean getOntologyUploaded() {
    return ontologyUploaded;
  }

  /**
   * Sets uploading indicator
   *
   * @param ontologyUploaded Uploading indicator
   */
  public void setOntologyUploaded(Boolean ontologyUploaded) {
    this.ontologyUploaded = ontologyUploaded;
  }

  /**
   * Gets success message displayed in form
   *
   * @return Returns success message displayed in form
   */
  public String getSuccessMessage() {
    return successMessage;
  }

  /**
   * Sets success message to be displayed in form
   *
   * @param successMessage Success message to be displayed in form
   */
  public void setSuccessMessage(String successMessage) {
    this.successMessage = successMessage;
  }

  /**
   * Gets user group in which uploaded types will be shared
   * 
   * @return Returns user group in which uploaded types will be shared
   */
  public String getuGroup() {
    return uGroup;
  }

  /**
   * Sets user group in which uploaded types will be shared
   *
   * @param uGroup User group in which uploaded types will be shared
   */
  public void setuGroup(String uGroup) {
    this.uGroup = uGroup;
  }

  /**
   * Gets selected import method
   * 
   * @return Returns selected import method
   */
  public int getiMethod() {
    return iMethod;
  }

  /**
   * Sets selected import method
   * 
   * @param iMethod Selected import method
   */
  public void setiMethod(int iMethod) {
    this.iMethod = iMethod;
  }
  
  /**
   * Gets selected import language
   * 
   * @return Returns selected import language
   */
  public String getImportLang() {
    return importLang;
  }

  /**
   * Sets selected import language
   * 
   * @param iLanguage Selected import language
   */
  public void setImportLang(String iLanguage) {
    this.importLang = iLanguage;
  }
  
  // </editor-fold>
  
}  // public class UploadOntology