Java Code Examples for freemarker.core.Environment#getVariable()

/**
 * 将params的值复制到variable中
 * 
 * @param env
 * @param params
 * @return 原Variable中的值
 * @throws TemplateException
 */
public static Map<String, TemplateModel> addParamsToVariable(
		Environment env, Map<String, TemplateModel> params)
		throws TemplateException {
	Map<String, TemplateModel> origMap = new HashMap<String, TemplateModel>();
	if (params.size() <= 0) {
		return origMap;
	}
	Set<Map.Entry<String, TemplateModel>> entrySet = params.entrySet();
	String key;
	TemplateModel value;
	for (Map.Entry<String, TemplateModel> entry : entrySet) {
		key = entry.getKey();
		value = env.getVariable(key);
		if (value != null) {
			origMap.put(key, value);
		}
		env.setVariable(key, entry.getValue());
	}
	return origMap;
}
 

/**
* Gets BeanModel from FreeMarker context and returns the object that it wraps.
* @param varName the name of the variable in the FreeMarker context.
* @param env the FreeMarker Environment
*/
public static <T> T getWrappedObject(String varName, Environment env) {
    Object obj = null;
    try {
        obj = env.getVariable(varName);
        if (obj != null) {
            if (obj == TemplateModel.NOTHING) {
                obj = null;
            } else if (obj instanceof BeanModel) {
                BeanModel bean = (BeanModel) obj;
                obj = bean.getWrappedObject();
            } else if (obj instanceof SimpleScalar) {
                obj = obj.toString();
            }
        }
    } catch (TemplateModelException e) {
        Debug.logInfo(e.getMessage(), module);
    }
    return UtilGenerics.<T>cast(obj);
}
 

private String getPutContents(Environment env, String blockName) throws TemplateModelException {
    SimpleScalar putContentsModel = (SimpleScalar) env.getVariable(getBlockContentsVarName(blockName));
    String putContents = "";
    if (putContentsModel != null) {
        putContents = putContentsModel.getAsString();
    }
    return putContents;
}
 

protected SiteItem getContentModel(Environment env) throws TemplateException {
    TemplateModel contentModel = env.getVariable(CrafterPageView.KEY_CONTENT_MODEL);
    if (contentModel != null) {
        Object unwrappedContentModel = DeepUnwrap.unwrap(contentModel);
        if (unwrappedContentModel instanceof SiteItem) {
            return (SiteItem)unwrappedContentModel;
        } else {
            throw new TemplateException("Variable '" + CrafterPageView.KEY_CONTENT_MODEL + " of unexpected type: expected: " +
                                        SiteItem.class.getName() + ", actual: " + unwrappedContentModel.getClass().getName(),
                                        env);
        }
    } else {
        return null;
    }
}
 

private String extractAttribute() throws JspException {
if (null == this.getVar()) {
	return null;
}
String objectToString = null;
try {
	Object object = this.pageContext.getAttribute(this.getVar());
	if (null == object) {
		Environment environment = Environment.getCurrentEnvironment();
		if (null != environment) {
			Object wrapper = environment.getVariable(this.getVar());
			if (null != wrapper) {
				if (wrapper instanceof StringModel) {
					object = ((StringModel) wrapper).getWrappedObject();
				} else {
					object = wrapper;
				}
			}
		}
	}
	if (null != object) {
		objectToString = object.toString();
	}
      } catch (Throwable t) {
      	_logger.error("error extracting freemarker attribute", t);
          throw new JspException("Error extracting freemarker attribute", t);
      }
return objectToString;
  }
 

@Override
  public int doStartTag() throws JspException {
ServletRequest request = this.pageContext.getRequest();
RequestContext reqCtx = (RequestContext) request.getAttribute(RequestContext.REQCTX);
try {
	ExecutorBeanContainer ebc = (ExecutorBeanContainer) reqCtx.getExtraParam(SystemConstants.EXTRAPAR_EXECUTOR_BEAN_CONTAINER);
	TemplateModel templateModel = ebc.getTemplateModel();
	if (!(templateModel instanceof AllHttpScopesHashModel)) {
		return EVAL_BODY_INCLUDE;
	}
	AllHttpScopesHashModel hashModel = (AllHttpScopesHashModel) templateModel;
	Object object = this.pageContext.getAttribute(this.getValueName());
	if (null == object) {
		Environment environment = Environment.getCurrentEnvironment();
		if (null != environment) {
			Object wrapper = environment.getVariable(this.getValueName());
			if (null != wrapper) {
				if (wrapper instanceof StringModel) {
					object = ((StringModel) wrapper).getWrappedObject();
				} else {
					object = wrapper;
				}
			}
		}
	}
	if (null != object) {
		hashModel.put(this.getVar(), object);
	}
      } catch (Throwable t) {
      	_logger.error("error in doStartTag", t);
          throw new JspException("Error during tag initialization", t);
      }
      return EVAL_BODY_INCLUDE;
  }
 

protected <T> T getVariable(String varName, Environment env) throws TemplateModelException{
	Object value = env.getVariable(varName);
	if (value instanceof BeanModel) {
		value = ((BeanModel) value).getWrappedObject();
	}
	return (T)value;
}
 

public static TemplateModel getVariable(Environment env, String name, boolean throwIfError){
	TemplateModel model = null;
	try {
		model = env.getVariable(name);
	} catch (Exception e) {
		if(throwIfError)
			throw new BaseException("get variable["+name+"] error: " + e.getMessage(), e);
	}
	return model;
}
 

/**
 * Executes an arbitrary FTL function - non-abstracted version (for optimization only!).
 */
public static TemplateModel execFunction(Template functionCall, TemplateModel[] args, Environment env) throws TemplateModelException {
    final int argCount = (args != null) ? args.length : 0;
    for(int i=0; i < argCount; i++) {
        env.setVariable("_scpEfnArg"+i, args[i]);
    }
    execFtlCode(functionCall, env);
    return env.getVariable("_scpEfnRes");
}
 

/**
 * Executes an arbitrary FTL built-in - non-abstracted version (for optimization only!).
 */
public static TemplateModel execBuiltIn(Template builtInCall, TemplateModel value, TemplateModel[] builtInArgs, Environment env) throws TemplateModelException {
    final int argCount = (builtInArgs != null) ? builtInArgs.length : 0;
    env.setVariable("_scpEbiVal", value);
    for(int i=0; i < argCount; i++) {
        env.setVariable("_scpEbiArg"+i, builtInArgs[i]);
    }
    execFtlCode(builtInCall, env);
    return env.getVariable("_scpEbiRes");
}
 

@Override
public Object exec(@SuppressWarnings("rawtypes") List args) throws TemplateModelException {
    if (args == null || args.size() != 2)
        throw new TemplateModelException("Invalid number of arguments");
    if (!(args.get(0) instanceof TemplateScalarModel))
        throw new TemplateModelException("First argument not an instance of TemplateScalarModel");
    // SCIPIO: This is too limiting
    //if (!(args.get(1) instanceof BeanModel) && !(args.get(1) instanceof TemplateNumberModel) && !(args.get(1) instanceof TemplateScalarModel))
    //    throw new TemplateModelException("Second argument not an instance of BeanModel nor TemplateNumberModel nor TemplateScalarModel");

    Environment env = FreeMarkerWorker.getCurrentEnvironment();
    BeanModel globalContextModel = (BeanModel) env.getVariable("globalContext");
    @SuppressWarnings("unchecked")
    Map<String, Object> globalContext = (Map<String, Object>) globalContextModel.getWrappedObject();

    String name = LangFtlUtil.getAsStringNonEscaping(((TemplateScalarModel) args.get(0)));
    Object valueModel = args.get(1);
    Object value = null;
    // SCIPIO: Let DeepUnwrap handle this...
    //if (args.get(1) instanceof TemplateScalarModel)
    //    value = ((TemplateScalarModel) args.get(1)).getAsString();
    //if (args.get(1) instanceof TemplateNumberModel)
    //    value = ((TemplateNumberModel) args.get(1)).getAsNumber();
    //if (args.get(1) instanceof BeanModel)
    //    value = ((BeanModel) args.get(1)).getWrappedObject();
    // SCIPIO: NOTE: Unlike this above, this call will avoid the auto-escaping as implemented by Ofbiz (sensitive to DeepUnwrap implementation)
    value = LangFtlUtil.unwrapAlwaysUnlessNull(valueModel);

    globalContext.put(name, value);
    return new SimpleScalar("");
}
 

@SuppressWarnings("unchecked")
public Object exec(@SuppressWarnings("rawtypes") List args) throws TemplateModelException {
    if (args == null || args.size() != 2)
        throw new TemplateModelException("Invalid number of arguements");
    if (!(args.get(0) instanceof TemplateScalarModel))
        throw new TemplateModelException("First argument not an instance of TemplateScalarModel");
    // SCIPIO: This is too limiting...
    //if (!(args.get(1) instanceof BeanModel) && !(args.get(1) instanceof TemplateNumberModel) && !(args.get(1) instanceof TemplateScalarModel))
    //    throw new TemplateModelException("Second argument not an instance of BeanModel nor TemplateNumberModel nor TemplateScalarModel");

    Environment env = FreeMarkerWorker.getCurrentEnvironment();
    BeanModel req = (BeanModel)env.getVariable("context");
    Map<String, Object> context = (Map<String, Object>) req.getWrappedObject();

    // SCIPIO: name should not be escaped
    //String name = ((TemplateScalarModel) args.get(0)).getAsString();
    String name = LangFtlUtil.getAsStringNonEscaping(((TemplateScalarModel) args.get(0)));
    Object valueModel = args.get(1);
    Object value = null;
    // SCIPIO: Let DeepUnwrap handle this...
    //if (args.get(1) instanceof TemplateNumberModel)
    //    value = ((TemplateNumberModel) args.get(1)).getAsNumber();
    //if (args.get(1) instanceof BeanModel)
    //    value = ((BeanModel) args.get(1)).getWrappedObject();
    // SCIPIO: NOTE: Unlike this above, this call will avoid the auto-escaping as implemented by Ofbiz (sensitive to DeepUnwrap implementation)
    value = LangFtlUtil.unwrapAlwaysUnlessNull(valueModel);

    context.put(name, value);
    return new SimpleScalar("");
}
 

public Object exec(@SuppressWarnings("rawtypes") List args) throws TemplateModelException {
    if (args == null || args.size() != 2)
        throw new TemplateModelException("Invalid number of arguements");
    if (!(args.get(0) instanceof TemplateScalarModel))
        throw new TemplateModelException("First argument not an instance of TemplateScalarModel");
    // SCIPIO: This is too limiting...
    //if (!(args.get(1) instanceof BeanModel) && !(args.get(1) instanceof TemplateNumberModel) && !(args.get(1) instanceof TemplateScalarModel))
    //    throw new TemplateModelException("Second argument not an instance of BeanModel nor TemplateNumberModel nor TemplateScalarModel");

    Environment env = FreeMarkerWorker.getCurrentEnvironment();
    BeanModel req = (BeanModel)env.getVariable("request");
    HttpServletRequest request = (HttpServletRequest) req.getWrappedObject();

    // SCIPIO: name should not be escaped
    //String name = ((TemplateScalarModel) args.get(0)).getAsString();
    String name = LangFtlUtil.getAsStringNonEscaping(((TemplateScalarModel) args.get(0)));
    Object valueModel = args.get(1);
    Object value = null;
    // SCIPIO: Let DeepUnwrap handle this...
    //if (args.get(1) instanceof TemplateScalarModel)
    //    value = ((TemplateScalarModel) args.get(1)).getAsString();
    //if (args.get(1) instanceof TemplateNumberModel)
    //    value = ((TemplateNumberModel) args.get(1)).getAsNumber();
    //if (args.get(1) instanceof BeanModel)
    //    value = ((BeanModel) args.get(1)).getWrappedObject();
    // SCIPIO: NOTE: Unlike this above, this call will avoid the auto-escaping as implemented by Ofbiz (sensitive to DeepUnwrap implementation)
    value = LangFtlUtil.unwrapAlwaysUnlessNull(valueModel);

    request.setAttribute(name, value);
    return new SimpleScalar("");
}
 

@SuppressWarnings("unchecked")
public static Map<String, Object> getRenderContextGeneric(Environment env) throws TemplateModelException {
    TemplateModel pcm = env.getVariable("context");
    if (pcm != null && pcm instanceof WrapperTemplateModel) {
        Object obj = ((WrapperTemplateModel) pcm).getWrappedObject();
        if (obj instanceof MapStack) {
            return (Map<String, Object>) obj;
        }
    }
    return null;
}
 

@SuppressWarnings("unchecked")
public static MapStack<String> getRenderContext(Environment env) throws TemplateModelException {
    TemplateModel pcm = env.getVariable("context");
    if (pcm != null && pcm instanceof WrapperTemplateModel) {
        Object obj = ((WrapperTemplateModel) pcm).getWrappedObject();
        if (obj instanceof MapStack) {
            return (MapStack<String>) obj;
        }
    }
    return null;
}
 

private PutType getPutType(Environment env, String blockName) throws TemplateException {
    SimpleScalar putTypeScalar = (SimpleScalar) env.getVariable(getBlockTypeVarName(blockName));
    if (putTypeScalar == null) {
        return PutType.APPEND;
    }

    return PutType.valueOf(putTypeScalar.getAsString());
}
 

public static HttpServletResponse getResponse(Environment env) throws TemplateModelException {
    WrapperTemplateModel req = (WrapperTemplateModel) env.getVariable("response");
    return (req != null) ? (HttpServletResponse) req.getWrappedObject() : null;
}
 

public static HttpServletRequest getRequest(Environment env) throws TemplateModelException {
    WrapperTemplateModel req = (WrapperTemplateModel) env.getVariable("request");
    return (req != null) ? (HttpServletRequest) req.getWrappedObject() : null;
}
 

@Override
public void execute(Environment env,
        Map params, TemplateModel[] loopVars,
        TemplateDirectiveBody body)
        throws TemplateException, IOException {

    if (loopVars.length != 0) {
            throw new TemplateModelException(
                "This directive does not allow loop variables.");
    }

    // Check if no parameters were given:
    if (body != null) {
        throw new TemplateModelException(
                "This directive does not allow body content.");
    }

    TemplateModel textVar = env.getVariable("text");
    if (!(textVar instanceof TemplateScalarModel)) {
        throw new TemplateModelException(
                "text variable is not a TemplateScalarModel");
    }

    String text = ((TemplateScalarModel) textVar).getAsString();

    if (PLACEHOLDER.equals(text)) {

        TemplateModel parentVar = env.getVariable("parent");
        if (!(parentVar instanceof ContentNodeHashModel)) {
            throw new TemplateModelException(
                    "pareant variable is not a ContentNodeHashModel");
        }

        ContentNode parent = ((ContentNodeHashModel) parentVar).getContentNode();

        String source;
        if (parent instanceof Block) {
            source = ((Block) parent).getSource();
        } else if (parent instanceof Cell) {
            source = ((Cell) parent).getSource();
        } else {
            throw new TemplateModelException(
                    "parent is not a Block or a Cell");
        }

        if (source == null || source.isEmpty()) {
            throw new TemplateModelException(
                    "source is null or empty");
        }

        String fixed = formatInlineSource(source);
        env.getOut().write(fixed);

    } else {
        // nothing to do, just write the text out
        env.getOut().write(text);
    }
}
 

/**
 * Resovle a FreeMarker variable as a FreeMarker template model object.
 *
 * @param env The FreeMarker environment.
 * @param name The name of the variable.
 * @return The FreeMarker variable, resolved as a FreeMarker template model object.
 * @see #resolve(Environment, String, Class) for the preferred means to resolve variables for
 * inline rendering.
 */
public static TemplateModel resolveModel(Environment env, String name) {
    try {
        return env.getVariable(name);
    } catch (TemplateModelException e) {
        throw new IllegalArgumentException("Failed to resolve " + name + " in current freemarker environment", e);
    }
}