P2AnnotationProcessor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: P2AnnotationProcessor.java
 * Description: Class which parses and process XML with messages with annotations for 
 * protocol version 2.
 */

/**
 * @file P2AnnotationProcessor.java
 *
 * @brief Class which parses and process XML with messages with annotations for protocol
 * version 2.
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.PersistM;
import cz.vutbr.fit.knot.annotations.comet.RequestInfo;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
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.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

/**
 * Class which parses and process XML with messages with annotations for protocol
 * version 2.
 *
 * @brief Class which parses and process XML with messages with annotations for 
 * protocol version 2
 * @author Martin Petr (xpetrm05)
 */
public class P2AnnotationProcessor extends P2AnnotBaseProcessor{
  /** Informations about client request */
  RequestInfo requestInfo = null;
  
  /**
   * Constructor
   */
  public P2AnnotationProcessor() {
    
  }
  
  /**
   * Method processes element with annotations to add.
   * 
   * @param addAnnotationsEl Element with annotations to add
   * @param requestInfo Informations about client request
   */
  public void processAddAnnotations(Element addAnnotationsEl, RequestInfo requestInfo) {
    NodeList annotationsMsg = addAnnotationsEl.getElementsByTagName("oa:Annotation");
    int annotCount = annotationsMsg.getLength();
    ArrayList<Annotation> annotsToAdd = new ArrayList<Annotation>();
   
    this.requestInfo = requestInfo;
    
    for(int index = 0; index < annotCount; index++){
      Element annotationEl = (Element) annotationsMsg.item(index);
      if(annotationEl != null) {
        Annotation newAnnotation = procesAnnotAdd(annotationEl,requestInfo);
        if(newAnnotation != null){
          annotsToAdd.add(newAnnotation);
        }
      }
    }
    
    connectAnnotations(annotsToAdd,null);
    requestInfo.getFlier().setAddedAnnotations(annotsToAdd);
  }
  
  /**
   * Method processes element with annotations to change.
   * 
   * @param changeAnnotationsEl Element with annotations to change
   * @param requestInfo Informations about client request
   */
  public void processChangeAnnotations(Element changeAnnotationsEl, RequestInfo requestInfo) {
    NodeList annotationsMsg = changeAnnotationsEl.getElementsByTagName("oa:Annotation");
    int annotCount = annotationsMsg.getLength();
    ArrayList<Annotation> annotsToChange = new ArrayList<Annotation>();
    
    this.requestInfo = requestInfo;
    
    for(int index = 0; index < annotCount; index++){
      Element annotationEl = (Element) annotationsMsg.item(index);
      if(annotationEl != null) {
        Annotation changedAnnotation = procesAnnotChange(annotationEl,requestInfo);
        if(changedAnnotation != null){
          annotsToChange.add(changedAnnotation);
        }
      }
    }
    
    connectAnnotations(annotsToChange,this.requestInfo.getFlier().getAddedAnnotations());
    requestInfo.getFlier().setEditedAnnotations(annotsToChange);
  }
  
  /**
   * Method processes element with annotations to delete.
   * 
   * @param deleteAnnotationsEl Element with annotations to delete
   * @param requestInfo Informations about client request
   */
  public void processDeleteAnnotations(Element deleteAnnotationsEl, RequestInfo requestInfo) {
    NodeList annotationsMsg = deleteAnnotationsEl.getElementsByTagName("annotation");
    int annotCount = annotationsMsg.getLength();
    this.requestInfo = requestInfo;
    
    for(int index = 0; index < annotCount; index++){
      Element annotationEl = (Element) annotationsMsg.item(index);
      if(annotationEl != null) {
        Annotation actualAnnot = procesAnnotDelete(annotationEl,requestInfo);
        if(actualAnnot == null){
          continue;
        }
        
        requestInfo.getFlier().AddRemovedAnnotation(actualAnnot);
      }
    }
  }
  
  /**
   * Method which reconstruct links between annotation objects (references 
   * to appropriate objects) using URIs in attributes. For example if there 
   * is link to another annotation but only URI of annotation is set 
   * in the attribute, it will set also reference to linked annotation. 
   * It also reconstruct both sides of nesting relation.
   * 
   * @param annotsToConnect Annotations in which links should be reconstructed
   * @param added List of just added annotations
   */
  private void connectAnnotations(ArrayList<Annotation> annotsToConnect, ArrayList<Annotation> added){
    Iterator<Annotation> connectIt = annotsToConnect.iterator();
    while(connectIt.hasNext()){
      
      // go trough all added annotations
      Annotation actualAnnot = connectIt.next();
      if (actualAnnot.getAttributes() != null) {

        // go tough all attributes
        Iterator<BaseAttribute> attributesIt = actualAnnot.getAttributes().iterator();
        while (attributesIt.hasNext()) {

          // try find nested or linked attribute
          BaseAttribute actualAttribute = attributesIt.next();
          if ((actualAttribute instanceof LinkedAnnotationAttribute)) {
            if (actualAttribute.getUri() != null && !actualAttribute.getUri().isEmpty()) {
              // try find annotation uri in just added annotations
              String annotUri = actualAttribute.getUri();
              String uriType = getUriType(annotUri);
              
              if (actualAttribute.getLinkedAnnotation() == null) {
                if (uriType.equals("temp")) {
                  Annotation findedAnnot = findAnnotByTempUri(annotsToConnect, actualAttribute.getUri());
                  if (findedAnnot == null) {
                    if (added != null) {
                      // try find it in
                      findedAnnot = findAnnotByTempUri(added, annotUri);
                      if(findedAnnot == null){
                        // error - cant find linked annotation
                        int langNum = requestInfo.getSession().getLanguageNum();
                        int lod = requestInfo.getSession().getProtocolLOD();
                        String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2() 
                                    + "\" uri=\"" + actualAttribute.getUriInOntology() 
                                    + "\" name=\"" + actualAttribute.getName() 
                                    + "\" name=\"" + actualAttribute.getName() 
                                    + "\" valueType=\"" + actualAttribute.getValueType() 
                                    + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                        requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                            String msg = "Link to unknown annotation:" + actualAttribute.getUri() + "";
                            Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
                        }
                      }
                    } else {
                      // error - cant find linked annotation
                      int langNum = requestInfo.getSession().getLanguageNum();
                      int lod = requestInfo.getSession().getProtocolLOD();
                      String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2() 
                                  + "\" uri=\"" + actualAttribute.getUriInOntology() 
                                  + "\" name=\"" + actualAttribute.getName() 
                                  + "\" valueType=\"" + actualAttribute.getValueType() 
                                  + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                      requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                        String msg = "Link to unknown annotation:" + actualAttribute.getUri() + "";
                        Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
                      }
                    }
                  }
                  actualAttribute.setLinkedAnnotation(findedAnnot);
                } else if (uriType.equals("serv")) {
                  Annotation findedAnnot = findAnnotByServUri(annotsToConnect, annotUri);
                  if (findedAnnot == null) {
                    Integer id = null;
                    String idString = annotUri.replace(AppBean.getBaseUri() + "/serv/","");
                    try {
                      id = Integer.decode(idString);
                    } catch (NumberFormatException ex) {
                      // error - cant decode id
                      int langNum = requestInfo.getSession().getLanguageNum();
                      int lod = requestInfo.getSession().getProtocolLOD();
                      String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2() 
                                    + "\" uri=\"" + actualAttribute.getUriInOntology() 
                                    + "\" name=\"" + actualAttribute.getName() 
                                    + "\" valueType=\"" + actualAttribute.getValueType() 
                                    + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                      requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                        String msg = "Cannot decode id of annotation:" + idString + "";
                        Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
                      }
                    } finally {
                      PersistM persistMan = AppBean.getPersistenceManager();

                      Object[] annotParams = new Object[2];
                      annotParams[0] = "id";
                      annotParams[1] = id;
                      @SuppressWarnings("unchecked")
                      List<Annotation> annotList = persistMan.queryDB("Annotation.findById", annotParams);
                      if(annotList == null || annotList.isEmpty()){
                        //error - cant find linked annot in DB
                        int langNum = requestInfo.getSession().getLanguageNum();
                        int lod = requestInfo.getSession().getProtocolLOD();
                        String info = "<attribute annotationUri=\"" + actualAnnot.getURIV2() 
                                    + "\" uri=\"" + actualAttribute.getUriInOntology() 
                                    + "\" name=\"" + actualAttribute.getName() 
                                    + "\" valueType=\"" + actualAttribute.getValueType() 
                                    + "\" type=\"" + actualAttribute.getTypeUriV2() + "\"/>";
                        requestInfo.addError(lod, langNum, Localisation.ERROR_7_ATTRIBUTE_VALUE, info);
                        if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
                          String msg = "Linked annotation is't presented in DB. Annotation id:" + idString + "";
                          Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
                        }
                        return;
                      }

                      LinkedAnnotationAttribute actualLinked = (LinkedAnnotationAttribute)actualAttribute;
                      actualLinked.setValue(annotList.get(0));
                      actualLinked.setAttributeType(annotList.get(0).getAnnotType());
                    }  
                  } else {
                    actualAttribute.setLinkedAnnotation(findedAnnot);
                  }
                }
              }
            }
          }
          
          if ((actualAttribute instanceof NestedAnnotationAttribute)) {
            NestedAnnotationAttribute nestedAttr = (NestedAnnotationAttribute) actualAttribute;
            if (actualAttribute.getUri() != null && !actualAttribute.getUri().isEmpty()) {

              // try find annotation uri in just added annotations
              Annotation findedAnnot = findAnnotByTempUri(annotsToConnect, actualAttribute.getUri());
              if (findedAnnot == null) {
                findedAnnot = findAnnotByServUri(annotsToConnect, actualAttribute.getUri());
              }
              if (findedAnnot == null) {
                findedAnnot = findAnnotByTempUri(added, actualAttribute.getUri());
              }
              if (findedAnnot != null) {
                actualAttribute.setNestedAnnotation(findedAnnot);
                findedAnnot.setNestedInAnnot(actualAnnot);
              }
            }
          }
        }
      }
    }
  }  // connectAnnotations()
  
  /**
   * Method processes element with annotation to add.
   * 
   * @param annotationEl Element with annotation to add
   * @param requestInfo Informations about client request
   * @return Returns annotation to add (in case of error it returns null)
   */
  private Annotation procesAnnotAdd(Element annotationEl,RequestInfo requestInfo){
    Annotation newAnnot;
    newAnnot = processAnnotation(annotationEl, requestInfo);
    return newAnnot;
  }
  
  /**
   * Method processes element with annotation to change.
   * 
   * @param annotationEl Element with annotation to change
   * @param requestInfo Informations about client request
   * @return Returns annotation to change (in case of error it returns null)
   */
  private Annotation procesAnnotChange(Element annotationEl, RequestInfo requestInfo) {
    Annotation newAnnotation = processAnnotation(annotationEl, requestInfo);
    if (newAnnotation != null) {
      Integer annotID =  newAnnotation.getId();
      
      // check if annotation in from server
      if (annotID != null) {
        // get annotation from DB
        PersistM persistMan = AppBean.getPersistenceManager();
        Annotation findedAnnot = null;

        Object[] params = new Object[2];
        params[0] = "id";
        params[1] = annotID;
        @SuppressWarnings("unchecked")
        List<Annotation> annotList = persistMan.queryDB("Annotation.findById", params);
        if (annotList != null && !annotList.isEmpty()) {
          findedAnnot = annotList.get(0);
        } else {
          // error - cant find annotation in DB
          int langNum = requestInfo.getSession().getLanguageNum();
          int lod = requestInfo.getSession().getProtocolLOD();
          String info = "<annotation uri=\"" + newAnnotation.getURIV2() + "\"/>";
          requestInfo.addError(lod, langNum, Localisation.ERROR_29_CHANGED_ANNOT_NOT_FOUND, info);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Annotation is't presented in DB. Annotation id:" + annotID.toString() + "";
            Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
          }
          return null;
        } 

        newAnnotation.setId(findedAnnot.getId());
      }
    }

    return newAnnotation;
  }  // procesAnnotChange()
  
  /**
   * Method processes element with annotation to delete.
   * 
   * @param annotationEl Element with annotation to delete
   * @param requestInfo Informations about client request
   * @return Returns annotation to delete (in case of error it returns null)
   */
  private Annotation procesAnnotDelete(Element annotationEl, RequestInfo requestInfo) {
    Annotation deleteAnnotation = null;
    String uri = annotationEl.getAttribute("uri");
    if(uri == null || uri.isEmpty()){
      // error - bad annotation uri
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_30_REM_ANNOT_NOT_FOUND, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Uri of annotation is wrong.";
        Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    Integer annotId = null;
    
    try{
      annotId = Integer.decode(uri.replace(AppBean.getBaseUri() + "/serv/", ""));
    } catch(NumberFormatException ex){
      // error - bad annotation id
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + uri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_30_REM_ANNOT_NOT_FOUND, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Id of annotation is wrong.";
        Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    // get document from DB
    PersistM persistMan = AppBean.getPersistenceManager();
    
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = annotId;
    @SuppressWarnings("unchecked")
    List<Annotation> annotList = persistMan.queryDB("Annotation.findById", params);
    if(annotList != null && !annotList.isEmpty()) {
      deleteAnnotation = annotList.get(0);
    }else{
      // error - can't find annotation to delete
      int langNum = requestInfo.getSession().getLanguageNum();
      int lod = requestInfo.getSession().getProtocolLOD();
      String info = "<annotation uri=\"" + uri + "\"/>";
      requestInfo.addError(lod, langNum, Localisation.ERROR_30_REM_ANNOT_NOT_FOUND, info);
      if(Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "Unable to find annotation to delete.";
        Logger.getLogger(P2AnnotationProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;
    }
    
    return deleteAnnotation;
  }  // procesAnnotDelete()
   
  /**
   * Find annotation in the list by temporary
   * 
   * @param annots List of annotations
   * @param uri Uri of annotation which should be found
   * @return If it was found returns given annotation, null otherwise
   */
  private Annotation findAnnotByTempUri(ArrayList<Annotation> annots, String uri){
    Iterator<Annotation> annotsIt = annots.iterator();
    while(annotsIt.hasNext()){
      Annotation currentAnnot = annotsIt.next();
      if(currentAnnot.getTmpId() != null && uri.equals(AppBean.getBaseUri() + "/temp/" + currentAnnot.getTmpId())){
        return currentAnnot;
      }
    }
    return null;
  }
  
  /**
   * Find annotation in the list by server uri
   * 
   * @param annots List of annotations
   * @param uri Uri of annotation which should be found
   * @return If it was found returns given annotation, null otherwise
   */
  private Annotation findAnnotByServUri(ArrayList<Annotation> annots, String uri){
    Iterator<Annotation> annotsIt = annots.iterator();
    while(annotsIt.hasNext()){
      Annotation currentAnnot = annotsIt.next();
      if(currentAnnot.getId() != null && uri.equals(AppBean.getBaseUri() + "/serv/" + currentAnnot.getId())){
        return currentAnnot;
      }
    }
    return null;
  }
  
}  // public class P2AnnotationProcessor