@Override
  public void populate(HttpServletRequest request) {
    super.populate(request);

    if (StringUtils.isNotBlank(
        request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER))) {
      setViewedPageNumber(
          Integer.parseInt(
              request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER)));
    } else {
      setViewedPageNumber(0); // first page is page 0
    }

    if (KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD.equals(getMethodToCall())) {
      final String paramPrefix =
          KRADConstants.DISPATCH_REQUEST_PARAMETER
              + "."
              + KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD
              + ".";
      setSwitchToPageNumber(
          PagingBannerUtils.getNumbericalValueAfterPrefix(
              paramPrefix, request.getParameterNames()));
      if (getSwitchToPageNumber() == -1) {
        throw new RuntimeException("Couldn't find page number");
      }
    }

    if (KRADConstants.TableRenderConstants.SORT_METHOD.equals(getMethodToCall())) {
      final String paramPrefix =
          KRADConstants.DISPATCH_REQUEST_PARAMETER
              + "."
              + KRADConstants.TableRenderConstants.SORT_METHOD
              + ".";
      setColumnToSortIndex(
          PagingBannerUtils.getNumbericalValueAfterPrefix(
              paramPrefix, request.getParameterNames()));
      if (getColumnToSortIndex() == -1) {
        throw new RuntimeException("Couldn't find column to sort");
      }
    }

    setPreviouslySelectedObjectIdSet(parsePreviouslySelectedObjectIds(request));
    setSelectedObjectIdSet(parseSelectedObjectIdSet(request));
    setDisplayedObjectIdSet(parseDisplayedObjectIdSet(request));

    setSearchUsingOnlyPrimaryKeyValues(parseSearchUsingOnlyPrimaryKeyValues(request));
    if (isSearchUsingOnlyPrimaryKeyValues()) {
      setPrimaryKeyFieldLabels(getLookupable().getPrimaryKeyFieldLabels());
    }
  }
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String param = "";
    java.util.Enumeration<String> names = request.getParameterNames();
    if (names.hasMoreElements()) {
      param = names.nextElement(); // just grab first element
    }

    org.owasp.benchmark.helpers.ThingInterface thing =
        org.owasp.benchmark.helpers.ThingFactory.createThing();
    String bar = thing.doSomething(param);

    try {
      java.nio.file.Path path =
          java.nio.file.Paths.get(org.owasp.benchmark.helpers.Utils.testfileDir + bar);
      java.io.InputStream is =
          java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
    } catch (Exception e) {
      // OK to swallow any exception for now
      // TODO: Fix this, if possible.
      System.out.println("File exception caught and swallowed: " + e.getMessage());
    }
  }
Example #3
0
  /** Servlet GET request: handles event requests. */
  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    Event event = null;

    try {
      // Event parm identifies event type from the client
      String eventType = Servlets.getParameter(request, P_EVENT);

      // Always must have an event type
      if (eventType == null) {
        Log.warn("Pushlet.doGet(): bad request, no event specified");
        response.sendError(HttpServletResponse.SC_BAD_REQUEST, "No eventType specified");
        return;
      }
      // Create Event and set attributes from parameters
      event = new Event(eventType);
      for (Enumeration e = request.getParameterNames(); e.hasMoreElements(); ) {
        String nextAttribute = (String) e.nextElement();
        event.setField(nextAttribute, request.getParameter(nextAttribute));
      }
    } catch (Throwable t) {
      // Error creating event
      Log.warn("Pushlet: Error creating event in doGet(): ", t);
      response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
      return;
    }
    // Handle parsed request
    doRequest(event, request, response);
  }
  /** @see HttpServlet#service(HttpServletRequest request, HttpServletResponse response) */
  protected void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    Session s = HibernateUtils.getSession();
    int id;
    String attr = null;
    @SuppressWarnings("rawtypes")
    Enumeration lf = request.getParameterNames();

    while (lf.hasMoreElements()) {
      attr = (String) lf.nextElement();
      if (!("idinv").equals(attr)) {
        id = Integer.parseInt(attr);
        ImprimantesClient f = new ImprimantesClient();
        f.setIdImprimante(id);
        f = ServiceImprimanteClient.rechercheImprimantesClient(s, f);
        ServiceImprimanteClient.removeImprimantesClient(s, f);
      }
    }

    request.setAttribute("messageAdd", "Supression  faite avec succès...");
    request.setAttribute(
        "inv", Utilitaire.setInventaire(s, Integer.parseInt(request.getParameter("idinv"))));
    request
        .getServletContext()
        .getRequestDispatcher("/modificationInventaire.jsp")
        .forward(request, response);
    s.close();
  }
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String param = "";
    java.util.Enumeration<String> names = request.getParameterNames();
    if (names.hasMoreElements()) {
      param = names.nextElement(); // just grab first element
    }

    String bar = new Test().doSomething(param);

    // Create the file first so the test won't throw an exception if it doesn't exist.
    // Note: Don't actually do this because this method signature could cause a tool to find THIS
    // file constructor
    // as a vuln, rather than the File signature we are trying to actually test.
    // If necessary, just run the benchmark twice. The 1st run should create all the necessary
    // files.
    // new java.io.File(org.owasp.benchmark.helpers.Utils.testfileDir + bar).createNewFile();

    java.io.FileInputStream fileInputStream =
        new java.io.FileInputStream(org.owasp.benchmark.helpers.Utils.testfileDir + bar);
    java.io.FileDescriptor fd = fileInputStream.getFD();
    java.io.FileOutputStream anotOutputStream = new java.io.FileOutputStream(fd);
  } // end doPost
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String param = "";
    java.util.Enumeration<String> names = request.getParameterNames();
    if (names.hasMoreElements()) {
      param = names.nextElement(); // just grab first element
    }

    String bar = doSomething(param);

    String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";

    try {
      java.sql.Connection connection =
          org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
      java.sql.PreparedStatement statement =
          connection.prepareStatement(
              sql, java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY);
      statement.setString(1, "foo");
      statement.execute();
    } catch (java.sql.SQLException e) {
      throw new ServletException(e);
    }
  } // end doPost
  private static void load(HttpServletRequest request, Builder b) {
    Enumeration<String> e = request.getHeaderNames();
    String s;
    while (e.hasMoreElements()) {
      s = e.nextElement();
      b.headers.put(s, request.getHeader(s));
    }

    e = request.getAttributeNames();
    while (e.hasMoreElements()) {
      s = e.nextElement();
      b.localAttributes.put(s, attributeWithoutException(request, s));
    }

    e = request.getParameterNames();
    while (e.hasMoreElements()) {
      s = e.nextElement();
      b.queryStrings.put(s, request.getParameterValues(s));
    }
    b.queryString = request.getQueryString();

    Enumeration<Locale> l = request.getLocales();
    while (l.hasMoreElements()) {
      b.locale(l.nextElement());
    }
  }
  /*
   * Return a view sending all params from a request
   *
   * @param request HttpServletRequest to send to the view
   * @param viewname String with the view name to load
   * @return ModelAndView return a view with viewname
   */
  public static ModelAndView buildViewParams(HttpServletRequest request, String viewname) {

    Map<String, Object> map = new HashMap<String, Object>();

    ModelAndView mav = new ModelAndView(viewname, map);

    Enumeration<String> parameterNames = request.getParameterNames();

    while (parameterNames.hasMoreElements()) {
      String paramName = parameterNames.nextElement();

      // if the request var is a Array
      if ((request.getParameterValues(paramName).getClass().isArray())
          // if Array size is more than 1
          && (request.getParameterValues(paramName).length > 1)) {
        map.put(paramName, Arrays.toString(request.getParameterValues(paramName)));
      } else
        // if the request var is a simple var
        map.put(paramName, request.getParameter(paramName));
    }

    mav.addAllObjects(map);

    // return view
    return mav;
  }
Example #9
0
  public void save(HttpServletRequest request) {
    for (Enumeration<?> e = request.getParameterNames(); e.hasMoreElements(); ) {
      String key = (String) e.nextElement();

      if (key.startsWith("p_")) {
        String value = request.getParameter(key);

        String name = key.substring(key.indexOf('_') + 1);
        Config entry = this.repository.getByName(name);

        if (entry == null) {
          entry = new Config();
          entry.setName(name);
        }

        entry.setValue(value);

        this.config.clearProperty(name);
        this.config.setProperty(name, value);

        this.repository.update(entry);
      }
    }

    this.i18n.changeBoardDefaultLanguage(this.config.getValue(ConfigKeys.I18N_DEFAULT));
  }
Example #10
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String param = "";
    java.util.Enumeration<String> names = request.getParameterNames();
    if (names.hasMoreElements()) {
      param = names.nextElement(); // just grab first element
    }

    String bar;

    // Simple if statement that assigns param to bar on true condition
    int i = 196;
    if ((500 / 42) + i > 200) bar = param;
    else bar = "This should never happen";

    String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";

    try {
      java.sql.Connection connection =
          org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
      java.sql.PreparedStatement statement = connection.prepareStatement(sql);
      statement.setString(1, "foo");
      statement.execute();
    } catch (java.sql.SQLException e) {
      throw new ServletException(e);
    }
  }
  @Override
  protected void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    String targetModel = getServletConfig().getInitParameter("targetModel");

    if (targetModel != null) {
      StringBuilder targetUri = new StringBuilder("/model.do?model=");

      targetUri.append(targetModel);

      for (Enumeration params = request.getParameterNames(); params.hasMoreElements(); ) {
        String paramName = (String) params.nextElement();
        String paramValue = request.getParameter(paramName);

        targetUri.append("&" + paramName + "=" + paramValue);
      }

      RequestDispatcher rd = request.getRequestDispatcher(targetUri.toString());

      rd.forward(request, response);

      return;
    }

    throw new ServletException("No target specified");
  }
Example #12
0
  /** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    if (request.getCharacterEncoding() == null) request.setCharacterEncoding("UTF-8");
    response.setContentType("application/json;charset=UTF-8");
    response.setCharacterEncoding("UTF-8");

    JSONObject ret = new JSONObject();

    PrintWriter out = response.getWriter();
    Enumeration<String> enumTest = request.getParameterNames();
    HashMap<String, Object> requestMap = new HashMap<String, Object>();
    while (enumTest.hasMoreElements()) {
      String tmp = enumTest.nextElement().toString();
      requestMap.put(tmp, request.getParameter(tmp));
    }
    try {
      Kayttaja kayttaja =
          new Kayttaja(SecurityContextHolder.getContext().getAuthentication().getName());
      int orgId = Integer.parseInt(requestMap.get("org_id").toString());
      String lang = requestMap.get("lang").toString();
      if (lang == null || lang == "") lang = "fi";

      org = new Organisation(lang);
      MapData md = new MapData(lang);
      ret = md.getExtentByType(MapData.TYPE_ORGANISATIONS, orgId);
      ret.put("success", true);
      out.println(ret.toString());

    } catch (Exception e) {
      log.error(ExceptionUtils.getStackTrace(e));
      out.println("{'success':'false', 'msg': 'Tapahtui odottamaton virhe sovelluksessa.'}");
    }
  }
Example #13
0
  public ServletRequestCopy(HttpServletRequest request) {
    this.servletPath = request.getServletPath();
    this.contextPath = request.getContextPath();
    this.pathInfo = request.getPathInfo();
    this.requestUri = request.getRequestURI();
    this.requestURL = request.getRequestURL();
    this.method = request.getMethod();
    this.serverName = request.getServerName();
    this.serverPort = request.getServerPort();

    HttpSession session = request.getSession(true);
    httpSession = new HttpSessionCopy(session);

    String s;
    Enumeration<String> e = request.getHeaderNames();
    while (e != null && e.hasMoreElements()) {
      s = e.nextElement();
      Enumeration<String> headerValues = request.getHeaders(s);
      this.headers.put(s, headerValues);
    }

    e = request.getAttributeNames();
    while (e != null && e.hasMoreElements()) {
      s = e.nextElement();
      attributes.put(s, request.getAttribute(s));
    }

    e = request.getParameterNames();
    while (e != null && e.hasMoreElements()) {
      s = e.nextElement();
      parameters.put(s, request.getParameterValues(s));
    }
  }
  private void logRequest(HttpServletRequest request) {
    if (logger.isInfoEnabled()) {
      logger.info("Request method: " + request.getMethod());
      logger.info("Request contextPath: " + request.getContextPath());
      logger.info("Request pathInfo: " + request.getPathInfo());
      logger.info("Request pathTranslated: " + request.getPathTranslated());
      logger.info("Request queryString: " + request.getQueryString());
      logger.info("Request requestURI: " + request.getRequestURI());
      logger.info("Request requestURL: " + request.getRequestURL());
      logger.info("Request servletPath: " + request.getServletPath());
      Enumeration headers = request.getHeaderNames();
      if (headers != null) {
        while (headers.hasMoreElements()) {
          Object headerName = headers.nextElement();
          logger.info(
              "Request header " + headerName + ":" + request.getHeader((String) headerName));
        }
      }

      Enumeration params = request.getParameterNames();
      if (params != null) {
        while (params.hasMoreElements()) {
          Object paramName = params.nextElement();
          logger.info(
              "Request parameter " + paramName + ":" + request.getParameter((String) paramName));
        }
      }
      logger.info("- End of request -");
    }
  }
Example #15
0
 /**
  * Obtain debug information from the servlet request object
  *
  * @param httpRequest
  * @return
  */
 public static String deriveUsefulInfo(HttpServletRequest httpRequest) {
   StringBuilder sb = new StringBuilder();
   sb.append("[").append(httpRequest.getContextPath());
   sb.append(":cookies=").append(httpRequest.getCookies()).append(":headers=");
   // Append Header information
   Enumeration<?> en = httpRequest.getHeaderNames();
   while (en.hasMoreElements()) {
     String headerName = (String) en.nextElement();
     sb.append(headerName).append("=");
     // Ensure HTTP Basic Password is not logged
     if (headerName.contains("authorization") == false)
       sb.append(httpRequest.getHeader(headerName)).append(",");
   }
   sb.append("]");
   // Append Request parameter information
   sb.append("[parameters=");
   Enumeration<?> enparam = httpRequest.getParameterNames();
   while (enparam.hasMoreElements()) {
     String paramName = (String) enparam.nextElement();
     String[] paramValues = httpRequest.getParameterValues(paramName);
     int len = paramValues != null ? paramValues.length : 0;
     for (int i = 0; i < len; i++) sb.append(paramValues[i]).append("::");
     sb.append(",");
   }
   sb.append("][attributes=");
   // Append Request attribute information
   Enumeration<?> enu = httpRequest.getAttributeNames();
   while (enu.hasMoreElements()) {
     String attrName = (String) enu.nextElement();
     sb.append(attrName).append("=");
     sb.append(httpRequest.getAttribute(attrName)).append(",");
   }
   sb.append("]");
   return sb.toString();
 }
Example #16
0
 public static List<RequestKV> getParameterMap(
     HttpServletRequest req, Map<String, String> skipParam) {
   @SuppressWarnings("unchecked")
   Enumeration<String> it = req.getParameterNames();
   Set<String> keys = new HashSet<String>();
   List<RequestKV> list = new ArrayList<RequestKV>();
   while (it.hasMoreElements()) {
     String key = it.nextElement();
     if ((skipParam != null) && skipParam.containsKey(key)) {
       continue;
     }
     if (keys.contains(key)) {
       continue;
     }
     keys.add(key);
     String values[] = req.getParameterValues(key);
     if (!ArrayUtils.isEmpty(values)) {
       for (String v : values) {
         RequestKV kv = new RequestKV(key, v);
         list.add(kv);
       }
     }
   }
   return list;
 }
Example #17
0
  protected void populateBeanFromParams(Object bean, HttpServletRequest request) {
    Map params = request.getParameterMap();
    Enumeration paramNames = request.getParameterNames();
    while (paramNames.hasMoreElements()) {
      String key = "";
      try {
        key = (String) paramNames.nextElement();
      } catch (ClassCastException cce) {
        log.error("populateBeanFromParams() could not cast parameter name to String");
      }
      String value = "";
      if (key.equals(MULTIPLEXED_PARAMETER_NAME)) {
        String multiplexedStr = request.getParameterValues(key)[0];
        Map paramMap = FormUtils.beanParamMapFromString(multiplexedStr);
        Iterator paramIt = paramMap.keySet().iterator();
        while (paramIt.hasNext()) {
          String param = (String) paramIt.next();
          String demultiplexedValue = (String) paramMap.get(param);
          FormUtils.beanSet(bean, param, demultiplexedValue);
        }

      } else {
        try {
          value = (String) request.getParameterValues(key)[0];
        } catch (ClassCastException cce) {
          try {
            value = ((Integer) params.get(key)).toString();
          } catch (ClassCastException ccf) {
            log.error("populateBeanFromParams() could not cast parameter name to String");
          }
        }
        FormUtils.beanSet(bean, key, value);
      }
    }
  }
  @SuppressWarnings("unchecked")
  private void parse(HttpServletRequest req) {
    Enumeration<String> params = req.getParameterNames();

    int limit = 0;
    int pageNum = 0;

    while (params.hasMoreElements()) {
      String param = params.nextElement();
      Object value = req.getParameter(param);

      if (value == null) continue;

      if (param.startsWith(QUERY_PREFIX)) {
        parseQuery(param, value);
      } else if (param.startsWith(ORDER_PREFIX)) {
        parsetOrder(param, (String) value);
      } else if (param.equals(pageParamName)) {
        pageNum = RequestUtils.getIntegerParameter(req, pageParamName);
      } else if (param.equals(limitParamName)) {
        limit = RequestUtils.getIntegerParameter(req, limitParamName);
      } else {
        // ignore other parameters
      }
    }

    IPage page = new DefaultPage();
    if (limit != 0) {
      page.setLimit(limit);
    }
    if (pageNum != 0) {
      page.setPageNumber(pageNum);
    }
    super.setPage(page);
  }
Example #19
0
  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType(TEXT_HTML);
    Enumeration<String> parameterNames = req.getParameterNames();
    Map<String, String> params = new HashMap<>();
    while (parameterNames.hasMoreElements()) {
      String current = parameterNames.nextElement();
      params.put(current, req.getParameter(current));
    }

    if (params.get(LOGIN) != null) {
      UserDto userDto = userController.getByLogin(params.get(EMAIL));
      User user = userDto.getUser();
      if (user == null || !user.getPassword().equals(params.get(PASSWORD))) {
        req.setAttribute(LOGIN_FAILED, true);
      } else {
        HttpSession session = req.getSession(true);
        session.setAttribute(USER, user);
      }
    }
    if (params.get(REGISTER) != null) {
      resp.sendRedirect("/cafe/register");
    } else {
      if (params.get(LOGOUT) != null) {
        HttpSession session = req.getSession(true);
        session.removeAttribute(USER);
        session.removeAttribute(ORDER);
      }
      RequestDispatcher dispatcher = getServletContext().getRequestDispatcher(MAIN_JSP);
      dispatcher.forward(req, resp);
    }
  }
  public void doGet(HttpServletRequest req, HttpServletResponse res)
      throws ServletException, IOException {

    res.setContentType("text/html");
    PrintWriter out = res.getWriter();
    Enumeration values = req.getParameterNames();
    String name = "";
    String value = "";
    String id = "";
    while (values.hasMoreElements()) {
      name = ((String) values.nextElement()).trim();
      value = req.getParameter(name).trim();
      if (name.equals("id")) id = value;
    }
    if (url.equals("")) {
      url = getServletContext().getInitParameter("url");
      cas_url = getServletContext().getInitParameter("cas_url");
    }
    HttpSession session = null;
    session = req.getSession(false);
    if (session != null) {
      session.invalidate();
    }
    res.sendRedirect(cas_url);
    return;
  }
Example #21
0
  private PostMethod convertHttpServletRequestToPostMethod(String url, HttpServletRequest request) {
    PostMethod postMethod = new PostMethod(url);

    for (Enumeration headers = request.getHeaderNames(); headers.hasMoreElements(); ) {
      String headerName = (String) headers.nextElement();
      String headerValue = (String) request.getHeader(headerName);
      postMethod.addRequestHeader(headerName, headerValue);
    }

    postMethod.removeRequestHeader("Host");
    postMethod.addRequestHeader("Host", request.getRequestURL().toString());

    for (Enumeration names = request.getParameterNames(); names.hasMoreElements(); ) {
      String paramName = (String) names.nextElement();
      String paramValue = (String) request.getParameter(paramName);
      postMethod.addParameter(paramName, paramValue);
    }

    StringBuilder requestBody = new StringBuilder();
    try {
      BufferedReader reader = request.getReader();
      String line;
      while (null != (line = reader.readLine())) {
        requestBody.append(line);
      }
      reader.close();
    } catch (IOException e) {
      requestBody.append("");
    }

    postMethod.setRequestEntity(new StringRequestEntity(requestBody.toString()));

    return postMethod;
  }
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    String pathInfo = req.getPathInfo();

    if (pathInfo.equals("/")) {
      HttpSession session = req.getSession();
      if (session == null) {
        resp.setStatus(401);
        return;
      }
      String username = (String) session.getAttribute("username");
      if (username == null) {
        resp.setStatus(401);
        return;
      }

      Map userMap = loadUserSettingsMap(username);
      if (userMap == null) {
        resp.setStatus(401);
        return;
      }
      Enumeration parameterNames = req.getParameterNames();
      while (parameterNames.hasMoreElements()) {
        String parameterName = (String) parameterNames.nextElement();
        userMap.put(parameterName, req.getParameter(parameterName));
      }
      saveUserSettingsMap(username, userMap);
      return;
    }

    super.doPost(req, resp);
  }
  @Override
  public Object resolveArgument(
      MethodParameter parameter,
      ModelAndViewContainer mavContainer,
      NativeWebRequest webRequest,
      WebDataBinderFactory binderFactory)
      throws Exception {

    System.out.println("resolveArgument");

    CommandMap commandMap = new CommandMap();

    HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
    Enumeration<?> enumeration = request.getParameterNames();

    String key = null;
    String[] values = null;
    while (enumeration.hasMoreElements()) {
      key = (String) enumeration.nextElement();
      values = request.getParameterValues(key);
      if (values != null) {
        commandMap.put(key, (values.length > 1) ? values : values[0]);
      }
    }
    return commandMap;
  }
Example #24
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String param = "";
    java.util.Enumeration<String> names = request.getParameterNames();
    if (names.hasMoreElements()) {
      param = names.nextElement(); // just grab first element
    }

    String bar = doSomething(param);

    try {
      java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-512", "SUN");
    } catch (java.security.NoSuchAlgorithmException e) {
      System.out.println(
          "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
      throw new ServletException(e);
    } catch (java.security.NoSuchProviderException e) {
      System.out.println(
          "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
      throw new ServletException(e);
    }

    response
        .getWriter()
        .println(
            "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
  } // end doPost
  public void testSetParameters() {
    HttpServletRequest request = createMock(HttpServletRequest.class);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("p2", "2a");
    model.put("p3", null);

    expect(request.getParameterNames())
        .andReturn(Collections.enumeration(Arrays.asList("p1", "p2", "p3", "p4")));
    expect(request.getParameter("p1")).andReturn("1");
    // expect(request.getParameter("p2")).andReturn("2");
    // expect(request.getParameter("p3")).andReturn("3");
    expect(request.getParameter("p4")).andReturn("");

    replay(request);

    RequestModelHelper.setParameters(request, model);

    assertEquals(4, model.size());
    assertEquals("1", model.get("p1"));
    assertEquals("2a", model.get("p2"));
    assertEquals(null, model.get("p3"));
    assertEquals("", model.get("p4"));

    verify(request);
  }
  public void testImplicitParams() throws Exception {
    HttpServletRequest request = createMock(HttpServletRequest.class);
    expect(request.getParameterNames())
        .andReturn(
            new Enumeration<String>() {

              private String[] list = {"one", "two"};
              int index;

              public boolean hasMoreElements() {
                return (index < list.length);
              }

              public String nextElement() {
                final String string = list[index];
                index++;
                return string;
              }
            });

    expect(request.getParameter("one")).andReturn("v1");
    expect(request.getParameter("two")).andReturn("v2");

    replay(request);
    final ModelMap modelMap = new ModelMap();
    RequestModelHelper.setParameters(request, modelMap);
    assertEquals(2, modelMap.size());
    verify(request);
  }
 /**
  * Override to provide population of current form with request parameters when validation fails.
  *
  * @see org.apache.struts.action.ActionForm#validate(org.apache.struts.action.ActionMapping,
  *     javax.servlet.http.HttpServletRequest)
  */
 public org.apache.struts.action.ActionErrors validate(
     org.apache.struts.action.ActionMapping mapping,
     javax.servlet.http.HttpServletRequest request) {
   final org.apache.struts.action.ActionErrors errors = super.validate(mapping, request);
   if (errors != null && !errors.isEmpty()) {
     // we populate the current form with only the request parameters
     Object currentForm = request.getSession().getAttribute("form");
     // if we can't get the 'form' from the session, try from the request
     if (currentForm == null) {
       currentForm = request.getAttribute("form");
     }
     if (currentForm != null) {
       final java.util.Map parameters = new java.util.HashMap();
       for (final java.util.Enumeration names = request.getParameterNames();
           names.hasMoreElements(); ) {
         final String name = String.valueOf(names.nextElement());
         parameters.put(name, request.getParameter(name));
       }
       try {
         org.apache.commons.beanutils.BeanUtils.populate(currentForm, parameters);
       } catch (java.lang.Exception populateException) {
         // ignore if we have an exception here (we just don't populate).
       }
     }
   }
   return errors;
 }
Example #28
0
  public QueryFilter(HttpServletRequest request) {
    this.request = request;
    Enumeration<?> paramEnu = request.getParameterNames();
    while (paramEnu.hasMoreElements()) {
      String paramName = (String) paramEnu.nextElement();

      if (paramName.startsWith("Q_")) {
        String paramValue = request.getParameter(paramName);
        addFilter(paramName, paramValue);
      }
    }

    Integer start = Integer.valueOf(0);
    Integer limit = PagingBean.DEFAULT_PAGE_SIZE;

    String s_start = request.getParameter("start");
    String s_limit = request.getParameter("limit");
    if (StringUtils.isNotEmpty(s_start)) {
      start = new Integer(s_start);
    }
    if (StringUtils.isNotEmpty(s_limit)) {
      limit = new Integer(s_limit);
    }

    String sort = request.getParameter("sort");
    String dir = request.getParameter("dir");

    if ((StringUtils.isNotEmpty(sort)) && (StringUtils.isNotEmpty(dir))) {
      addSorted(sort, dir);
    }

    this.pagingBean = new PagingBean(start.intValue(), limit.intValue());
  }
Example #29
0
  private ExtendedMap parseSimpleRequest(HttpServletRequest request, boolean keepEmpty) {
    ExtendedMap formItems = new ExtendedMap(keepEmpty);

    Enumeration paramNames = request.getParameterNames();
    while (paramNames.hasMoreElements()) {
      String key = paramNames.nextElement().toString();
      String[] paramValues = request.getParameterValues(key);

      if (paramValues != null) {
        if (paramValues.length == 1 && paramValues[0] != null) {
          String value = paramValues[0];
          if (value.length() > 0) {
            if ("true".equals(value)) {
              formItems.putBoolean(key, true);
            } else if ("false".equals(value)) {
              formItems.putBoolean(key, false);
            } else {
              formItems.putString(key, value);
            }
          } else if (keepEmpty) {
            formItems.putString(key, value);
          }
        } else if (paramValues.length > 1) {
          formItems.put(key, paramValues);
        }
      }
    }

    return formItems;
  }
  protected DataListBinder createDataListBinderFromRequestInternal(
      AppDefinition appDef, String datalistId, String binderId, HttpServletRequest request) {
    DataListBinder binder = null;
    if (binderId != null && binderId.trim().length() > 0) {
      // create binder
      binder = dataListService.getBinder(binderId);

      if (request != null) {
        // get request params
        Enumeration e = request.getParameterNames();
        while (e.hasMoreElements()) {
          String paramName = (String) e.nextElement();
          if (paramName.startsWith(PREFIX_BINDER_PROPERTY)) {
            String[] paramValue = (String[]) request.getParameterValues(paramName);
            String propName = paramName.substring(PREFIX_BINDER_PROPERTY.length());

            String value = CsvUtil.getDeliminatedString(paramValue);

            if (value.contains(SecurityUtil.ENVELOPE)
                || value.contains(PropertyUtil.PASSWORD_PROTECTED_VALUE)) {
              DatalistDefinition datalist = datalistDefinitionDao.loadById(datalistId, appDef);

              if (datalist != null) {
                value = PropertyUtil.propertiesJsonStoreProcessing(datalist.getJson(), value);
              }
            }

            binder.setProperty(propName, AppUtil.processHashVariable(value, null, null, null));
          }
        }
      }
    }
    return binder;
  }