Ejemplo n.º 1
0
 @SuppressWarnings("unchecked")
 protected void setBlockParametersForRender(State state, Parameters blockParameters) {
   ServletRequest request = state.getRequest();
   String prefix = getPrefix(state);
   log.debug("prefix " + prefix);
   blockParameters.setAutoCasting(true);
   for (Map.Entry<String, String[]> entry :
       ((Map<String, String[]>) request.getParameterMap()).entrySet()) {
     String key = entry.getKey();
     if (key.startsWith(prefix)) {
       log.trace("setting" + entry);
       blockParameters.setIfDefined(key.substring(prefix.length()), entry.getValue());
     }
   }
   if (log.isDebugEnabled()) {
     log.debug("Set " + blockParameters);
   }
 }
Ejemplo n.º 2
0
 @Override
 public String getProcessUrl(
     String path, Map<String, ?> parameters, Parameters frameworkParameters, boolean escapeAmps)
     throws FrameworkException {
   HttpServletRequest request =
       BasicUrlConverter.getUserRequest(frameworkParameters.get(Parameter.REQUEST));
   State state = State.getState(request);
   frameworkParameters.set(ACTION, state.getId());
   Url url = urlConverter.getProcessUrl(path, parameters, frameworkParameters, escapeAmps);
   if (url == Url.NOT) {
     log.debug("Fall back url");
     return fallbackConverter
         .getProcessUrl(path, parameters, frameworkParameters, escapeAmps)
         .getUrl();
   } else {
     log.debug("Url converter url " + url);
     return url.getUrl();
   }
 }
Ejemplo n.º 3
0
 /**
  * I think in the basic framework this method is never called explicitely, because processing is
  * done implicitly by the render
  */
 @Override
 public void process(
     Processor processor, Parameters blockParameters, Parameters frameworkParameters)
     throws FrameworkException {
   HttpServletRequest request = frameworkParameters.get(Parameter.REQUEST);
   State state = State.getState(request);
   state.startBlock(frameworkParameters, null);
   setBlockParametersForProcess(state, blockParameters);
   processor.process(blockParameters);
 }
Ejemplo n.º 4
0
 @Override
 public Block getRenderingBlock(Parameters frameworkParameters) {
   HttpServletRequest request = frameworkParameters.get(Parameter.REQUEST);
   State state = State.getState(request);
   if (state.isRendering()) {
     return state.getBlock();
   } else {
     return null;
   }
 }
Ejemplo n.º 5
0
 @SuppressWarnings("unchecked")
 @Override
 public <C> C setSettingValue(Setting<C> setting, Parameters parameters, C value) {
   if (parameters == null)
     throw new SecurityException("You should provide Cloud and request parameters");
   boolean useSession = parameters.get(USE_REQ);
   if (useSession) {
     C ret = getSettingValue(setting, parameters);
     HttpServletRequest req = parameters.get(Parameter.REQUEST);
     req.getSession(true).setAttribute(getKey(setting), value);
     return ret;
   } else {
     Cloud cloud = parameters.get(Parameter.CLOUD);
     if (cloud.getUser().getRank() == org.mmbase.security.Rank.ADMIN) {
       saveSettingValue(setting, value);
       return (C) settingValues.put(setting, value);
     } else {
       throw new SecurityException("Permission denied");
     }
   }
 }
Ejemplo n.º 6
0
 @SuppressWarnings("unchecked")
 @Override
 public <C> C getSettingValue(Setting<C> setting, Parameters parameters) {
   boolean useSession = parameters != null && parameters.get(USE_REQ);
   if (useSession) {
     HttpServletRequest req = parameters.get(Parameter.REQUEST);
     if (req != null) {
       Object v = req.getSession(true).getAttribute(getKey(setting));
       if (v != null) {
         return setting.getDataType().cast(v, null, null);
       }
     }
   }
   if (settingValues.containsKey(setting)) {
     return (C) settingValues.get(setting);
   } else {
     C settingValue = loadSettingValue(setting);
     if (settingValue != null) {
       settingValues.put(setting, settingValue);
       return settingValue;
     }
     return setting.getDataType().getDefaultValue();
   }
 }
Ejemplo n.º 7
0
 @Override
 public Node getUserNode(Parameters frameworkParameters) {
   Cloud cloud = frameworkParameters.get(Parameter.CLOUD);
   if (cloud == null) {
     return null;
   } else {
     try {
       int userNode = cloud.getCloudContext().getAuthentication().getNode(cloud.getUser());
       if (cloud.hasNode(userNode)) {
         return cloud.getNode(userNode);
       } else {
         return null;
       }
     } catch (UnsupportedOperationException uoe) {
       // never mind
       return null;
     }
   }
 }
Ejemplo n.º 8
0
  /**
   * Basic Framework implicitely also processes, i'm not sure if we should require any framework to
   * do that (perhaps we could say, that the render method must process, if that is necessary, and
   * not yet done).
   */
  @Override
  public void render(
      Renderer renderer,
      Parameters blockParameters,
      Parameters frameworkParameters,
      Writer w,
      WindowState windowState)
      throws FrameworkException {
    ServletRequest request = frameworkParameters.get(Parameter.REQUEST);
    if (request == null) {
      throw new IllegalArgumentException("No request object given");
    }

    State state = State.getState(request);
    if (state
        .isRendering()) { // mm:component used during rending of a component, that's fine, but use a
                          // new State.
      state = new State(request);
      log.debug("Alreadying rendering, taking a new state for sub-block-rendering: " + state);
    }

    log.debug("Rendering " + renderer.getBlock() + " " + renderer);
    Object prevHints = request.getAttribute(RenderHints.KEY);
    try {

      request.setAttribute(COMPONENT_CLASS_KEY, getComponentClass());
      request.setAttribute(COMPONENT_CURRENTUSER_KEY, getUserNode(frameworkParameters));

      Renderer actualRenderer = state.startBlock(frameworkParameters, renderer);
      if (!actualRenderer.equals(renderer)) {
        Parameters newBlockParameters = actualRenderer.getBlock().createParameters();
        newBlockParameters.setAllIfDefined(blockParameters);
        blockParameters = newBlockParameters;
      }
      state.setAction(request.getParameter(ACTION.getName()));
      if (state.needsProcess()) {
        log.service("Performing action on " + actualRenderer.getBlock());
        Processor processor = actualRenderer.getBlock().getProcessor();
        state.process(processor);
        log.service("Processing " + actualRenderer.getBlock() + " " + processor);
        setBlockParametersForProcess(state, blockParameters);
        processor.process(blockParameters);
        state.endProcess();
      }

      state.render(actualRenderer);

      setBlockParametersForRender(state, blockParameters);

      RenderHints hints =
          new RenderHints(
              actualRenderer,
              windowState,
              state.getId(),
              getComponentClass(),
              RenderHints.Mode.NORMAL);
      request.setAttribute(RenderHints.KEY, hints);
      actualRenderer.render(blockParameters, w, hints);
      request.setAttribute("org.mmbase.framework.hints", hints);
    } catch (FrameworkException fe) {
      log.debug(fe);
      URI uri = renderer.getUri();
      Renderer error =
          new ErrorRenderer(
              renderer.getType(),
              renderer.getBlock(),
              (uri != null) ? uri.toString() : null,
              500,
              fe);
      RenderHints hints =
          new RenderHints(
              error, windowState, state.getId(), getComponentClass(), RenderHints.Mode.NORMAL);
      error.render(blockParameters, w, hints);
    } finally {
      request.setAttribute(RenderHints.KEY, prevHints);
      state.endBlock();
    }
  }
Ejemplo n.º 9
0
 /** @todo */
 protected void setBlockParametersForProcess(State state, Parameters blockParameters) {
   ServletRequest request = state.getRequest();
   for (Map.Entry<String, ?> entry : blockParameters.toMap().entrySet()) {
     request.setAttribute(entry.getKey(), entry.getValue());
   }
 }