Persister.java

Go to the documentation of this file.

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

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

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
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.Fragment;
import cz.vutbr.fit.knot.annotations.entity.Settings;
import cz.vutbr.fit.knot.annotations.entity.Source;
import cz.vutbr.fit.knot.annotations.entity.Subscription;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import cz.vutbr.fit.knot.annotations.entity.attribute.AttributeManager;
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 java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
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 data to the database
 *
 * @brief Static class which persists data to the database
 * @author idytrych
 */
public class Persister {

  /**
   * Persist informations from request to the database
   * (it persists derived and related informations too)
   *
   * @param requestInfo Informations about client request
   * @return If succeed, returns false, in case of error returns true
   */
  public static boolean persist(RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    try {
      transaction.begin();
  
      /* Update settings */
      if (requestInfo.getSettings() != null && !requestInfo.getSettings().isEmpty()) {
        /* Remove old settings */
        ArrayList<Settings> settings = new ArrayList<Settings>();
        Object[] params = new Object[2];
        params[0] = "userId";
        params[1] = requestInfo.getSession().getUser().getId();
        List sList = AppBean.getPersistenceManager().queryDB("Settings.findByUser", params);
        if (sList != null && !sList.isEmpty()) {
          Iterator sListIter = sList.iterator();
          while (sListIter.hasNext()) {
            settings.add((Settings) sListIter.next());
          }
        }
        
        // Condition that check whether protocol version 2 is used
        if(requestInfo.getSession().getProtocolLOD() == Constants.PROTOCOL_LOD_V2){
          //Getting current user's settings
          Iterator<Settings> clientSettIt = requestInfo.getSettings().iterator();

          while(clientSettIt.hasNext()){
            Iterator<Settings> oldSettingIt = settings.iterator();
            Settings clientTmpSett = clientSettIt.next();
            Boolean flag = false;

            //Looking for a current setting within old ones
            while(oldSettingIt.hasNext()){
              Settings oldSetting = oldSettingIt.next();

              if((oldSetting.getName()).equals(clientTmpSett.getName())){
                flag = true;               
                //Update current setting
                if(clientTmpSett.getValue() != null){
                  oldSetting = em.merge(oldSetting);
                  oldSetting.setValue(clientTmpSett.getValue());
                  oldSetting.setDescription(clientTmpSett.getDescription());
                }
                //Remove current setting
                else{
                  oldSetting = em.merge(oldSetting);
                  em.remove(oldSetting);
                }
                break;
              }
            }

            //Adding new setting into database
            if(flag == false){
              if(clientTmpSett.getValue() != null)
                em.persist(clientTmpSett);
            }
          }
        }
        // Protocol version 1 is used
        else{
          Iterator<Settings> oldSettingsIter = settings.iterator();
          while (oldSettingsIter.hasNext()) {
            Settings param = oldSettingsIter.next();
            param = em.merge(param);
            em.remove(param);
          }

          /* Save new settings */
          Iterator<Settings> settingsIter = requestInfo.getSettings().iterator();
          while (settingsIter.hasNext()) {
            Settings param = settingsIter.next();
            em.persist(param);
          }
        }
      }
      
      /* Create new subscriptions */
      if(requestInfo.getNewSubscriptions() != null && !requestInfo.getNewSubscriptions().isEmpty()){
        ArrayList<Subscription> persistedSubscriptions = new ArrayList<Subscription>();
        Iterator<Subscription> subNewIter = requestInfo.getNewSubscriptions().iterator();
        while (subNewIter.hasNext()) {
          Subscription subscription = subNewIter.next();
          Integer savedTmpId = subscription.getTmpId();
          subscription = em.merge(subscription);
          em.persist(subscription);
          subscription.setTmpId(savedTmpId);
          persistedSubscriptions.add(subscription);
        }

        requestInfo.setNewSubscriptions(persistedSubscriptions);
        requestInfo.getFlier().setNewSubscriptions(persistedSubscriptions);
      }
      
      /* Update subscriptions */
      if(requestInfo.getUpdatedSubscriptions() != null && !requestInfo.getUpdatedSubscriptions().isEmpty()){
        ArrayList<Subscription> changedSubscriptions = new ArrayList<Subscription>();
        Iterator<Subscription> subChangeIter = requestInfo.getUpdatedSubscriptions().iterator();
        while (subChangeIter.hasNext()){
          Subscription currentSub = subChangeIter.next();
          
          // get subscription
          Object[] params = new Object[2];
          params[0] = "id";
          params[1] = currentSub.getId();
          @SuppressWarnings("unchecked")
          List<Subscription> SubsList = AppBean.getPersistenceManager().queryDB("Subscription.findById", params);
          if(SubsList == null || SubsList.isEmpty()){
            //error
            break;
          }
          
          Subscription oldSub = SubsList.get(0);
          requestInfo.addBeforeUpdatedSubscriptions(oldSub);
          
          // delete old sources 
          Iterator<Source> oldSourcesIt = oldSub.getSubscriptions().iterator();
          while(oldSourcesIt.hasNext()){
            Source currentSource = oldSourcesIt.next();
            Source mergedSource = em.merge(currentSource);
            em.remove(mergedSource);
          }

          // save subscriptions with new sources 
          em.merge(currentSub);
          if(requestInfo.getSession().isInSubscribeList(oldSub)){
            requestInfo.addToUnsubscribe(oldSub);
            requestInfo.addToSubscribe(oldSub);
          }
          requestInfo.getFlier().addChangedSubscription(currentSub);
        }
      }
      
      /* Delete subscriptions */
      if(requestInfo.getDeletedSubscriptions() != null && !requestInfo.getDeletedSubscriptions().isEmpty()){
        ArrayList<Subscription> deletedSubscriptions = new ArrayList<Subscription>();
        Iterator<Subscription> subDeleteIter = requestInfo.getDeletedSubscriptions().iterator();
        while (subDeleteIter.hasNext()) {
          Subscription subscription = subDeleteIter.next();
          subscription = em.merge(subscription);
          em.remove(subscription);
          deletedSubscriptions.add(subscription);
          
          if(requestInfo.getSession().isInSubscribeList(subscription)){
            requestInfo.addToUnsubscribe(subscription);
          }
        }

        requestInfo.setDeletedSubscriptions(deletedSubscriptions);
      }
      
      /* Update user groups */
      if (!requestInfo.getJoinedGroups().isEmpty() || !requestInfo.getLeavedGroups().isEmpty()) {
        requestInfo.getSession().setUser(em.merge(requestInfo.getSession().getUser()));
        Iterator<UserGroup> ugIter = requestInfo.getJoinedGroups().iterator();
        while (ugIter.hasNext()) {
          UserGroup jug = ugIter.next();
          em.merge(jug);
        }
        Iterator<UserGroup> lgIter = requestInfo.getLeavedGroups().iterator();
        while (lgIter.hasNext()) {
          UserGroup lug = lgIter.next();
          em.merge(lug);
        }
      }

      /* Persist new document or changes */
      if (requestInfo.getSyncDocument() != null) {
        if (requestInfo.isNewDocument()) {
          em.persist(requestInfo.getSyncDocument());
        } else {
          em.merge(requestInfo.getSyncDocument());
        }
      }
      if (requestInfo.isDocumentChanged()) {
        em.merge(requestInfo.getSession().getSyncDocument());
      }

      /* 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 = flier.getAddedTypes().iterator(); ntIt.hasNext();) {
        AnnotType type = ntIt.next();
        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> mergedTypes = new ArrayList<AnnotType>();
      Map<String, AnnotType> mTypesMap = new HashMap<String, AnnotType>();
      for (Iterator<AnnotType> nTWAIt = nTWA.iterator(); nTWAIt.hasNext();) {
        AnnotType type = nTWAIt.next();
        type = em.merge(type);
        mergedTypes.add(type);
        mTypesMap.put(type.getUri(), type);
      }

      // fix, add and merge attributes and ancestors
      for (Iterator<AnnotType> mIt = mergedTypes.iterator(); mIt.hasNext();) {
        AnnotType mType = mIt.next();
        AnnotType oType = nTMap.get(mType.getUri());  // get original type

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

        // primary ancestor
        if (oType.getAncestorType() != null) {
          // replace type with merged one
          AnnotType rType = mTypesMap.get(oType.getAncestorType().getUri());
          if (rType == null) {  // it is not new type, it is in database
            rType = queryType(oType.getAncestorType().getUri(), em);
          }
          mType.setAncestorType(rType);
        }

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

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


      Iterator<AnnotType> editAnnotTypeIter = flier.getEditedTypes().iterator();
      while (editAnnotTypeIter.hasNext()) {  // traverse edited types
        AnnotType type = editAnnotTypeIter.next();
        Query query = em.createNamedQuery("AnnotType.findById");
        query.setParameter("id", type.getId());
        List tList = query.getResultList();
        if (tList == null || tList.isEmpty()) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
            String msg = "Edited type of annotation was not found by Persister: " + type.getUri();
            Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
          }
          throw new RuntimeException("Object not found.");
        }
        AnnotType pType = (AnnotType) tList.get(0);
        boolean differ = false;
        List<AnnotTypeAttr> attrs = pType.getAttributes();
        Iterator<AnnotTypeAttr> attrIter = attrs.iterator();
        Iterator<AnnotTypeAttr> newAttrIter = type.getAttributes().iterator();
        while (attrIter.hasNext()) {
          AnnotTypeAttr attr = attrIter.next();
          if (!newAttrIter.hasNext()) {
            em.remove(attr);
          } else {
            AnnotTypeAttr newAttr = newAttrIter.next();
            newAttr.setId(attr.getId());
          }
        }
        // create new list of ancestors (with all types from database)
        ArrayList<AnnotType> newAnc = new ArrayList<AnnotType>();
        for (Iterator<AnnotType> ancIt = type.getAncestorTypes().iterator(); ancIt.hasNext();) {
          AnnotType ancT = ancIt.next();
          if (ancT == null) {
            // if it's a new type of annotation, it must be set again after merge
            AnnotType annotType = null;
            Object[] params = new Object[2];
            params[0] = "uri";
            params[1] = ancT.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);
              annotType = em.merge(annotType);
              newAnc.add(annotType);
            } else {  // if type was not found (merge failed)
              if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
                String msg = "Ancestor type of annotaton was not found by Persister: " + ancT.getUri();
                Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
              }
              throw new RuntimeException("New type not found!");
            }
          } else {  // if ancestor is not new
            ancT = em.merge(ancT);
            newAnc.add(ancT);
          }
        }  // create new list of ancestors

        type.setAncestorTypes(newAnc);  // replace old list with new

        // save changes and new attribues
        type = em.merge(type);
      }  // traverse edited types
      
      Iterator<AnnotType> delAnnotTypeIter = flier.getRemovedTypes().iterator();
      while (delAnnotTypeIter.hasNext()) {
        AnnotType type = delAnnotTypeIter.next();
        type = em.merge(type);
        em.remove(type);
      }
      
      /* Persist annotations */
      ArrayList<Annotation> nowSavedAnnots = new ArrayList<Annotation>();
      ArrayList<Annotation> justSavedAnnots = new ArrayList<Annotation>();
      ArrayList<Annotation> nestedBeforeSave = new ArrayList<Annotation>();
      ArrayList<Annotation> nestedAfterSave = new ArrayList<Annotation>();
      HashMap<Annotation,ArrayList<BaseAttribute>> unSavedLinks = new HashMap<Annotation, ArrayList<BaseAttribute>>();
      Iterator<Annotation> addedAnnotIter = flier.getAddedAnnotations().iterator();
      while (addedAnnotIter.hasNext()) {  // for each added annotation
        Annotation annotation = addedAnnotIter.next();
        if (annotation.getAnnotType().getId() == null) {
          updateTypes(annotation, em, "New type of annotation was not found by Persister: ");
        }
        updateTypesInNested(annotation, em);  // update types in nested annotations
        if (justSavedAnnots.contains(annotation)) {  // skip just saved to avoid duplicity
          continue;
        }
        // update tmpId links in attributes
        saveTmpIdRefAnnotations(annotation, requestInfo, em, justSavedAnnots, nowSavedAnnots, nestedBeforeSave, nestedAfterSave, unSavedLinks);
      }  // for each added annotation
      saveTmpIdRefAnnotationsSolveLinks(requestInfo, em, justSavedAnnots, nowSavedAnnots, nestedBeforeSave, nestedAfterSave, unSavedLinks);
      flier.setAddedAnnotations(nowSavedAnnots);
      
      // Find mappings of temp URI to serv URI for nested annotations
      Iterator<Annotation> naIt = nestedBeforeSave.iterator();
      while (naIt.hasNext()) {
        Annotation a = naIt.next();
        int ni = nestedBeforeSave.indexOf(a);
        Annotation sav = nestedAfterSave.get(ni);
        requestInfo.getFlier().addJustAddedAnnotation(AppBean.getBaseUri() + "/temp/" + a.getTmpId(), sav.getURIV2());
      }

      Iterator<Annotation> editAnnotIter = flier.getEditedAnnotations().iterator();
      while (editAnnotIter.hasNext()) {
        Annotation annotation = editAnnotIter.next();
        if (annotation.getAnnotType().getId() == null) {
          updateTypes(annotation, em, "New type of annotation for edited annotation was not found by Persister: ");
        }
        updateAnnot(em, annotation, requestInfo);
      }
      
      Iterator<Annotation> delAnnotIter = flier.getRemovedAnnotations().iterator();
      while (delAnnotIter.hasNext()) {
        Annotation annotation = delAnnotIter.next();
        annotation = em.merge(annotation);
        em.remove(annotation);
      }
      
      em.flush();

      // Update URI of linked annotations
      Iterator<Annotation>addeAnnotIter = flier.getAddedAnnotations().iterator();
      while(addeAnnotIter.hasNext()){
        Annotation actualAnnot = addeAnnotIter.next();
        setUriOfAnnotationsParams(actualAnnot);
      }
      Iterator<Annotation>edAnnotIter = flier.getEditedAnnotations().iterator();
      while(edAnnotIter.hasNext()){
        Annotation actualAnnot = edAnnotIter.next();
        setUriOfAnnotationsParams(actualAnnot);
      }
      Iterator<Annotation>updatedAnnotIter = flier.getAutoUpdatedAnnotations().iterator();
      while(updatedAnnotIter.hasNext()){
        Annotation actualAnnot = updatedAnnotIter.next();
        setUriOfAnnotationsParams(actualAnnot);
      }
      // update confirmed version of the suggestion with the one persisted in the database
      Iterator<SuggestionLogEntry>confirmedSuggIt = requestInfo.getConfirmedSuggestions().iterator();
      while (confirmedSuggIt.hasNext()) {
        SuggestionLogEntry sle = confirmedSuggIt.next();
        Iterator<Annotation>aAnnotIter = nowSavedAnnots.iterator();
        while (aAnnotIter.hasNext()) {
          Annotation addAn = aAnnotIter.next();
          // some annotations can exist without tmpId, therefore the value must
          // be compared with a null value
          if (addAn.getTmpId() != null && addAn.getTmpId().equals(sle.getTmpId())) {
            sle.setConfirmedVersion(addAn);
            break;
          }
        }
      }
      
      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(Persister.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 errorOccurred;
  }  // persist

  /**
   * Sets uri from value in annotation link parameters of given annotation, also 
   * recursively in nested annotations
   *
   * @param annot Given annotation
   */
  public static void setUriOfAnnotationsParams(Annotation annot){
    List attrList = annot.getAttributes();
    Iterator attrIt = attrList.iterator();
    while(attrIt.hasNext()){ // For all attributes od Annotation
      BaseAttribute attr = (BaseAttribute)attrIt.next();
      
      if(!AttributeManager.hasAttributeRightInstance(attr)){
        attr = AttributeManager.changeAttributeInstance(attr);
      }
      
      //for all annotation links which have uri set to null or empty value
      if(attr.getSimpleType().equals("AnnotationLink") && ((LinkedAnnotationAttribute)attr).getValue() != null){
        if(((LinkedAnnotationAttribute)attr).getUri() == null || ((LinkedAnnotationAttribute)attr).getUri().isEmpty()){
          Annotation value = (Annotation) ((LinkedAnnotationAttribute)attr).getValue();
          ((LinkedAnnotationAttribute)attr).setUri(value.getURI());
        }
      }
      
      //recursively update nested annotations
      if(attr.getSimpleType().equals("NestedAnnotation") && ((NestedAnnotationAttribute)attr).getValue() != null){
        Annotation value = (Annotation) ((NestedAnnotationAttribute)attr).getValue();
        setUriOfAnnotationsParams(value);
      }
    }
  }
  
  /**
   * Updates complete informations about annotation in database
   *
   * @param em Entity manager
   * @param annotation Updated annotation
   * @param requestInfo Informations about client request
   */
  public static void updateAnnot(EntityManager em, Annotation annotation, RequestInfo requestInfo) throws RuntimeException {
    Query query = em.createNamedQuery("Annotation.findById");
    query.setParameter("id", annotation.getId());
    List aList = query.getResultList();
    if (aList == null || aList.isEmpty()) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "Updated annotation was not found by the Persister.";
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
      }
      throw new RuntimeException("Object not found.");
    }
    Annotation a = (Annotation) aList.get(0);
    // update fragments
    List<Fragment> fragments = a.getFragments();
    Iterator<Fragment> frIter = fragments.iterator();
    Iterator<Fragment> newFrIter = annotation.getFragments().iterator();
    while (frIter.hasNext()) {
      Fragment fr = frIter.next();
      if (!newFrIter.hasNext()) {
        em.remove(fr);
      } else {
        Fragment newFr = newFrIter.next();
        newFr.setId(fr.getId());
      }
    }
    // update attributes
    List attrs = a.getAttributes();
    List newAttrs = annotation.getAttributes();
    Iterator attrsIt = attrs.iterator();
    
    // find already saved nested annotations
    HashMap<Integer, Annotation> nestedAnnots = new HashMap<Integer, Annotation>();
    ArrayList<Integer> updatedNested = new ArrayList<Integer>();
    ArrayList<BaseAttribute> newNested = new ArrayList<BaseAttribute>();
    
    while (attrsIt.hasNext()) {
      BaseAttribute attr = (BaseAttribute) attrsIt.next();
      if (attr.getNestedAnnotation() != null) {
        nestedAnnots.put(attr.getNestedAnnotation().getId(), attr.getNestedAnnotation());
      }
      
      // delete additional atributes in entity attribute
      /*if(attr.getEntityAdditionalAttributes() != null){
        Iterator<EntityAdditionalAttribute> additionalAttrIt = attr.getEntityAdditionalAttributes().iterator();
        while(additionalAttrIt.hasNext()){
          em.remove(additionalAttrIt);
        }
      }*/
    }
    
    // update tmpId links in attributes
    saveTmpIdRefAnnotations(annotation, requestInfo, em);
    
    attrsIt = attrs.iterator();
    Iterator newAttrsIt = newAttrs.iterator();
    
    // delete old attributes
    while (attrsIt.hasNext()) {
      BaseAttribute attr = (BaseAttribute) attrsIt.next();
      attr.setNestedAnnotation(null);
      em.remove(attr);
    }
    ArrayList<BaseAttribute> empty = new ArrayList<BaseAttribute>();
    a.setAttributes(empty);
    // delete
    
    
    // delete attributes id
    while (newAttrsIt.hasNext()) {
      BaseAttribute attr = (BaseAttribute) newAttrsIt.next();
      attr.setId(null);
    }
    
    // set iterator again
    newAttrsIt = newAttrs.iterator();

    // save new attributes
    while (newAttrsIt.hasNext()) {
      BaseAttribute newAttr = (BaseAttribute) newAttrsIt.next();
      if (newAttr.getNestedAnnotation() != null) {
        if(nestedAnnots.containsKey(newAttr.getNestedAnnotation().getId())) {
          Annotation lost = nestedAnnots.get(newAttr.getNestedAnnotation().getId());
          updatedNested.add(lost.getId());
          newAttr.getNestedAnnotation().setId(lost.getId());
          updateAnnot(em, newAttr.getNestedAnnotation(), requestInfo);
          newAttr.getNestedAnnotation().setNestedInAnnot(a);
        } else {
          newAttr.getNestedAnnotation().setNestedInAnnot(a);
          newNested.add(newAttr);
        }
      }
      
      // persist additional atributes in entity attribute
      /*if(newAttr.getEntityAdditionalAttributes() != null && !newAttr.getEntityAdditionalAttributes().isEmpty()){
        ArrayList<EntityAdditionalAttribute> newAdditionalAttrs = new ArrayList<EntityAdditionalAttribute>();
        Iterator<EntityAdditionalAttribute> additionalAttrIt = attr.getEntityAdditionalAttributes().iterator();
        while(additionalAttrIt.hasNext()){
          EntityAdditionalAttribute savedAttr = em.persist(additionalAttrIt);
        }
      }*/
    }
            
    // remove lost nested annotations
    Iterator<Entry<Integer,Annotation>> lIter = nestedAnnots.entrySet().iterator();
    while (lIter.hasNext()) {
      Annotation lAnnot = lIter.next().getValue();
      if(!updatedNested.contains(lAnnot.getId())){
        requestInfo.getFlier().AddRemovedNestedAnnotation(lAnnot);
        em.remove(lAnnot);
      }
    }
    // merge new nested annotations in attributes
    // (to set their id it must be done here)
    Iterator<BaseAttribute> newNestedIt = newNested.iterator();
    while (newNestedIt.hasNext()) {
      BaseAttribute newNestedAt = newNestedIt.next();
      if (newNestedAt.getNestedAnnotation() != null) {
        String nNUri = AppBean.getBaseUri() + "/temp/" + newNestedAt.getNestedAnnotation().getTmpId();
        Annotation newN = em.merge(newNestedAt.getNestedAnnotation());
        newNestedAt.setNestedAnnotation(newN);
        em.flush();
        requestInfo.getFlier().addJustAddedAnnotation(nNUri, newN.getURIV2());
        requestInfo.getFlier().getAddedAnnotations().add(newN);
      }
    }
    
    // check if we are updating nestedAnnotation and update nestedin reference
    // this code shouldn't be here but it fixes client bug with only nested update
    if(annotation.getNestedInAnnot() == null && a.getNestedInAnnot() != null){
      annotation.setNestedInAnnot(a.getNestedInAnnot());
      
      ArrayList<Annotation> editedInFlier = requestInfo.getFlier().getEditedAnnotations();
      if(editedInFlier.contains(annotation)){
        editedInFlier.remove(annotation);
        Annotation parent = a.getNestedInAnnot();
        while(parent.getNestedInAnnot() != null){
          parent = parent.getNestedInAnnot();
        }
        editedInFlier.add(parent);
      }
    }
    // update nestedin reference
    
    // merge Annotation
    Annotation mergenAn = em.merge(annotation);
    em.flush();
    annotation.setAttributes(new ArrayList<BaseAttribute>(mergenAn.getAttributes()));   
  }  // updateAnnot()
  
  /**
   * 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()

  /**
   * Persist informations about automatically updated annotations
   *
   * @param requestInfo Informations about client request
   * @return If succeed, returns false, in case of error returns true
   */
  public static boolean persistAUpdAnnot(RequestInfo requestInfo) {
    Flier flier = requestInfo.getFlier();
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    try {
      transaction.begin();

      Iterator<Annotation> autoUpdAnnotIter = flier.getAutoUpdatedAnnotations().iterator();
      while (autoUpdAnnotIter.hasNext()) {  // for each automatically updated annotation
        Annotation annotation = autoUpdAnnotIter.next();
        if (annotation.getAnnotType().getId() == null) {
          // if it's a new type of annotation, it must be set again after merge
          AnnotType annotType = queryType(annotation.getAnnotType().getUri(), em);
          annotation.setAnnotType(annotType);
          // type of the nested and linked attribute also has to be updated
          Iterator<BaseAttribute> attIt = annotation.getAttributes().iterator();
          while (attIt.hasNext()) {
            BaseAttribute att = attIt.next();
            // nested and linked attributes must have type set
            if (att instanceof NestedAnnotationAttribute || att instanceof LinkedAnnotationAttribute) {
              // 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));
              }
            }
          }
        }
        updateAnnot(em, annotation, requestInfo);
      }  // for each automatically updated annotation

      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 automatically updated annotations.";
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg, e);
      }
      errorOccurred = true;
    } finally {
      em.close();
    }

    return errorOccurred;
  }  // persistAUpdAnnot

  /**
   * Updates types in nested annotations (use types stored in DB)
   * 
   * @param annotation Annotation, which attributes will be updated
   * @param em Entity manager
   */
  private static void updateTypesInNested(Annotation annotation, EntityManager em) {
    Iterator<BaseAttribute> aIt = annotation.getAttributes().iterator();
    while (aIt.hasNext()) {  // for each attribute
      BaseAttribute attribute = aIt.next();
      Annotation nested = attribute.getNestedAnnotation();
      if (nested != null) {  // if nested annotation is included
        if (nested.getAnnotType().getId() == null) {  // if it is a new type
          // if it's a new type of annotation, 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<BaseAttribute> attIt = annotation.getAttributes().iterator();
          while (attIt.hasNext()) {
            BaseAttribute att = attIt.next();
            // nested and linked attributes must have type set
            if (att instanceof NestedAnnotationAttribute || att instanceof LinkedAnnotationAttribute) {
              // 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 annotations recursively
      }  // if nested annotation is included
    }  // for each attribute
  }  // updateTypesInNested()
  
  /**
   * Recursively saves annotations in attributes of given annotation.
   * @param annot Annotation for reference update
   * @param requestInfo Informations about client request
   * @param em current EntityManager
   * @return uri of the new saved annotation
   * @throws RuntimeException 
   */
  private static Annotation saveTmpIdRefAnnotations(Annotation annot, RequestInfo requestInfo, EntityManager em) throws RuntimeException {
    Annotation saved = null;
    List attrList = annot.getAttributes();
    Iterator attrIt = attrList.iterator();
    while(attrIt.hasNext()){ // For all attributes of Annotation
      BaseAttribute attr = (BaseAttribute)attrIt.next();
      if(attr.getSimpleType().equals("AnnotationLink") && ((LinkedAnnotationAttribute)attr).getValue() != null){
        Annotation val = (Annotation) ((LinkedAnnotationAttribute)attr).getValue();
        if (val.getId() == null) {
          Annotation annot4update = saveTmpIdRefAnnotations(val, requestInfo, em);
          attr.setValue(annot4update);
          if(annot4update != null){
            attr.setUri(annot4update.getURI());
            attr.setAttributeType(annot4update.getAnnotType());
          }
        }
      } else if(attr.getSimpleType().equals("NestedAnnotation") && attr.getNestedAnnotation() != null){
        saveTmpIdRefAnnotations(attr.getNestedAnnotation(), requestInfo, em);
      }
    }
    if(annot.getId() == null && annot.getNestedInAnnot() == null){
      updateTypes(annot, em, "New type of annotation for tmpId linked annotation was not found by Persister: ");
      updateTypesInNested(annot, em);
      saved = em.merge(annot);
      em.flush();
      saved.setTmpId(annot.getTmpId());
      updateTmpIdRefInAddedEditedASuggested(annot.getTmpId(), saved, requestInfo);
    }
    
    return saved;
  }
   
  /**
   * Updates links in saved annotations
   * 
   * @param requestInfo Informations about client request
   * @param em current EntityManager
   * @param justSaved List of just saved annotations (versions before saving)
   * @param nowSaved List of just saved annotations (really saved versions)
   * @param nestedBeforeSave List of just saved nested annotations (versions before saving)
   * @param nestedAfterSave List of just saved nested annotations (really saved versions)
   * @param unSavedLinks HashMap of arraylist of unsaved links for annotation
   * @throws RuntimeException 
   */
  private static void saveTmpIdRefAnnotationsSolveLinks(RequestInfo requestInfo, EntityManager em,
            ArrayList<Annotation> justSaved, ArrayList<Annotation> nowSaved,
            ArrayList<Annotation> nestedBeforeSave, ArrayList<Annotation> nestedAfterSave,
            HashMap<Annotation,ArrayList<BaseAttribute>> unSavedLinks) throws RuntimeException {
    //update links
    Iterator<Entry<Annotation,ArrayList<BaseAttribute>>> unsavedIt = unSavedLinks.entrySet().iterator();
    while(unsavedIt.hasNext()){
      Entry<Annotation,ArrayList<BaseAttribute>> entry = unsavedIt.next();
      Annotation solvedAnnot = entry.getKey();
      Iterator<BaseAttribute> solvedLinksIt = entry.getValue().iterator();
      
      Integer nowSavedIndex = null;
      Integer nestedIndex = null;
      // saved nested annotations - we have to find real reference
      if(solvedAnnot.getId() == null){
        if(nestedBeforeSave.contains(solvedAnnot)){
          nestedIndex = nestedBeforeSave.indexOf(solvedAnnot);
          solvedAnnot = nestedAfterSave.get(nestedIndex);
        }
        else{
          //should never happen
          solvedAnnot = null;
        }
      }else{
        nowSavedIndex = nowSaved.indexOf(solvedAnnot);
      }

      if(solvedAnnot != null){
        //save new link attributes for annotation
        while(solvedLinksIt.hasNext()){
          BaseAttribute attr = (BaseAttribute) solvedLinksIt.next();
          Annotation link = (Annotation) ((LinkedAnnotationAttribute)attr).getValue();
          attr.setRefAnnotation(solvedAnnot);
          if(justSaved.contains(link)){
            int index = justSaved.indexOf(link);
            Annotation annot4update = nowSaved.get(index);
            attr.setValue(annot4update);
            if(annot4update != null){
              attr.setUri(annot4update.getURI());
              attr.setAttributeType(annot4update.getAnnotType());
            }
          }
          else if(nowSaved.contains(link) || nestedAfterSave.contains(link)){
            attr.setValue(link);
            if(link != null){
              attr.setUri(link.getURI());
              attr.setAttributeType(link.getAnnotType());
            }
          }
          else if(nestedBeforeSave.contains(link)){
            int index = nestedBeforeSave.indexOf(link);
            Annotation annot4update = nestedAfterSave.get(index);
            attr.setValue(annot4update);
            if(annot4update != null){
              attr.setUri(annot4update.getURI());
              attr.setAttributeType(annot4update.getAnnotType());
            }
          }
          else{
            //should never happen
            attr.setValue(null);
          }
          solvedAnnot.addAttribute(attr);
        }
        //merge new links
        Annotation afterMerge = em.merge(solvedAnnot);
        updateTmpIdRefInAddedEditedASuggested(solvedAnnot.getTmpId(), afterMerge, requestInfo);
        
        //updates saved lists
        if(nowSavedIndex != null){
          nowSaved.set((int)nowSavedIndex, afterMerge);
        }
        else if(nestedIndex != null){
          nestedAfterSave.set((int)nestedIndex, afterMerge);
        }
      }
    }
    //update links
    
    //update ConfirmedVersions
    Iterator<SuggestionLogEntry> confirmedIt = requestInfo.getConfirmedSuggestions().iterator();
    while(confirmedIt.hasNext()){
      SuggestionLogEntry sugLog = confirmedIt.next();
      if(nestedBeforeSave.contains(sugLog.getConfirmedVersion())){
        int index = nestedBeforeSave.indexOf(sugLog.getConfirmedVersion());
        sugLog.setConfirmedVersion(nestedAfterSave.get(index));
      }
    }
    //update ConfirmedVersions
  }
  
  /**
   * Recursively saves annotations in attributes of given annotation.
   * @param annot Annotation for reference update
   * @param requestInfo Informations about client request
   * @param em current EntityManager
   * @param justSaved List of just saved annotations (versions before saving)
   * @param nowSaved List of just saved annotations (really saved versions)
   * @param nested4Links temporary list for nested annotation links
   * @param nested4LinksFromDB temporary list for saved nested annotation links
   * @param unSavedLinks HashMap of arraylist of unsaved links for annotation
   * @return uri of the new saved annotation
   * @throws RuntimeException 
   */
  private static Annotation saveTmpIdRefAnnotations(Annotation annot, RequestInfo requestInfo, EntityManager em,
            ArrayList<Annotation> justSaved, ArrayList<Annotation> nowSaved, 
            ArrayList<Annotation> nested4Links, ArrayList<Annotation> nested4LinksFromDB, 
            HashMap<Annotation,ArrayList<BaseAttribute>> unSavedLinks) throws RuntimeException {
    Annotation saved = null;   
    ArrayList<BaseAttribute> annotLinks = new ArrayList<BaseAttribute>();
    List attrList = annot.getAttributes();
    Iterator attrIt = attrList.iterator();
    while(attrIt.hasNext()){ // For all attributes of Annotation
      BaseAttribute attr = (BaseAttribute)attrIt.next();
      if(attr.getSimpleType().equals("AnnotationLink") && ((LinkedAnnotationAttribute)attr).getValue() != null){
        Annotation val = (Annotation) ((LinkedAnnotationAttribute)attr).getValue();
        //if we have some link on already saved annotation then don't save
        if (nowSaved.contains(val) || nested4LinksFromDB.contains(val) || val.getId() == null) {
            annotLinks.add(attr);
            attrIt.remove();
        }
      } else if(attr.getSimpleType().equals("NestedAnnotation") && attr.getNestedAnnotation() != null){
        nested4Links.add(attr.getNestedAnnotation());
        saveTmpIdRefAnnotations(attr.getNestedAnnotation(), requestInfo, em, justSaved, nowSaved, nested4Links, nested4LinksFromDB, unSavedLinks);
      }
    }
    if(annot.getId() == null && annot.getNestedInAnnot() == null){
      updateTypes(annot, em, "New type of annotation for tmpId linked annotation was not found by Persister: ");
      updateTypesInNested(annot, em);
      saved = em.merge(annot);
      em.flush();
      saved.setTmpId(annot.getTmpId());
      justSaved.add(annot);
      nowSaved.add(saved);
      requestInfo.getFlier().addJustAddedAnnotation(AppBean.getBaseUri() + "/temp/" + annot.getTmpId(), saved.getURIV2());
      //add new reference on nested annotations
      addNewReferenceOnNestedAnnotation(saved, nested4LinksFromDB);
      updateTmpIdRefInAddedEditedASuggested(annot.getTmpId(), saved, requestInfo);
    }
    
    //add links for future update
    if(unSavedLinks != null && !annotLinks.isEmpty()){
      if(saved != null){
        unSavedLinks.put(saved, annotLinks);
      }
      else{
        unSavedLinks.put(annot, annotLinks);
      }
    }
    
    return saved;
  } // saveTmpIdAnnotations
  
  /**
   * Add new reference on nested annotations recursively to list
   * @param saved Annotation with nested
   * @param nested4LinksFromDB List of new references
   */
  private static void addNewReferenceOnNestedAnnotation(Annotation saved, ArrayList<Annotation> nested4LinksFromDB) {
    Iterator<BaseAttribute> nowSavedAttrIt = saved.getAttributes().iterator();
    while(nowSavedAttrIt.hasNext()){
      BaseAttribute savedAttribute = nowSavedAttrIt.next();
      if(savedAttribute.getSimpleType().equals("NestedAnnotation") && savedAttribute.getNestedAnnotation() != null){
        Annotation nestedAnnotation = savedAttribute.getNestedAnnotation();
        nested4LinksFromDB.add(nestedAnnotation);
        addNewReferenceOnNestedAnnotation(nestedAnnotation, nested4LinksFromDB);
      }
    }
  }
  /**
   * Method updates types in Annotation
   * 
   * @param annotation annotation for update
   * @param em current EntityManager
   * @param logMsg Message which should be used for logging.
   * @throws RuntimeException 
   */
  private static void updateTypes(Annotation annotation, EntityManager em, String logMsg) throws RuntimeException {
    // if it's a new type of annotation, it must be set again after merge
    AnnotType annotType = null;
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = annotation.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);
      annotation.setAnnotType(annotType);
      // type of the nested and linked attribute also has to be updated
      Iterator<BaseAttribute> attIt = annotation.getAttributes().iterator();
      while (attIt.hasNext()) {
        BaseAttribute att = attIt.next();
        // nested and linked attributes must have type set
        if (att instanceof NestedAnnotationAttribute || att instanceof LinkedAnnotationAttribute) {
          if (att.getAttributeType() == null) {
              continue;
          }
          // second parameter of the query is the uri of the attribute type
          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 + annotation.getAnnotType().getUri();
        Logger.getLogger(Persister.class.getName()).log(Level.SEVERE, msg);
      }
      throw new RuntimeException("New type not found!");
    }
  } // updateTypes
  
  /**
   * Updates LinkedAnnotationAttribute references after saving new Annotations to DB
   * @param tmpId old tmpId link of Annotation
   * @param newLink new link of Annotation
   * @param requestInfo Informations about client request
   */
  private static void updateTmpIdRefInAddedEditedASuggested(String tmpId, Annotation newLink, RequestInfo requestInfo){
    Flier flier = requestInfo.getFlier();
    
    // Replace all links in added annotations.
    Iterator<Annotation> addedIt = flier.getAddedAnnotations().iterator();
    while(addedIt.hasNext()){
      Annotation annot = addedIt.next();
      Iterator attrIt = annot.getAttributes().iterator();
      while(attrIt.hasNext()){
        BaseAttribute attr = (BaseAttribute)attrIt.next();
        if(attr.getSimpleType().equals("AnnotationLink") && tmpId != null && 
                ((LinkedAnnotationAttribute)attr).getTmpId() != null &&
                ((LinkedAnnotationAttribute)attr).getTmpId().equals(tmpId)){
          attr.setValue(newLink);
          if(newLink != null){
            attr.setAttributeType(newLink.getAnnotType());
          }
        }
        else if(attr.getSimpleType().equals("NestedAnnotation") && attr.getNestedAnnotation() != null){
          updateTmpIdRefInNested(tmpId, attr.getNestedAnnotation(), newLink);
        }
      }
    }
    
    // Replace all links in edited annotations
    Iterator<Annotation> editedIt = flier.getEditedAnnotations().iterator();
    while(editedIt.hasNext()){
      Annotation annot = editedIt.next();
      Iterator attrIt = annot.getAttributes().iterator();
      while(attrIt.hasNext()){
        BaseAttribute attr = (BaseAttribute)attrIt.next();
        if(attr.getSimpleType().equals("AnnotationLink") && tmpId != null && 
                ((LinkedAnnotationAttribute)attr).getTmpId() != null &&
                ((LinkedAnnotationAttribute)attr).getTmpId().equals(tmpId)){
          attr.setValue(newLink);
          if(newLink != null){
            attr.setAttributeType(newLink.getAnnotType());
          }
        }
        else if(attr.getSimpleType().equals("NestedAnnotation") && attr.getNestedAnnotation() != null){
          updateTmpIdRefInNested(tmpId, attr.getNestedAnnotation(), newLink);
        }
      }
    }
    
    // Replace all links in confirmed suggestions
    Iterator<SuggestionLogEntry> suggIt = requestInfo.getConfirmedSuggestions().iterator();
    while(suggIt.hasNext()){
      SuggestionLogEntry suggest = suggIt.next();
      Annotation annot = suggest.getConfirmedVersion();
      Iterator attrIt = annot.getAttributes().iterator();
      while(attrIt.hasNext()){
        BaseAttribute attr = (BaseAttribute)attrIt.next();
        if(attr.getSimpleType().equals("AnnotationLink") && tmpId != null && 
                ((LinkedAnnotationAttribute)attr).getTmpId() != null &&
                ((LinkedAnnotationAttribute)attr).getTmpId().equals(tmpId)){
          attr.setValue(newLink);
          if(newLink != null){
            attr.setAttributeType(newLink.getAnnotType());
          }
        }
        else if(attr.getSimpleType().equals("NestedAnnotation") && attr.getNestedAnnotation() != null){
          updateTmpIdRefInNested(tmpId, attr.getNestedAnnotation(), newLink);
        }
      }
    }
    
  } // updateTmpIdRefInAddedEditedASuggested
  
  
  /**
   * Updates NestAnnotationAttribute references after saving new Annotations to DB 
   * @param tmpId old tmpId link of Annotation
   * @param nestedAnn Nested Annotation link
   * @param newLink new link of Annotation
   */
  private static void updateTmpIdRefInNested(String tmpId, Annotation nestedAnn, Annotation newLink){ 
    Iterator<BaseAttribute> aIt = nestedAnn.getAttributes().iterator();
    while (aIt.hasNext()) {  // for each attribute
      BaseAttribute attribute = aIt.next();
      if(attribute.getSimpleType().equals("AnnotationLink") && tmpId != null && !tmpId.isEmpty() &&
              ((LinkedAnnotationAttribute)attribute).getTmpId() != null &&
              ((LinkedAnnotationAttribute)attribute).getTmpId().equals(tmpId)){
        attribute.setValue(newLink);
        if(newLink != null){
          attribute.setAttributeType(newLink.getAnnotType());
        }
      }
      else if(attribute.getSimpleType().equals("NestedAnnotation") && attribute.getNestedAnnotation() != null){
        updateTmpIdRefInNested(tmpId, attribute.getNestedAnnotation(), newLink);
      }
    }  // for each attribute
  } // updateTmpIdRefInNested
  
}  // class Persister