Examples of ImportManager

de.iritgo.aktera.importer.ImportManager
Import manager.
edu.uga.galileo.voci.model.ImportManager
net.crystalyx.bukkit.simplyperms.imports.ImportManager
org.dmd.util.codegen.ImportManager
org.eclipse.xtext.xbase.compiler.ImportManager
org.jboss.dashboard.export.ImportManager
Dashboard import manager.

Examples of de.iritgo.aktera.importer.ImportManager

   */
  protected void convertToXml(ModelRequest request, String fileName, String xslt)
    throws IOException, javax.xml.transform.TransformerConfigurationException,
    javax.xml.transform.TransformerException, ModelException
  {
    ImportManager im = (ImportManager) request.getSpringBean(ImportManager.ID);


    if (im.validateXmlFile(new File(fileName)))
    {
      return;
    }


    if (StringTools.isTrimEmpty(xslt))

View Full Code Here

Examples of de.iritgo.aktera.importer.ImportManager

   */
  protected boolean analyze(final ModelRequest req, ModelResponse res, final String fileName, final String handlerId,
          final boolean bulkImport, String xslt, final Properties properties) throws ModelException
  {
    final I18N i18n = (I18N) req.getSpringBean(I18N.ID);
    final ImportManager im = (ImportManager) req.getSpringBean(ImportManager.ID);


    FileTools.newAkteraFile("/var/tmp/iritgo").mkdirs();


    final File lockFile = FileTools.newAkteraFile("/var/tmp/iritgo/import.lck");


    if ("Y".equals(req.getParameter("force")))
    {
      lockFile.delete();
    }


    if (lockFile.exists())
    {
      return false;
    }


    try
    {
      lockFile.createNewFile();


      File reportFile = FileTools.newAkteraFile("/var/tmp/iritgo/import-report.txt");


      reportFile.delete();
      reportFile.createNewFile();


      final PrintWriter reporter = new PrintWriter(new FileOutputStream(reportFile), true);


      convertToXml(req, fileName, xslt);


      if (im.validateXmlFile(new File(fileName)))
      {
        new Thread()
        {
          public void run()
          {
            boolean ok = true;


            try
            {
              File file = new File(fileName);
              Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(
                      "file://" + file.getAbsolutePath());


              if (doc.getChildNodes().getLength() > 0)
              {
                XPath xPath = XPathFactory.newInstance().newXPath();
                Node importElem = (Node) xPath.evaluate("import", doc, XPathConstants.NODE);


                if (importElem != null)
                {
                  reporter.println(i18n.msg(req, "Aktera", "startingImportAnalysis"));
                  ok = im.analyzeImport(req, doc, importElem, reporter, i18n, handlerId, bulkImport, properties);
                }
                else
                {
                  reporter.println(i18n
                          .msg(req, "AkteraImporter", "importErrorNoImportRootNodeFound"));

View Full Code Here

Examples of de.iritgo.aktera.importer.ImportManager

   */
  protected boolean perform(final ModelRequest req, ModelResponse res, final String fileName, final String handlerId,
          String xslt, final boolean bulkImport, final Properties properties) throws ModelException
  {
    final I18N i18n = (I18N) req.getSpringBean(I18N.ID);
    final ImportManager im = (ImportManager) req.getSpringBean(ImportManager.ID);


    FileTools.newAkteraFile("/var/tmp/iritgo").mkdirs();


    final File lockFile = FileTools.newAkteraFile("/var/tmp/iritgo/import.lck");


    if (lockFile.exists())
    {
      return true;
    }


    try
    {
      lockFile.createNewFile();


      File reportFile = FileTools.newAkteraFile("/var/tmp/iritgo/import-report.txt");


      reportFile.delete();
      reportFile.createNewFile();


      final PrintWriter reporter = new PrintWriter(new FileOutputStream(reportFile), true);


      convertToXml(req, fileName, xslt);


      if (im.validateXmlFile(new File(fileName)))
      {
        new Thread()
        {
          public void run()
          {
            boolean ok = true;
            File file = null;


            try
            {
              file = new File(fileName);


              Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(
                      "file://" + file.getAbsolutePath());


              XPath xPath = XPathFactory.newInstance().newXPath();


              Node importElem = (Node) xPath.evaluate("import", doc, XPathConstants.NODE);


              reporter.println(i18n.msg(req, "Aktera", "startingImport"));


              ok = im.performImport(req, doc, importElem, reporter, i18n, handlerId, bulkImport, properties);
            }
            catch (ParserConfigurationException x)
            {
              reporter.println(i18n.msg(req, "Aktera", "importError", x.toString()));
            }

View Full Code Here

Examples of edu.uga.galileo.voci.model.ImportManager

      HttpServletResponse response) {
    Command command = (Command) request.getAttribute("command");
    User user = (User) request.getSession().getAttribute("user");
    ArrayList<String> errors = new ArrayList<String>();
    ArrayList<VociBusinessObject> problems = new ArrayList<VociBusinessObject>();
    ImportManager iman = new ImportManager();


    // always get the list of importers for display to users
    String importers;
    if ((importers = Configuration.getString("vociImporters")) != null) {
      String[] importerArray = importers.split(",");
      ArrayList<Importer> importerCollection = new ArrayList<Importer>();
      String arrayElement;
      for (int m = 0; m < importerArray.length; m++) {
        arrayElement = importerArray[m].trim();
        if (arrayElement.length() > 0) {
          Importer importer = iman.getImporter(arrayElement, errors);
          importerCollection.add(importer);
        }
      }


      if (importerCollection.size() > 0) {
        request.setAttribute("vociImporters", importerCollection);
      }
    }


    // ...then handle user interaction
    String query;
    if ((command.getModifier() != null)
        && (command.getModifier().equals("query"))
        && ((query = request.getParameter("query")) != null)
        && ((query = query.trim()).length() > 0)) {
      Logger.debug("Import query started: " + query + " for type "
          + request.getParameter("ctype"));
      // successfulImportCount will get updated if some are done
      request.setAttribute("successfulImportCount", 0);


      request.setAttribute("successfulImportCount", iman.performImport(
          user, request.getParameter("importer"), query, request
              .getParameter("ctype"), command.getProject(),
          errors, problems));


      if ((problems == null) || (problems.size() == 0)) {

View Full Code Here

Examples of net.crystalyx.bukkit.simplyperms.imports.ImportManager

            return true;
        } else if (subcommand.equals("import")) {
            if (!checkPerm(sender, "import")) return true;
            if (split.length != 2) return usage(sender, command, subcommand);
          String pluginName = split[1].toLowerCase();
          ImportManager manager;


          if (pluginName.equals("permissionsbukkit")) {
            manager = new ImportPermBukkit(plugin);
          } else if (pluginName.equals("privileges")) {
            manager = new ImportPrivileges(plugin);
          } else if (pluginName.equals("file")) {
            manager = new ImportFile(plugin);
          } else if (plugin.getConfig().getString("db/type") != null
              && pluginName.equals(plugin.getConfig().getString("db/type").toLowerCase())) {
            manager = new ImportDB(plugin);
          } else {
            sender.sendMessage(ChatColor.RED + "Unknown import type !");
            return true;
          }


            try {
              manager.run();
              plugin.refreshPermissions();
              sender.sendMessage(ChatColor.GREEN + "Operation success !");
            } catch (Exception e) {
              plugin.reloadConfig();
              sender.sendMessage(ChatColor.RED + "An error occurred ! Please check server log...");

View Full Code Here

Examples of org.dmd.util.codegen.ImportManager

        out.close();
  }
  
  public static void formatPlaceHistoryMapper(String outdir, WebApplication app, TreeMap<CamelCaseName, Place> places) throws IOException {
        BufferedWriter   out = FileUpdateManager.instance().getWriter(outdir, app.getAppName() + "PlaceHistoryMapper.java");
        ImportManager imports = new ImportManager();
        getImports(imports,app,places);


        out.write("package " + app.getDefinedInModule().getGenPackage() + ".generated.mvw.places;\n\n");
        
        out.write("\n");
        out.write(imports.getFormattedImports());
        out.write("\n");
        out.write("@WithTokenizers({\n");
        int count = 1;
        for(Place place: places.values()){
          out.write("                    " + place.getPlaceName() + ".Tokenizer.class");

View Full Code Here

Examples of org.dmd.util.codegen.ImportManager


    static void dumpExtendedReferenceType(String header, String od, ExtendedReferenceTypeDefinition ertd) throws IOException, ResultException {
      String       ctn       = ertd.getName().getNameString();
      String       fieldSeparator   = ertd.getFieldSeparator();
        Iterator<Field>  fields       = null;
        ImportManager  imports      = new ImportManager();
        
      if (fieldSeparator == null)
        fieldSeparator = " ";
      
      if (header == null)
        header = "";
      
//        BufferedWriter out = new BufferedWriter(new FileWriter(od + "/" + ctn + ".java"));
        BufferedWriter out = FileUpdateManager.instance().getWriter(od, ctn + ".java");
        
//DebugInfo.debug("Generating: " + od + "/" + ctn + ".java");
        
        fields = ertd.getField();
        
        // Determine if we have any reference fields
        boolean hasRefs = false;
        ArrayList<String> refFields = new ArrayList<String>();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinitionDMO type = field.getType().getObject();
          
          if (type == null){
            DebugInfo.debug("Unknown type in ExtendedReferenceTypeDefinition: " + field.getType().getObjectName());
            System.exit(1);
          }


          if (type.getIsRefType()){
            hasRefs = true;
            refFields.add(field.getName());
          }
        }
        
        out.write(header);
        
        out.write("package " + ertd.getDefinedIn().getSchemaPackage() + ".generated.types;\n\n");
        
        String nameBaseImport = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getDefinedIn().getSchemaPackage() + ".generated.types.DmcType";
        String nameImport = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getName().getNameString() + "SV";
        String staticNameType = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getName().getNameString() + "STATIC";


        imports.addImport(nameBaseImport + nameImport, "Name type");
        imports.addImport(ertd.getExtendedReferenceClass().getIsNamedBy().getType().getPrimitiveType(), "Name type");
        
        imports.addImport(nameBaseImport + staticNameType, "Static type for name");
        
        imports.addImport(ertd.getExtendedReferenceClass().getDmoImport(), "Object based constructor");


        imports.addImport("org.dmd.dmc.DmcExtendedReferenceIF", "Marker interface for extended references");


//        out.write("import java.io.Serializable;\n");
//        out.write("import org.dmd.dmc.DmcInputStreamIF;\n");
//        out.write("import org.dmd.dmc.DmcOutputStreamIF;\n");
//        out.write("import org.dmd.dmc.types.IntegerVar;\n");
        
        imports.addImport("java.io.Serializable", "Serialization support");
        imports.addImport("org.dmd.dmc.DmcInputStreamIF", "Serialization support");
        imports.addImport("org.dmd.dmc.DmcOutputStreamIF", "Serialization support");
        imports.addImport("org.dmd.dmc.types.IntegerVar", "Parsing support");
        
        if (hasRefs){
//            out.write("import org.dmd.dmc.DmcNameResolverIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectREF;\n");
//            out.write("import org.dmd.dmc.DmcContainerIF;\n");
            
            imports.addImport("org.dmd.dmc.DmcNameResolverIF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcNamedObjectIF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcNamedObjectREF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcContainerIF", "Object reference support");
        }


//        out.write("import org.dmd.dmc.DmcValueException;\n\n");
        
        imports.addImport("org.dmd.dmc.DmcValueException", "Value exceptions");
        
//        out.write(getComplexTypeImports(ertd));
        
        getComplexTypeImports(ertd, imports);
        
        out.write(imports.getFormattedImports() + "\n\n");
        
        out.write("@SuppressWarnings(\"serial\")\n");


        out.write("/**\n * The " + ctn + " class.\n");
        out.write(" * This code was auto-generated and shouldn't be alterred manually.\n");

View Full Code Here

Examples of org.dmd.util.codegen.ImportManager

  
  ///////////////////////////////////////////////////////////////////////////
  
  void dumpMetaSchemaNew(String od) throws IOException, ResultException {
    BufferedWriter out = null;
    ImportManager    imports = new ImportManager();
    
    imports.addImport("org.dmd.dmc.DmcValueException", "To handle potential value exceptions.");
    imports.addImport("org.dmd.dms.generated.dmo.*", "Access to meta schema DMOs");


    // out = new BufferedWriter(new FileWriter(od + "/MetaSchemaAG.java"));
    out = FileUpdateManager.instance().getWriter(od, "MetaSchemaAG.java");


//    // Strip the nameAttribute from all name types so that we don't cause
//    // problems
//    // when loading the meta schema
//    for (DmcUncheckedObject type : typeDefs.values()) {
//      type.rem("nameAttributeDef");
//      type.rem("filterAttributeDef");
//    }


    out.write(LGPL.toString());
    out.write("package org.dmd.dms;\n\n");


    out.write(imports.getFormattedImports() + "\n\n");
    
    out.write("/**\n");
    out.write("  * This class creates the basic definitions that allow for the definition of schemas.\n");
    out.write("  * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
    out.write("  */\n");

View Full Code Here

Examples of org.dmd.util.codegen.ImportManager

              .getWriter(od, cn + "DMO.java");


          out.write(LGPL.toString());
          out.write("package org.dmd.dms.generated.dmo;\n\n");


          ImportManager imports = new ImportManager();


          imports.addImport("java.io.Serializable",
              "Serializable marker interface");
          imports.addImport("java.util.*", "Attribute info support");


          // out.write("import java.io.Serializable;\n\n");
          // out.write("import java.util.*;\n\n");


          boolean needBasicTypes = getAllMustAndMay(go, must, may);


          // HACK HACK HACK
          if (!cn.equals("DmwWrapper")) {
            // Only include if the type of an attribute has a
            // primitive type specified
            if (needBasicTypes)
              imports.addImport("org.dmd.dmc.types.*",
                  "Basic type access");
            // out.write("import org.dmd.dmc.types.*;\n");
          }
          if (cn.endsWith("RuleData")) {
            // if (needBasicTypes)
            imports.addImport("org.dmd.dmc.types.*",
                "Basic type access");
          }


          imports.addImport("org.dmd.dmc.*", "Dark matter core");
          // imports.addImport("org.dmd.dms.generated.dmo.MetaVCAG",
          // "Old validation framework - obsolete");


          // out.write("import org.dmd.dmc.*;\n");
          // out.write("import org.dmd.dms.generated.dmo.MetaVCAG;\n");


          if (cn.equals("EnumDefinition")) {
            imports.addImport("org.dmd.dms.types.*", "Enum support");
            // out.write("import org.dmd.dms.types.*;\n");
          }


          imports.addImport("org.dmd.dms.generated.types.*",
              "Generated type access");


          // out.write("import org.dmd.dms.generated.types.*;\n");


          if (hasAnyEnumAttributes(go)) {
            imports.addImport("org.dmd.dms.generated.enums.*",
                "Has enum attributes");
            // out.write("import org.dmd.dms.generated.enums.*;\n");
          }


          out.write(imports.getFormattedImports() + "\n");


          out.write("\n");


          out.write("/**\n");

View Full Code Here

Examples of org.dmd.util.codegen.ImportManager

   * @throws ResultException 
   * @throws IOException 
   */
  public void dumpBaseImplementations(String schemaName, String schemaPackage, TreeMap<String,DmcUncheckedObject> ruleDefs, TreeMap<String,DmcUncheckedObject> ruleCategoryDefs, String rulesDir) throws ResultException, IOException{
    
    ImportManager factoryImports = new ImportManager();
    
    for(DmcUncheckedObject rule: ruleDefs.values()){
        String name = GenUtility.capTheName(rule.getSV("name"));
        NamedStringArray categories = rule.get("ruleCategory");
        
        String scope = rule.getSV("ruleScope");
        String type = rule.getSV("ruleType");
        
        ImportManager baseImports = new ImportManager();
        StringBuffer interfaces = new StringBuffer();
            
//        baseImports.addImport("org.dmd.dms.generated.enums.RuleScopeEnum", "Rule scope");
        baseImports.addImport("org.dmd.dms.generated.enums.RuleTypeEnum", "Rule type");
        baseImports.addImport("org.dmd.dmc.rules.RuleIF", "All rules implement this");
        baseImports.addImport("java.util.ArrayList", "To store category IDs");
        baseImports.addImport("java.util.Iterator", "To access category IDs");
        interfaces.append("RuleIF");


        
        baseImports.addImport(schemaPackage + ".generated.dmo." + name + "DataDMO", "Rule parameters object");
        
        StringBuffer categoryInit = new StringBuffer();
        
        for(String cname: categories){
          DmcUncheckedObject category = ruleCategoryDefs.get(cname);
          
          if (category == null){
            ResultException ex = new ResultException("Unknown rule category: " + cname);
            throw(ex);
          }
          
          String categoryID = category.getSV("ruleCategoryID");
          categoryInit.append("            categories.add(" + categoryID + ");\n");
            
          String ruleInterface = category.getSV("ruleInterface");
          baseImports.addImport(ruleInterface, "Required by RuleCategory " + cname);
          
          if (interfaces.length() > 0)
            interfaces.append(", ");
          
          int lastDot = ruleInterface.lastIndexOf(".");
          interfaces.append(ruleInterface.substring(lastDot + 1));
        }
        
        factoryImports.addImport(schemaPackage + ".extended.rules." + name, "The implementation of the " + name);
        
      BufferedWriter   out = FileUpdateManager.instance().getWriter(rulesDir, name + "BaseImpl.java");
      
      out.write("package " + schemaPackage + ".generated.rules;\n\n");
      
      out.write(baseImports.getFormattedImports() + "\n\n");
      
      out.write("// Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
      out.write("abstract public class " + name + "BaseImpl implements " + interfaces + " {\n\n");
      
      out.write("    static RuleScopeEnum      scope = RuleScopeEnum." + scope + ";\n");

View Full Code Here

0 1 2 3 4

TOP

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.