RenameTypes.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: RenameTypes.java
 * Description: Backbean for page for batch renaming and commenting of types
 *              of annotations
 */

/**
 * @file RenameTypes.java
 *
 * @brief Backbean for page for batch renaming of types of annotations
 */
package cz.vutbr.fit.knot.annotations.web;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.Flier;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import cz.vutbr.fit.knot.annotations.comet.ResponseCreator;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.AnnotTypeAttr;
import cz.vutbr.fit.knot.annotations.entity.UserGroup;
import java.io.IOException;
import java.io.Serializable;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.commons.io.IOUtils;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Backbean for page for batch renaming and commenting of types of annotations
 *
 * @brief Backbean for page for batch renaming of types of annotations
 * @author idytrych
 */
@ManagedBean
@ViewScoped
public class RenameTypes implements Serializable {
  /**
   * Error message displayed in form
   */
  private String errorMessage = "";
  /**
   * Success message displayed in form
   */
  private String successMessage = "";
  /**
   * Uploaded file
   */
  private UploadedFile uploadedFile;
  /**
   * File name
   */
  private String fileName;
  /**
   * User group in which uploaded types will be renamed
   */
  private String uGroup;


  /**
   * Action listener for upload button
   *
   * @return Returns page outcome (identificator of next page or null to stay here)
   */
  public String btnUploadAction() {

    errorMessage = "";
    successMessage = "";

    if (uGroup.isEmpty()) {
      errorMessage = MessageProvider.getMessage("groupMustBeSet");
      return null;
    }
    // query database for user group
    Object[] params = new Object[2];  // parameters for database query
    params[0] = "name";
    params[1] = uGroup;
    List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findByName", params);
    UserGroup userGroup = null;
    if (gList != null && !gList.isEmpty()) {  // if group was found
      userGroup = (UserGroup) gList.get(0);
    } else {
      errorMessage = MessageProvider.getMessage("unknownGroup");
      return null;
    }

    // Informations about uploaded file
    // String fileType = uploadedFile.getContentType();
    // String fileNameStr = uploadedFile.getName();
    // Long fileSize = uploadedFile.getSize();  // bytes

    // Create writer with file data
    StringWriter fWriter = new StringWriter();
    try {
      IOUtils.copy(uploadedFile.getInputStream(), fWriter);
    } catch (IOException ex) {
      errorMessage = MessageProvider.getMessage("uploadingError");
      return null;
    }

    // parse XML witch changes
    Document changesDoc = parseXml(fWriter.toString());
    Element docEl = changesDoc.getDocumentElement();
    
    List<AnnotType> affectedTypes = new ArrayList<AnnotType>();
    
    NodeList changeNodes = docEl.getElementsByTagName("change");
    int changesCnt = changeNodes.getLength();
    for (int i = 0; i < changesCnt; i++) {  // for each change
      Element changeEl = (Element) changeNodes.item(i);
      String uri = changeEl.getAttribute("uri");
      if (uri == null || uri.isEmpty()) {
        errorMessage = errorMessage + MessageProvider.getMessage("badUriPatternFound") + "<br/>";
        continue;
      }
      
      // process new name
      String name = changeEl.getAttribute("newName");
      if (name != null && name.isEmpty()) {
        name = null;
      }
      
      // process comment
      String comment = null;
      NodeList commentNL = changeEl.getElementsByTagName("comment");
      if (commentNL.getLength() != 0) {  // if any comment found
        Element commentEl = (Element) commentNL.item(0);
        int k = 1;
        while (commentEl.getParentNode() != changeEl && k < commentNL.getLength()) {
          // if it is node on nested level
          commentEl = (Element) commentNL.item(k);  // skip node
          k++;
        }
        if (commentEl.getParentNode() == changeEl) {  // if node is on right level
          comment = MessageProcessor.getElementContent(commentEl);
        }
      }  // if any comment found
      
      // find affected types
      List<AnnotType> changedTypes = getChangedTypes(uri, userGroup);
      
      if (changedTypes.isEmpty()) {
        errorMessage = errorMessage + MessageProvider.getMessage("noTypesSelectedByPattern") + ": " + uri +  "<br/>";
        continue;
      }
      
      for (Iterator<AnnotType> chTIt = changedTypes.iterator(); chTIt.hasNext();) {
        AnnotType chType = chTIt.next();

        // find annotations of this type and check whether name can be changed
        if (name != null) {
          params[0] = "type";
          params[1] = chType.getId();
          List aList = AppBean.getPersistenceManager().queryDB("Annotation.findByType", params);
          if (aList != null && !aList.isEmpty()) {  // if some annotations found
            errorMessage = errorMessage + MessageProvider.getMessage("ifAnnotationsExistsNameCantBeChanged") 
                                        + " (" + chType.getUri() + ")<br/>";
            name = null;  // name can't be changed
          }
        }

        affectedTypes.add(chType);  // type will be affected by change
        if (name != null) {  // if name will be changed
          boolean someChange = true;
          while (someChange) {  // while some types added
            someChange = false;
            List<AnnotType> nowAdd = new ArrayList<AnnotType>();
            for (Iterator<AnnotType> afIt = affectedTypes.iterator(); afIt.hasNext();) {  // for all affected
              AnnotType afT = afIt.next();
              // query DB for types which primary ancestor is actual type
              params[0] = "ancestor";
              params[1] = afT.getId();
              
              @SuppressWarnings("unchecked")
              List<AnnotType> tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByAncestor", params);
              if (tList != null && !tList.isEmpty()) {  // if some type found
                for (Iterator<AnnotType> tIt = tList.iterator(); tIt.hasNext();) {
                  AnnotType t = tIt.next();
                  if (!affectedTypes.contains(t) && !nowAdd.contains(t)) {
                    nowAdd.add(t);  // type will be affected by change of ancestor
                    someChange = true;
                  }
                }
              }  // if some type found
            }  // for all affected
            affectedTypes.addAll(nowAdd);
          }  // while some types added
          // change name
          chType.setName(name);
        }  // if name will be changed

        
        // change comment
        if (comment != null) {
          chType.setComment(comment);
        }
        
        // process changes in attributes
        NodeList attrNodes = changeEl.getElementsByTagName("attribute");
        int attrCnt = attrNodes.getLength();
        for (int j = 0; j < attrCnt; j++) {  // for each attribute
          Element attrEl = (Element) attrNodes.item(j);
          String aName = attrEl.getAttribute("name");
          if (aName == null || aName.isEmpty()) {
            errorMessage = errorMessage + MessageProvider.getMessage("badAttrChangeDescriprionFound") + "<br/>";
            continue;
          }
          
          AnnotTypeAttr chAttr = null;
          for (Iterator<AnnotTypeAttr> attrIt = chType.getAttributes().iterator(); attrIt.hasNext();) {
            AnnotTypeAttr aTA = attrIt.next();
            if (aTA.getName().equals(aName)) {
              chAttr = aTA;
            }
          }
          
          if (chAttr == null) {
            errorMessage = errorMessage + MessageProvider.getMessage("badAttrChangeDescriprionFound") 
                                        + ": " + aName + "<br/>";
            continue;
          }
          
          // process new name
          String newAttrName = attrEl.getAttribute("newName");
          if (newAttrName != null && newAttrName.isEmpty()) {
            newAttrName = null;
          }
          
          // update name
          if (newAttrName != null) {
            chAttr.setName(newAttrName);
          }

          // process comment
          String attrComment = null;
          NodeList aCNL = attrEl.getElementsByTagName("comment");
          if (aCNL.getLength() != 0) {
            Element aCEl = (Element) aCNL.item(0);
            attrComment = MessageProcessor.getElementContent(aCEl);
          }
      
          // update comment
          if (attrComment != null) {
            chAttr.setComment(attrComment);
          }
          
        }  // for each attribute
      }  // for each changed type
    }  // for each change
    
    // check for duplicit attributes
    for (Iterator<AnnotType> aTIt = affectedTypes.iterator(); aTIt.hasNext();) {
      AnnotType aType = aTIt.next();
      ArrayList<String> nList = new ArrayList<String>();
      for (Iterator<AnnotTypeAttr> aTAIt = aType.getAttributes().iterator(); aTAIt.hasNext();) {
        AnnotTypeAttr aTA = aTAIt.next();
        if (!nList.contains(aTA.getName())) {
          nList.add(aTA.getName());
        } else {  // if duplicit attribute found
          errorMessage = errorMessage + MessageProvider.getMessage("changesViolateRestrictions")
                         + ": " + MessageProvider.getMessage("duplicitAttrsFound")
                         + ": " + aTA.getName() + "<br/>";
          return null;
        }
      }
    }  // check for duplicit attributes
   
    
    // persist changes to database
    EntityManager em = AppBean.getPersistenceManager().getEM();
    EntityTransaction transaction = em.getTransaction();
    boolean errorOccurred = false;
    try {
      transaction.begin();

      List<AnnotType> sTypes = new ArrayList<AnnotType>();  // stored affected types
      
      for (Iterator<AnnotType> aTIt = affectedTypes.iterator(); aTIt.hasNext();) {  // for each type
        AnnotType aType = aTIt.next();
        AnnotType sType = queryType(aType.getUri(), em);  // get stored variant of type
        sTypes.add(sType);        
        // update type
        sType.setName(aType.getName());
        sType.setComment(aType.getComment());
        // update attributes
        for (Iterator<AnnotTypeAttr> aTAIt = sType.getAttributes().iterator(); aTAIt.hasNext();) {
          AnnotTypeAttr aTA = aTAIt.next();
          // find new data and update attribute
          for (Iterator<AnnotTypeAttr> nATAIt = aType.getAttributes().iterator(); nATAIt.hasNext();) {
            AnnotTypeAttr nATA = nATAIt.next();
            if (aTA.getId() == nATA.getId()) {
              aTA.setName(nATA.getName());
              aTA.setComment(nATA.getComment());
              break;
            }
          }
        }
      }  // for each type
      
      for (Iterator<AnnotType> sTIt = sTypes.iterator(); sTIt.hasNext();) {
        AnnotType sType = sTIt.next();
        sType.setUri(sType.getGeneratedURI());  // update URI
      }

      // check for duplicit types
      for (Iterator<AnnotType> sTIt = sTypes.iterator(); sTIt.hasNext();) {
        AnnotType type = sTIt.next();
        // query DB for types with given URI
        params[0] = "uri";
        params[1] = type.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 tList = q.getResultList();
        if (tList != null && !tList.isEmpty()) {  // if type was found
          if (tList.size() > 1) {  // if more than one type found
            errorMessage = errorMessage + MessageProvider.getMessage("changesViolateRestrictions")
                           + ": " + MessageProvider.getMessage("duplicitUrisFound")
                           + ": " + type.getUri() + "<br/>";
            throw new RuntimeException("Duplicit URIs found!");
          }
        } else {  // if type was not found
          throw new RuntimeException("Some type was not found!");
        }
      }  // check for duplicit types
      
      em.flush();
      transaction.commit();
    } catch (Exception e) {
      transaction.rollback();
      if (errorMessage.isEmpty()) {
        errorMessage = errorMessage + MessageProvider.getMessage("typePersistingError") + "<br/>";
      }
      return null;
    } finally {
      em.close();
    }

    // update URIs
    for (Iterator<AnnotType> aTIt = affectedTypes.iterator(); aTIt.hasNext();) {
      AnnotType aType = aTIt.next();
      aType.setUri(aType.getGeneratedURI());  // update URI
    }
    
    // prepare messages for connected clients
    ResponseCreator rc = AppBean.getResponseCreator();
    Iterator<EditorSession> sesIt = AppBean.getSessions().iterator();
    synchronized(AppBean.getSessions()){
      while (sesIt.hasNext()) {  // for each client
        EditorSession es = sesIt.next();
        Flier flier = new Flier();
        // create list of changed types
        for (Iterator<AnnotType> atIt = affectedTypes.iterator(); atIt.hasNext();) {
          AnnotType at = atIt.next();
          flier.AddEditedType(at);
        }
        es.addMessageTS(rc.createCometResponse(flier, es));  // create message
      }
    }
    
    // display message about success
    successMessage = MessageProvider.getMessage("uploadSuccessfull") + "<br/>"
                    +MessageProvider.getMessage("changesInTypesApplied");

    return null;
  }  // btnUploadAction()

  /**
   * Gets changed types of annotations
   *
   * @param uriPattern URI pattern
   * @param userGroup User group in which changed types are
   * @return Returns list of changed types
   */
  private List<AnnotType> getChangedTypes(String uriPattern, UserGroup userGroup) {
    if (!uriPattern.contains("*") && uriPattern.contains(AppBean.getBaseTypeUri())) {
      // if pattern contains URI without wildcards, exact matching type will be returned
      return getChangedTypeExact(uriPattern);
    } else if (uriPattern.contains("*") && uriPattern.contains(AppBean.getBaseTypeUri())) {
      // if pattern contains URI with wildcards
      // replaces wildcards by these required for database query
      uriPattern = uriPattern.replace("*", "%");
      // return matching types
      return getChangedTypesLike(uriPattern);
    } else if (!uriPattern.contains("*")) {
      // if pattern contains linearized name without wildcards
      // creates list of names to URI
      uriPattern = MessageProcessor.replaceArrows(uriPattern);
      if (MessageProcessor.isGroupIncluded(uriPattern)) {  // if group number is included
        // create URI of type
        uriPattern = AppBean.getBaseTypeUri() + uriPattern;
        // return exactly matching types
        return getChangedTypeExact(uriPattern);
      } else {  // if group number is not included
        // create URI of type
        String uriPatternWG = AppBean.getBaseTypeUri() + "g" + userGroup.getId() + "/" + uriPattern;
        // return type exactly matching in this group
        return getChangedTypeExact(uriPatternWG);
      }
    } else {  // if pattern contains linearized name with wildcards
      // replaces wildcards by these required for database query
      uriPattern = uriPattern.replace("*", "%");
      uriPattern = MessageProcessor.replaceArrows(uriPattern);
      if (MessageProcessor.isGroupIncluded(uriPattern)) {  // if group number is included
        // create URI of type
        uriPattern = AppBean.getBaseTypeUri() + uriPattern;
        // return matching types
        return getChangedTypesLike(uriPattern);
      } else {  // if group number is not included
        // create URI of type
        String uriPatternWG = AppBean.getBaseTypeUri() + "g" + userGroup.getId() + "/" + uriPattern;
        // return types matching in this group
        return getChangedTypesLike(uriPatternWG);
      }
    }  // if filter contains linearized name with wildcards
  }  // getQueriedTypes()

  /**
   * Gets type of annotations with given URI serialized in XML
   *
   * @param uri URI of requested type of annotations
   * @return Returns list with types of annotations with given URI
   */
  private List<AnnotType> getChangedTypeExact(String uri) {
    // query database for type with given URI
    Object[] params = new Object[2];
    params[0] = "uri";
    params[1] = uri;
    
    @SuppressWarnings("unchecked")
    List<AnnotType> tList = AppBean.getPersistenceManager().queryDB("AnnotType.findByUri", params);
    if (tList != null && !tList.isEmpty()) {  // if type was found
      return tList;
    }
    return new ArrayList<AnnotType>();  // return empty list
  }  // getChangedTypeExact()

  /**
   * Gets type of annotations with URI matching given pattern
   * Character % is used as wildcard.
   *
   * @param uriPattern Pattern of URI of requested type of annotations
   * @return Returns list with types of annotations with URI matching given pattern
   */
  @SuppressWarnings("unchecked")
  private List<AnnotType> getChangedTypesLike(String uriPattern) {
    List tList = null;
    // query database for matching types
    EntityManager em = AppBean.getPersistenceManager().getEM();
    try {
      Query query = em.createQuery("SELECT a FROM AnnotType a WHERE a.uri LIKE '" + uriPattern + "'");
      tList = query.getResultList();
    } catch (Exception e) {
      tList = null;
    } finally {
      em.close();
    }

    if (tList != null && !tList.isEmpty()) {  // if some types was found
      return tList;
    }
    return new ArrayList<AnnotType>();  // return empty list
  }  // getChangedTypesLike()
  

  /**
   * 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)
      throw new RuntimeException("New type not found!");
    }
    return annotType;
  }  // queryType()

  /**
   * Gets uploaded file
   *
   * @return Returns uploaded file
   */
  public UploadedFile getUploadedFile() {
    return uploadedFile;
  }

  /**
   * Sets uploaded file
   *
   * @param uploadedFile Uploaded file
   */
  public void setUploadedFile(UploadedFile uploadedFile) {
    this.uploadedFile = uploadedFile;
  }

  /**
   * Gets uploaded file name
   *
   * @return Returns uploaded file name
   */
  public String getFileName() {
    return fileName;
  }

  /**
   * Gets error message displayed in form
   *
   * @return Returns error message displayed in form
   */
  public String getErrorMessage() {
    return errorMessage;
  }

  /**
   * Sets error message to be displayed in form
   *
   * @param errorMessage Error message to be displayed in form
   */
  public void setErrorMessage(String errorMessage) {
    this.errorMessage = errorMessage;
  }

  /**
   * Gets success message displayed in form
   *
   * @return Returns success message displayed in form
   */
  public String getSuccessMessage() {
    return successMessage;
  }

  /**
   * Sets success message to be displayed in form
   *
   * @param successMessage Success message to be displayed in form
   */
  public void setSuccessMessage(String successMessage) {
    this.successMessage = successMessage;
  }

  /**
   * Gets user group in which uploaded types will be shared
   *
   * @return Returns user group in which uploaded types will be shared
   */
  public String getuGroup() {
    return uGroup;
  }

  /**
   * Sets user group in which uploaded types will be shared
   *
   * @param uGroup User group in which uploaded types will be shared
   */
  public void setuGroup(String uGroup) {
    this.uGroup = uGroup;
  }

  /**
   * Parses XML with changes
   *
   * @param XMLString String with XML with changes
   * @return Parsed XML in w3c.dom.Document
   */
  private static Document parseXml(String XMLString) {
    Document dom;
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);

    try {
      DocumentBuilder db = dbf.newDocumentBuilder();
      InputSource is = new InputSource();
      is.setCharacterStream(new StringReader(XMLString));
      dom = db.parse(is);
    } catch (ParserConfigurationException pce) {
      return null;  // bad request
    } catch (SAXException se) {
      return null;
    } catch (IOException ioe) {
      return null;
    }

    return dom;
  }  // parseXml()
  
}  // public class RenameTypes