AlternativeManager.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: AlternativeManager.java
 * Description: Class for manipulation with alternatives of suggestions
 */

/**
 * @file AlternativeManager.java
 *
 * @brief Class for manipulation with alternatives of suggestions
 */

/**
 * @package cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative
 * 
 * @brief Classes responsible for work with alternatives of suggestions
 */
package cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SECAPIInterface;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SECAPISuggestionTranslator;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SugPersister;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.Suggestion;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionManager;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugBaseAttribute;
import java.util.ArrayList;
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.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

/**
 * Class for manipulation with alternatives of suggestions
 * 
 * @brief Class for manipulation with alternatives of suggestions
 * @author Marek Kopecky
 */
public class AlternativeManager extends Thread {
  
  /** Informations about request from client*/
  RequestInfo requestInfo = null;
  
  /** Linearized document */
  String document;
  
  /** URI of original document */
  String documentUri;
  
  /** Array for adding new types of alternatives */
  ArrayList<AnnotType> newTypes;
  
  /** New saved suggestions */
  ArrayList<Suggestion> validSuggestions;
  
  /** Suggestion manager */
  SuggestionManager sugManager;
  
  /** ID of synchronized document */
  Integer docID;
  
  /**
   * Constructor
   * 
   * @param request Informations about request from client
   * @param document Linearized document
   * @param documentUri URI of original document
   * @param validSuggestions New saved suggestions
   * @param sugManager Suggestion manager which created this
   * @param docID ID of synchronized document
   */
  public AlternativeManager(RequestInfo request, String document, String documentUri,
                              ArrayList<Suggestion> validSuggestions, SuggestionManager sugManager, Integer docID) {
    //super("AlternativeManagerThread");
    this.requestInfo = request;
    this.document = document;
    this.documentUri = documentUri;
    this.newTypes = new ArrayList<AnnotType>();
    this.validSuggestions = validSuggestions;
    this.sugManager = sugManager;
    this.docID = docID;
  }
  
  /**
   * Method start the thread code execution. 
   * 
   * Consider adding locks.
   */
  @Override
  public void run() {
    // lock for read
    while(true){
      if(AppBean.getLockMaster().getDocumentLock(docID).lockForRead()){
        break;
      }
    }
      
    try { // lock for read has to be unlock
      processAlternative();
    } catch(Exception ex){
      String msg = "Unknown exception in AlternativeManager: " + ex.getMessage();
      Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg, ex);
    } finally {
      // unlock for read
      AppBean.getLockMaster().getDocumentLock(docID).unlockForRead();
    }
    
  }
  
  /**
   * Get and process alternatives.
   */
  private void processAlternative() {
    while(true){
      if(AppBean.getLockMaster().getSuggReqLock(requestInfo.getSession().getSyncDocument().getId()).lockForChange()){
        break;
      }
    }
    try {
      // detect source of suggestions
      SuggestionManager.SuggestionSource suggestionSource = SuggestionManager.sourceOfSuggestions(document);

      // get new alternatives from SEC API as a raw data
      String rawNewAlternatives = null;
      if (suggestionSource == SuggestionManager.SuggestionSource.SEC_API) {
        if (Constants.USE_REMOTE_SEC_API || SECAPIInterface.isSecCommandEmpty()) {
          rawNewAlternatives = sugManager.getSuggestionsFromRemoteSECAPI(requestInfo, document, documentUri, true, validSuggestions);
        } else {
          rawNewAlternatives = sugManager.getSuggestionsFromSECAPI(requestInfo, document, documentUri, true, validSuggestions);
        }
      }

      if (rawNewAlternatives != null) {  // if alternatives are available
        ArrayList<Suggestion> alternativesCreatedFor = new ArrayList<Suggestion>();

        // lock document for suggestion change 
        sugManager.lockDocForChange(docID);

        try { // lock for change has to be unlock
          // transform raw data to alternatives
          SECAPISuggestionTranslator st = new SECAPISuggestionTranslator(sugManager.userGroup);
          ArrayList<Alternative> newAlternatives = st.translateAlternativeFromSecApi(requestInfo, rawNewAlternatives, newTypes, validSuggestions);

          if (newAlternatives != null && !newAlternatives.isEmpty()) {
            if (!SuggestionManager.persistTypes(newTypes)) {
              // delete all alternatives for actual document
              deleteAlternativesForDocument();

              // update types
              if (newTypes != null) {
                Iterator<AnnotType> newTypesUpdateIt = newTypes.iterator();
                while (newTypesUpdateIt.hasNext()) {
                  AnnotType currentNewType = newTypesUpdateIt.next();

                  Iterator<Alternative> newAlternativesIt = newAlternatives.iterator();
                  while (newAlternativesIt.hasNext()) {
                    Alternative currentAlternative = newAlternativesIt.next();
                    if (currentAlternative.getAnnotType().getUri().equals(currentNewType.getUri())) {
                      currentAlternative.setAnnotType(currentNewType);
                    }
                  }
                }
              }

              // if alternatives should be automatically activated, collect suggestions
              if (requestInfo.getSession().getAutoActivateAlternatives()) {
                Iterator<Alternative> newAlternativesIt = newAlternatives.iterator();
                while (newAlternativesIt.hasNext()) {
                  Alternative currentAlternative = newAlternativesIt.next();
                  if (!alternativesCreatedFor.contains(currentAlternative.getAlternativeOfSuggestion())) {
                    alternativesCreatedFor.add(currentAlternative.getAlternativeOfSuggestion());
                  }
                }
              }

              // persist data
              persistAlternatives(newAlternatives);
              Iterator<EditorSession> sessIt = AppBean.getSessions().iterator();
              while (sessIt.hasNext()) {
                EditorSession sess = sessIt.next();
                String typesStr = SuggestionManager.printTypes(requestInfo, sess, newTypes);
                sess.addMessageTS(typesStr);
              }
            } else {
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
                String msg = "Persisting of types of annotations failed.";
                Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg);
              }
            }
          }
        } catch (Exception ex) {
          String msg = "Unknown exception in AlternativeManager: " + ex.getMessage();
          Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg, ex);
        }

        // unlock document for suggestions change
        sugManager.unlockDocForChange(docID);

        // if alternatives should be automatically activated, activate them
        if (requestInfo.getSession().getAutoActivateAlternatives()) {
          Iterator<Suggestion> newAltIt = alternativesCreatedFor.iterator();
          while (newAltIt.hasNext()) {
            Suggestion sug = newAltIt.next();
            activateAlternatives(requestInfo, sug);
          }
          String result = sugManager.printSuggestionsDiff(requestInfo.getSession(), new ArrayList<Suggestion>(), new ArrayList<AnnotType>());
          requestInfo.getSession().addMessageTS(result);
          requestInfo.getSession().notifyComet();
        }

      }  // if alternatives are available
    } finally {
      AppBean.getLockMaster().getSuggReqLock(requestInfo.getSession().getSyncDocument().getId()).unlockForChange();
    }
  }  // processAlternative()
  
  /**
   * Top level function to select alternatives for refused suggestion and activate it.
   * This function is called, when user refuse some suggestion.
   * 
   * @param request Informations about client request
   * @param sug Refused suggestion.
   */
  public static void activateAlternatives(RequestInfo request, Suggestion sug) {
    // id of top level alternativeOf
    int topAlternativeOfId;
    Suggestion alternativeOf = sug.getAlternativeOfSuggestion();
    
    // determine, if refused suggestion if alternative of another suggestion (false) or not (true)
    boolean suggIsAlternativeOfAnotherSuggestion = true;
    if (alternativeOf == null) {
      topAlternativeOfId = sug.getId();
      suggIsAlternativeOfAnotherSuggestion = false;
    } else {
      topAlternativeOfId = alternativeOf.getId();
    }
    
    // get all possible alternatives
    List<Alternative> alternativeList = getAlternatives(topAlternativeOfId);
    
    // no alternatives => no action here
    ArrayList<Alternative> alternativeToPersist = new ArrayList<Alternative>();
    if (alternativeList.isEmpty()) {
      return;
    }
    
    if (alternativeList.size() == 1 || suggIsAlternativeOfAnotherSuggestion) {
      // only on alternative exist or there are not any suggestion based on refused suggestion
      alternativeToPersist.add(alternativeList.get(0));
    } else {
      // persist batch of alternatives as suggestions
      for (int i = 0; i < Constants.MAX_COUNT_OF_ALTERNATIVES_IN_BATCH && i < alternativeList.size(); i++) {
        alternativeToPersist.add(alternativeList.get(i));
      }
    }
    
    ArrayList<Alternative> open = new ArrayList<Alternative>(alternativeToPersist);
    ArrayList<Alternative> closed = new ArrayList<Alternative>();
    
    while(!open.isEmpty()){
      Alternative tmpAlt = open.get(0);
      ArrayList<Alternative> tmpList = new ArrayList<Alternative>();
      
      //Search for all links within alternative attributes
      Iterator<AlternativeAttribute> attIt = tmpAlt.getAttributes().iterator();
      while(attIt.hasNext()){
        AlternativeAttribute tmpAtt = attIt.next();
        if(tmpAtt.getUri() != null && !tmpAtt.getUri().isEmpty()){
          //Search for nested alternative
          Alternative a = null;
          
          if(tmpAtt.getSimpleType().equalsIgnoreCase("NestedSuggestion")){
            a = tmpAtt.getNestedAlternative();
          }
          else if(tmpAtt.getSimpleType().equalsIgnoreCase("SuggestionLink")){
            a = tmpAtt.getLinkedAlternative();
          }
       
          if(a != null){
            a.setTmpId(tmpAtt.getUri());
            //Check whether this alternative is not already in open or closed list
            if(!open.contains(a) && !closed.contains(a)){
              tmpList.add(a);
            }
          }
          else{
            if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
              String msg = "Alternative attribute with name: "
                      + tmpAtt.getName() 
                      + "does not contain reference to linked/nested alternative.";
              Logger.getLogger(AlternativeManager.class.getName()).log(Level.WARNING, msg);
            }
          }
        }
      }
      closed.add(tmpAlt);
      open.remove(tmpAlt);
      open.addAll(tmpList);
    }
    
    // transform all selected alternatives to suggestion and delete alternatives from DB
    ArrayList<Suggestion> sugAlternativeToPersist = alternativesToSuggestions(closed);
    setAsUsed(closed);
    
    /* Map all suggestions that have tmpId (they are linked or nested ) */
    HashMap<String, Suggestion> sugsMap = new HashMap<String, Suggestion>();
    Iterator<Suggestion> tmpSugIt = sugAlternativeToPersist.iterator();
    while(tmpSugIt.hasNext()){
      Suggestion s = tmpSugIt.next();
      if(s.getTmpId() != null && !s.getTmpId().isEmpty()){
        sugsMap.put(s.getTmpId(), s);
      }
    }
    
    /* Iterate through all attributes of all suggestions to connect links */
    tmpSugIt = sugAlternativeToPersist.iterator();
    while(tmpSugIt.hasNext()){
      Suggestion s = tmpSugIt.next();
      
      Iterator<SugBaseAttribute> sbAttIt = s.getAttributes().iterator();
      while(sbAttIt.hasNext()){
        SugBaseAttribute sbAtt = sbAttIt.next();
        if(sbAtt.getSimpleType().equalsIgnoreCase("NestedSuggestion")){
          sbAtt.setNestedSuggestion(sugsMap.get(sbAtt.getUri()));
        }
        else if(sbAtt.getSimpleType().equalsIgnoreCase("SuggestionLink")){
          sbAtt.setLinkedSuggestion(sugsMap.get(sbAtt.getUri()));
        }
      }
    }
    
    // update suggestion fragments
    for (Iterator<Suggestion> it = sugAlternativeToPersist.iterator(); it.hasNext(); ) {
      Suggestion actualSuggestion = it.next();
      SuggestionManager.updateSuggestion(actualSuggestion,request);
      // check updated suggestion fragment if there is some bad fragment
      Iterator<SuggestionFragment> fragIt = actualSuggestion.getFragments().iterator();
      while(fragIt.hasNext()){
        SuggestionFragment actualFragment = fragIt.next();
        // if some fragment is bad, suggestion is removed
        if(!actualFragment.getIsGood()){
          it.remove();
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Some alternative fragment can not be recovered.";
            Logger.getLogger(AlternativeManager.class.getName()).log(Level.WARNING, msg);
          }
          break;
        }
      }
    }
    
    // persist new suggestions
    SugPersister.persist(request, null, null, sugAlternativeToPersist, false, new ArrayList<AnnotType>());
  }  // activateAlternatives()
  
  /**
   * Top level function to remove alternatives of confirmSuggs and
   * refuse suggestions, that were alternatives of confirmSuggs.
   * 
   * @param request Informations about client request
   * @param confirmSuggs List of suggestions
   */
  public static void confirmSuggestions(RequestInfo request, ArrayList<Suggestion> confirmSuggs) {
    // remove isFromSECAPI flag from confirmed suggestions
    // alternative will be never assigned to these suggestions
    clearIsFromSECAPI(confirmSuggs);
    
    // iterate suggestions
    ArrayList<Alternative> alternativeToDelete = new ArrayList<Alternative>();
    ArrayList<Suggestion> suggestionsToRefuse = new ArrayList<Suggestion>();
    for (Iterator<Suggestion> it = confirmSuggs.iterator(); it.hasNext(); ) {
      Suggestion sg = it.next();
      Integer sugId = sg.getId();
      Suggestion alternativeOfSug = sg.getAlternativeOfSuggestion();
      Integer alternativeOfId = (alternativeOfSug != null ? alternativeOfSug.getId() : null);
      if (alternativeOfId != null && sugId != null) {
        // confirmed suggestion is alternative of another suggestion
        alternativeToDelete.addAll(getAlternatives(alternativeOfId));
        suggestionsToRefuse.addAll(getOtherSuggestions(alternativeOfId, sugId));
      } else if (sugId != null) {
        // confirmed suggestion is not alternative of another suggestion
        alternativeToDelete.addAll(getAlternatives(sugId));
      }
    }
    
    // set alternatives as used
    if (!alternativeToDelete.isEmpty()) {
      setAsUsed(alternativeToDelete);
    }
    
    // refuse suggestions
    refuseSuggestions(request, suggestionsToRefuse);
  }  // confirmSuggestions()
  
  /**
   * Refuse suggestionsToRefuse list.
   * 
   * @param request Informations about client request
   * @param suggestionsToRefuse List of suggestions
   */
  private static void refuseSuggestions(RequestInfo request, ArrayList<Suggestion> suggestionsToRefuse) {
    if (request.getSession() == null || request.getSession().getDefaultGroup() == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Missing default group in refusing process.";
        Logger.getLogger(AlternativeManager.class.getName()).log(Level.WARNING, msg);
      }
      return;  // it is not possible to do it without valid user group
    }
    Integer groupId = request.getSession().getDefaultGroup().getId();
    for (Iterator<Suggestion> it = suggestionsToRefuse.iterator(); it.hasNext(); ) {
      SuggestionManager.updateSuggNegativeFeedback(request, groupId, it.next().getId(), true);
    }
  }
  
  /**
   * Persist function for alternatives
   * 
   * @param alternatives Alternatives to persist
   */
  private void persistAlternatives(ArrayList<Alternative> alternatives) {
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    // updateTypes
    try {
      transaction.begin();
      // for each alternative
      for (Iterator<Alternative> itAlt = alternatives.iterator(); itAlt.hasNext();) {
        Alternative alt = itAlt.next();
        // persist alternative
        em.merge(alt);
        // persist attributes
        for (Iterator<AlternativeAttribute> itAttr = alt.getAttributes().iterator(); itAttr.hasNext(); ) {
          AlternativeAttribute atr = itAttr.next();
          em.merge(atr);
        }
        // persist fragments
        for (Iterator itFra = alt.getFragments().iterator(); itFra.hasNext(); ) {
          AlternativeFragment fra = (AlternativeFragment) itFra.next();
          em.merge(fra);
        }
      }
      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(AlternativeManager.class.getName()).log(Level.SEVERE, msg, e);
      }
    } finally {
      em.close();
    }
  }  // persistAlternatives()
  
  
  /**
   * Determine, if on fragment overlap some fragments from suggestion
   * 
   * @param sugFragments Suggestion fragments
   * @param newFragStart Start offset of reference fragment
   * @param newFragEnd End offset of reference fragment
   * @return Determine, if on fragment overlap some fragments from suggestion
   */
  public static boolean overlappingFragment(ArrayList<SuggestionFragment> sugFragments, int newFragStart, int newFragEnd) {
    Iterator<SuggestionFragment> sugFragmentsIt = sugFragments.iterator();
    while(sugFragmentsIt.hasNext()){
      SuggestionFragment actualSuggFragment = sugFragmentsIt.next();
      
      // Skip null fragments
      if(actualSuggFragment == null){
        continue;
      }
      
      // get position of current suggestion fragment content in linearized document
      int sugFragStart = actualSuggFragment.getOffset().intValue();
      int sugFragEnd = sugFragStart + actualSuggFragment.getLength().intValue();

      if(newFragStart <= sugFragStart && newFragEnd >= sugFragStart){
        // suggestion fragment starts in reference fragment
        return true;
      }else if(newFragStart <= sugFragEnd && newFragEnd >= sugFragEnd){
        // suggestion fragment ends in reference fragment
        return true;
      }
    }
    return false;
  }  // overlappingFragment()
  
  /**
   * Transform all selected alternatives to suggestion
   * 
   * @param alternatives List of alternatives
   * @return List of suggestions
   */
  private static ArrayList<Suggestion> alternativesToSuggestions(ArrayList<Alternative> alternatives) {
    ArrayList<Suggestion> sugAlternativeToPersist = new ArrayList<Suggestion>();
    
    for (Iterator<Alternative> altIt = alternatives.iterator(); altIt.hasNext(); ) {
      Alternative alt = altIt.next();
      sugAlternativeToPersist.add(new Suggestion(alt));
    }
    
    return sugAlternativeToPersist;
  }
  
  /**
   * Delete all alternatives for actual document.
   */
  private void deleteAlternativesForDocument() {
    Integer documentId = requestInfo.getSession().getSyncDocument().getId();
    
    // get alternatives for document from database
    Object[] params = {"sourceDocumentId",documentId};
    @SuppressWarnings("unchecked")
    List<Alternative> suggestionList = AppBean.getPersistenceManager().queryDB("Alternative.findBySourceDocumentID",params);

    // delete alternatives from db
    if (suggestionList != null && !suggestionList.isEmpty()) {
      deleteAlternatives(suggestionList);
    }
  }
  
  /**
   * Sets alternatives as used
   * 
   * @param alternatives Alternatives which should be set as used
   */
  private static void setAsUsed(List<Alternative> alternatives) {
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    
    try {
      transaction.begin();
      Iterator<Alternative> altIt = alternatives.iterator();
      while (altIt.hasNext()) {
        Alternative alt = altIt.next();
        Object[] params = {"id",alt.getId()};
        @SuppressWarnings("unchecked")
        List<Alternative> alternativeList = AppBean.getPersistenceManager().queryDB("Alternative.findById", params);
        if (alternativeList == null || alternativeList.isEmpty()) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
            String msg = "Error during the setting of alternative usages (alternative was not found).";
            Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg);
          }
          continue;
        }
        Alternative a = alternativeList.get(0);
        a.setUsed(true);
        em.merge(a);
      }
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the setting of alternative usages.";
        Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg, e);
      }
    } finally {
      em.close();
    }
  }  // setAsUsed()
  
  /**
   * Delete alternatives from DB
   * 
   * @param alternativeToPersist Alternatives which should be deleted
   */
  private static void deleteAlternatives(List<Alternative> alternativeToPersist) {
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    
    try {
      transaction.begin();
      for (Iterator<Alternative> altIt = alternativeToPersist.iterator(); altIt.hasNext(); ) {
        Integer altId = altIt.next().getId();
        // remove attributes
        Query q = em.createNamedQuery("AlternativeAttribute.deleteByAltId");
        q.setParameter("altId", altId);
        q.executeUpdate();
        // remove fragments
        q = em.createNamedQuery("AlternativeFragment.deleteByAltId");
        q.setParameter("altId", altId);
        q.executeUpdate();
        // remove alternative
        q = em.createNamedQuery("Alternative.deleteById");
        q.setParameter("id", altId);
        q.executeUpdate();
      }
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the deleting of data.";
        Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg, e);
      }
    } finally {
      em.close();
    }
  }
  
  /**
   * Set isFromSECAPI flag of suggestion to false.
   * 
   * @param confirmSuggs List of suggestions.
   */
  private static void clearIsFromSECAPI(ArrayList<Suggestion> confirmSuggs) {
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    
    try {
      transaction.begin();
      for (Iterator<Suggestion> sugIt = confirmSuggs.iterator(); sugIt.hasNext(); ) {
        Suggestion sug = sugIt.next(); 
        // get id of suggestion
        Integer sugId;
        Suggestion alternativeOf = sug.getAlternativeOfSuggestion();
        if (alternativeOf == null) {
          sugId = sug.getId();
        } else {
          sugId = alternativeOf.getId();
        }
        // set isFromSECAPI flag to false
        Query q = em.createNamedQuery("Suggestion.clearIsFromSECAPI");
        q.setParameter("id", sugId);
        q.executeUpdate();
      }
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Exception during the updating of data.";
        Logger.getLogger(AlternativeManager.class.getName()).log(Level.SEVERE, msg, e);
      }
    } finally {
      em.close();
    }
  }  // clearIsFromSECAPI()
  
  /**
   * Method loads alternative specified by alternativeOf from the database.
   * 
   * @param alternativeOfId AlternativeOf id.
   * @return list of querried alternatives
   */
  private static List<Alternative> getAlternatives(int alternativeOfId) {
    Integer id = alternativeOfId;
    Object[] params = {"alternativeOf",id.toString()};
    @SuppressWarnings("unchecked")
    List<Alternative> alternativeList = AppBean.getPersistenceManager().queryDB("Alternative.findByAlternativeOf",params);
    if (alternativeList == null) {
      alternativeList = new ArrayList<Alternative>();
    }
    return alternativeList;
  }
  
  /**
   * Method loads alternative specified by alternativeOf from the database.
   * 
   * @param alternativeOfId AlternativeOf id.
   * @return list of querried alternatives
   */
  public static List<Suggestion> getOtherSuggestions(int alternativeOfId) {
    Integer id = alternativeOfId;
    Object[] params = {"alternativeOf",id.toString()};
    @SuppressWarnings("unchecked")
    List<Suggestion> suggestionList = AppBean.getPersistenceManager().queryDB("Suggestion.findByAlternativeOf",params);
    if (suggestionList == null) {
      suggestionList = new ArrayList<Suggestion>();
    }
    return suggestionList;
  }
  
  /**
   * Method loads alternative specified by alternativeOf from the database.
   * 
   * @param alternativeOfId AlternativeOf id.
   * @param notThisSugId All alternatives except alternative suggestion with this id
   * @return list of querried alternatives
   */
  private static List<Suggestion> getOtherSuggestions(int alternativeOfId, int notThisSugId) {
    Integer id = alternativeOfId;
    Object[] params = {"alternativeOf",id.toString(), "notThisSugId", (Integer) notThisSugId};
    @SuppressWarnings("unchecked")
    List<Suggestion> suggestionList = AppBean.getPersistenceManager().queryDB("Suggestion.findByAlternativeOfAndNotSugg",params);
    if (suggestionList == null) {
      suggestionList = new ArrayList<Suggestion>();
    }
    return suggestionList;
  }
}  // public class AlternativeManager