@Override
  public RunResult run(GeneratorInstanceRunRequest request) {
    RunResult runResult = new RunResult();
    Authentication authentication = request.getAuthentication();
    Long userId = authentication.getUserId();

    Long id = request.getId();
    GeneratorInstance generatorInstance = generatorInstanceRepository.selectById(id);
    if (generatorInstance == null) {
      throw new AppException("实例不存在");
    }

    if (!userId.equals(generatorInstance.getUser().getId())) {
      throw new AppException("权限不足");
    }

    Long generatorId = generatorInstance.getGenerator().getId();
    Generator generator = generatorRepository.selectById(generatorId);
    if (generator == null) {
      throw new AppException("生成器不存在");
    }

    if (generatorInstance.getVersion() < generator.getVersion()) {
      throw new AppException("当前生成器已升级发布,请刷新数据,重新操作!");
    }

    if (!generator.getIsOpen() && !generator.getDeveloper().getId().equals(userId)) {
      throw new AppException("当前生成器正在维护,请暂停操作,等待发布!");
    }

    Long templateStrategyId = request.getTemplateStrategyId();
    TemplateStrategy templateStrategy = templateStrategyRepository.selectById(templateStrategyId);

    DynamicModelQueryRequest dynamicModelQueryRequest = new DynamicModelQueryRequest();
    dynamicModelQueryRequest.setGeneratorId(generatorId);
    dynamicModelQueryRequest.setAuthentication(authentication);
    List<DynamicModel> dynamicModels = dynamicModelService.query(dynamicModelQueryRequest);
    Map<Long, DynamicModel> dynamicModelCache = new HashMap<>();
    Map<Long, Map<String, Map<String, Set<String>>>> dynamicModelKeysCache = new HashMap<>();
    dynamicModels.forEach(
        dynamicModel -> {
          DynamicModel newDynamicModel = new DynamicModel();
          newDynamicModel.setId(dynamicModel.getId());
          newDynamicModel.setName(dynamicModel.getName());
          newDynamicModel.setIcon(dynamicModel.getIcon());

          Map<String, Map<String, Set<String>>> keysCache = new HashMap<>();
          Map<String, Set<String>> propertiesKeys = new HashMap<>();
          Set<String> propertiesKeys_dateTypeKeys = new HashSet<>();
          Set<String> propertiesKeys_dataModelTypeKeys = new HashSet<>();
          propertiesKeys.put("dateTypeKeys", propertiesKeys_dateTypeKeys);
          propertiesKeys.put("dataModelTypeKeys", propertiesKeys_dataModelTypeKeys);
          Map<String, Set<String>> associationKeys = new HashMap<>();
          Set<String> associationKeys_dateTypeKeys = new HashSet<>();
          Set<String> associationKeys_dataModelTypeKeys = new HashSet<>();
          associationKeys.put("dateTypeKeys", associationKeys_dateTypeKeys);
          associationKeys.put("dataModelTypeKeys", associationKeys_dataModelTypeKeys);
          keysCache.put("propertiesKeys", propertiesKeys);
          keysCache.put("associationKeys", associationKeys);
          dynamicModelKeysCache.put(dynamicModel.getId(), keysCache);

          List<DynamicProperty> properties = dynamicModel.getProperties();
          properties.forEach(
              property -> {
                if ("Date".equals(property.getType())) {
                  propertiesKeys_dateTypeKeys.add(property.getName());
                } else if ("Model".equals(property.getType())) {
                  propertiesKeys_dataModelTypeKeys.add(property.getName());
                }

                DynamicProperty newDynamicProperty = new DynamicProperty();
                newDynamicProperty.setId(property.getId());
                newDynamicProperty.setLabel(property.getLabel());
                newDynamicProperty.setName(property.getName());
                newDynamicProperty.setViewWidth(property.getViewWidth());
                newDynamicProperty.setType(property.getType());
                newDynamicProperty.setDefaultValue(property.getDefaultValue());
                newDynamicModel.getProperties().add(newDynamicProperty);
              });
          List<DynamicProperty> association = dynamicModel.getAssociation();
          association.forEach(
              property -> {
                if ("Date".equals(property.getType())) {
                  associationKeys_dateTypeKeys.add(property.getName());
                } else if ("Model".equals(property.getType())) {
                  associationKeys_dataModelTypeKeys.add(property.getName());
                }

                DynamicProperty newDynamicProperty = new DynamicProperty();
                newDynamicProperty.setId(property.getId());
                newDynamicProperty.setLabel(property.getLabel());
                newDynamicProperty.setName(property.getName());
                newDynamicProperty.setViewWidth(property.getViewWidth());
                newDynamicProperty.setType(property.getType());
                newDynamicProperty.setDefaultValue(property.getDefaultValue());
                newDynamicModel.getAssociation().add(newDynamicProperty);
              });
          dynamicModelCache.put(newDynamicModel.getId(), newDynamicModel);
        });

    List<Long> excludeIds = request.getExcludeIds();
    Map<Long, Long> excludeIdCache = new HashMap<>();
    excludeIds.forEach(excludeId -> excludeIdCache.put(excludeId, excludeId));

    Long dataModelId = generatorInstance.getDataModel().getId();
    DataModel rootDataModel = dataModelRepository.selectById(dataModelId);

    Map<Long, DataModel> dataModelSourceCache = new HashMap<>();
    Map<Long, DataModel> dataModelTargetCache = new HashMap<>();
    LinkedList<DataModel> stack = new LinkedList<>();
    stack.push(rootDataModel);
    while (!stack.isEmpty()) {
      DataModel dataModel = stack.pop();
      dataModelSourceCache.put(dataModel.getId(), dataModel);
      dataModelTargetCache.put(dataModel.getId(), new DataModel());
      dataModel.getChildren().forEach(stack::push);
    }
    dataModelSourceCache.forEach(
        (dataModelSourceId, dataModelSource) -> {
          DataModel dataModelTarget = dataModelTargetCache.get(dataModelSourceId);
          dataModelTarget.setId(dataModelSource.getId());
          dataModelTarget.setName(dataModelSource.getName());
          if (dataModelSource.getParent() != null) {
            Long parentId = dataModelSource.getParent().getId();
            DataModel parentSource = dataModelSourceCache.get(parentId);
            if (parentSource != null) {
              DataModel parentTarget = dataModelTargetCache.get(parentId);
              dataModelTarget.setParent(parentTarget);
            }
          }
          dataModelSource
              .getChildren()
              .forEach(
                  child -> {
                    Long childId = child.getId();
                    if (!excludeIdCache.containsKey(childId)) {
                      dataModelTarget.getChildren().add(dataModelTargetCache.get(childId));
                    }
                  });

          if (!dataModelSource.equals(rootDataModel)) {
            DynamicModel dynamicModel =
                dynamicModelCache.get(dataModelSource.getDynamicModel().getId());
            dataModelTarget.setDynamicModel(dynamicModel);

            Map<String, Map<String, Set<String>>> keysCache =
                dynamicModelKeysCache.get(dynamicModel.getId());
            Map<String, Set<String>> propertiesKeys = keysCache.get("propertiesKeys");
            Map<String, Set<String>> associationKeys = keysCache.get("associationKeys");
            Set<String> propertiesKeys_dateTypeKeys = propertiesKeys.get("dateTypeKeys");
            Set<String> propertiesKeys_dataModelTypeKeys = propertiesKeys.get("dataModelTypeKeys");
            Set<String> associationKeys_dateTypeKeys = associationKeys.get("dateTypeKeys");
            Set<String> associationKeys_dataModelTypeKeys =
                associationKeys.get("dataModelTypeKeys");
            dataModelSource
                .getProperties()
                .forEach(
                    (name, value) -> {
                      try {
                        if (propertiesKeys_dateTypeKeys.contains(name)) {
                          dataModelTarget.getProperties().put(name, new Date((Long) value));
                        } else if (propertiesKeys_dataModelTypeKeys.contains(name)) {
                          dataModelTarget
                              .getProperties()
                              .put(name, dataModelTargetCache.get(value));
                        } else {
                          dataModelTarget.getProperties().put(name, value);
                        }
                      } catch (Exception e) {
                        //
                      }
                    });
            dataModelSource
                .getAssociation()
                .forEach(
                    property -> {
                      Map<String, Object> newProperty = new LinkedHashMap<>();
                      property.forEach(
                          (name, value) -> {
                            try {
                              if (associationKeys_dateTypeKeys.contains(name)) {
                                newProperty.put(name, new Date((Long) value));
                              } else if (associationKeys_dataModelTypeKeys.contains(name)) {
                                newProperty.put(name, dataModelTargetCache.get(value));
                              } else {
                                newProperty.put(name, value);
                              }
                            } catch (Exception e) {
                              //
                            }
                          });
                      dataModelTarget.getAssociation().add(newProperty);
                    });
          }
        });

    Template templateTemplate = new Template();
    templateTemplate.setIsDelete(false);
    templateTemplate.setGenerator(generator);
    List<Template> templates = templateRepository.selectList(templateTemplate);
    Map<Long, Template> templateCache = new HashMap<>();
    templates.forEach(
        template -> {
          Template newTemplate = new Template();
          newTemplate.setId(template.getId());
          newTemplate.setName(template.getName());
          newTemplate.setUrl(template.getUrl());
          templateCache.put(template.getId(), newTemplate);
        });

    Long generateId = idWorker.nextId();
    User developer = userRepository.selectById(generator.getDeveloper().getId());
    TemplateStrategy templateStrategyClone = templateStrategy.clone();

    Global global = new Global();
    global.setGenerateId(generateId);
    global.setTemplateCache(templateCache);

    User userClone = new User();
    userClone.setId(userId);
    userClone.setUserName(authentication.getUserName());
    global.setUser(userClone);

    Generator generatorClone = new Generator();
    generatorClone.setId(generator.getId());
    generatorClone.setName(generator.getName());
    global.setGenerator(generatorClone);

    GeneratorInstance generatorInstanceClone = new GeneratorInstance();
    generatorInstanceClone.setId(generatorInstance.getId());
    generatorInstanceClone.setName(generatorInstance.getName());
    global.setGeneratorInstance(generatorInstanceClone);

    User developerClone = new User();
    developerClone.setId(developer.getId());
    developerClone.setUserName(developer.getUserName());
    global.setDeveloper(developerClone);

    global.setTemplateStrategy(templateStrategyClone);

    Context context = new Context();
    context.setVariable("global", global);
    context.setVariable("data", dataModelTargetCache.get(rootDataModel.getId()));
    try {
      templateStrategyClone.execute(context);
    } catch (Throwable e) {
      List<String> messages = new ArrayList<>();
      LinkedList<Throwable> exceptionStack = new LinkedList<>();
      exceptionStack.push(e);
      while (!exceptionStack.isEmpty()) {
        Throwable exception = exceptionStack.pop();
        messages.add(exception.toString());
        if (exception.getCause() != null) {
          exceptionStack.push(exception.getCause());
        }
      }
      runResult.setMessages(messages);
      return runResult;
    }
    String generatePath =
        ConfigProperties.TEMPORARY_PATH
            + ConfigProperties.fileSeparator
            + userId
            + ConfigProperties.fileSeparator
            + generatorInstance.getName()
            + "("
            + generateId
            + ")";
    FileUtil.mkdirs(generatePath);
    File generateFolder = new File(generatePath);
    try {
      ZipUtil.compress(generateFolder);
    } catch (Exception e) {
      throw new AppException(e, "压缩文件失败");
    }
    FileUtil.deleteFile(generateFolder);
    runResult.setUrl(userId + "/" + generatorInstance.getName() + "(" + generateId + ").zip");
    runResult.setFileName(generatorInstance.getName() + "(" + generateId + ").zip");
    return runResult;
  }
Exemplo n.º 2
0
  public static void main(String[] args) throws Exception {

    /* You should do this ONLY ONCE in the whole application life-cycle: */

    /* Create and adjust the configuration singleton */
    Configuration cfg = new Configuration(Configuration.VERSION_2_3_22);
    cfg.setDirectoryForTemplateLoading(new File("/Users/ian.goldsmith/projects/freemarker"));
    cfg.setDefaultEncoding("UTF-8");
    cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);

    /*
     * You usually do these for MULTIPLE TIMES in the application
     * life-cycle:
     */

    /* Create a data-model */
    Map message = new HashMap();
    message.put(
        "contentAsXml",
        freemarker.ext.dom.NodeModel.parse(
            new File("/Users/ian.goldsmith/projects/freemarker/test.xml")));

    Map root = new HashMap();
    root.put("message", message);

    /* Get the template (uses cache internally) */
    Template temp = cfg.getTemplate("testxml.ftl");

    /* Merge data-model with template */
    Writer out = new OutputStreamWriter(System.out);
    temp.process(root, out);
    // Note: Depending on what `out` is, you may need to call `out.close()`.
    // This is usually the case for file output, but not for servlet output.
  }
Exemplo n.º 3
0
 /**
  * Create a template from definition
  *
  * @param template the template definition
  * @return template
  */
 private ProcTemplate createTemplate(Template template) {
   List<ProcTemplateElement> elements = new ArrayList<ProcTemplateElement>();
   if (template.getElements() != null) {
     for (TemplateElement element : template.getElements()) {
       if (element instanceof Constant) {
         elements.add(new TemplateConstant(((Constant) element).getValue()));
       } else if (element instanceof NamedValue) {
         NamedValue el = (NamedValue) element;
         elements.add(new ProcNamedValue(el.getName(), el.getFunction()));
       }
     }
     return new ProcTemplate(elements);
   } else {
     return ProcTemplate.EMPTY;
   }
 }
  /** generate delivery items and give them to the player */
  protected void makeDeliveryItems() {
    Long playerOid = getPlayerOid();
    Long bagOid = playerOid;
    if (Log.loggingDebug)
      log.debug("makeDeliveryItems: playerOid " + playerOid + ", bagOid + " + bagOid);

    // Normally the persistence flag is inherited from the enclosing
    // object, but all we have are OIDs.  Assume this is only used
    // for players and players are always persistent.
    Template overrideTemplate = new Template();
    overrideTemplate.put(Namespace.OBJECT_MANAGER, ObjectManagerClient.TEMPL_PERSISTENT, true);

    for (String templateName : deliveryItems) {
      Long itemOid = ObjectManagerClient.generateObject(templateName, overrideTemplate);
      InventoryClient.addItem(bagOid, playerOid, bagOid, itemOid);
    }
  }
Exemplo n.º 5
0
 @Override
 public Node execute(ExecutionContext ec, Template tmpl) throws IOException { // {{{
   Map<String, StartNamedBlock> blocks = tmpl.getBlocks();
   Node n = blocks.get(this.blockName);
   if (blocks.containsKey(this.blockName)) {
     return blocks.get(this.blockName).getExecuteNode();
   } else {
     return this.executeNode;
   }
   // return this.getNextNode();
 } // }}}
Exemplo n.º 6
0
  @Override
  protected void writePlans(String dir) {
    Properties p = new Properties();
    p.setProperty("resource.loader", "class");
    p.setProperty(
        "class.resource.loader.class",
        "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");

    Velocity.init(p);
    Context context = new VelocityContext();
    context.put("plans", plans);

    Template template = Velocity.getTemplate("pl/poznan/put/transims/demand/matsim/plans.xml.vm");
    File planFile = new File(dir + "\\plans.xml");

    try (Writer writer = new BufferedWriter(new FileWriter(planFile))) {
      template.merge(context, writer);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
Exemplo n.º 7
0
  /**
   * A method that defines matching between Item and Template.
   *
   * @param item the item to match
   * @return true if item matches the template requirements, false if not
   */
  private static boolean matches(Template t, AbstractLookup.Pair item) {
    if (!AbstractLookup.matches(t, item)) {
      return false;
    }

    Class type = t.getType();

    if (type != null && !type.isAssignableFrom(item.getType())) {
      return false;
    }

    return true;
  }
 /** This replaces the user input variables in the XML template * */
 public String replaceVariablesInString(String xmlStringArg) {
   String modXmlString = xmlStringArg;
   Properties prop = new Properties();
   for (int i = 0; i < uiList.size(); i++) {
     UserInput ui = (UserInput) uiList.get(i);
     XmlUIElement el = (XmlUIElement) uiElementsList.get(i);
     ui.setValue(el.getValue());
     prop.put("$UserInput$" + ui.getID(), el.getValue());
     // modXmlString = StringUtil.replaceStringBySpecifiedString(modXmlString,"$UserInput$" +
     // ui.getID(),el.getValue());
   }
   Template template = null;
   try {
     template = new Template(xmlStringArg);
     //			template = PopulateTemplateParams.substituteParams(template, prop, 3);
     template = PopulateTemplateParams.substituteParams(template, prop);
   } catch (Exception exc) {
     exc.printStackTrace();
   }
   // return modXmlString;
   return template.toString();
 }
Exemplo n.º 9
0
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
     throws ServletException, IOException {
   Map root = new HashMap();
   Connection conn = null;
   conn = ConFact.getInstance().makeConnection();
   String id = req.getParameter("id");
   String sql = "select title,description,language_id from film where film_id=" + id + ";";
   java.sql.PreparedStatement pst;
   try {
     pst = conn.prepareStatement(sql);
     ResultSet rs = pst.executeQuery();
     while (rs.next()) {
       java.sql.PreparedStatement pst1;
       String sql1 = "select name from language where language_id=" + rs.getString(3) + ";";
       pst1 = conn.prepareStatement(sql1);
       ResultSet rs1 = pst1.executeQuery();
       while (rs1.next()) {
         Template t = cfg.getTemplate("test.ftl");
         root.put("title", rs.getString(1));
         root.put("description", rs.getString(2));
         root.put("language", rs1.getString(1));
         resp.setContentType("text/html; charset=" + t.getEncoding());
         Writer out = resp.getWriter();
         t.process(root, out);
       }
       rs1.close();
     }
     rs.close();
     pst.close();
     conn.close();
   } catch (TemplateException e) {
     e.printStackTrace();
   } catch (SQLException e1) {
     e1.printStackTrace();
   }
 }
Exemplo n.º 10
0
 /**
  * Prepends the value of the specified Template to the begining of this Template.
  *
  * @param hout the Template
  */
 public Template prepend(Template hout) {
   if (hout != null) m_template = new StringBuffer(hout.toString() + m_template.toString());
   return this;
 }
Exemplo n.º 11
0
 /**
  * Appends the value of the specified Template to the end of this Template.
  *
  * @param hout the Template
  */
 public Template append(Template hout) {
   if (hout != null) m_template = m_template.append(hout.toString());
   return this;
 }
Exemplo n.º 12
0
 public void setLastTag(String tag, Template tagvalue) {
   setLastTag(tag, tagvalue.toString());
 }
Exemplo n.º 13
0
 /**
  * Constructs a new Template with the specified template.
  *
  * @param templ the Template
  */
 public Template(Template templ) {
   m_template = new StringBuffer(templ.toString());
   m_template2 = new StringBuffer(templ.toString());
 }