SugPersister.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: SugPersister.java
 * Description: Static class which persists data to the database
 */

/**
 * @file SugPersister.java
 *
 * @brief Static class which persists data to the database
 */

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.comet.Persister;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.comet.SuggestionLogEntry;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.LinkedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.NestedAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugAttributeManager;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugBaseAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugLinkedAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugNestedAttribute;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

/**
 * Static class which persists suggestion data to the database
 *
 * @brief Static class which persists suggestion data to the database
 */
public class SugPersister {

  /**
   * Persist informations from request to the database
   * (it persists derived and related informations too)
   * 
   * @param requestInfo Informations about client request
   * @param addedAnnotations Added Annotations
   * @param editedAnnotations Edited Annotations
   * @param NERsuggestions suggestionsFromNER
   * @param solveFeedbacks If I should update suggestion feedback and confidence
   * @param addedTypes Added types
   * @return If succeed, returns false, in case of error returns true
   */
  public static ArrayList<Suggestion> persist(RequestInfo requestInfo, ArrayList<Annotation> addedAnnotations, ArrayList<Annotation> editedAnnotations,
          ArrayList<Suggestion> NERsuggestions, boolean solveFeedbacks, ArrayList<AnnotType> addedTypes)
  {
    ArrayList<Annotation> requestAnnotations = null;
    if (addedAnnotations != null || editedAnnotations != null) {
      requestAnnotations = new ArrayList<Annotation>();
      if (addedAnnotations != null) {
        requestAnnotations.addAll(addedAnnotations);
      }
      if (editedAnnotations != null) {
        requestAnnotations.addAll(editedAnnotations);
      }
    }

    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    ArrayList<Suggestion> touchedSuggestions = new ArrayList<Suggestion>();
    try {
      transaction.begin();

      /* Persist types */
      // create list without attributes and ansestors and map with original types
      ArrayList<AnnotType> nTWA = new ArrayList<AnnotType>();
      Map<String, AnnotType> nTMap = new HashMap<String, AnnotType>();
      for (Iterator<AnnotType> ntIt = addedTypes.iterator(); ntIt.hasNext();) {
        AnnotType type = ntIt.next();
        // skip type, that is stored in DB
        if (type.getId() != null) {
          continue;
        }
        AnnotType nT = new AnnotType(type.getUri(), type.getName(), null, type.getGroup());
        nT.setRestrictedAtt(type.getRestrictedAtt());
        nT.setUriInOntology(type.getUriInOntology());
        nT.setComment(type.getComment());
        nTWA.add(nT);
        nTMap.put(type.getUri(), type);
      }

      // merge types without attributes and create map with merged types
      ArrayList<AnnotType> newCreatedTypes = new ArrayList<AnnotType>();
      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();
        // skip type, that is stored in DB
        if (type.getId() != null) {
          continue;
        }
        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
        // skip type, that is stored in DB
        if (oType == null || mType == null){
          continue;
        }
        // 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);
          }
          // skip type, that is stored in DB
          if (rType != null && rType.getId() == null){
            mType.setAncestorType(rType);
          }
        }

        // ancestors
        ArrayList<AnnotType> newAncestors = new ArrayList<AnnotType>();
        if (oType.getAncestorTypes() != null) {
          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);
            }
            // skip type, that is stored in DB
            if (mAnc != null && (ancType.getId() != null || mAnc.getId() != null)) {
              continue;
            }
            newAncestors.add(mAnc);
          }
        }
        mType.setAncestorTypes(newAncestors);

        mType = em.merge(mType);
        newCreatedTypes.add(mType);
      }  // fix, add and merge attributes and ancestors

      // delete every type without id from addedTypes and add types with id
      for (Iterator<AnnotType> it = addedTypes.iterator(); it.hasNext();) {
        AnnotType type = it.next();
        if (type.getId() == null) {
          it.remove();
        }
      }
      addedTypes.addAll(newCreatedTypes);


      // get all confirmed suggestions
      ArrayList<Suggestion> suggestions = new ArrayList<Suggestion>();
      ArrayList<SuggestionLogEntry> confirmed = requestInfo.getConfirmedSuggestions();
      ArrayList<Annotation> confirmedAnnotations = new ArrayList<Annotation>();
      // Maps annotation on it's old suggestion, it will be used for
      // linked attribute value update
      HashMap<Annotation, Suggestion> anOldSugLinkMap = new HashMap<Annotation, Suggestion>();
      // suggestion for annotation (that was edited) was like confirmed suggestions
      if (editedAnnotations != null) {
        for (Iterator<Annotation> it = editedAnnotations.iterator(); it.hasNext();) {
          Annotation an = it.next();
          Query query2 = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
          query2.setParameter(1, an.getId());
          List sList = query2.getResultList();
          if (sList != null && !sList.isEmpty()) {
            SuggestionFeedback sugFeed = (SuggestionFeedback) sList.get(0);
            Suggestion s = sugFeed.getSuggestion();
            s.setConfidence(0);
            s = em.merge(s);
            sugFeed.setAnnot(null);
            em.merge(sugFeed);
            setNestedZeroConfidence(em, an, touchedSuggestions);
            anOldSugLinkMap.put(an, s);
            if (!touchedSuggestions.contains(s)) {
              touchedSuggestions.add(s);
            }
          }
        }
      }

      if(requestAnnotations != null){
        if(confirmed != null && !confirmed.isEmpty()){
          Iterator<SuggestionLogEntry> logIt = confirmed.iterator();
          while(logIt.hasNext()){
            SuggestionLogEntry actualLogItem = logIt.next();
            Suggestion actualSuggestion = getSuggestionFromDB(Integer.parseInt(actualLogItem.getTmpId()), em);
            if(actualSuggestion != null){                 
              if (actualLogItem.getConfirmMethod() == Constants.CONFIRMED_MANUALLY_EDITED) {
                actualSuggestion.setConfidence(0);
                em.merge(actualSuggestion);
                setNestedSugZeroConfidence(em, actualSuggestion, touchedSuggestions);
                if (actualLogItem.getConfirmedVersion() != null && actualLogItem.getConfirmedVersion().getAnnotType() != null && actualLogItem.getConfirmedVersion().getAnnotType().getGroup() != null) {
                  createNewFeedback(em, null, actualSuggestion, actualLogItem.getConfirmedVersion().getAnnotType().getGroup());
                }
                if (!touchedSuggestions.contains(actualSuggestion)) {
                  touchedSuggestions.add(actualSuggestion);
                }
              } else {
                suggestions.add(actualSuggestion);
                confirmedAnnotations.add(actualLogItem.getConfirmedVersion());
              }
            }
          }
        }
      }


      // get all annotations which doesn't have suggestion and save their suggestions without nested and links
      Iterator<Annotation> reqAnnotIt;
      ArrayList<Annotation> nestedInReqAnnotations = new ArrayList<Annotation>();
      HashMap<Integer, Suggestion> reqSuggs = new HashMap<Integer, Suggestion>();
      // Maps annotation on it's new suggestion, it will be used for
      // linked attribute value update
      HashMap<Annotation, Suggestion> anNewSugLinkMap = new HashMap<Annotation, Suggestion>();
      if(requestAnnotations != null){
        reqAnnotIt = requestAnnotations.iterator();
        while(reqAnnotIt.hasNext()){
          Annotation annot = reqAnnotIt.next();
          if(!confirmedAnnotations.contains(annot)){
            saveSuggestionsWithoutLinks(requestInfo, em, annot, reqSuggs, nestedInReqAnnotations, touchedSuggestions, anNewSugLinkMap);
          }
        }
      }
      em.flush();

      // divide suggestions
      ArrayList<Suggestion> sugForStore = new ArrayList<Suggestion>();
      ArrayList<Suggestion> sugForActualization = new ArrayList<Suggestion>();
      if(requestAnnotations != null){
        for (Iterator<Suggestion> it = suggestions.iterator(); it.hasNext();) {
          Suggestion sg = it.next();
          if (sg.getId() == null) {
            sugForStore.add(sg);
          } else {
            sugForActualization.add(sg);
          }
        }
      }
      else{
        Iterator<Suggestion> sugListIt = NERsuggestions.iterator();
        while(sugListIt.hasNext()){
          Suggestion sug = sugListIt.next();
          
          List sList = null;
          if (sug.getId() != null) {
            Query query = em.createNamedQuery("Suggestion.findById");
            query.setParameter("id", sug.getId());
            sList = query.getResultList();
          }
          
          if (sList == null || sList.isEmpty()) {
            //new
            sugForStore.add(sug);
          }
          else{
            sugForActualization.add(sug);
          }
        }
      }

      /* Persist suggestions */
      ArrayList<Suggestion> nowSavedSugs = new ArrayList<Suggestion>();
      ArrayList<Suggestion> justSavedSugs = new ArrayList<Suggestion>();
      Iterator<Suggestion> addedSugIter = sugForStore.iterator();
      while (addedSugIter.hasNext()) {  // for each added suggestion
        Suggestion sug = addedSugIter.next();
        if (sug.getAnnotType() == null) {
          continue;
        }
        if (sug.getAnnotType().getId() == null) {
          updateTypes(sug, em, "New type of suggestion was not found by Persister: ");
        }
        updateTypesInNested(sug, em);  // update types in nested suggestions
        if (justSavedSugs.contains(sug)) {  // skip just saved to avoid duplicity
          continue;
        }
        // update tmpId links in attributes
        saveTmpIdRefSuggestions(sug, requestInfo, em, justSavedSugs, nowSavedSugs);
      }  // for each added suggestion

      // change suggestion list
      suggestions.clear();
      if (NERsuggestions != null) {
        NERsuggestions.clear();
      }
      for (Iterator<Suggestion> it = nowSavedSugs.iterator(); it.hasNext();) {
        Suggestion sg = it.next();
        suggestions.add(sg);
        if (NERsuggestions != null) {
          NERsuggestions.add(sg);
        }
        touchedSuggestions.add(sg);
      }

      Iterator<Suggestion> editSuggIter = sugForActualization.iterator();
      while (editSuggIter.hasNext()) {
        Suggestion suggestion = editSuggIter.next();
        if (suggestion.getAnnotType() == null || suggestion.getAnnotType().getId() == null) {
          updateTypes(suggestion, em, "New type of annotation for edited suggestion was not found by Persister: ");
        }
        if(requestAnnotations != null){
          updateSugg(em, suggestion, requestInfo, touchedSuggestions, solveFeedbacks);
        }
        else{
          updateNerSugg(em, suggestion, touchedSuggestions, requestInfo);
        }
        if (!touchedSuggestions.contains(suggestion)) {
          touchedSuggestions.add(suggestion);
        }
        if (NERsuggestions != null && !NERsuggestions.contains(suggestion)) {
          NERsuggestions.add(suggestion);
        }
      }

      em.flush();

      if(requestAnnotations != null){
        // do linked attributes of request annotations
        reqAnnotIt = requestAnnotations.iterator();
        while(reqAnnotIt.hasNext()){
          updateLinksAndNested(reqAnnotIt.next(), reqSuggs, em, touchedSuggestions);
        }

        // do linked attributes of nested in request annotations
        Iterator<Annotation> nestedInReqIt = nestedInReqAnnotations.iterator();
        while(nestedInReqIt.hasNext()){
          updateLinksAndNested(nestedInReqIt.next(), reqSuggs, em, touchedSuggestions);
        }
      }

      // Update URI of linked annotations
      Iterator<Suggestion>addeSuggIter = sugForStore.iterator();
      while(addeSuggIter.hasNext()){
        Suggestion actualSugg = addeSuggIter.next();
        setUriOfSuggParams(actualSugg);
      }

      Iterator<Suggestion>edSuggIter = sugForActualization.iterator();
      while(edSuggIter.hasNext()){
        Suggestion actualSugg = edSuggIter.next();
        setUriOfSuggParams(actualSugg);
      }
      
      // annotations link in DB that points to old suggestions will be update to point to new suggestions
      Iterator oldSugIt = anOldSugLinkMap.entrySet().iterator();
      // go trough map of edited annotations and corresponding suggestions from feedback
      while (oldSugIt.hasNext()) {
        Map.Entry pair = (Map.Entry)oldSugIt.next();
        // find matching new annotations
        if (anNewSugLinkMap.containsKey((Annotation)pair.getKey())) {
          // get new and old suggestion for the given annotation
          Suggestion newSug = anNewSugLinkMap.get((Annotation)pair.getKey());
          Suggestion oldSug = (Suggestion)pair.getValue();
          
          // find attributes that links old suggestion
          Query query = em.createNamedQuery("SuggestionAttribute.findByLinked");
          query.setParameter("linked", oldSug.getId());
          
          @SuppressWarnings("unchecked")
          List<SugBaseAttribute> attList = query.getResultList();
          // linked attributes found in the DB
          if (attList != null && !attList.isEmpty()) {
            // update linked attributes from the database
            Iterator<SugBaseAttribute> sugListIt = attList.iterator();
            while (sugListIt.hasNext()) {
              SugBaseAttribute sba = sugListIt.next();
              // sla must be instance of SugLinkedAttribute
              if(!SugAttributeManager.hasAttributeRightInstance(sba)){
                sba = SugAttributeManager.changeAttributeInstance(sba);
              }
              if (!(sba instanceof SugLinkedAttribute)) {
                continue;
              }
              SugLinkedAttribute sla = (SugLinkedAttribute) sba;
              // attribute's value is pointing to the old version
              if (sla.getLinkedSuggestion() != null && sla.getLinkedSuggestion().getURI() != null
                    && oldSug.getURI() != null) {
                // update the value
                sla.setValue(newSug);
                em.merge(sla);
              } else {
                if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
                  String msg = "Wrong attribute.";
                  Logger.getLogger(SuggestionManager.class.getName()).log(Level.SEVERE, msg);
                }
              }
            }
          }
        }
      }
      

      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the persisting of data.";
        Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg, e);
      }
      errorOccurred = true;
    } finally {
      em.close();
    }

    if (errorOccurred && (!requestInfo.getJoinedGroups().isEmpty() || !requestInfo.getLeavedGroups().isEmpty())) {
      // refresh user informations
      Object[] params = new Object[2];
      params[0] = "id";
      params[1] = requestInfo.getSession().getUser().getId();
      List uList = AppBean.getPersistenceManager().queryDB("User.findById", params);
      if (uList != null && !uList.isEmpty()) {
        requestInfo.getSession().setUser((User) uList.get(0));
        requestInfo.getSession().actualizeAllCachedSettings();
      }
    }

    return touchedSuggestions;
  }  // persist()
 
  /**
   * Update suggestion from NER
   * 
   * @param em Entity Manager
   * @param sug Suggestion
   * @param touchedSug Changed suggestions
   * @param request information about client request
   */
  public static void updateNerSugg(EntityManager em, Suggestion sug, ArrayList<Suggestion> touchedSug, RequestInfo request){
    Query query = em.createNamedQuery("Suggestion.findById");
    query.setParameter("id", sug.getId());
    List sList = query.getResultList();

    if (sList == null || sList.isEmpty()) {
      //new
      sug = em.merge(sug);
    }
    else{
      Suggestion s = (Suggestion) sList.get(0);
      // update fragments
      List<SuggestionFragment> fragments = s.getFragments();
      Iterator<SuggestionFragment> frIter = fragments.iterator();
      Iterator<SuggestionFragment> newFrIter = sug.getFragments().iterator();
      while (frIter.hasNext()) {
        SuggestionFragment fr = frIter.next();
        if (!newFrIter.hasNext()) {
          em.remove(fr);
        } else {
          SuggestionFragment newFr = newFrIter.next();
          newFr.setId(fr.getId());
        }
      }

      // update attributes
      List attrs = s.getAttributes();
      Iterator attrsIt = attrs.iterator();

      // find already saved nested suggestions
      HashMap<Integer, Suggestion> nestedSugs = new HashMap<Integer, Suggestion>();

      while (attrsIt.hasNext()) {
        SugBaseAttribute attr = (SugBaseAttribute) attrsIt.next();
        if (attr.getNestedSuggestion() != null) {
          nestedSugs.put(attr.getNestedSuggestion().getId(), attr.getNestedSuggestion());
        }
      }

      // update tmpId links in attributes
      saveTmpIdRefSuggestions(sug, request, em);
      
      // Update of attributes is not implemented and not necessary as they are not changing.
      // Only fragments and confidences should be changed here if somebody would like to upgrade it.

      // merge Suggestion
      em.merge(sug);
      em.flush();
    }
  }  // updateNerSugg()
 
  /**
   * Function saves Annotation as Suggestion into DB without linked attributes.
   * 
   * @param requestInfo information about client request
   * @param em Entity manager
   * @param annot Annotation which is converted
   * @param reqSuggs HasMap with Original Annotation ID as key and new Suggestion as value
   * @param nestedInReqAnnotations Array with nested annotations
   * @param touchedSuggestions Array with changed suggestions
   * @param anNewSugLinkMap Annotation and new link map
   * @return saved suggestion
   */
  public static Suggestion saveSuggestionsWithoutLinks(RequestInfo requestInfo, EntityManager em, Annotation annot, HashMap<Integer, Suggestion> reqSuggs,
          ArrayList<Annotation> nestedInReqAnnotations, ArrayList<Suggestion> touchedSuggestions, HashMap<Annotation, Suggestion> anNewSugLinkMap)
  {
    Suggestion newSug = null;
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = annot.getId();
    Query q = em.createNamedQuery("SuggestionFeedback.findByAnnotNotNull");
    for (int p = 0; p < params.length; p = p + 2) {
      q.setParameter((String) params[p], params[p + 1]);
    }
    List sList = q.getResultList();
    if (sList == null || sList.isEmpty()) {
      newSug = new Suggestion(annot);
      // remove all nested attributes from suggestion
      if (newSug.getAttributes() != null) {
        Iterator<SugBaseAttribute> newSugAttIt = newSug.getAttributes().iterator();
        if (newSugAttIt != null) {
          while (newSugAttIt.hasNext()) {
            SugBaseAttribute sba = newSugAttIt.next();
            if (sba.getSimpleType().contentEquals("NestedSuggestion")) {
              newSugAttIt.remove();
            }
          }
        }
      }
      newSug.setConfidence(SuggestionManager.CONFIRMED_CONFIDENCE);
      List<BaseAttribute> attrs = annot.getAttributes();
      Iterator<BaseAttribute> attrsIt = attrs.iterator();

      // delete linked attributes
      if (newSug.getAttributes() != null) {
        for (Iterator it = newSug.getAttributes().iterator(); it.hasNext();) {
          Object attribute = it.next();
          if (attribute instanceof SugLinkedAttribute /*|| attribute instanceof SugNestedAttribute*/) {
            it.remove();
          }
        }
      }

      // to all suggesiton in this list should be set NestedInSuggestion newSug
      ArrayList<Suggestion> toAddNestedIn = new ArrayList<Suggestion>();
      // create nested attributes again
      while(attrsIt.hasNext()){
        BaseAttribute attr = attrsIt.next();
        if(attr.getSimpleType().equalsIgnoreCase("NestedAnnotation")){
          // create nested again with value
          if (((NestedAnnotationAttribute)attr).getValue() != null) {
            Suggestion nested = saveSuggestionsWithoutLinks(requestInfo, em, (Annotation) ((NestedAnnotationAttribute)attr).getValue(),
                    reqSuggs, nestedInReqAnnotations, touchedSuggestions, anNewSugLinkMap);
            if(nested != null){
              Boolean unknownError = false;
              SugBaseAttribute nestedAttr = null;
              try{
                nestedAttr = SugAttributeManager.createAttribute(attr.getName(), "NestedSuggestion", newSug);
                nestedAttr.updateFromBaseAttribut(attr);
              }
              catch(ClassNotFoundException ex){
                unknownError = true;
              }
              if(!unknownError){
                if (attr.getAttributeType() != null) {
                  ((SugNestedAttribute) nestedAttr).setAttributeType(attr.getAttributeType());
                }
                nestedAttr.setNestedSuggestion(nested);
                toAddNestedIn.add(nested);
                newSug.addAttribute(nestedAttr);
              }
            }
            nestedInReqAnnotations.add((Annotation) ((NestedAnnotationAttribute)attr).getValue());
          } else { // create nested again without value
            try{
              SugBaseAttribute nestedAttr = SugAttributeManager.createAttribute(attr.getName(), "NestedSuggestion", newSug);
              nestedAttr.updateFromBaseAttribut(attr);
              if (attr.getAttributeType() != null) {
                ((SugNestedAttribute) nestedAttr).setAttributeType(attr.getAttributeType());
              }
              newSug.addAttribute(nestedAttr);
            } catch(ClassNotFoundException ex) {
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
                String msg = "Unknown type of attribute found.";
                Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg);
              }
            }
          }
        }
      }
      
      newSug = em.merge(newSug);
      anNewSugLinkMap.put(annot, newSug);
      em.flush();
      
      // add nestedIn
      for (Iterator<Suggestion> it = toAddNestedIn.iterator(); it.hasNext();) {
        Suggestion nested = it.next();
        nested.setNestedInSuggestion(newSug);
        em.merge(nested);
      }
      
      createNewFeedback(em, annot, newSug, annot.getAnnotType().getGroup());
      if(!touchedSuggestions.contains(newSug)){
        touchedSuggestions.add(newSug);
      }
      reqSuggs.put(annot.getId(), newSug);
    }
    return newSug;
  }  // saveSuggestionsWithoutLinks()
 
  /**
   * Method updates links in saved suggestions
   * 
   * @param annot Annotation which is updated
   * @param reqSuggs HasMap with Original Annotation ID as key and new Suggestion as value
   * @param em Entity manager
   * @param touchedSuggestions changed suggestions
   */
  public static void updateLinksAndNested(Annotation annot,
          HashMap<Integer, Suggestion> reqSuggs, EntityManager em, ArrayList<Suggestion> touchedSuggestions)
  {
    Iterator<BaseAttribute> attrsIt = annot.getAttributes().iterator();
    while(attrsIt.hasNext()){
      BaseAttribute attr = attrsIt.next();
      if(attr.getSimpleType().equalsIgnoreCase("AnnotationLink")){
        Suggestion lSug = reqSuggs.get(annot.getId());
        if (lSug != null) {
          SugLinkedAttribute linkedAttr = null;
          try {
            linkedAttr = (SugLinkedAttribute) SugAttributeManager.createAttribute(attr.getName(), "SuggestionLink", lSug);
          } catch (Exception e) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
              String msg = "Attempt to create unsupported type of attribute.";
              Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg);
            }
            continue;
          }
          linkedAttr.updateFromBaseAttribut(attr);
          linkedAttr.setName(attr.getName());
          lSug.addAttribute(linkedAttr);
          LinkedAnnotationAttribute laat = (LinkedAnnotationAttribute) attr;
          if(laat.getValue() == null){
            // annotation link is null
            continue;
          }
          Annotation aVal = (Annotation) laat.getValue();
          int linkedID = aVal.getId();
          try {
            Query query = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
            query.setParameter(1, linkedID);
            List sList = query.getResultList();
            if (sList != null && !sList.isEmpty()) {
              SuggestionFeedback linkedSugFeed = (SuggestionFeedback) sList.get(0);
              Suggestion linkedSug = linkedSugFeed.getSuggestion();
              linkedAttr.setValue(linkedSug);
              em.merge(lSug);
              if (!touchedSuggestions.contains(lSug)) {
                touchedSuggestions.add(lSug);
              }
            }
          } catch (Exception e) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
              String msg = "Problem with database.";
              Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg);
            }
          }
        } else {
          try {
            Query query = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
            query.setParameter(1, annot.getId());
            List sList = query.getResultList();
            if (sList != null && !sList.isEmpty()) {
              SuggestionFeedback lSugFeed = (SuggestionFeedback) sList.get(0);
              lSug = lSugFeed.getSuggestion();
              SugLinkedAttribute linkedAttr = (SugLinkedAttribute) SugAttributeManager.createAttribute(attr.getName(), "SuggestionLink", lSug);
              linkedAttr.updateFromBaseAttribut(attr);
              lSug.addAttribute(linkedAttr);
              LinkedAnnotationAttribute laat = (LinkedAnnotationAttribute) attr;
              Annotation aVal = (Annotation) laat.getValue();
              if(laat.getValue() == null){
                // annotation link is null
                continue;
              }
              int linkedID = aVal.getId();
              Query query2 = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
              query2.setParameter(1, linkedID);
              sList = query2.getResultList();
              if (sList != null && !sList.isEmpty()) {
                SuggestionFeedback linkedSugFeed = (SuggestionFeedback) sList.get(0);
                Suggestion linkedSug = linkedSugFeed.getSuggestion();
                linkedAttr.setValue(linkedSug);
                em.merge(lSug);
                if (!touchedSuggestions.contains(lSug)) {
                  touchedSuggestions.add(lSug);
                }
              }
            }
          } catch (Exception e) {
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
              String msg = "Problem with database.";
              Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg);
            }
          }
        }  // else
      }
    }  // while(attrsIt.hasNext()){
  }  // updateLinksAndNested()
  
  /**
   * Updates suggestion feedback and confidence in DB
   *
   * @param em Entity manager
   * @param suggestion Updated suggestion
   * @param requestInfo Information about client request
   * @param touchedSuggestions Touched suggestions in persister
   * @param solveFeedback determines if we are solving a feedback
   * @throws RuntimeException 
   */
  public static void updateSugg(EntityManager em, Suggestion suggestion, RequestInfo requestInfo,
          ArrayList<Suggestion> touchedSuggestions, boolean solveFeedback) throws RuntimeException
  {
    Integer setConfidence = null;
    SuggestionLogEntry actualEntry = null;
    
    ArrayList<SuggestionLogEntry> confirmeSug = requestInfo.getConfirmedSuggestions();
    if(confirmeSug != null){
      Iterator<SuggestionLogEntry> confirmeSugIt = confirmeSug.iterator();
      while(confirmeSugIt.hasNext()){
        SuggestionLogEntry sugLog = confirmeSugIt.next();
        String tmpId = sugLog.getTmpId();
        int tmpIdInt;
        try{
          tmpIdInt = Integer.parseInt(tmpId);
        }
        catch(NumberFormatException ex){
          continue;
        }
        if(tmpIdInt == suggestion.getId()){
          actualEntry = sugLog;
          if(sugLog.getConfirmMethod() == Constants.CONFIRMED_MANUALLY_EDITED
                  || sugLog.getConfirmMethod() == Constants.CONFIRMED_MANUALLY)
          {
            setConfidence = 95;
          }
          else if(sugLog.getConfirmedVersion().getNestedInAnnot() != null){
            if(sugLog.getConfirmMethod() == Constants.CONFIRMED_AUTOMATICALLY
                    || sugLog.getConfirmMethod() == Constants.CONFIRMED_AUTOMATICALLY_EDITED){
              setConfidence = 95;
            }
          }
          break;
        }
      }
    }

    // update tmpId links in attributes
    Suggestion sg = saveTmpIdRefSuggestions(suggestion, requestInfo, em);
    if(sg != null && !touchedSuggestions.contains(sg)){
      touchedSuggestions.add(sg);
    }
    
    if(setConfidence != null && solveFeedback){
      suggestion.setConfidence(setConfidence);
    }
    em.merge(suggestion);

    if(solveFeedback){
      Annotation confirmedAnnot = actualEntry.getConfirmedVersion();
      UserGroup userGroup = actualEntry.getConfirmedVersion().getAnnotType().getGroup();
      createNewFeedback(em, confirmedAnnot, suggestion, userGroup);
    }

    if(!touchedSuggestions.contains(suggestion)){
      touchedSuggestions.add(suggestion);
    }
  }  // updateSugg()

  /**
   * Sets uri from value in annotation link parameters of given suggestion, also
   * recursively in nested suggestions
   *
   * @param sugg Given suggestion
   */
  public static void setUriOfSuggParams(Suggestion sugg){
    List attrList = sugg.getAttributes();
    Iterator attrIt = attrList.iterator();
    while(attrIt.hasNext()){ // For all attributes od Annotation
      SugBaseAttribute attr = (SugBaseAttribute)attrIt.next();

      //for all annotation links which have uri set to null or empty value
      if((attr.getSimpleType().equals("AnnotationLink") || attr.getSimpleType().equals("SuggestionLink"))
              && attr instanceof SugLinkedAttribute && ((SugLinkedAttribute)attr).getValue() != null){
        if(((SugLinkedAttribute)attr).getUri() == null || ((SugLinkedAttribute)attr).getUri().isEmpty()){
          Suggestion value = (Suggestion) ((SugLinkedAttribute)attr).getValue();
          ((SugLinkedAttribute)attr).setUri(value.getURI());
        }
      }

      //recursively update nested suggestions
      if(attr.getSimpleType().equals("NestedAnnotation") && ((SugNestedAttribute)attr).getValue() != null){
        Suggestion value = (Suggestion) ((SugNestedAttribute)attr).getValue();
        setUriOfSuggParams(value);
      }
    }
  }  // setUriOfSuggParams()


  /**
   * 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)
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Queried type of annotation was not found by the Persister: " + uri;
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
      }
      throw new RuntimeException("New type not found!");
    }
    return annotType;
  }  // queryType()

  /**
   * Method updates types in Suggestion
   * 
   * @param sug suggestion for update
   * @param em current EntityManager
   * @param logMsg String with error
   * @throws RuntimeException
   */
  private static void updateTypes(Suggestion sug, EntityManager em, String logMsg) throws RuntimeException {
    // if it's a new type of suggestion, it must be set again after merge
    if (sug.getAnnotType() == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "The annotation has no type.";
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
      }
      return;
    }
    AnnotType annotType = null;
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = sug.getAnnotType().getUri();
    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);
      sug.setAnnotType(annotType);
      // type of the nested and linked attribute also has to be updated
      Iterator<SugBaseAttribute> attIt = sug.getAttributes().iterator();
      while (attIt.hasNext()) {
        SugBaseAttribute att = attIt.next();
        // nested and linked attributes must have type set
        if (att instanceof SugNestedAttribute || att instanceof SugLinkedAttribute) {
          // second parameter of the query is the uri of the attribute type
          if (att.getAttributeType() == null) {
            continue;
          }
          params[1] = att.getAttributeType().getUri();
          Query attTypeQuery = em.createNamedQuery("AnnotType.findByUri");
          attTypeQuery.setParameter((String) params[0], params[1]);
          // search in the database for the type with given uri
          List typeList = attTypeQuery.getResultList();
          // if the type's been found
          if (typeList != null && !typeList.isEmpty()) {
            // set attribute type to the one from the database
            att.setAttributeType((AnnotType)typeList.get(0));
          }
        }
      }
    } else {  // if type was not found (merge failed)
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = logMsg + sug.getAnnotType().getUri();
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
      }
      throw new RuntimeException("New type not found!");
    }
  } // updateTypes

  /**
   * Updates types in nested suggestions (use types stored in DB)
   *
   * @param sug Suggestion, which attributes will be updated
   * @param em Entity manager
   */
  private static void updateTypesInNested(Suggestion sug, EntityManager em) {
    Iterator<SugBaseAttribute> aIt = sug.getAttributes().iterator();
    while (aIt.hasNext()) {  // for each attribute
      SugBaseAttribute attribute = aIt.next();
      Suggestion nested = attribute.getNestedSuggestion();
      if (nested != null) {  // if nested suggestions is included
        if (nested.getAnnotType().getId() == null) {  // if it is a new type
          // if it's a new type of suggestion, it must be set again after merge
          AnnotType annotType = queryType(nested.getAnnotType().getUri(), em);
          nested.setAnnotType(annotType);
          // type of the nested and linked attribute also has to be updated
          Iterator<SugBaseAttribute> attIt = sug.getAttributes().iterator();
          while (attIt.hasNext()) {
            SugBaseAttribute att = attIt.next();
            // nested and linked attributes must have type set
            if (att instanceof SugNestedAttribute || att instanceof SugLinkedAttribute) {
              // second parameter of the query is the uri of the attribute type
              if (att.getAttributeType() == null) {
                continue;
              }
              Object[] params = new Object[2];
              params[0] = "uri";
              params[1] = att.getAttributeType().getUri();
              Query attTypeQuery = em.createNamedQuery("AnnotType.findByUri");
              attTypeQuery.setParameter((String) params[0], params[1]);
              // search in the database for the type with given uri
              List typeList = attTypeQuery.getResultList();
              // if the type's been found
              if (typeList != null && !typeList.isEmpty()) {
                // set attribute type to the one from the database
                att.setAttributeType((AnnotType)typeList.get(0));
              }
            }
          }
        }  // if it is a new type
        updateTypesInNested(nested, em);  // update nested suggestions recursively
      }  // if nested suggestion is included
    }  // for each attribute
  }  // updateTypesInNested()

  /**
   * Recursively saves suggestions in attributes of given suggestion.
   * @param sug Suggestion for reference update
   * @param requestInfo Informations about client request
   * @param em current EntityManager
   * @return uri of the new saved suggestion
   * @throws RuntimeException
   */
  private static Suggestion saveTmpIdRefSuggestions(Suggestion sug, RequestInfo requestInfo, EntityManager em) throws RuntimeException {
    return saveTmpIdRefSuggestions(sug, requestInfo, em, null, null);
  }

  /**
   * Recursively saves suggestions in attributes of given suggestion.
   * @param sug Suggestion for reference update
   * @param requestInfo Informations about client request
   * @param em current EntityManager
   * @param justSaved List of just saved suggestions (versions before saving)
   * @param nowSaved List of just saved suggestions (really saved versions)
   * @return uri of the new saved suggestion
   * @throws RuntimeException
   */
  private static Suggestion saveTmpIdRefSuggestions(Suggestion sug, RequestInfo requestInfo, EntityManager em, ArrayList<Suggestion> justSaved, ArrayList<Suggestion> nowSaved) throws RuntimeException {
    Suggestion saved = null;

    List attrList = sug.getAttributes();
    Iterator attrIt = attrList.iterator();
    while(attrIt.hasNext()){ // For all attributes of Suggestion
      SugBaseAttribute attr = (SugBaseAttribute)attrIt.next();
      if((attr instanceof SugLinkedAttribute) && ((SugLinkedAttribute)attr).getValue() != null){
        Suggestion val = (Suggestion) ((SugLinkedAttribute)attr).getValue();
        if (val.getId() == null) {
          Iterator<Suggestion> nsIt = nowSaved.iterator();
          boolean found = false;
          while (nsIt.hasNext()) {
            Suggestion suggestion = nsIt.next();
            if (suggestion.getTmpId() != null && suggestion.getTmpId().equals(val.getTmpId())) {
              attr.setValue(suggestion);
              attr.setUri(suggestion.getURI());
              found = true;
            }
          }
          if (!found) {
            Suggestion annot4update = saveTmpIdRefSuggestions(val, requestInfo, em, justSaved, nowSaved);
            attr.setValue(annot4update);
            attr.setUri(annot4update.getURI());
          }
        }
      } else if (attr instanceof SugNestedAttribute && attr.getNestedSuggestion() != null) {
        saveTmpIdRefSuggestions(attr.getNestedSuggestion(), requestInfo, em, justSaved, nowSaved);
      }
    }
    if (sug.getId() == null && sug.getNestedInSuggestion() == null) {
      updateTypes(sug, em, "New type of suggestion for tmpId linked suggestion was not found by Persister: ");
      updateTypesInNested(sug, em);
      saved = em.merge(sug);
      em.flush();
      saved.setTmpId(sug.getTmpId());
      if (justSaved != null) {
        justSaved.add(sug);
      }
      if (nowSaved != null) {
        nowSaved.add(saved);
      }
    }

    return saved;
  } // saveTmpIdRefSuggestions()

  /**
   * Creates new feedback in DB
   * 
   * @param em current EntityManager
   * @param annot Annotation
   * @param sugg Suggestion
   * @param group UserGroup
   */
  private static void createNewFeedback(EntityManager em, Annotation annot, Suggestion sugg, UserGroup group){
    SuggestionFeedback feed = new SuggestionFeedback();
    feed.setAnnot(annot);
    if (annot != null) {
      feed.setAnnotationId(annot.getId());
    }
    feed.setSuggestion(sugg);
    feed.setSuggestionId(sugg.getId());
    feed.setGroup(group);
    feed.setGroupId(group.getId());
    em.merge(feed);
  }

  /**
   * Changes existing feedback in DB
   * 
   * @param em current EntityManager
   * @param annot Annotation
   * @param oldSuggID Ols suggestion ID
   * @param newSugg New suggestion
   * @param group UserGroup
   */
  private static void changeFeedback(EntityManager em, Annotation annot, int oldSuggID, Suggestion newSugg, UserGroup group){
    try {
      Query query = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId=?2 AND s.groupId=?3");
      query.setParameter(1, annot.getId());
      query.setParameter(2, oldSuggID);
      query.setParameter(3, group.getId());
      List sList = query.getResultList();
      if (sList != null && !sList.isEmpty()) {
        SuggestionFeedback oldFeed = (SuggestionFeedback) sList.get(0);
        oldFeed.setAnnotationId(null);
        oldFeed.setAnnot(null);
        em.merge(oldFeed);
        em.flush();
      } else {
        Suggestion sg = getSuggestionByID(oldSuggID, em);
        if (sg != null) {
          createNewFeedback(em, null, sg, group);
        }
      }
      createNewFeedback(em, annot, newSugg, group);
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Persisting of feedback failed.";
        Logger.getLogger(SugPersister.class.getName()).log(Level.SEVERE, msg, e);
      }
    }
  }  // changeFeedback()

  /**
   * Gets suggestion from DB by ID
   * 
   * @param id suggestion ID
   * @param em current EntityManager
   * @return Suggestion or null if not found
   */
  private static Suggestion getSuggestionByID(Integer id, EntityManager em) {
    if (id == null) {
      return null;
    }
    SuggestionFeedback fb = null;
    Query query = em.createNamedQuery("Suggestion.findById");
    query.setParameter("id", id);
    List sList = query.getResultList();
    if (sList == null || sList.isEmpty()) {
      return null;
    }
    return (Suggestion) sList.get(0);
  }

  /**
   * Select suggestion attribute from database
   * 
   * @param id Id of attribute
   * @param em Entity manager
   * @return attribute or null
   */
  private static SugBaseAttribute getSugAttributeByID(Integer id, EntityManager em) {
    if (id == null) {
      return null;
    }
    SugBaseAttribute fb = null;
    Query query = em.createNamedQuery("SuggestionAttribute.findById");
    query.setParameter("id", id);
    List sList = query.getResultList();
    if (sList == null || sList.isEmpty()) {
      return null;
    }
    return (SugBaseAttribute) sList.get(0);
  }

  /**
   * Gets suggestion from suggestion feedback table by Annotation 
   * 
   * @param annot annotation ID
   * @param em Entity manager
   * @return Suggestion or null if not found
   */
  private static Suggestion getSuggestionByAnnotation(Annotation annot, EntityManager em) {
    if (annot == null || annot.getId() == null) {
      return null;
    }
    SuggestionFeedback fb = getFeedbackByAnnot(annot.getId(), em);
    if (fb == null || fb.getSuggestionId() == null) {
      return null;
    }
    return getSuggestionByID(fb.getSuggestionId(), em);
  }

  /**
   * Method loads suggestion positive feedback specified by annotation.
   *
   * @param annotId annotation id that specify suggestion feedback
   * @param em Entity manager
   * @return array list with founded negative suggestions feedback
   */
  public static SuggestionFeedback getFeedbackByAnnot(Integer annotId, EntityManager em){
    Query query2 = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
    query2.setParameter(1, annotId);
    List feedbackList = query2.getResultList();
    if(feedbackList != null && !feedbackList.isEmpty()){
      return (SuggestionFeedback) feedbackList.get(0);
    }
    return null;
  }

  /**
   * Method loads suggestion specified by id from the database.
   *
   * @param id id that specify suggestions
   * @param em Entity manager
   * @return querried suggestion or null if suggestion isn't found
   */
  public static Suggestion getSuggestionFromDB(Integer id, EntityManager em){
    Query query = em.createQuery("SELECT s FROM Suggestion s WHERE s.id=?1");
    query.setParameter(1, id);
    List suggestionList = query.getResultList();
    if(suggestionList != null && !suggestionList.isEmpty()){
      return (Suggestion) suggestionList.get(0);
    }

    return null;
  }

  /**
   * Sets Zero confidence to all nested Suggestions
   * 
   * @param em Entity manager
   * @param an Refused annotation
   * @param touchedSuggestions modified suggestions
   */
  private static void setNestedZeroConfidence (EntityManager em, Annotation an, ArrayList<Suggestion> touchedSuggestions) {
    if (an.getAttributes() != null) {  // if annotation have some attributes
      for (Iterator<BaseAttribute> it = an.getAttributes().iterator(); it.hasNext();) {
        BaseAttribute at = it.next();
        if (at.getNestedAnnotation() != null && at.getNestedAnnotation().getId() != null) {
          Query query2 = em.createQuery("SELECT s FROM SuggestionFeedback s WHERE s.annotationId=?1 AND s.suggestionId IS NOT NULL");
          query2.setParameter(1, at.getNestedAnnotation().getId());
          List sList = query2.getResultList();
          if (sList != null && !sList.isEmpty()) {
            SuggestionFeedback sugFeed = (SuggestionFeedback) sList.get(0);
            Suggestion s = sugFeed.getSuggestion();
            s.setConfidence(0);
            s = em.merge(s);
            sugFeed.setAnnot(null);
            em.merge(sugFeed);
            setNestedZeroConfidence (em, at.getNestedAnnotation(), touchedSuggestions);
            if (!touchedSuggestions.contains(s)) {
              touchedSuggestions.add(s);
            }
          }
        }
      }
    }  // if annotation have some attributes
  }  // setNestedZeroConfidence()

  /**
   * Sets Zero confidence to all nested Suggestions
   * 
   * @param em Entity manager
   * @param sug Refused suggestion
   * @param touchedSuggestions modified suggestions
   */
  private static void setNestedSugZeroConfidence (EntityManager em, Suggestion sug, ArrayList<Suggestion> touchedSuggestions) {
    if (sug.getAttributes() != null) {
      for (Iterator<SugBaseAttribute> it = sug.getAttributes().iterator(); it.hasNext();) {
        SugBaseAttribute at = it.next();
        if (at.getNestedSuggestion() != null && at.getNestedSuggestion().getId() != null) {
          Suggestion s = at.getNestedSuggestion();
          s.setConfidence(0);
          s = em.merge(s);
          setNestedSugZeroConfidence(em, s, touchedSuggestions);
          if (!touchedSuggestions.contains(s)) {
            touchedSuggestions.add(s);
          }
        }
      }
    }
  }  // setNestedSugZeroConfidence
  
}  // class SugPersister