Suggestion.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: Annotation.java
 * Description: Class representing suggestion of annotation
 */

/**
 * @file Suggestion.java
 *
 * @brief Class representing suggestion of annotation
 */
package cz.vutbr.fit.knot.annotations.modules.suggestionManager;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.Fragment;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.Alternative;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.AlternativeAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.AlternativeFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.SecFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.SecSuggestion;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.*;
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;

/**
 * Class representing suggestion of annotation
 *
 * @brief Class representing suggestion of annotation
 * @author Martin Petr (xpetrm05)
 */
@Entity
@Table(name = "suggestion")
@XmlRootElement
@NamedQueries({
  @NamedQuery(name = "Suggestion.findAll", query = "SELECT s FROM Suggestion s"),
  @NamedQuery(name = "Suggestion.findById", query = "SELECT s FROM Suggestion s WHERE s.id = :id"),
  @NamedQuery(name = "Suggestion.findByAlternativeOfAndNotSugg", query = "SELECT s FROM Suggestion s WHERE s.alternativeOf = :alternativeOf AND s.id <> :notThisSugId"),
  @NamedQuery(name = "Suggestion.findByAlternativeOf", query = "SELECT s FROM Suggestion s WHERE s.alternativeOf = :alternativeOf"),
  @NamedQuery(name = "Suggestion.findByType", query = "SELECT s FROM Suggestion s WHERE s.type = :type"),
  @NamedQuery(name = "Suggestion.findByAuthorIdStr", query = "SELECT s FROM Suggestion s WHERE s.authorIdStr = :authorIdStr"),
  @NamedQuery(name = "Suggestion.findByAuthorName", query = "SELECT s FROM Suggestion s WHERE s.authorName = :authorName"),
  @NamedQuery(name = "Suggestion.findByAuthorAddress", query = "SELECT s FROM Suggestion s WHERE s.authorAddress = :authorAddress"),
  @NamedQuery(name = "Suggestion.findBySource", query = "SELECT s FROM Suggestion s WHERE s.source = :source"),
  @NamedQuery(name = "Suggestion.findBySourceDocId", query = "SELECT s FROM Suggestion s WHERE s.sourceDocumentId = :sourceDocId"),
  @NamedQuery(name = "Suggestion.findForAlternatives", query = "SELECT s FROM Suggestion s WHERE s.sourceDocumentId = :sourceDocId AND s.confidence >= :minCon AND s.alternativeOf IS NULL AND s.isFromSECAPI = TRUE"),
  @NamedQuery(name = "Suggestion.findBySourceDocIdNNConfid", query = "SELECT s FROM Suggestion s WHERE s.sourceDocumentId = :sourceDocId AND s.confidence > 0"),
  @NamedQuery(name = "Suggestion.findBySourceDocument", query = "SELECT s FROM Suggestion s WHERE s.sourceDocument = :sourceDocument"),
  @NamedQuery(name = "Suggestion.findByAutorId", query = "SELECT s FROM Suggestion s WHERE s.autorId = :autorId"),
  @NamedQuery(name = "Suggestion.clearIsFromSECAPI", query = "UPDATE Suggestion s SET s.isFromSECAPI = FALSE WHERE s.id = :id")
})
public class Suggestion implements Serializable, SecSuggestion {
  private static final long serialVersionUID = 1L;
  /** Id of suggestion */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  
  /** Id of type of annotation */
  @Basic(optional = false)
  @NotNull
  @Column(name = "type", nullable=false, insertable=false, updatable=false)
  private int type;
  
  /** Date of creation */
  @Basic(optional = true)
  @Column(name = "created")
  @Temporal(TemporalType.TIMESTAMP)
  private Date created;
  
  /** URI of suggestion author (user) */
  @Basic(optional = true)
  @Size(min = 1, max = 255)
  @Column(name = "authorIdStr")
  private String authorIdStr;
  
  /** Name of suggestion author (user) */
  @Size(max = 40)
  @Column(name = "authorName")
  private String authorName;
  
  /** E-mail of suggestion author (user) */
  @Size(max = 255)
  @Column(name = "authorAddress")
  private String authorAddress;
  
  /** URI of annotated copy of document to which this suggestion belongs */
  @Basic(optional = false)
  @NotNull
  @Size(min = 1, max = 255)
  @Column(name = "source")
  private String source;
  
  /** Id of annotated copy of document to which this suggestion belongs */
  @Basic(optional = false)
  @NotNull
  @Column(name = "sourceDocumentId", nullable=false, insertable=false, updatable=false)
  private int sourceDocumentId;
  
  /** Textual content of suggestion */
  @Basic(optional = false)
  @Lob
  @Column(name = "content")
  private String content;
  
  /** Confidence of suggestion */
  @Basic(optional = false)
  @Column(name = "confidence")
  private Integer confidence;
  
  /** Should be confidence displayed? */
  @Basic(optional = false)
  @NotNull
  @Column(name = "displayConfidence")
  private boolean displayConfidence;
  
  /** Id of suggestion author (user) */
  @Column(name = "authorId", insertable=false, updatable=false)
  private String autorId;
  
  /** If this suggestion is nested, here is id of parent suggestion */
  @Column(name = "nestedIn", insertable=false, updatable=false)
  private String nestedIn;
  
  /** If this suggestion was created from alternative, here is id of main suggestion */
  @Column(name = "alternativeOf", insertable=false, updatable=false)
  private String alternativeOf;

  /** Type of suggestion */
  @OneToOne(optional = false)
  @JoinColumn(name = "type", referencedColumnName = "id")
  private AnnotType annotType;
  
  /** Annotated copy of document to which this suggestion belongs */
  @OneToOne(optional = false)
  @JoinColumn(name = "sourceDocumentId", referencedColumnName = "id")
  private AnnotDocument sourceDocument;
  
  /** List of attributes of suggestion */
  @OneToMany(mappedBy = "refSuggestion", cascade = CascadeType.ALL,
  targetEntity = SugBaseAttribute.class)
  private List<SugBaseAttribute> attributes; 
  
  /** List of suggested fragments */
  @OneToMany(mappedBy = "refSuggestion", cascade = CascadeType.ALL,
  targetEntity = SuggestionFragment.class)
  private List<SuggestionFragment> fragments;
  
  /** Author of suggestion (user) */
  @OneToOne(optional = true)
  @JoinColumn(name = "authorId", referencedColumnName = "id")
  private User user;
  
  /** If this suggestion is nested, here is parent suggestion */
  @OneToOne(optional = true)
  @JoinColumn(name = "nestedIn", referencedColumnName = "id")
  private Suggestion nestedInSuggestion;
  
  /** If this suggestion was created from alternative, here is id of main suggestion */
  @OneToOne(optional = true)
  @JoinColumn(name = "alternativeOf", referencedColumnName = "id")
  private Suggestion alternativeOfSuggestion;
  
  /** Is this suggestion from SEC API? */
  @Basic(optional = false)
  @NotNull
  @Column(name = "isFromSECAPI")
  private boolean isFromSECAPI;

  /** Identifier of entity from SEC API (to detect same suggestions on more places) */
  @Basic(optional = true)
  @Column(name = "SAEntityIdentifier")
  private String SAEntityIdentifier;
  
  /** Temporary id to identify targets of links in suggestions from client */
  @Transient
  private String tmpId;
  
  /** If this suggestion is nested, here is parent annotation */
  @Transient
  private Annotation nestedInAnnot;
  
  /**
   * Constructor
   */
  public Suggestion() {
  }

  /**
   * Constructor of reference objects for searching purposes - no initialization
   * needed
   *
   * @param id Id of suggestion
   */
  public Suggestion(Integer id) {
    this.id = id;
  }
  
  /**
   * Constructor for creating suggestion from annotation
   *
   * @param a Annotation from which is the suggestion created
   */
  public Suggestion(Annotation a) {
    this.updateWithAnnotationForDB(a);
    isFromSECAPI = false; // annotation is created by user, not by SEC API
  }
  
  /**
   * Constructor for creating suggestion from alternative.
   * 
   * @param a Alternative from which is the suggestion created
   */
  public Suggestion(Alternative a) {
    this.updateWithAlternativeForDB(a);
    isFromSECAPI = true; // alternative is created by SEC API
  }

  /**
   * Constructor
   *
   * @param type Type of suggestion
   * @param content Textual content of suggestion
   * @param nestedIn If this suggestion is nested, then parent suggestion, null otherwise
   */
  public Suggestion(AnnotType type, String content, String nestedIn) {
    this.annotType = type;
    this.content = content;
    this.nestedIn = nestedIn;
    this.attributes = new ArrayList<SugBaseAttribute>();
    this.fragments = new ArrayList<SuggestionFragment>();
    isFromSECAPI = false;
    displayConfidence = false;
  }
  
  /**
   * Constructor
   *
   * @param id Id of suggestion
   * @param authorIdStr URI of suggestion author (user)
   * @param authorName Name of suggestion author (user)
   * @param authorAddress E-mail of suggestion author (user)
   * @param sourceDocument Annotated copy of document to which this suggestion belongs
   * @param content Textual content of suggestion
   * @param nestedIn If this suggestion is nested, then parent suggestion, null otherwise
   */
  public Suggestion(Integer id, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, String nestedIn) {
    this.id = id;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedIn = nestedIn;
    this.nestedInSuggestion = null;
    this.attributes = new ArrayList<SugBaseAttribute>();
    this.fragments = new ArrayList<SuggestionFragment>();
    isFromSECAPI = false;
    displayConfidence = false;
  }

  /**
   * Constructor
   *
   * @param annotType Type of suggestion
   * @param created Date of creation
   * @param authorIdStr URI of suggestion author (user)
   * @param authorName Name of suggestion author (user)
   * @param authorAddress E-mail of suggestion author (user)
   * @param sourceDocument Annotated copy of document to which this suggestion belongs
   * @param content Textual content of suggestion
   */
  public Suggestion(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content) {
    this.annotType = annotType;
    this.created = created;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedInSuggestion = null;
    this.attributes = new ArrayList<SugBaseAttribute>();
    this.fragments = new ArrayList<SuggestionFragment>();
    isFromSECAPI = false;
    displayConfidence = false;
  }

  /**
   * Constructor
   *
   * @param annotType Type of suggestion
   * @param created Date of creation
   * @param authorIdStr URI of suggestion author (user)
   * @param authorName Name of suggestion author (user)
   * @param authorAddress E-mail of suggestion author (user)
   * @param sourceDocument Annotated copy of document to which this suggestion belongs
   * @param content Textual content of suggestion
   * @param nestedInAnnot If this suggestion is nested, then parent suggestion, null otherwise
   */
  public Suggestion(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, Suggestion nestedInAnnot) {
    this.annotType = annotType;
    this.created = created;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedInSuggestion = nestedInAnnot;
    this.attributes = new ArrayList<SugBaseAttribute>();
    this.fragments = new ArrayList<SuggestionFragment>();
    isFromSECAPI = false;
    displayConfidence = false;
  }

  /**
   * Updates data in this suggestion with data from another suggestion
   *
   * @param newData Suggestion with new data
   */
  public void updateWithSuggestion(Suggestion newData) {
    this.type = newData.getAnnotType().getId();
    this.created = newData.getCreated();
    this.authorIdStr = newData.getAuthorIdStr();
    this.authorName = newData.getAuthorName();
    this.authorAddress = newData.getAuthorAddress();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    if (newData.getNestedInSuggestion() != null) {
      this.nestedIn = newData.getNestedInSuggestion().getId().toString();
    }
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    this.attributes = newData.getAttributes();
    this.fragments = newData.getFragments();
    this.user = newData.getUser();
    this.nestedInSuggestion = newData.getNestedInSuggestion();
    this.displayConfidence = newData.displayConfidence;
  }
  
  /**
   * Update data of suggestion with annotation data
   * 
   * @param newData Annotation data
   */
  public void updateWithAnnotation(Annotation newData){
    this.type = newData.getAnnotType().getId();
    this.created = newData.getCreated();
    this.authorIdStr = newData.getAuthorIdStr();
    this.authorName = newData.getAuthorName();
    this.authorAddress = newData.getAuthorAddress();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    this.attributes = new ArrayList<SugBaseAttribute>();
    if (newData.getAttributes() != null) {
      Iterator<BaseAttribute> atIt = newData.getAttributes().iterator();
      while (atIt.hasNext()) {
        BaseAttribute at = atIt.next();
        SugBaseAttribute newAt;
        try {
          newAt = SugAttributeManager.createAttribute(at.getName(), at.getSimpleType(), this);
        } catch (ClassNotFoundException ex) {
          String msg = "Unable to create suggestion attribute with type = " + at.getSimpleType();
          Logger.getLogger(Suggestion.class.getName()).log(Level.SEVERE, null, msg);
          continue;
        }
        newAt.updateFromBaseAttribut(at);
        this.attributes.add(newAt);
      }
    }
    this.fragments = new ArrayList<SuggestionFragment>();
    if (newData.getFragments() != null) {
      Iterator<Fragment> fragIt = newData.getFragments().iterator();
      while (fragIt.hasNext()) {
        Fragment fr = fragIt.next();
        SuggestionFragment newFrag = new SuggestionFragment(fr.getPath(), fr.getOffset(), fr.getLength(), fr.getAnnotatedText(), this);
        this.fragments.add(newFrag);
      }
    }
    this.user = newData.getUser();
    displayConfidence = false;
  }  // updateWithAnnotation()
  
  /**
   * Update data of suggestion with alternative data in correct way to save to db
   * 
   * @param newData Alternative data
   */
  private void updateWithAlternativeForDB(Alternative newData){
    this.tmpId = newData.getTmpId();
    this.type = newData.getAnnotType().getId();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    this.confidence = newData.getConfidence();
    this.alternativeOfSuggestion = newData.getAlternativeOfSuggestion();
    this.SAEntityIdentifier = newData.getSAEntityIdentifier();
    List newDataAtts = newData.getAttributes();
    if (newDataAtts != null && !newDataAtts.isEmpty()) { 
      for (int i = 0; i < newDataAtts.size(); i++) {
        if (!(newDataAtts.get(i) instanceof AlternativeAttribute)) {
          continue;
        }
        AlternativeAttribute attr = (AlternativeAttribute) newDataAtts.get(i);
        SugBaseAttribute sba;
        try {
          sba = SugAttributeManager.createAttribute("", attr.getSimpleType(), this);
        } catch (Exception e) {
          String msg = "Unable to create suggestion attribute with type = " + attr.getSimpleType();
          Logger.getLogger(Suggestion.class.getName()).log(Level.SEVERE, msg, e);
          continue;
        }
        if (sba == null) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unable to create suggestion attribute with type = " + attr.getSimpleType();
            Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, msg);
          }
          continue;
        }
        sba.updateFromAlternativeAttribut(attr);
        if (this.attributes == null) {
          this.attributes = new ArrayList<SugBaseAttribute>(); 
        }
        this.attributes.add(sba);
      }
    }
    else{
      this.attributes = new ArrayList<SugBaseAttribute>();
    }
    
    Iterator frIt = newData.getFragments().iterator();
    if (this.fragments == null) {
      this.fragments = new ArrayList<SuggestionFragment>();
    }
    this.fragments.clear();
    while (frIt.hasNext()) { 
      SuggestionFragment newSugFr = new SuggestionFragment();
      newSugFr.updateFromAlternativeFragment((AlternativeFragment) frIt.next());
      newSugFr.setRefSuggestion(this);
      fragments.add(newSugFr);
    }
    displayConfidence = false;
  }  // updateWithAlternativeForDB()
  
  /**
   * Update data of suggestion with annotation data in correct way to save to db
   * @param newData Annotation data
   */
  public final void updateWithAnnotationForDB(Annotation newData){
    this.type = newData.getAnnotType().getId();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    List newDataAtts = newData.getAttributes();
    if (newDataAtts != null && !newDataAtts.isEmpty()) { 
      for (int i = 0; i < newDataAtts.size(); i++) {
        if (!(newDataAtts.get(i) instanceof BaseAttribute)) {
          continue;
        }
        BaseAttribute ba = (BaseAttribute) newDataAtts.get(i);
        SugBaseAttribute sba;
        try {
          sba = SugAttributeManager.createAttribute("", ba.getSimpleType(), this);
        } catch (Exception e) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Unable to create suggestion attribute with type = " + ba.getSimpleType();
            Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, msg, e);
          }
          continue;
        }
        sba.updateFromBaseAttribut(ba);
        if (this.attributes == null) {
          this.attributes = new ArrayList<SugBaseAttribute>(); 
        }
        this.attributes.add(sba);
      }
    }
    Iterator<Fragment> frIt = newData.getFragments().iterator();
    if (this.fragments == null) {
      this.fragments = new ArrayList<SuggestionFragment>();
    }
    this.fragments.clear();
    while (frIt.hasNext()) { 
      SuggestionFragment newSugFr = new SuggestionFragment();
      newSugFr.updateFromFragment(frIt.next());
      newSugFr.setRefSuggestion(this);
      fragments.add(newSugFr);
    }
    displayConfidence = false;
  }  // updateWithAnnotationForDB()

  // <editor-fold defaultstate="collapsed" desc="Get and set function">
  /**
   * Gets id of suggestion
   *
   * @return Returns id of suggestion
   */
  public Integer getId() {
    return id;
  }

  /**
   * Sets id of suggestion
   *
   * @param id Id of suggestion
   */
  public void setId(Integer id) {
    this.id = id;
  }
  
  /**
   * Gets type of suggestion
   *
   * @return Returns type of suggestion
   */
  public AnnotType getAnnotType() {
    return annotType;
  }

  /**
   * Sets type of suggestion
   *
   * @param annotType Type of suggestion
   */
  public void setAnnotType(AnnotType annotType) {
    this.annotType = annotType;
  }
  
   /**
   * Gets date of creation
   *
   * @return Returns date of creation
   */
  public Date getCreated() {
    return created;
  }

  /**
   * Sets date of creation
   *
   * @param created Date of creation
   */
  public void setCreated(Date created) {
    this.created = created;
  }
  
  /**
   * Gets author of suggestion (user)
   *
   * @return Returns author of suggestion (user)
   */
  public User getUser() {
    return user;
  }

  /**
   * Sets author of suggestion (user)
   * URI is also set and if available, full name and e-mail too
   *
   * @param user Author of suggestion (user)
   */
  public void setUser(User user) {
    this.user = user;
    if (user != null) {
      authorIdStr = user.getURI();
      if (user.getName() != null && !user.getName().contentEquals("")) {
        authorName = user.getName();
      }
      if (user.getEmail() != null && !user.getEmail().contentEquals("")) {
        authorAddress = user.getEmail();
      }
    }
  }

  /**
   * Gets URI of author of suggestion (user)
   *
   * @return Returns URI of author of suggestion (user)
   */
  public String getAuthorIdStr() {
    return authorIdStr;
  }

  /**
   * Sets URI of author of suggestion (user)
   *
   * @param authorIdStr URI of author of suggestion (user)
   */
  public void setAuthorIdStr(String authorIdStr) {
    this.authorIdStr = authorIdStr;
  }

  /**
   * Gets name of author of suggestion (user)
   *
   * @return Returns name of author of suggestion (user)
   */
  public String getAuthorName() {
    return authorName;
  }

  /**
   * Sets name of author of suggestion (user)
   *
   * @param authorName Name of author of suggestion (user)
   */
  public void setAuthorName(String authorName) {
    this.authorName = authorName;
  }

  /**
   * Gets e-mail of author of suggestion (user)
   *
   * @return Returns e-mail of author of suggestion (user)
   */
  public String getAuthorAddress() {
    return authorAddress;
  }

  /**
   * Sets e-mail of author of suggestion (user)
   *
   * @param authorAddress E-mail of author of suggestion (user)
   */
  public void setAuthorAddress(String authorAddress) {
    this.authorAddress = authorAddress;
  }

   /**
   * Gets annotated copy of document to which this suggestion belongs
   *
   * @return Returns annotated copy of document to which this suggestion belongs
   */
  public String getSource() {
    return source;
  }

  /**
   * Sets annotated copy of document to which this suggestion belongs
   *
   * @param source Annotated copy of document to which this suggestion belongs
   */
  public void setSource(String source) {
    this.source = source;
  }

  /**
   * Gets id of annotated copy of document to which this suggestion belongs
   *
   * @return Returns id of annotated copy of document to which this suggestion belongs
   */
  public Integer getSourceDocumentId() {
    return sourceDocumentId;
  }

  /**
   * Sets id of annotated copy of document to which this suggestion belongs
   * 
   * @param sourceDocumentId id of annotated copy of document to which this suggestion belongs
   */
  public void setSourceDocumentId(Integer sourceDocumentId) {
    this.sourceDocumentId = sourceDocumentId;
  }

  /**
   * Gets id of type of suggestion
   *
   * @return Returns id of type of suggestion
   */
  public Integer getType() {
    return type;
  }

  /**
   * Sets id of type of suggestion
   * 
   * @param type id of type of suggestion
   */
  public void setType(Integer type) {
    this.type = type;
  }

 /**
   * Gets textual content of suggestion
   *
   * @return Returns textual content of suggestion
   */
  public String getContent() {
    return content;
  }

  /**
   * Sets textual content of suggestion
   *
   * @param content Textual content of suggestion
   */
  public void setContent(String content) {
    this.content = content;
  }

  /**
   * Gets id of suggestion author (user)
   *
   * @return Returns id of suggestion author (user)
   */
  public String getAutorId() {
    return autorId;
  }

  /**
   * Sets id of suggestion author (user)
   * 
   * @param autorId id of suggestion author (user)
   */
  public void setAutorId(String autorId) {
    this.autorId = autorId;
  }
  
  /**
   * Gets annotated copy of document to which this suggestion belongs
   *
   * @return Returns annotated copy of document to which this suggestion belongs
   */
  public AnnotDocument getSourceDocument() {
    return sourceDocument;
  }

  /**
   * Sets annotated copy of document to which this suggestion belongs
   * (if  document is not null, his URI is also set)
   *
   * @param sourceDocument Annotated copy of document to which this suggestion belongs
   */
  public void setSourceDocument(AnnotDocument sourceDocument) {
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
  }

  /**
   * Gets URI of suggestion in which is this suggestion nested
   * 
   * @return Returns URI of suggestion in which is this suggestion nested
   */
  public String getNestedIn() {
    return nestedIn;
  }

  /**
   * Sets URI of suggestion in which is this suggestion nested
   * 
   * @param nestedIn URI of suggestion in which is this suggestion nested
   */
  public void setNestedIn(String nestedIn) {
    this.nestedIn = nestedIn;
  }

  /**
   * Gets list of suggestion attributes
   *
   * @return Returns list of suggestion attributes
   */
  public List<SugBaseAttribute> getAttributes() {
    return attributes;
  }

  /**
   * Sets list of suggestion attributes
   *
   * @param attributes List of suggestion attributes
   */
  public void setAttributes(ArrayList<SugBaseAttribute> attributes) {
    this.attributes = attributes;
  }
  
  /**
   * Adds an attribute to list of suggestion attributes
   *
   * @param attribute Attribute to add
   */
  public void addAttribute(SugBaseAttribute attribute) {
    this.attributes.add(attribute);
  }
  
  /**
   * Gets list of suggested fragments
   *
   * @return Returns list of suggested fragments
   */
  @Override
  public List<SuggestionFragment> getFragments() {
    return fragments;
  }

  /**
   * Gets list of suggested fragments as ArrayList
   *
   * @return Returns list of suggested fragments as ArrayList
   */
  public ArrayList<SuggestionFragment> getFragmentsAL() {
    return new ArrayList<SuggestionFragment>(fragments);
  }

  /**
   * Sets list of suggested fragments
   *
   * @param fragments List of suggested fragments
   */
  public void setFragments(ArrayList<SuggestionFragment> fragments) {
    this.fragments = fragments;
  }
  
  
  /**
   * Gets parent suggestion of nested suggestion
   *
   * @return If this suggestion is nested, returns parent suggestion, null otherwise
   */
  public Suggestion getNestedInSuggestion() {
    return nestedInSuggestion;
  }

  /**
   * Sets parent suggestion of nested suggestion
   *
   * @param nestedInSuggestion If this suggestion is nested, then parent suggestion, null otherwise
   */
  public void setNestedInSuggestion(Suggestion nestedInSuggestion) {
    this.nestedInSuggestion = nestedInSuggestion;
  }

  /**
   * Gets suggestion which alternative is this suggestion
   *
   * @return Gets suggestion which alternative is this suggestion or null
   */
  public Suggestion getAlternativeOfSuggestion() {
    return alternativeOfSuggestion;
  }

  /**
   * Sets suggestion which alternative is this suggestion
   *
   * @param alternativeOfSuggestion Suggestion which alternative is this suggestion
   */
  public void setAlternativeOfSuggestion(Suggestion alternativeOfSuggestion) {
    this.alternativeOfSuggestion = alternativeOfSuggestion;
  }

  /**
   * Gets annotation in which is this suggestion nested
   * 
   * @return annotation in which is this suggestion nested
   */
  public Annotation getNestedInAnnot() {
    return nestedInAnnot;
  }
  
  /**
   * Sets annotation in which is this suggestion nested
   * 
   * @param nestedInAnnot Annotation in which is this suggestion nested
   */
  public void setNestedInAnnot(Annotation nestedInAnnot) {
    this.nestedInAnnot = nestedInAnnot;
  }
  
  /**
   * Gets confidence of this suggestion
   * 
   * @return Returns confidence of this suggestion
   */
  public Integer getConfidence() {
    return confidence;
  }

  /**
   * Sets confidence of this suggestion
   * 
   * @param confidence Confidence of this suggestion
   */
  public void setConfidence(Integer confidence) {
    this.confidence = confidence;
  }

  /**
   * Returns whether should be confidence displayed
   * 
   * @return Returns whether should be confidence displayed
   */
  public boolean getDisplayConfidence() {
    return displayConfidence;
  }

  /**
   * Sets whether should be confidence displayed
   * 
   * @param displayConfidence Should be confidence displayed?
   */
  public void setDisplayConfidence(boolean displayConfidence) {
    this.displayConfidence = displayConfidence;
  }

  /**
   * Gets tmpId of this suggestion 
   * (warning - tmpId is in id field for suggestion - this is an auxiliary value)
   * 
   * @return Returns tmpId of this suggestion
   */
  public String getTmpId() {
    return tmpId;
  }

  /**
   * Sets tmpId of this suggestion 
   * (warning - tmpId is in id field for suggestion - this is an auxiliary value)
   * 
   * @param tmpId tmpId of this suggestion
   */
  public void setTmpId(String tmpId) {
    this.tmpId = tmpId;
  }

  /**
   * Gets isFromSECAPI
   * 
   * @return isFromSECAPI
   */
  public boolean getIsFromSECAPI() {
    return isFromSECAPI;
  }

  /**
   * Sets isFromSECAPI
   * 
   * @param isFromSECAPI new isFromSECAPI
   */
  public void setIsFromSECAPI(boolean isFromSECAPI) {
    this.isFromSECAPI = isFromSECAPI;
  }

  /**
   * Gets SEC API Entity Identifier (to detect same suggestions)
   * 
   * @return isFromSECAPI SEC API Entity Identifier
   */
  public String getSAEntityIdentifier() {
    return SAEntityIdentifier;
  }

  /**
   * Sets SEC API Entity Identifier
   * 
   * @param SAEntityIdentifier SEC API Entity Identifier
   */
  @Override
  public void setSAEntityIdentifier(String SAEntityIdentifier) {
    this.SAEntityIdentifier = SAEntityIdentifier;
  }
  
  // </editor-fold>
  
  /**
   * Adds fragment to the list of suggested fragments
   *
   * @param fragment Suggested fragment
   */
  public void addFragment(SuggestionFragment fragment) {
    fragments.add(fragment);
  }

  /**
   * Adds fragment to the list of suggested fragments
   *
   * @param fragment Suggested fragment
   */
  @Override
  public void addSecFragment(SecFragment fragment) {
    if (fragment instanceof SuggestionFragment) {
      fragments.add((SuggestionFragment) fragment);
    }
  }

  @Override
  public int hashCode() {
    int hash = 0;
    hash += (id != null ? id.hashCode() : 0);
    return hash;
  }
  
  /**
   * Gets URI of suggestion for protocol V2
   *
   * @return URI of suggestion
   */
  public String getURIV2() {
    if (id == null) {
      return "";
    }
    return AppBean.getBaseUri() + "/sugg/" + id;
  }

  /**
   * Returns xpointers of all suggestion fragments
   *
   * @return Returns xpointers of all suggestion fragments
   */
  public String getFragmentXpointersV2(){
    String xpointers = "";

    Iterator<SuggestionFragment> fragIt = fragments.iterator();
    while(fragIt.hasNext()){
      xpointers += "#" + fragIt.next().getXpointerV2();
    }
    
    return xpointers;
  }
  
  /**
   * Returns serialized informations about suggestion in XML for protocol V2
   *
   * @param attFilter Filter for attributes
   * @param langNum Number of language
   * @param KBRefMode Is KB_Ref mode on?
   * @return Returns serialized informations about suggestion in XML for protocol V2
   */
  public String toXMLStringV2(ArrayList<String> attFilter, int langNum, Boolean KBRefMode){
    if (attFilter == null) {
      attFilter = new ArrayList<String>();
      attFilter.add(Constants.UPDATABLE_AN_AT_NAME);
    }
    if (KBRefMode == null) {
      KBRefMode = false;
    }
    StringBuilder result = new StringBuilder();
    String suggUri = AppBean.getBaseUri()+ "/sugg/" + id;
    
    // serialize suggestion + suggestion uri
    result.append("<suggestion confidence=\"");
    result.append(confidence);
    result.append("\" displayConfidence=\"");
    if (displayConfidence) {
      result.append("true");
    } else {
      result.append("false");
    }
    result.append("\">");
    result.append("<oa:Annotation rdf:about=\"");
    result.append(suggUri);
    result.append("\">");
    
    // serialize annotation type
    result.append("<oa:hasBody>");
    result.append("<oa:SemanticTag rdf:about=\"");
    result.append(annotType.getUri());
    result.append("\"/>");
    result.append("</oa:hasBody>");

    // serialize fragments
    if(fragments == null || fragments.isEmpty()){
      // suggestion of whole document
      result.append("<oa:hasTarget>");
      
      result.append("<dctypes:Text rdf:about=\"");
      result.append(source);
      result.append("\">");
      result.append("<dc:format>text/xml</dc:format>");
      result.append("</dctypes:Text>");
      
      result.append("</oa:hasTarget>");
    } else if (fragments.size() == 1) {
      // suggestion have only one fragment
      result.append("<oa:hasTarget>");
      result.append(((SuggestionFragment) fragments.get(0)).toXMLStringV2());
      result.append("</oa:hasTarget>");
    } else if (fragments.size() > 1) {
      // suggestion with multiple fragments
      result.append("<oa:hasTarget>");
      result.append("<oa:Composite rdf:about=\"");
      // make uri of composite 
      result.append(source);
      result.append(getFragmentXpointersV2());
      result.append("\">");

      Iterator<SuggestionFragment> fragIt = fragments.iterator();
      while(fragIt.hasNext()){
        SuggestionFragment tmpFrag = fragIt.next();
        result.append("<oa:item>");
        result.append(tmpFrag.toXMLStringV2());
        result.append("</oa:item>");
      }

      result.append("</oa:Composite>");
      result.append("</oa:hasTarget>");
    }

    // serialize suggestion content
    result.append("<oa:hasBody>");
    
    result.append("<cnt:ContentAsText rdf:about=\"");
    result.append(suggUri);
    result.append("#body\">");
    
    result.append("<rdf:type rdf:resource=\"http://purl.org/dc/dcmitype/Text\"/>");
    result.append("<cnt:chars><![CDATA[");
    result.append(content);
    result.append("]]></cnt:chars><dc:format>text/plain</dc:format>");
    result.append("</cnt:ContentAsText>");
    result.append("</oa:hasBody>");
    

    // serialize attributes
    result.append("<oa:hasBody>");
    
    result.append("<cnt:ContentAsText rdf:about=\"");
    result.append(source);
    result.append("\">");
    
    result.append("<rdf:type rdf:resource=\"http://www.w3.org/2004/03/trix/rdfg-1/Graph\"/>");
    
    result.append("<trix:TriX>");
    result.append("<trix:graph>");
    
    if (KBRefMode 
        && !Constants.FORBIDDEN_ENTITY_TYPES.contains(this.getAnnotType().getName().toLowerCase())) {
      // KB_Ref mode
      result.append(attributesToKBRefString(attFilter, langNum));
    } else {
      Iterator<SugBaseAttribute> attribIt = attributes.iterator();
      while (attribIt.hasNext()) {
        SugBaseAttribute tmpAttrib = attribIt.next();
        if (!SugAttributeManager.hasAttributeRightInstance(tmpAttrib)) {
          tmpAttrib = SugAttributeManager.changeAttributeInstance(tmpAttrib);
        }
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        result.append(tmpAttrib.toXMLStringV2());
      }
    }
    
    result.append("</trix:graph>");
    result.append("</trix:TriX>");
    
    result.append("<dc:format>text/xml</dc:format>");
    result.append("</cnt:ContentAsText>");
    result.append("</oa:hasBody>");
    
    // serialize time and date of creation
    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ");
    String date;
    if(created == null){
      Date now = new Date();
      date = df.format(now.getTime());
    }else{
      date = df.format(created);
    }
    
    result.append("<oa:annotatedAt>");
    result.append(date);
    result.append("</oa:annotatedAt>");
    
    result.append("<oa:serializedAt>");
    result.append(date);
    result.append("</oa:serializedAt>");
    
    // end of annotation
    result.append("</oa:Annotation>");
    result.append("</suggestion>");

    // Serializing all nested suggestions and annotations
    Iterator<SugBaseAttribute> attrNestedIt = attributes.iterator();
    while(attrNestedIt.hasNext()){
      SugBaseAttribute tmpAttrib = attrNestedIt.next();
      String aName = tmpAttrib.getName();
      if (attFilter.contains(aName)) {
        continue;
      }
      if(tmpAttrib.getNestedAnnotation() != null){
        result.append(tmpAttrib.getNestedAnnotation().toXMLStringV2(attFilter, langNum, KBRefMode));
      }
      if(tmpAttrib.getNestedSuggestion() != null){
        result.append(tmpAttrib.getNestedSuggestion().toXMLStringV2(attFilter, langNum, KBRefMode));
      }
    }
    
    return result.toString();
  }  // toXMLStringV2()
  
  /**
   * Returns serialized attributes in KB Ref mode
   * 
   * @param attFilter Filter for attributes
   * @param langNum Number of language
   * @return Returns serialized attributes in KB Ref mode
   */
  private StringBuilder attributesToKBRefString(ArrayList<String> attFilter, int langNum) {
    StringBuilder result = new StringBuilder();
    StringBuilder tmpResult = new StringBuilder();
    Iterator<SugBaseAttribute> attribIt = attributes.iterator();
    SugEntityAttribute kRefAt = new SugEntityAttribute();
    kRefAt.setSimpleType("Entity");
    kRefAt.setEntityAdditionalAttributes(new ArrayList<SugEntityAdditionalAttribute>());
    kRefAt.setRefSuggestion(this);
    kRefAt.setName(Constants.KB_REF_ATT_NAME);
    kRefAt.setEntityType(this.getAnnotType().getName());
    Boolean nameSet = false;
    Boolean uriSet = false;  // was URI set?
    Boolean vrSet = false;
    Boolean desSet = false;
    while (attribIt.hasNext()) {
      SugBaseAttribute tmpAttrib = attribIt.next();
      Boolean processed = false;  // was attribute processed?
      if (!SugAttributeManager.hasAttributeRightInstance(tmpAttrib)) {
        tmpAttrib = SugAttributeManager.changeAttributeInstance(tmpAttrib);
      }
      if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_ARTWORK_NAME))) {
        if (tmpAttrib.getStringValue() != null && !nameSet) {
          kRefAt.setEntityName(tmpAttrib.getStringValue());
          nameSet = true;
          processed = true;
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_DESCRIPTION))) {
        if (SugTextAttribute.class.isInstance(tmpAttrib)) {
          processed = true;
          if (tmpAttrib.getTextValue() != null) {
            if (desSet) {
              kRefAt.setDescription(kRefAt.getDescription() + tmpAttrib.getTextValue());
            } else {
              kRefAt.setDescription(tmpAttrib.getTextValue());
              desSet = true;
            }
          }
        } else if (SugStringAttribute.class.isInstance(tmpAttrib)) {
          processed = true;
          if (tmpAttrib.getStringValue() != null) {
            if (desSet) {
              kRefAt.setDescription(kRefAt.getDescription() + tmpAttrib.getStringValue());
            } else {
              kRefAt.setDescription(tmpAttrib.getStringValue());
              desSet = true;
            }
          }
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_ENTITY_URI))) {
        if (tmpAttrib.getUri() != null && !uriSet) {
          kRefAt.setUri(tmpAttrib.getUri());
          uriSet = true;
          processed = true;
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_VISUAL_REPRESENTATION))) {
        if (tmpAttrib.getUri() != null) {
          kRefAt.setEntityVisualURI(tmpAttrib.getUri());
          vrSet = true;
          processed = true;
        }
      }
      if (!processed) {
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_DISAMBIGUATION))) {
          tmpResult.append(tmpAttrib.toXMLStringV2());
        } else {  // it is not disambiguation attribute
          SugEntityAdditionalAttribute adAt = tmpAttrib.toSugEntityAdditionalAttribute();
          if (adAt != null) {
            adAt.setRefEntityAttribute(kRefAt);
            kRefAt.getEntityAdditionalAttributes().add(adAt);
          } else {
            tmpResult.append(tmpAttrib.toXMLStringV2());
          }
        }
      }  // if (!processed)
    }  // while (attribIt.hasNext ...
    if (nameSet && desSet && uriSet) {  // successfull conversion
      result.append(kRefAt.toXMLStringV2());
      result.append(tmpResult);
    } else {  // unsuccessfull conversion
      attribIt = attributes.iterator();
      while (attribIt.hasNext()) {
        SugBaseAttribute tmpAttrib = attribIt.next();
        if (!SugAttributeManager.hasAttributeRightInstance(tmpAttrib)) {
          tmpAttrib = SugAttributeManager.changeAttributeInstance(tmpAttrib);
        }
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        result.append(tmpAttrib.toXMLStringV2());
      }
    }
    return result;
  }  // attributesToKBRefString()
  
  /**
   * Returns xpointers of all suggestion fragments
   *
   * @return Returns xpointers of all suggestion fragments
   */
  public String getFragmentXpointers(){
    String xpointers = "";

    Iterator<SuggestionFragment> fragIt = fragments.iterator();
    while(fragIt.hasNext()){
      xpointers += "#" + fragIt.next().getXpointer();
    }
    
    return xpointers;
  }
  
  /**
   * Returns serialized informations about suggestion in XML
   *
   * @param proto11 If true, protocol version is greather then 1.0
   * @return Returns serialized informations about suggestion in XML
   */
  public String toXMLString(boolean proto11) {
    return toXMLString(true, "", proto11);
  }

  /**
   * Returns serialized informations about suggestion in XML
   *
   * @param annotTag Denotes whether wrapping tag suggestion should be included
   * @param annotTagAttrs Attributes of created suggestion tag
   * @param proto11 If true, protocol version is greather then 1.0
   * @return Returns serialized informations about suggestion in XML
   */
  public String toXMLString(boolean annotTag, String annotTagAttrs, boolean proto11) {
    String authorAttr = "";
    if (authorName != null) {
      authorAttr = authorAttr + " name=\"" + authorName + "\"";
    }
    if (authorAddress != null) {
      authorAttr = authorAttr + " address=\"" + authorAddress + "\"";
    }
    String tIdForD = " tmpId=\"" + id + "\"";
    String authorIdString = "";
    if (authorIdStr != null) {
      authorIdString = authorIdStr;
    }
    
    String tmpContent = "";
    if(content != null){
      tmpContent = content;
    }
    
    if (annotTag) {
      return "<annotation" + annotTagAttrs + ">"
        + "<rdf:Description" + tIdForD + " rdf:about=\"\">"
          + "<rdf:type rdf:resource=\"" + annotType.getUri() + "\"/>"
          + "<a:author id=\"" + authorIdString + "\"" + authorAttr + "/>"
          + "<a:source rdf:resource=\"" + source + "\"/>"
          + fragmentsToXMLString()
          + "<a:content>"
          + "<![CDATA["
          + tmpContent
          + "]]>"
          + "</a:content>"
          + attributesToXMLString(proto11)
        + "</rdf:Description>"
        + "</annotation>";
    }
    return "<rdf:Description" + tIdForD + " rdf:about=\"\">"
        + "<rdf:type rdf:resource=\"" + annotType.getUri() + "\"/>"
        + "<a:author id=\"" + authorIdString + "\"" + authorAttr + "/>"
        + "<a:source rdf:resource=\"" + source + "\"/>"
        + fragmentsToXMLString()
        + "<a:content>"
        + "<![CDATA["
        + tmpContent
        + "]]>"
        + "</a:content>"
        + attributesToXMLString(proto11)
      + "</rdf:Description>";
  }  // toXMLString()
  
  /**
   * Returns serialized informations about suggested fragments in XML
   *
   * @return Returns serialized informations about suggested fragments in XML
   */
  public String fragmentsToXMLString() {
    String fragmentsString = "";
    Iterator<SuggestionFragment> fragIt = fragments.iterator();
    SuggestionFragment fr;
    while (fragIt.hasNext()) {
      fr = fragIt.next();
      fragmentsString += fr.toXMLString();
    }
    return fragmentsString;
  }

  /**
   * Returns serialized informations about suggestion attributes in XML
   *
   * @param proto11 If true, protocol version is greather then 1.0
   * @return Returns serialized informations about suggestion attributes in XML
   */
  public String attributesToXMLString(boolean proto11) {
    String attrString = "";
    // a name of the attribute without additional number at the end
    String attrNameString;
    // the key consists of an attribute name and an attribute simple type
    String attrMapKey;
    // the value is used in case that the list contains more attributes with
    // the same name, the number is appended at the end of the name
    // represents number of identical names found so far, the value is obtained
    // from the map
    Integer attrNameIdx;
    HashMap<String, Integer> sameNameCntMap = new HashMap<String, Integer>();

    Collections.sort(attributes);
    Iterator<SugBaseAttribute> attrIt = attributes.iterator();
    SugBaseAttribute attr;
    while (attrIt.hasNext()) {
      attr = attrIt.next();
      if(!SugAttributeManager.hasAttributeRightInstance(attr)){
        SugAttributeManager.changeAttributeInstance(attr);
      }
      attrNameString = attr.getName();
      attrMapKey = attrNameString.concat(attr.getSimpleType());
      if (sameNameCntMap.containsKey(attrMapKey)) {
        // the same attribute name was found before, get the count of previously
        // found names
        attrNameIdx = sameNameCntMap.get(attrMapKey);
        attrNameIdx += 1;
        // append the number at the end of the name and make an XML string
        attr.setName(attrNameString.concat(attrNameIdx.toString()));
        attrString += attr.toXMLString(proto11, false);
        // restore original name
        attr.setName(attrNameString);
        // update the entry
        sameNameCntMap.put(attrMapKey, attrNameIdx);
      } else {
        // the attribute name wasn't fount until now, make a map entry
        attrString += attr.toXMLString(proto11, false);
        sameNameCntMap.put(attrMapKey, 1);
      }
    }
    return attrString;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same id.
   *
   * @param object Object to compare with
   * @return If object is same type and have same id, returns true, false otherwise
   */
  @Override
  public boolean equals(Object object) {
    if (!(object instanceof Suggestion)) {
      return false;
    }
    Suggestion other = (Suggestion) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    
    if(other.id == null && this.id == null){
      if(!contentEquals(object)){
        return false;
      }
    }
    
    return true;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same id, but not go to deeper comparation if noLinked is set to true.
   *
   * @param object Object to compare with
   * @param noLinked No trace links and compare them if is set to true
   * @return If object is same type and have same id, returns true, false otherwise
   */
  public boolean equals(Object object, boolean noLinked){
    if (!(object instanceof Suggestion)) {
      return false;
    }
    Suggestion other = (Suggestion) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    
    if(other.id == null && this.id == null){
      if(!contentEquals(object,false,noLinked)){
        return false;
      }
    }
    
    return true;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irelevant). Contents of fragments
   * and attributes are also compared.
   *
   * @param obj Object to compare with
   * @return If object is same type and have same content, returns true, false otherwise
   */
  public boolean contentEquals(Object obj) {
    return contentEquals(obj,false,false);
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irrelevant). Contents of fragments
   * and attributes are also compared.
   *
   * @param obj Object to compare with
   * @param withCreated If true, dates of creation will be compared, if false, dates will be omitted
   * @param noLinked If true, links in attributes will be omitted, if false, links will be compared
   * @return If object is same type and have same content, returns true, false otherwise
   */
  public boolean contentEquals(Object obj, boolean withCreated, boolean noLinked) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final Suggestion other = (Suggestion) obj;
    if (withCreated) {
      if (this.created != other.created && (this.created == null || !this.created.equals(other.created))) {
        return false;
      }
    }
    if ((this.authorIdStr == null) ? (other.authorIdStr != null) : !this.authorIdStr.equals(other.authorIdStr)) {
      return false;
    }
    if ((this.authorName == null) ? (other.authorName != null) : !this.authorName.equals(other.authorName)) {
      return false;
    }
    if ((this.authorAddress == null) ? (other.authorAddress != null) : !this.authorAddress.equals(other.authorAddress)) {
      return false;
    }
    if ((this.source == null) ? (other.source != null) : !this.source.equals(other.source)) {
      return false;
    }
    if ((this.content == null) ? (other.content != null) : !this.content.equals(other.content)) {
      return false;
    }
    if (this.annotType != other.annotType && (this.annotType == null || !this.annotType.equals(other.annotType))) {
      return false;
    }
    if (this.sourceDocument != other.sourceDocument && (this.sourceDocument == null || !this.sourceDocument.equals(other.sourceDocument))) {
      return false;
    }

    if (this.attributes == null && other.attributes != null) {
      return false;
    } else if (this.attributes != null && other.attributes == null) {
      return false;
    } else if (this.attributes != other.attributes && this.attributes != null && other.attributes != null) {
      if (this.attributes.size() != other.attributes.size()) {
        return false;
      }
      Iterator<SugBaseAttribute> atIt = this.attributes.iterator();
      while (atIt.hasNext()) {
        SugBaseAttribute at = atIt.next();
        boolean found = false;
        Iterator<SugBaseAttribute> oAtIt = other.attributes.iterator();
        if(noLinked && at instanceof SugLinkedAttribute){
          continue;
        }
        while (oAtIt.hasNext()) {
          SugBaseAttribute oAt = oAtIt.next();
          
          if(at instanceof SugLinkedAttribute && oAt instanceof SugLinkedAttribute){
            if(at.getValue() != null && ((Suggestion)at.getValue()).equals(oAt,true)){
              found = true;
              break;
            }
          }
          
          if (at.contentEquals(oAt,false)) {
            found = true;
            break;
          }
        }
        if (!found) {
          return false;
        }
      }
    }
    if (this.fragments == null && other.fragments != null) {
      return false;
    } else if (this.fragments != null && other.fragments == null) {
      return false;
    } else if (this.fragments != other.fragments && this.fragments != null && other.fragments != null) {
      if (this.fragments.size() != other.fragments.size()) {
        return false;
      }
      Iterator<SuggestionFragment> frIt = this.fragments.iterator();
      while (frIt.hasNext()) {
        SuggestionFragment fr = frIt.next();
        boolean found = false;
        Iterator<SuggestionFragment> oFrIt = other.fragments.iterator();
        while (oFrIt.hasNext()) {
          SuggestionFragment oFr = oFrIt.next();
          if (fr.contentEquals(oFr)) {
            found = true;
            break;
          }
        }
        if (!found) {
          return false;
        }
      }
    }
    if (this.user != other.user && (this.user == null || !this.user.equals(other.user))) {
      return false;
    }
    if (this.nestedInSuggestion == null && other.nestedInSuggestion != null) {
      return false;
    } else if (this.nestedInSuggestion != null && other.nestedInSuggestion == null) {
      return false;
    }
    return true;
  }  // contentEquals()

  @Override
  public String toString() {
    return "cz.vutbr.fit.knot.annotations.modules.SuggestionManager.Suggestion[ id=" + id + " ]";
  }
  
  /**
   * Gets URI of suggestion
   *
   * @return URI of suggestion
   */
  public String getURI() {
    if (id == null) {
      return "";
    }
    return AppBean.getBaseSugUri() + id;
  }
}  // class Suggestion