Examples of edu.isi.karma.controller.update.UpdateContainer

edu.isi.karma.controller.update.UpdateContainer
Container class to carry multiple update objects. @author szekely

      }
    });
    for (JSONObject obj : objects) {
      array.put(obj);
    }
    return new UpdateContainer(new AbstractUpdate() {


      @Override
      public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
        System.out.println(array.toString());
        pw.print(array.toString());

View Full Code Here

      }
      // logger.trace(out.toString());
      // logger.info("Connnection success : " + url + " Successful.");
      final JSONObject data1 = new JSONObject(out.toString());
      // logger.trace("Data--->" + data1);
      return new UpdateContainer(new AbstractUpdate() {


        @Override
        public void generateJson(String prefix, PrintWriter pw,
            VWorkspace vWorkspace) {
          JSONObject response = new JSONObject();
          // logger.trace("Reached here");
          try {
            response.put("updateType", "CleaningServiceOutput");
            response.put("chartData", data1);
            response.put("hNodeId", hNodeId);
            // logger.trace(response.toString(4));
          } catch (JSONException e) {
            pw.print("Error");
          }


          pw.print(response.toString());
        }
      });
    } catch (Exception e) {
      e.printStackTrace();
      return new UpdateContainer(new ErrorUpdate("Error!"));
    }
  }

View Full Code Here

    return CommandType.notUndoable;
  }


  @Override
  public UpdateContainer doIt(Workspace workspace) throws CommandException {
    UpdateContainer c = new UpdateContainer();
    if (forgetSemanticTypes) {
      boolean deletTypes = workspace.getSemanticTypeModelHandler().removeAllLabels();
      if (!deletTypes)
        c.add(new ErrorUpdate("Error occured while removing semantic types."));
    }
    
    if (forgetModels) {
      File dir = new File(ServletContextParameterMap.getParameterValue(ContextParameter.R2RML_USER_DIR));
      if (!dir.exists() || !dir.isDirectory()) {
        logger.error("Directory not found where the model histories are stored.");
        c.add(new ErrorUpdate("Error occured while removing Model Histories: Directory was not found"));
      } else {
      
        File[] workspaceFiles = dir.listFiles();
        if (workspaceFiles != null && workspaceFiles.length != 0) {
          for (File file: workspaceFiles) {
            file.delete();
          }
        }
      }
    }
      
    if(forgetAlignment) {
      File dir = new File(ServletContextParameterMap.getParameterValue(ContextParameter.ALIGNMENT_GRAPH_DIRECTORY));
      if (!dir.exists() || !dir.isDirectory()) {
        logger.error("Directory not found where the Alignment is stored.");
        c.add(new ErrorUpdate("Error occured while removing Alignment: Directory was not found"));
      } else {
      
        File[] workspaceFiles = dir.listFiles();
        if (workspaceFiles != null && workspaceFiles.length != 0) {
          for (File file: workspaceFiles) {
            file.delete();
          }
        }
      }
    }
    
    c.add(new AbstractUpdate(){
        
  
        @Override
        public void generateJson(String prefix, PrintWriter pw,
            VWorkspace vWorkspace) {
          JSONObject obj = new JSONObject();
          try {
            obj.put(GenericJsonKeys.updateType.name(), "ResetKarmaCommandUpdate");
            pw.println(obj.toString());
          } catch (JSONException e) {
            logger.error("Unable to generate Json", e);
          }
          
        }
      });
    
    
    
    c.add(new InfoUpdate("Reset complete"));
    return c;
  }

View Full Code Here

  }




  @Override
  public UpdateContainer doIt(Workspace workspace) throws CommandException {
    UpdateContainer uc = new UpdateContainer();
    //save the preferences 
    savePreferences(workspace);
    boolean storeOldHistory = ModelingConfiguration.isStoreOldHistoryEnabled();
    System.out.println("storeOldHistory: " + storeOldHistory);
    Worksheet worksheet = workspace.getWorksheet(worksheetId);
    SuperSelection selection = getSuperSelection(worksheet);
    CommandHistory history = workspace.getCommandHistory();
    List<Command> oldCommands = history.getCommandsFromWorksheetId(worksheetId);
    if (storeOldHistory) {      
      JSONArray oldCommandsArray = new JSONArray();
      for (Command refined : oldCommands)
        oldCommandsArray.put(workspace.getCommandHistory().getCommandJSON(workspace, refined));
      worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
          Property.oldCommandHistory, oldCommandsArray.toString());
    }
    CommandHistoryUtil historyUtil = new CommandHistoryUtil(history.getCommandsFromWorksheetId(worksheetId), workspace, worksheetId);
    historyUtil.consolidateHistory();  
    if (!oldCommands.equals(historyUtil.getCommands())) {
      uc.append(historyUtil.replayHistory());
      uc.removeUpdateByClass(HistoryAddCommandUpdate.class);
      uc.removeUpdateByClass(InfoUpdate.class);
      uc.removeUpdateByClass(ErrorUpdate.class);
      historyUtil.consolidateHistory();
      uc.add(new HistoryUpdate(workspace.getCommandHistory()));


    }
    Set<String> inputColumns = historyUtil.generateInputColumns();
    Set<String> outputColumns = historyUtil.generateOutputColumns();
    JSONArray inputColumnsArray = new JSONArray();
    JSONArray outputColumnsArray = new JSONArray();
    for (String hNodeId : inputColumns) {
      HNode hnode = workspace.getFactory().getHNode(hNodeId);
      JSONArray hNodeRepresentation = hnode.getJSONArrayRepresentation(workspace.getFactory());
      inputColumnsArray.put(hNodeRepresentation);
    }


    for (String hNodeId : outputColumns) {
      HNode hnode = workspace.getFactory().getHNode(hNodeId);
      JSONArray hNodeRepresentation = hnode.getJSONArrayRepresentation(workspace.getFactory());
      outputColumnsArray.put(hNodeRepresentation);
    }
    worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
        Property.inputColumns, inputColumnsArray.toString());
    worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
        Property.outputColumns, outputColumnsArray.toString());    
    this.worksheetName = worksheet.getTitle();
    String graphLabel = worksheet.getMetadataContainer().getWorksheetProperties().
        getPropertyValue(Property.graphLabel); 


    if (graphLabel == null || graphLabel.isEmpty()) {
      worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
          Property.graphLabel, worksheet.getTitle());
      graphLabel = worksheet.getTitle();
      worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
          Property.graphName, WorksheetProperties.createDefaultGraphName(graphLabel));  
    }
    // Prepare the model file path and names
    final String modelFileName = graphLabel + "-model.ttl"; 
    final String modelFileLocalPath = ServletContextParameterMap.getParameterValue(
        ContextParameter.R2RML_PUBLISH_DIR) +  modelFileName;


    // Get the alignment for this Worksheet
    Alignment alignment = AlignmentManager.Instance().getAlignment(AlignmentManager.
        Instance().constructAlignmentId(workspace.getId(), worksheetId));


    if (alignment == null) {
      logger.info("Alignment is NULL for " + worksheetId);
      return new UpdateContainer(new ErrorUpdate(
          "Please align the worksheet before generating R2RML Model!"));
    }
    Set<LabeledLink> links = new HashSet<LabeledLink>();
    if (alignment.getSteinerTree() != null) {
      for (LabeledLink link : alignment.getSteinerTree().edgeSet()) {
        if ((link.getStatus() == LinkStatus.Normal || link.getStatus() == LinkStatus.PreferredByUI) && (link.getType() == LinkType.ObjectPropertyLink)) {
          links.add(link);
        }
      }
    }
    JSONArray newEdges = new JSONArray();
    JSONArray initialEdges = new JSONArray();
    ChangeInternalNodeLinksCommandFactory cinlcf = new ChangeInternalNodeLinksCommandFactory();
    for (LabeledLink link : links) {
      JSONObject newEdge = new JSONObject();
      JSONObject initialEdge = new JSONObject();
      newEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeSourceId.name(), link.getSource().getId());
      newEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeTargetId.name(), link.getTarget().getId());
      newEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeId.name(), link.getUri());
      initialEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeSourceId.name(), link.getSource().getId());
      initialEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeTargetId.name(), link.getTarget().getId());
      initialEdge.put(ChangeInternalNodeLinksCommand.JsonKeys.edgeId.name(), link.getUri());
      newEdges.put(newEdge);
      initialEdges.put(initialEdge);
    }
    JSONArray inputJSON = new JSONArray();
    JSONObject t = new JSONObject();
    t.put("name", "worksheetId");
    t.put("type", HistoryJsonUtil.ParameterType.worksheetId.name());
    t.put("value", worksheetId);
    inputJSON.put(t);
    t = new JSONObject();
    t.put("name", "initialEdges");
    t.put("type", HistoryJsonUtil.ParameterType.other.name());
    t.put("value", initialEdges);
    inputJSON.put(t);
    t = new JSONObject();
    t.put("name", "newEdges");
    t.put("type", HistoryJsonUtil.ParameterType.other.name());
    t.put("value", newEdges);
    inputJSON.put(t);
    if (newEdges.length() > 0 || initialEdges.length() > 0) {
      try {
        Command changeInternalNodeLinksCommand = cinlcf.createCommand(inputJSON, workspace);
        workspace.getCommandHistory().doCommand(changeInternalNodeLinksCommand, workspace);
        uc.add(new HistoryUpdate(workspace.getCommandHistory()));
        uc.append(WorksheetUpdateFactory.createRegenerateWorksheetUpdates(worksheetId, getSuperSelection(worksheet)));
        uc.append(computeAlignmentAndSemanticTypesAndCreateUpdates(workspace));
      }catch(Exception e)
      {
        e.printStackTrace();
      }
    }


    // mohsen: my code to enable Karma to leran semantic models
    // *****************************************************************************************
    // *****************************************************************************************


    SemanticModel semanticModel = new SemanticModel(workspace, worksheet, worksheetName, alignment.getSteinerTree(), selection);
    semanticModel.setName(worksheetName);
    try {
      semanticModel.writeJson(ServletContextParameterMap.getParameterValue(ContextParameter.JSON_MODELS_DIR) + 
          semanticModel.getName() + 
          ".model.json");
    } catch (Exception e) {
      logger.error("error in exporting the model to JSON!");
      //      e.printStackTrace();
    }
    try {
      semanticModel.writeGraphviz(ServletContextParameterMap.getParameterValue(ContextParameter.GRAPHVIZ_MODELS_DIR) + 
          semanticModel.getName() + 
          ".model.dot", false, false);
    } catch (Exception e) {
      logger.error("error in exporting the model to GRAPHVIZ!");
      //      e.printStackTrace();
    }


    if (ModelingConfiguration.isLearnerEnabled())
      ModelLearningGraph.getInstance(workspace.getOntologyManager(), ModelLearningGraphType.Compact).
      addModelAndUpdateAndExport(semanticModel);


    // *****************************************************************************************
    // *****************************************************************************************


    try {
      R2RMLAlignmentFileSaver fileSaver = new R2RMLAlignmentFileSaver(workspace);


      fileSaver.saveAlignment(alignment, modelFileLocalPath);


      // Write the model to the triple store


      // Get the graph name from properties
      String graphName = worksheet.getMetadataContainer().getWorksheetProperties()
          .getPropertyValue(Property.graphName);
      if (graphName == null || graphName.isEmpty()) {
        // Set to default
        worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
            Property.graphName, WorksheetProperties.createDefaultGraphName(worksheet.getTitle()));
        worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
            Property.graphLabel, worksheet.getTitle());
        graphName = WorksheetProperties.createDefaultGraphName(worksheet.getTitle());
      }


      boolean result = true;//utilObj.saveToStore(modelFileLocalPath, tripleStoreUrl, graphName, true, null);
      if (tripleStoreUrl != null && tripleStoreUrl.trim().compareTo("") != 0) {
        UriBuilder builder = UriBuilder.fromPath(modelFileName);
        String url = RESTserverAddress + "/R2RMLMapping/local/" + builder.build().toString();
        SaveR2RMLModelCommandFactory factory = new SaveR2RMLModelCommandFactory();
        SaveR2RMLModelCommand cmd = factory.createCommand(workspace, url, tripleStoreUrl, graphName, "URL");
        cmd.doIt(workspace);
        result &= cmd.getSuccessful();
        workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelUrl, url);
        workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelContext, graphName);
        workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelRepository, tripleStoreUrl);
      }
      if (result) {
        logger.info("Saved model to triple store");
        uc.add(new AbstractUpdate() {
          public void generateJson(String prefix, PrintWriter pw,  
              VWorkspace vWorkspace) {
            JSONObject outputObject = new JSONObject();
            try {
              outputObject.put(JsonKeys.updateType.name(), "PublishR2RMLUpdate");


              outputObject.put(JsonKeys.fileUrl.name(), ServletContextParameterMap.getParameterValue(
                  ContextParameter.R2RML_PUBLISH_RELATIVE_DIR) + modelFileName);
              outputObject.put(JsonKeys.worksheetId.name(), worksheetId);
              pw.println(outputObject.toString());
            } catch (JSONException e) {
              logger.error("Error occured while generating JSON!");
            }
          }
        });
        return uc;
      } 


      return new UpdateContainer(new ErrorUpdate("Error occured while generating R2RML model!"));


    } catch (Exception e) {
      logger.error("Error occured while generating R2RML Model!", e);
      return new UpdateContainer(new ErrorUpdate("Error occured while generating R2RML model!"));
    }
  }

View Full Code Here


    try {


      final String fileName = csvFileExport.publishCSV();
      if(fileName == null)
        return new UpdateContainer(new ErrorUpdate(
            "No data to export! Have you aligned the worksheet?"));
      return new UpdateContainer(new AbstractUpdate() {
        @Override
        public void generateJson(String prefix, PrintWriter pw,
            VWorkspace vWorkspace) {
          JSONObject outputObject = new JSONObject();
          try {
            outputObject.put(JsonKeys.updateType.name(),
                "PublishCSVUpdate");
            outputObject.put(JsonKeys.fileUrl.name(),
                fileName);
            outputObject.put(JsonKeys.worksheetId.name(),
                worksheetId);
            pw.println(outputObject.toString(4));
            
          } catch (JSONException e) {
            logger.error("Error occured while generating JSON!");
          }
        }
      });
    } catch (FileNotFoundException e) {
      logger.error("CSV folder not found!", e);
      return new UpdateContainer(new ErrorUpdate(
          "Error occurred while exporting CSV file!"));
    } catch(Exception e) {
      logger.error("CSV Export Error", e);
      return new UpdateContainer(new ErrorUpdate(
          "Error occurred while exporting CSV file!"));
    }
    
  }

View Full Code Here

    logger.debug("I get 1.....");
    ViewPreferences prefs = vWorkspace.getPreferences();
    JSONObject prefObject1 = prefs.getCommandPreferencesJSONObject("PublishRDFCommandPreferences");
    logger.debug("I get 1....."+prefObject1);
     */
    UpdateContainer c = new UpdateContainer();
    c.add(new FetchPreferencesUpdate( commandName+"Preferences", this.getId()));
    return c;
    
  }

View Full Code Here

      URL url = new URL(baseUrl + context + modelURL + "?modelRepository=" + modelRepository);


      File file = new File("tmp.ttl");  
      FileUtils.copyURLToFile(url, file);
      Command cmd = factory.createCommandFromFile(worksheetId, file, workspace, override);
      UpdateContainer uc = cmd.doIt(workspace);
      workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelUrl, modelURL);
      workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelContext, modelContext);
      workspace.getWorksheet(worksheetId).getMetadataContainer().getWorksheetProperties().setPropertyValue(Property.modelRepository, modelRepository);
      file.delete();
      return uc;
    }catch(Exception e) {
      String msg = "Error occured while applying history!";
      logger.error(msg, e);
      return new UpdateContainer(new ErrorUpdate(msg));
    }
    
  }

View Full Code Here

        return getFile().getName();
    }


    @Override
    public UpdateContainer doIt(Workspace workspace) throws CommandException {
        UpdateContainer c = new UpdateContainer();


        // Convert the Excel file to a CSV file.
        ToCSV csvConverter = new ToCSV();
        try {
            csvConverter.convertExcelToCSV(getFile().getAbsolutePath(),
                ServletContextParameterMap.getParameterValue(ContextParameter.CSV_PUBLISH_DIR));
        } catch (Exception e) {
            String message = "Error occured while converting the Excel file to CSV file.";
            logger.error(message, e);
            return new UpdateContainer(new ErrorUpdate(message));
        }


        List<File> csvFiles = csvConverter.getCsvFiles();


        // Each sheet is written to a separate CSV file
        if (!csvFiles.isEmpty()) {
            for (File csvFile : csvFiles) {




                try {
                    Import imp = new CSVFileImport(1, 2, ',', '"', encoding, maxNumLines, 
                        csvFile, workspace, null);
                    Worksheet wsht = imp.generateWorksheet();


                    if (hasRevisionId()) {
                        Worksheet revisedWorksheet = workspace.getWorksheet(getRevisionId());
                        wsht.setRevisedWorksheet(revisedWorksheet);
                    }


                    c.add(new WorksheetListUpdate());
                    c.append(WorksheetUpdateFactory.createWorksheetHierarchicalAndCleaningResultsUpdates(wsht.getId(), SuperSelectionManager.DEFAULT_SELECTION));
                } catch (Exception e) {
                    logger.error("Error occured while importing CSV file.", e);
                    return new UpdateContainer(new ErrorUpdate(
                            "Error occured while importing CSV File."));
                }
            }
        }
        return c;

View Full Code Here


    TripleStoreUtil utilObj = new TripleStoreUtil();
    try
    {
      HashMap<String, List<String>> list = utilObj.fetchModelNames(this.tripleStoreUrl);
      return new UpdateContainer(new FetchR2RMLUpdate(list.get("model_names"), list.get("model_urls")));
    }
    catch (Exception e)
    {
      return new UpdateContainer(new ErrorUpdate("Unable to fetch R2RML models: " + e.getMessage()));
    }
  }

View Full Code Here

    Alignment alignment = AlignmentManager.Instance().getAlignment(
        AlignmentManager.Instance().constructAlignmentId(workspace.getId(), worksheetId));


    if (alignment == null) {
      logger.info("Alignment is NULL for " + worksheetId);
      return new UpdateContainer(new ErrorUpdate(
          "Please align the worksheet before generating RDF!"));
    }


    // Generate the KR2RML data structures for the RDF generation
    final ErrorReport errorReport = new ErrorReport();
    KR2RMLMappingGenerator mappingGen = null;
    String url = worksheet.getMetadataContainer().getWorksheetProperties().getPropertyValue(Property.modelUrl);
    String modelContext = worksheet.getMetadataContainer().getWorksheetProperties().getPropertyValue(Property.modelContext);
    TripleStoreUtil utilObj = new TripleStoreUtil();
    String modelRepoUrl = worksheet.getMetadataContainer().getWorksheetProperties().getPropertyValue(Property.modelRepository);
    modelRepoUrl = modelRepoUrl == null || modelRepoUrl.isEmpty()? TripleStoreUtil.defaultModelsRepoUrl : modelRepoUrl;
    Map<String, String> bloomfilterMapping = new HashMap<String, String>();
    boolean result = true;
    try{
      mappingGen = new KR2RMLMappingGenerator(workspace, worksheet,


          alignment, worksheet.getSemanticTypes(), rdfSourcePrefix, rdfSourceNamespace, 
          Boolean.valueOf(addInverseProperties), errorReport);
    }
    catch (KarmaException e)
    {
      logger.error("Error occured while generating RDF!", e);
      return new UpdateContainer(new ErrorUpdate("Error occured while generating RDF: " + e.getMessage()));
    }


    KR2RMLMapping mapping = mappingGen.getKR2RMLMapping();
    if (url != null && !url.trim().isEmpty() && modelContext != null && !modelContext.trim().isEmpty() && generateBloomFilters && utilObj.testURIExists(modelRepoUrl, "", url)) {
      try {
        File tmp = new File("tmp");
        PrintWriter pw = new PrintWriter(tmp);
        pw.println(utilObj.getMappingFromTripleStore(modelRepoUrl, modelContext, url));
        pw.close();
        Model model = WorksheetR2RMLJenaModelParser.loadSourceModelIntoJenaModel(tmp.toURI().toURL());
        tmp.delete();
        R2RMLMappingIdentifier identifier = new R2RMLMappingIdentifier(mapping.getId().getName(), new URL(url));
        WorksheetR2RMLJenaModelParser parser = new WorksheetR2RMLJenaModelParser(model, identifier);
        mapping = parser.parse();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    logger.debug(mapping.toString());


    StringWriter sw = new StringWriter();
    // Generate the RDF using KR2RML data structures
    long start = 0;
    try {
      List<KR2RMLRDFWriter> writers = new ArrayList<KR2RMLRDFWriter>();
      File f = new File(rdfFileLocalPath);
      File parentDir = f.getParentFile();
      parentDir.mkdirs();
      BufferedWriter bw = new BufferedWriter(
          new OutputStreamWriter(new FileOutputStream(f),"UTF-8"));
      N3KR2RMLRDFWriter writer = new N3KR2RMLRDFWriter(new URIFormatter(workspace.getOntologyManager(), errorReport), new PrintWriter (bw));
      writer.setBaseURI(rdfSourceNamespace);
      writers.add(writer);
      if (generateBloomFilters && utilObj.testURIExists(modelRepoUrl, "", url)) {
        BloomFilterKR2RMLRDFWriter bfWriter = new BloomFilterKR2RMLRDFWriter(new PrintWriter(sw), false, this.rdfSourceNamespace);
        writers.add(bfWriter);
        bfWriter.setR2RMLMappingIdentifier(mapping.getId());
      }
      KR2RMLWorksheetRDFGenerator rdfGen = new KR2RMLWorksheetRDFGenerator(worksheet, 
          workspace.getFactory(), workspace.getOntologyManager(),
          writers, false, mapping, errorReport, selection);


      rdfGen.generateRDF(true);
      logger.info("RDF written to file: " + rdfFileLocalPath);
      if(saveToStore){
        //take the contents of the RDF file and save them to the store
        logger.info("Using Jena DB:" + hostName + "/"+dbName + " user="+userName);
        saveToStore(rdfFileLocalPath);
      }
      start = System.currentTimeMillis();
      if (generateBloomFilters && utilObj.testURIExists(modelRepoUrl, "", url)) {
        JSONObject obj = new JSONObject(sw.toString());
        result &= updateTripleStore(obj, bloomfilterMapping, modelRepoUrl, modelContext, utilObj);
        Map<String, String> verification = new HashMap<String, String>();
        Set<String> triplemaps = new HashSet<String>(Arrays.asList(obj.getString("ids").split(",")));
        verification.putAll(utilObj.getBloomFiltersForMaps(modelRepoUrl, modelContext, triplemaps));
        boolean verify = true;
        for (Entry<String, String> entry : verification.entrySet()) {
          String key = entry.getKey();
          String value = entry.getValue();
          KR2RMLBloomFilter bf2 = new KR2RMLBloomFilter(KR2RMLBloomFilter.defaultVectorSize, KR2RMLBloomFilter.defaultnbHash, Hash.JENKINS_HASH);
          KR2RMLBloomFilter bf = new KR2RMLBloomFilter(KR2RMLBloomFilter.defaultVectorSize, KR2RMLBloomFilter.defaultnbHash, Hash.JENKINS_HASH);
          bf2.populateFromCompressedAndBase64EncodedString(value);
          bf.populateFromCompressedAndBase64EncodedString(obj.getString(key));
          bf2.and(bf);
          bf2.xor(bf);
          try {
            Field f1 = BloomFilter.class.getDeclaredField("bits");
            f1.setAccessible(true);
            BitSet bits = (BitSet) f1.get(bf2);
            if (bits.cardinality() != 0) {
              verify = false;
              break;
            }
          } catch (Exception e) {
            
          }
        }
        if (!verify) {
          result &= updateTripleStore(obj, verification, modelRepoUrl, modelContext, utilObj);
        }
        long end = System.currentTimeMillis();
        System.out.println("execution time: " + (end - start) + " node total: " + bloomfilterMapping.size());
      }
    } catch (Exception e1) {
      logger.error("Error occured while generating RDF!", e1);
      return new UpdateContainer(new ErrorUpdate("Error occured while generating RDF: " + e1.getMessage()));
    }
    try {


      // Get the graph name from properties if empty graph uri 
      //      String graphName = worksheet.getMetadataContainer().getWorksheetProperties()
      //          .getPropertyValue(Property.graphName);
      //      if (this.graphUri == null || this.graphUri.isEmpty()) {
      //        // Set to default
      //        worksheet.getMetadataContainer().getWorksheetProperties().setPropertyValue(
      //            Property.graphName, WorksheetProperties.createDefaultGraphName(worksheet.getTitle()));
      //        this.graphUri = WorksheetProperties.createDefaultGraphName(worksheet.getTitle());
      //      }


      if (tripleStoreUrl == null || tripleStoreUrl.isEmpty()) {
        tripleStoreUrl = TripleStoreUtil.defaultDataRepoUrl;
      }
      logger.info("tripleStoreURl : " + tripleStoreUrl);




      result &= utilObj.saveToStoreFromFile(rdfFileLocalPath, tripleStoreUrl, this.graphUri, this.replaceContext, this.rdfSourceNamespace);
      if (url != null && !url.isEmpty() && url.compareTo("") != 0 && utilObj.testURIExists(modelRepoUrl, "", url)) {
        StringBuilder sb = new StringBuilder();
        url = url.trim();
        if(!url.startsWith("<"))
        {
          sb.append("<");
        }
        sb.append(url);
        if(!url.endsWith(">"))
        {
          sb.append(">");
        }
        sb.append(" <");
        sb.append( Uris.MODEL_HAS_DATA_URI);
        sb.append("> \"true\" .\n");
        String input = sb.toString();
        result &= utilObj.saveToStoreFromString(input, modelRepoUrl, modelContext, new Boolean(false), this.rdfSourceNamespace);
      }
      if(result) {
        logger.info("Saved rdf to store");
      } else {
        logger.error("Falied to store rdf to karma_data store");
        return new UpdateContainer(new ErrorUpdate("Error: Failed to store RDF to the triple store"));
      }
    } catch (Exception e) {
      logger.error(e.getMessage());
      e.printStackTrace();
      return new UpdateContainer(new ErrorUpdate("Error occured while generating RDF: " + e.getMessage()));
    }


    try {
      return new UpdateContainer(new AbstractUpdate() {
        public void generateJson(String prefix, PrintWriter pw,
            VWorkspace vWorkspace) {
          JSONObject outputObject = new JSONObject();
          try {
            outputObject.put(PublishRDFCommandJsonKeys.updateType.name(), "PublishRDFUpdate");
            outputObject.put(PublishRDFCommandJsonKeys.fileUrl.name(), 
                ServletContextParameterMap.getParameterValue(ContextParameter.RDF_PUBLISH_RELATIVE_DIR) + rdfFileName);
            outputObject.put(PublishRDFCommandJsonKeys.worksheetId.name(), worksheetId);
            outputObject.put(PublishRDFCommandJsonKeys.errorReport.name(), errorReport.toJSONString());
            pw.println(outputObject.toString(4));
          } catch (JSONException e) {
            logger.error("Error occured while generating JSON!");
          }
        }
      });
    } catch (Exception e) {
      return new UpdateContainer(new ErrorUpdate(e.getMessage()));
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of edu.isi.karma.controller.update.UpdateContainer

edu.isi.karma.controller.command.alignment.AddUserLinkToAlignmentCommand

edu.isi.karma.controller.command.alignment.AugmentDataCommand

edu.isi.karma.controller.command.alignment.AugmentDataDispachCommand

edu.isi.karma.controller.command.alignment.ClearTripleStoreCommand

edu.isi.karma.controller.command.alignment.InvokeDataMiningServiceCommand

edu.isi.karma.controller.command.alignment.SearchForDataToAugmentCommand

edu.isi.karma.controller.command.alignment.SetMetaPropertyCommand

edu.isi.karma.controller.command.alignment.SetSemanticTypeCommand

edu.isi.karma.controller.command.alignment.SuggestModelCommand

edu.isi.karma.controller.command.alignment.UnassignSemanticTypeCommand

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.