Java Examples for javax.servlet.http.HttpServletRequest

@Override
protected void init() {
    addMethod("javax.servlet.http.HttpServlet", "doDelete(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doGet(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doHead(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doOptions(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doPost(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doPut(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "doTrace(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "service(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)");
    addMethod("javax.servlet.http.HttpServlet", "service(javax.servlet.ServletRequest,javax.servlet.ServletResponse)");
    addMethodAnnotationToMatch("javax.ws.rs.Path");
}

/**
	 * Similar to javax.servlet.http.HttpServletRequest.toString() ,
	 * except it includes output of the Request parameters from the Request's Content Body
	 * @return		String representation of HttpServletRequestWrapper
	 */
public String toString() {
    // 	AND content Body has not been recorded
    if (request.getMethod().toUpperCase().equals("POST") && request.getContentLength() > 0 && !request.getContentType().toUpperCase().startsWith("MULTIPART/") && !contentBodyRecorded()) {
        // Also return the content parameters, these are not part 
        // of the standard HttpServletRequest.toString() output
        StringBuffer buf = new StringBuffer(request.toString());
        Set setParams = params.entrySet();
        for (Iterator itParams = setParams.iterator(); itParams.hasNext(); ) {
            Map.Entry me = (Map.Entry) itParams.next();
            Vector vecParamValues = (Vector) me.getValue();
            for (Iterator itParamValues = vecParamValues.iterator(); itParamValues.hasNext(); ) {
                RequestParamater p = (RequestParamater) itParamValues.next();
                if (p.type == RequestParamater.PARAM_TYPE_CONTENT) {
                    if (buf.charAt(buf.length() - 1) != '\n')
                        buf.append("&");
                    buf.append((String) me.getKey());
                    buf.append("=");
                    buf.append(p.getValue());
                }
            }
        }
        buf.append(System.getProperty("line.separator") + System.getProperty("line.separator"));
        return buf.toString();
    } else if (contentBodyRecorded()) {
        // XML-RPC request or plain XML REST POST
        StringBuffer buf = new StringBuffer(request.toString());
        buf.append(contentBodyAsString);
        buf.append(System.getProperty("line.separator") + System.getProperty("line.separator"));
        return buf.toString();
    } else {
        //Return standard HttpServletRequest.toString() output
        return request.toString();
    }
}

/**
     * Get all selected Files, the files are organized by the name of the parameter (key) and a list of files selected (value) via a hash.
     * 
     * @param request
     *            a {@link javax.servlet.http.HttpServletRequest} object.
     * @return a {@link java.util.Map} object.
     */
public static Map<String, List<File>> getAllSelectedFiles(HttpServletRequest request) {
    HashMap<String, List<File>> files = new HashMap<>();
    SortedSet<WorkflowParam> params = getCurrentWorkflow(request).getWorkflowParamsWithDifferentFileMetaType();
    // if current workflow not set in session
    if (params == null)
        return files;
    Map<Integer, List<File>> selectedFiles = getSelectedFilesFromSession(request);
    for (WorkflowParam param : params) {
        Integer key = param.getWorkflowParamId();
        String paramName = param.getKey();
        List<File> filesOneParam = selectedFiles.get(key);
        List<File> oldValues = files.get(paramName);
        if (oldValues == null) {
            files.put(paramName, filesOneParam);
        } else {
            oldValues.addAll(filesOneParam);
        }
    }
    return files;
}

/**
	 * @see org.springframework.web.servlet.mvc.SimpleFormController#referenceData(javax.servlet.http.HttpServletRequest)
	 */
@Override
protected Map<String, Object> referenceData(HttpServletRequest request) throws Exception {
    PatientMatchingReportMetadataService service = Context.getService(PatientMatchingReportMetadataService.class);
    Map<String, Object> requestMap = new HashMap<String, Object>();
    requestMap.put("configurations", service.getMatchingConfigs());
    requestMap.put("parameter", MatchingConstants.PARAM_NAME);
    return requestMap;
}

// Thymeleaf Error page
@RequestMapping("/error.html")
public String error(HttpServletRequest request, Model model) {
    model.addAttribute("errorCode", request.getAttribute("javax.servlet.error.status_code"));
    Throwable throwable = (Throwable) request.getAttribute("javax.servlet.error.exception");
    String errorMessage = null;
    if (throwable != null) {
        errorMessage = throwable.getMessage();
    }
    model.addAttribute("errorMessage", errorMessage);
    return "error";
}

public static String getAndCreateSession(HttpServletRequest request, String name) {
    String overrideValue = request.getParameter(name);
    if (StringUtils.isNotBlank(overrideValue)) {
        request.getSession().setAttribute(name, overrideValue);
        return overrideValue;
    }
    String value = (String) request.getSession().getAttribute(name);
    if (StringUtils.isNotBlank(value)) {
        request.getSession().setAttribute(name, value);
    }
    return value;
}

public static String getBaseURL(HttpServletRequest request) {
    if ((request.getServerPort() == 80) || (request.getServerPort() == 443))
        return request.getScheme() + "://" + request.getServerName() + request.getContextPath();
    else
        return request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath();
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response) {
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    if (("admin".equalsIgnoreCase(username)) && ("pass123".equalsIgnoreCase(password))) {
        request.setAttribute("USER", new User(username, password));
        return true;
    }
    response.setStatus(401);
    return false;
}

protected static String getRequiredParameter(HttpServletRequest request, String name) {
    try {
        String val = request.getParameter(name);
        if (val == null) {
            throw new RuntimeException("Parameter " + name + " is required");
        }
        return val;
    } catch (Exception ex) {
        throw new RuntimeException("Could not get parameter: " + name, ex);
    }
}

public static String read(HttpServletRequest request) {
    Cookie[] cookies = request.getCookies();
    if (cookies != null) {
        for (int i = 0; i < cookies.length; i++) {
            if (cookies[i].getName().equalsIgnoreCase("WSign_Token")) {
                return cookies[i].getValue();
            }
        }
    }
    return null;
}

/**
	 * Similar to javax.servlet.http.HttpServletRequest.toString() ,
	 * except it includes output of the Request parameters from the Request's Content Body
	 * @return		String representation of HttpServletRequestWrapper
	 */
public String toString() {
    // 	AND content Body has not been recorded
    if ("POST".equals(request.getMethod().toUpperCase()) && (request.getContentLength() > 0 || request.getContentLength() == -1) && !request.getContentType().toUpperCase().startsWith("MULTIPART/") && !contentBodyRecorded()) {
        // Also return the content parameters, these are not part 
        // of the standard HttpServletRequest.toString() output
        final StringBuilder buf = new StringBuilder(request.toString());
        final Set<Map.Entry<String, Vector<RequestParamater>>> setParams = params.entrySet();
        for (final Map.Entry<String, Vector<RequestParamater>> me : setParams) {
            final Vector<RequestParamater> vecParamValues = me.getValue();
            for (final RequestParamater p : vecParamValues) {
                if (p.type == RequestParamater.PARAM_TYPE_CONTENT) {
                    if (buf.charAt(buf.length() - 1) != '\n') {
                        buf.append("&");
                    }
                    buf.append((String) me.getKey());
                    buf.append("=");
                    buf.append(p.getValue());
                }
            }
        }
        buf.append(System.getProperty("line.separator")).append(System.getProperty("line.separator"));
        return buf.toString();
    } else if (contentBodyRecorded()) {
        // XML-RPC request or plain XML REST POST
        final StringBuilder buf = new StringBuilder(request.toString());
        try {
            appendContentBody(buf);
        } catch (final IOException ioe) {
            System.err.println("Error Reading the Content Body into the buffer: " + ioe);
            ioe.printStackTrace();
        }
        buf.append(System.getProperty("line.separator")).append(System.getProperty("line.separator"));
        return buf.toString();
    } else {
        //Return standard HttpServletRequest.toString() output
        return request.toString();
    }
}

/**
	 * Similar to javax.servlet.http.HttpServletRequest.toString() ,
	 * except it includes output of the Request parameters from the Request's Content Body
	 * @return		String representation of HttpServletRequestWrapper
	 */
public String toString() {
    // 	AND content Body has not been recorded
    if ("POST".equals(request.getMethod().toUpperCase()) && (request.getContentLength() > 0 || request.getContentLength() == -1) && !request.getContentType().toUpperCase().startsWith("MULTIPART/") && !contentBodyRecorded()) {
        // Also return the content parameters, these are not part 
        // of the standard HttpServletRequest.toString() output
        final StringBuilder buf = new StringBuilder(request.toString());
        final Set<Map.Entry<String, Vector<RequestParamater>>> setParams = params.entrySet();
        for (final Map.Entry<String, Vector<RequestParamater>> me : setParams) {
            final Vector<RequestParamater> vecParamValues = me.getValue();
            for (final RequestParamater p : vecParamValues) {
                if (p.type == RequestParamater.PARAM_TYPE_CONTENT) {
                    if (buf.charAt(buf.length() - 1) != '\n') {
                        buf.append("&");
                    }
                    buf.append((String) me.getKey());
                    buf.append("=");
                    buf.append(p.getValue());
                }
            }
        }
        buf.append(System.getProperty("line.separator")).append(System.getProperty("line.separator"));
        return buf.toString();
    } else if (contentBodyRecorded()) {
        // XML-RPC request or plain XML REST POST
        final StringBuilder buf = new StringBuilder(request.toString());
        try {
            appendContentBody(buf);
        } catch (final IOException ioe) {
            System.err.println("Error Reading the Content Body into the buffer: " + ioe);
            ioe.printStackTrace();
        }
        buf.append(System.getProperty("line.separator")).append(System.getProperty("line.separator"));
        return buf.toString();
    } else {
        //Return standard HttpServletRequest.toString() output
        return request.toString();
    }
}

/* (non-Javadoc)
     * @see org.dspace.plugin.CommunityHomeProcessor#process(org.dspace.core.Context, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.dspace.content.Community)
     */
@Override
public void process(Context context, HttpServletRequest request, HttpServletResponse response) throws PluginException, AuthorizeException {
    try {
        RecentSubmissionsManager rsm = new RecentSubmissionsManager(context);
        RecentSubmissions recent = rsm.getRecentSubmissions(null);
        request.setAttribute("recent.submissions", recent);
    } catch (RecentSubmissionsException e) {
        throw new PluginException(e);
    }
}

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    request.setAttribute("jaccTest", "true");
    try {
        HttpServletRequest requestFromPolicy = (HttpServletRequest) PolicyContext.getContext("javax.servlet.http.HttpServletRequest");
        if (requestFromPolicy != null) {
            response.getWriter().print("Obtained request from context.");
            if ("true".equals(requestFromPolicy.getAttribute("jaccTest"))) {
                response.getWriter().print("Attribute present in request from context.");
            }
            if ("true".equals(requestFromPolicy.getParameter("jacc_test"))) {
                response.getWriter().print("Request parameter present in request from context.");
            }
        }
    } catch (PolicyContextException e) {
        e.printStackTrace(response.getWriter());
    }
}

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    request.setAttribute("jaccTest", "true");
    try {
        HttpServletRequest requestFromPolicy = (HttpServletRequest) PolicyContext.getContext("javax.servlet.http.HttpServletRequest");
        if (requestFromPolicy != null) {
            response.getWriter().print("Obtained request from context.");
            if ("true".equals(requestFromPolicy.getAttribute("jaccTest"))) {
                response.getWriter().print("Attribute present in request from context.");
            }
            if ("true".equals(requestFromPolicy.getParameter("jacc_test"))) {
                response.getWriter().print("Request parameter present in request from context.");
            }
        }
    } catch (PolicyContextException e) {
        e.printStackTrace(response.getWriter());
    }
}

/* (non-Javadoc)
	 * @see org.springframework.web.servlet.HandlerExceptionResolver#resolveException(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Object, java.lang.Exception)
	 */
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    ModelAndView errorMav;
    logger.debug("resolving Exception");
    if (ex instanceof ValidationException) {
        logger.debug("is a ValidationException");
        ValidationException ve = (ValidationException) ex;
        errorMav = new ModelAndView(ve.getViewName());
        errorMav.addObject(errorMessageKey, ve.getErrorMessageKey());
        errorMav.addAllObjects(ve.getModelElements());
        return errorMav;
    } else if (ex instanceof IllegalArgumentException) {
        errorMav = new ModelAndView("editStep2");
        errorMav.addObject("error", "ERROR: " + ex.getMessage());
        return errorMav;
    //return new ModelAndView("arraystoreView");
    } else
        return null;
}

/*
	 *  (non-Javadoc)
	 * @see org.apache.struts.action.Action#execute(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
	 */
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    DetailForm detailForm = (DetailForm) form;
    String refId = detailForm.getRefId();
    logger.debug("Select detail for job ref [" + refId + "]");
    if (refId == null || "".equals(refId)) {
        return (mapping.findForward("nodetail"));
    } else {
        return (mapping.findForward("detail"));
    }
}

/**
     * @see org.openmrs.module.reporting.web.controller.portlet.ReportingPortletController#populateModel(javax.servlet.http.HttpServletRequest, java.util.Map)
     */
@Override
protected void populateModel(HttpServletRequest request, Map<String, Object> model) {
    super.populateModel(request, model);
    if (model.get("reportDefinitions") == null) {
        /*
	    	 * if we ever start caching these report definitions across page loads, or else if we
	    	 * speed up deserialization of reports to be instantaneous, it would be better to do
	    	 * the following:
	    	 * 
	    	 * model.put("reportDefinitions", Context.getService(ReportDefinitionService.class).getAllDefinitions(false)); 
	    	 */
        model.put("reportDefinitions", Context.getService(ReportDefinitionService.class).getAllDefinitionSummaries(false));
    }
}

/**
	 * Performs an HTTP GET request
	 * @param request The {@link javax.servlet.http.HttpServletRequest}
	 * @param response The {@link javax.servlet.http.HttpServletResponse}
	 */
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
    response.setContentType("text/html");
    URL url = new URL("http://wwwdev.ebi.ac.uk/frontier/template-service/templates/footer/main");
    // make post mode connection
    URLConnection urlc = url.openConnection();
    //urlc.setDoOutput(true);
    //urlc.setAllowUserInteraction(false);
    //OutputStreamWriter wr = new OutputStreamWriter(urlc.getOutputStream());
    //wr.flush();
    // retrieve result
    BufferedReader br1 = new BufferedReader(new InputStreamReader(urlc.getInputStream(), "UTF-8"));
    StringBuilder sb = new StringBuilder();
    String line;
    while ((line = br1.readLine()) != null) {
        sb.append(line);
        sb.append("\n");
    }
    br1.close();
    response.getWriter().write(sb.toString());
}

@Profile("!test")
@Bean(name = "csrfMatcher")
public RequestMatcher csrfMatcher() {
    /**
     * Copy of default request matcher from
     * CsrfFilter$DefaultRequiresCsrfMatcher
     */
    return new RequestMatcher() {

        private Pattern allowedMethods = Pattern.compile("^(GET|HEAD|TRACE|OPTIONS)$");

        /*
       * (non-Javadoc)
       *
       * @see
       * org.springframework.security.web.util.matcher.RequestMatcher#
       * matches(javax.servlet.http.HttpServletRequest)
       */
        public boolean matches(HttpServletRequest request) {
            return !allowedMethods.matcher(request.getMethod()).matches();
        }
    };
}

/**
     * @see net.unicon.idp.externalauth.CasToShibTranslator#doTranslation(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.jasig.cas.client.validation.Assertion)
     */
public void doTranslation(final HttpServletRequest request, final HttpServletResponse response, final Assertion assertion) {
    // i.e. username from CAS
    String authenticatedPrincipalName = assertion.getPrincipal().getName();
    // Pass authenticated principal back to IdP to finish its part of authentication request processing
    request.setAttribute(LoginHandler.PRINCIPAL_NAME_KEY, authenticatedPrincipalName);
}

/**
	 * @see org.springframework.web.servlet.mvc.Controller#handleRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
	 */
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
    String mode = request.getParameter("mode");
    if (mode == null) {
        // Just display it
        response.getOutputStream().println("Mode is '" + config.getMode() + "'");
    } else {
        // Change it
        String oldMode = config.getMode();
        config.setMode(mode);
        response.getOutputStream().println("Changed mode from '" + oldMode + "' to '" + mode + "'");
    }
    response.getOutputStream().flush();
    return null;
}

@Profile("!test")
@Bean(name = "csrfMatcher")
public RequestMatcher csrfMatcher() {
    /**
     * Copy of default request matcher from
     * CsrfFilter$DefaultRequiresCsrfMatcher
     */
    return new RequestMatcher() {

        private Pattern allowedMethods = Pattern.compile("^(GET|HEAD|TRACE|OPTIONS)$");

        /*
       * (non-Javadoc)
       *
       * @see
       * org.springframework.security.web.util.matcher.RequestMatcher#
       * matches(javax.servlet.http.HttpServletRequest)
       */
        public boolean matches(HttpServletRequest request) {
            return !allowedMethods.matcher(request.getMethod()).matches();
        }
    };
}

/* (non-Javadoc)
     * @see org.dspace.plugin.CommunityHomeProcessor#process(org.dspace.core.Context, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.dspace.content.Community)
     */
@Override
public void process(Context context, HttpServletRequest request, HttpServletResponse response) throws PluginException, AuthorizeException {
    try {
        RecentSubmissionsManager rsm = new RecentSubmissionsManager(context);
        RecentSubmissions recent = rsm.getRecentSubmissions(null);
        request.setAttribute("recent.submissions", recent);
    } catch (RecentSubmissionsException e) {
        throw new PluginException(e);
    }
}

@Override
protected String createServiceUrl(final HttpServletRequest request, final HttpServletResponse response) {
    ServiceProperties sp = getServiceProperties();
    StringBuilder serverName = new StringBuilder().append(request.getServerName());
    if (request.getServerPort() != 80) {
        serverName.append(':').append(request.getServerPort());
    }
    return CommonUtils.constructServiceUrl(request, response, sp.getService(), serverName.toString(), sp.getArtifactParameter(), getEncodeServiceUrlWithSessionId());
}

public static StringBuilder buildParameters(HttpServletRequest request) {
    StringBuilder result = new StringBuilder();
    Enumeration<?> names = request.getParameterNames();
    while (names.hasMoreElements()) {
        String name = (String) names.nextElement();
        result.append(name).append(": ").append(request.getParameter(name)).append('\n');
    }
    return result;
}

public UserDetails buildDetails(Object context) {
    Assert.isInstanceOf(HttpServletRequest.class, context);
    try {
        Constructor constructor = clazz.getConstructor(new Class[] { HttpServletRequest.class });
        return (UserDetails) constructor.newInstance(new Object[] { context });
    } catch (NoSuchMethodException ex) {
        ReflectionUtils.handleReflectionException(ex);
    } catch (InvocationTargetException ex) {
        ReflectionUtils.handleReflectionException(ex);
    } catch (InstantiationException ex) {
        ReflectionUtils.handleReflectionException(ex);
    } catch (IllegalAccessException ex) {
        ReflectionUtils.handleReflectionException(ex);
    }
    return null;
}

public String getResourceLocationFromRequest(final HttpServletRequest request) {
    String fileName = request.getParameter(LOCATION_PARAM);
    if (fileName == null) {
        final String pathInfo = request.getPathInfo();
        if (pathInfo != null && pathInfo.startsWith("/") && pathInfo.length() > 1) {
            //Support relative calls to the THEME from the homepage using ../theme
            fileName = pathInfo.substring(1);
        }
    }
    return fileName;
}

public static String getOrGenerate(final HttpServletRequest request) {
    final HttpSession session = request.getSession();
    final String oldTicket = (String) session.getAttribute(SESSION_VALUE_KEY);
    if (oldTicket != null) {
        return oldTicket;
    }
    final String ticket = UUID.randomUUID().toString().replace("-", "");
    session.setAttribute(SESSION_VALUE_KEY, ticket);
    return ticket;
}

public String readBody(HttpServletRequest request) {
    if (body != null) {
        return body;
    }
    try {
        StringBuilder status = new StringBuilder();
        BufferedReader in = new BufferedReader(new InputStreamReader(request.getInputStream()));
        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            status.append(inputLine);
        }
        in.close();
        body = status.toString();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return body;
}

@SuppressWarnings("unchecked")
public void afterPhase(PhaseEvent event) {
    FacesContext facesContext = event.getFacesContext();
    ExternalContext externalContext = facesContext.getExternalContext();
    HttpServletRequest request = (HttpServletRequest) externalContext.getRequest();
    if (!request.getMethod().equals("POST")) {
        Map flashScope = (Map) facesContext.getApplication().createValueBinding("#{flashScope}").getValue(facesContext);
        flashScope.clear();
    }
}

public boolean performAction(HttpServletRequest req, ServletContext context) throws ApplicationException {
    try {
        HttpSession se = req.getSession();
        TgDbCaller _caller = (TgDbCaller) se.getAttribute("caller");
        req.setAttribute("straintypes", modelManager.getStrainTypes(_caller));
    } catch (Exception e) {
        logger.error(getStackTrace(e));
    }
    return true;
}

public static String getIp(HttpServletRequest request) {
    if (null == request) {
        return null;
    }
    String ip = request.getHeader("x-forwarded-for");
    if (!validateIp(ip)) {
        ip = request.getHeader("Proxy-Client-IP");
        if (!validateIp(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
            if (!validateIp(ip)) {
                ip = request.getRemoteAddr();
            }
        }
    }
    return ip;
}

@Test
public void testAuthenticatorFilter() throws Exception {
    Doorkeeper doorkeeper = new Doorkeeper("doorkeeper.properties");
    AuthenticatorFilter filter = new AuthenticatorFilter();
    filter.setDoorkeeper(doorkeeper);
    HttpServletRequest request = mock(HttpServletRequest.class);
    HttpServletResponse response = mock(HttpServletResponse.class);
    FilterChain chain = mock(FilterChain.class);
//filter.doFilter(request, response, chain);
}

public void newRevision(Object revisionEntity) {
    String remoteIp = "";
    try {
        HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
        remoteIp = request.getRemoteAddr();
    } catch (Exception e) {
        remoteIp = "127.0.0.1";
    }
    RevInfo revEntity = (RevInfo) revisionEntity;
    System.out.println("timestamp : " + revEntity.getDataRevisao());
    System.out.println("RemoteIp  : " + remoteIp);
    revEntity.setIp(remoteIp);
}

public Object get(ServletContext sc, HttpServletRequest req, HttpServletResponse resp, Object refer) {
    Object re = req.getAttribute(name);
    if (null != re)
        return re;
    HttpSession session = Mvcs.getHttpSession(false);
    if (session != null) {
        re = session.getAttribute(name);
        if (null != re)
            return re;
    }
    return sc.getAttribute(name);
}

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("application/json;charset=utf-8");
    response.setStatus(HttpServletResponse.SC_OK);
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.getWriter().println("\"" + AutoModeSelector.getInstance().getAutoMode().getClass().getSimpleName() + "\"");
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object controller) throws Exception {
    String uri = request.getRequestURI();
    if (uri.endsWith("/login/login") || uri.endsWith("/login/logar") || uri.endsWith("/usuario") || uri.endsWith("/usuario/cadastrarUsuario") || uri.contains("resources")) {
        return true;
    }
    if (request.getSession().getAttribute("usuarioLogado") != null) {
        return true;
    }
    response.sendRedirect(request.getContextPath() + "/login/login");
    return false;
}

public ActionForward execute(ActionMapping actionMapping, ActionForm actionForm, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
    // Seta o mapeamento de retorno
    ActionForward retorno = actionMapping.findForward("selecionarComandoRetirarImovelTarifaSocial");
    SelecionarComandoRetirarImovelTarifaSocialActionForm form = (SelecionarComandoRetirarImovelTarifaSocialActionForm) actionForm;
    if (httpServletRequest.getParameter("menu") != null) {
        form.setIndicadorTipoCarta("3");
        form.setIndicadorSituacao(null);
    }
    return retorno;
}

public ActionForward execute(ActionMapping paramActionMapping, ActionForm paramActionForm, HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse) throws Exception {
    SimpleSQLNumericInjectionActionForm localSimpleSQLNumericInjectionActionForm = (SimpleSQLNumericInjectionActionForm) paramActionForm;
    List localList = getAttacksExampleFacade().getProductListByCategory(localSimpleSQLNumericInjectionActionForm.getCategory());
    localSimpleSQLNumericInjectionActionForm.setProducts(localList);
    return paramActionMapping.findForward("success");
}

public int doStartTag() throws JspException {
    UserService userService = UserServiceFactory.getUserService();
    try {
        pageContext.getOut().append(userService.createLogoutURL(((HttpServletRequest) pageContext.getRequest()).getRequestURI()));
    } catch (IOException e) {
        throw new JspException(e.getMessage(), e);
    }
    return SKIP_BODY;
}

@Override
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
    System.out.println("Looking for :" + urlPath);
    String[] parts = urlPath.split("/");
    String controller = parts[1];
    String action = parts[2];
    String controllerClassName = controller.substring(0, 1).toUpperCase().concat(controller.substring(1)).concat("Controller");
    controllerClassName = "app.controllers." + controllerClassName;
    return Class.forName(controllerClassName).newInstance();
}

public static String getActionName(HttpServletRequest request) {
    String requestURL = request.getRequestURI();
    int i1 = requestURL.lastIndexOf('/');
    int i2 = requestURL.indexOf(".action");
    String fileName = "home";
    if (i1 >= 0 && i2 >= 0 && i2 >= i1 + 1) {
        fileName = requestURL.substring(i1 + 1, i2);
    }
    return fileName;
}

/**
	 * ¼ì²âä¯ÀÀÆ÷UA
	 * 
	 * @return
	 */
public static String getAgent(HttpServletRequest request) {
    String agent = request.getHeader("USER-AGENT");
    if (agent == null || agent.equals("")) {
        return WEB;
    } else {
        agent = agent.toLowerCase();
        if (agent.indexOf(IPHONE) > 0) {
            return IPHONE;
        } else if (agent.indexOf(IPAD) > 0) {
            return IPAD;
        } else if (agent.indexOf(ANDROID) > 0) {
            return ANDROID;
        }
    }
    return WEB;
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.setContentType("text/html");
    ServletOutputStream out = resp.getOutputStream();
    Enumeration e = req.getHeaderNames();
    while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        out.print(String.format("%s = %s <br>", key, req.getHeader(key)));
    }
    out.flush();
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    if (request instanceof HttpServletRequest) {
        String url = ((HttpServletRequest) request).getRequestURI();
        if (url.startsWith("/main") || url.startsWith("/auth")) {
            ((HttpServletResponse) response).sendError(HttpServletResponse.SC_FORBIDDEN);
        }
        chain.doFilter(request, response);
    }
}

public static String extractMatched(final HttpServletRequest request) {
    String path = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
    String bestMatchPattern = (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
    AntPathMatcher apm = new AntPathMatcher();
    return apm.extractPathWithinPattern(bestMatchPattern, path);
}

@Override
public String getPropertyValue(HttpServletRequest req) throws PropertyProviderException {
    String userAgent = getUserAgent(req);
    if (userAgent.contains("opera")) {
        return "opera";
    }
    if (userAgent.contains("safari") || userAgent.contains("iphone") || userAgent.contains("ipad")) {
        return "safari";
    }
    if (userAgent.contains("gecko")) {
        return "gecko1_8";
    }
    throw new PropertyProviderException("Can not find user agent property for userAgent: '" + userAgent + "'");
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    try {
        db.deleteAll();
        request.setAttribute("msg", "Deleted");
    } catch (Exception e) {
        request.setAttribute("msg", e.getMessage());
        e.printStackTrace(System.err);
    }
    response.setContentType("text/html");
    response.setStatus(200);
    request.getRequestDispatcher("/index.jsp").forward(request, response);
}

@Test
public void testDoGet_noException() throws Exception {
    HttpServletRequest httpServletRequest = mock(HttpServletRequest.class);
    HttpServletResponse response = mock(HttpServletResponse.class);
    when(httpServletRequest.getPathInfo()).thenReturn("/foobar");
    ControlServlet testClass = new ControlServlet(mock(MusicPlayer.class));
    testClass.doGet(httpServletRequest, response);
}

public static String getIp(HttpServletRequest request) {
    String ip = request.getHeader("x-forwarded-for");
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getRemoteAddr();
    }
    return ip;
}

public Object get(ServletContext sc, HttpServletRequest req, HttpServletResponse resp, Object refer) {
    Object re = req.getAttribute(name);
    if (null != re)
        return re;
    HttpSession session = Mvcs.getHttpSession(false);
    if (session != null) {
        re = session.getAttribute(name);
        if (null != re)
            return re;
    }
    return sc.getAttribute(name);
}

public static String getIpAddr(HttpServletRequest request) {
    String ip = request.getHeader("x-forwarded-for");
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getRemoteAddr();
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = "unknown";
    }
    return ip.split(",")[0];
}

public static void ensureTokenIsValid(HttpServletRequest req) {
    String token = req.getParameter("token");
    if (token == null) {
        throw new IllegalArgumentException("Field [token] is required for current request !");
    }
    if (!SecurityTokenDAO.INSTANCE.isTokenValid(token)) {
        throw new IllegalStateException("Your token is invalid : we cannot go further from there !");
    }
}

public void testIndexShouldRenderWelcomeJSP() throws Exception {
    ControllerTestHelper helper = new ControllerTestHelper();
    HttpServletRequest request = helper.createMockRequest("GET");
    helper.setActionName("index");
    WelcomeController controller = new WelcomeController();
    assertNotNull(controller.handle(request));
    assertTrue(controller.handle(request).empty());
    assertEquals("/WEB-INF/pages/welcome.jsp", request.getAttribute("include_path"));
}

public Properties extractProperties(HttpServletRequest request) {
    Properties properties = new Properties();
    Map<String, String[]> propertyValues = new HashMap<String, String[]>();
    Enumeration<?> enumeration = request.getParameterNames();
    while (enumeration.hasMoreElements()) {
        String name = (String) enumeration.nextElement();
        if ((request.getParameterValues(name)).length > 1) {
            propertyValues.put(name, request.getParameterValues(name));
        } else
            properties.put(name, request.getParameterValues(name)[0]);
    }
    return properties;
}

public static String getIpAddr(HttpServletRequest request) {
    String ip = request.getHeader("x-forwarded-for");
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getRemoteAddr();
    }
    return ip;
}

@Override
public String execute() throws Exception {
    HttpServletRequest request = ServletActionContext.getRequest();
    HttpSession actionSession = request.getSession();
    Object object = actionSession.getAttribute("user");
    if (object != null) {
        try {
            request.getSession().removeAttribute("user");
        } catch (Exception e) {
            object = null;
        }
    }
    return SUCCESS;
}

public Resource resolve(HttpServletRequest request) {
    final String path;
    path = request.getPathInfo();
    if ("/".equals(path)) {
        return new AgentResource();
    } else if ("/remote-controls".equals(path) && "POST".equals(request.getMethod())) {
        return new RemoteControlCommand();
    }
    throw new InvalidRouteException(request.getPathInfo());
}

@Override
public int doStartTag() throws JspException {
    // TODO Auto-generated method stub
    HttpServletRequest request = (HttpServletRequest) this.pageContext.getRequest();
    JspWriter out = this.pageContext.getOut();
    String ip = request.getRemoteAddr();
    try {
        out.print(ip);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return super.doStartTag();
}

public Decorator getDecorator(HttpServletRequest request, Page page) {
    Decorator result = null;
    String decoratorParamValue = (String) request.getAttribute(decoratorParameter);
    if (decoratorParamValue != null && !decoratorParamValue.trim().equals("")) {
        result = getNamedDecorator(request, decoratorParamValue);
    }
    return result == null ? super.getDecorator(request, page) : result;
}

// Thymeleaf Error page
@RequestMapping("/error.html")
public String error(HttpServletRequest request, Model model) {
    model.addAttribute("errorCode", request.getAttribute("javax.servlet.error.status_code"));
    Throwable throwable = (Throwable) request.getAttribute("javax.servlet.error.exception");
    String errorMessage = null;
    if (throwable != null) {
        errorMessage = throwable.getMessage();
    }
    model.addAttribute("errorMessage", errorMessage);
    return "error";
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    System.out.println("DispatcherType=" + req.getDispatcherType());
    System.out.println("AsyncStarted=" + req.isAsyncStarted());
    if (req.getDispatcherType().equals(DispatcherType.REQUEST)) {
        System.out.println("Starting async request");
        req.startAsync(req, resp);
    }
}

public List<String> validateOrder(HttpServletRequest request) {
    validateStringParam(request.getParameter("HREFGOODS"), "HREFGOODS");
    validateStringParam(request.getParameter("NAMEGOODS"), "NAMEGOODS");
    validateStringParam(request.getParameter("CHINAGOODS"), "CHINAGOODS");
    validateStringParam(request.getParameter("COLORGOODS"), "COLORGOODS");
    validateStringParam(request.getParameter("SIZEGOODS"), "SIZEGOODS");
    validateDoubleParam(request.getParameter("PRICEGOODS"), "PRICEGOODS");
    validateDoubleParam(request.getParameter("WEIGHTGOODS"), "WEIGHTGOODS");
    validateIntegerParam(request.getParameter("AMOUNTGOODS"), "AMOUNTGOODS");
    return errors;
}

protected void setSeoTexts(HttpServletRequest request, String pageTitle, String pageSubtitle, String pageDescription) {
    //TODO: liferay internal - needs to be removed after transition
    if (StringUtils.isNotBlank(pageTitle)) {
    //  PortalUtil.setPageTitle(pageTitle, httpRequest);
    }
    if (StringUtils.isNotBlank(pageDescription)) {
    //PortalUtil.setPageDescription(pageDescription, httpRequest);
    }
    if (StringUtils.isNotBlank(pageSubtitle)) {
    //PortalUtil.setPageSubtitle(pageSubtitle, httpRequest);
    }
}

@Override
public void afterPhase(PhaseEvent event) {
    FacesContext facesContext = event.getFacesContext();
    ExternalContext externalContext = facesContext.getExternalContext();
    HttpServletRequest request = (HttpServletRequest) externalContext.getRequest();
    if (!request.getMethod().equals("POST")) {
        Map<?, ?> flashScope = (Map<?, ?>) facesContext.getApplication().createValueBinding("#{flashScope}").getValue(facesContext);
        flashScope.clear();
    }
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String file_name = req.getParameter(Const.FILE_NAME);
    SongEntry songEntry = SearchUtils.getSongEntryByFileName(file_name);
    if (songEntry != null) {
        resp.getOutputStream().write(songEntry.getUuid().getBytes());
    } else {
        resp.getOutputStream().write("missig".getBytes());
    }
}

/*
      * (non-Javadoc)
      *
      * @see
      * javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest
      * , javax.servlet.http.HttpServletResponse)
      */
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String name = req.getHeader("id");
    String token = req.getHeader("token");
    if (null == name || null == token || EMPTY.equals(name) || EMPTY.equals(token)) {
        ServletHelper.onRequestFailure(req, resp, new NullPointerException("User/Pass cannot be NULL or EMPTY"));
    }
    name = name.trim();
    token = token.trim();
    log.info("Got name + token: " + name);
    try {
        User user = UserManager.loadUser(name, token);
        if (null == user) {
            ServletHelper.onRequestFailure(req, resp, new NullPointerException("User is NULL"));
        } else {
            // todo: set refresh from client
            UserManager.fetchTwitterFriends(user);
            List<Friend> friends = UserManager.fetchTwitFriends(user);
            // prepare the output
            resp.getWriter().print(TypeFactory.toJson(friends, TypeFactory.FRIEND_LIST_TYPE));
        }
    } catch (TwitterException e) {
        e.printStackTrace();
        ServletHelper.onRequestFailure(req, resp, e);
    }
}

/**
	 * @see org.springframework.web.servlet.mvc.SimpleFormController#referenceData(javax.servlet.http.HttpServletRequest)
	 */
protected Map referenceData(HttpServletRequest request) throws Exception {
    //default empty Objects
    Integer errorSize = 0;
    //only fill the objects if the user has authenticated properly
    if (Context.isAuthenticated()) {
        FormEntryService fs = (FormEntryService) Context.getService(FormEntryService.class);
        errorSize = fs.getFormEntryErrorSize();
    }
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("errorSize", errorSize);
    return map;
}

@Override
public OAuthAuthenticationResult authenticate(HttpServletRequest httpRequest) {
    Assert.notNull(httpRequest, "httpRequest argument cannot be null.");
    Assert.isInstanceOf(javax.servlet.http.HttpServletRequest.class, httpRequest, "The specified httpRequest argument must be an instance of " + HTTP_SERVLET_REQUEST_FQCN);
    com.stormpath.sdk.impl.http.ServletHttpRequest stmpHttpRequest = new com.stormpath.sdk.impl.http.ServletHttpRequest(httpRequest);
    return Applications.oauthRequestAuthenticator(application).authenticate(stmpHttpRequest);
}

/**
	 * This is called prior to displaying a form for the first time. It tells Spring the
	 * form/command object to load into the request
	 * 
	 * @see org.springframework.web.servlet.mvc.AbstractFormController#formBackingObject(javax.servlet.http.HttpServletRequest)
	 */
protected List<String> formBackingObject(HttpServletRequest request) throws ServletException {
    Appender appender = Logger.getRootLogger().getAppender("MEMORY_APPENDER");
    if (appender instanceof MemoryAppender) {
        MemoryAppender memoryAppender = (MemoryAppender) appender;
        return memoryAppender.getLogLines();
    } else {
        return new ArrayList<String>();
    }
}

/**
	 * doEcho
	 * 
	 * <ul>
	 * <li>Log method, URL, headers, body</li>
	 * <li>Replicate request headers, except for setting location to received
	 * URL</li>
	 * <li>Replicate request body in response</li>
	 * </ul>
	 * 
	 * @param req
	 * @param resp
	 * @param method
	 */
@SuppressWarnings("rawtypes")
private void doEcho(HttpServletRequest req, HttpServletResponse resp, String method) throws IOException {
    String reqURI = req.getRequestURI();
    logger.debug(this.getClass().getName() + ":" + method + " - " + reqURI);
    for (Enumeration hdrse = req.getHeaderNames(); hdrse.hasMoreElements(); ) {
        String headerName = (String) hdrse.nextElement();
        int hnct = 0;
        for (Enumeration hdre = req.getHeaders(headerName); hdre.hasMoreElements(); ) {
            String headerValue = (String) hdre.nextElement();
            logger.debug(this.getClass().getName() + ":  header[" + headerName + "," + hnct + "]=" + headerValue);
            if (!headerName.equals("Location")) {
                resp.addHeader(headerName, headerValue);
            }
            hnct++;
        }
        if (hnct == 0) {
            resp.setHeader(headerName, "");
            logger.info(this.getClass().getName() + ":  header[" + headerName + "," + hnct + "]='' (empty)");
        }
    }
    resp.setHeader("Location", reqURI);
    resp.setStatus(HttpServletResponse.SC_OK);
    if (req.getContentLength() > 0 && !(method.equals("HEAD") || method.equals("DELETE"))) {
        String body = FileCopyUtils.copyToString(req.getReader());
        logger.debug(this.getClass().getName() + ":  body>>\n" + body + "\nbody<<");
        FileCopyUtils.copy(body, resp.getWriter());
        resp.flushBuffer();
        resp.setContentLength(req.getContentLength());
    } else {
        logger.debug(this.getClass().getName() + ":  body is empty");
        resp.setContentLength(0);
    }
}

/* (non-Javadoc)
     * @see org.apereo.portal.rendering.PipelineComponent#getEventReader(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
     */
@Override
public PipelineEventReader<CharacterEventReader, CharacterEvent> getEventReader(HttpServletRequest request, HttpServletResponse response) {
    final PipelineEventReader<CharacterEventReader, CharacterEvent> pipelineEventReader = this.wrappedComponent.getEventReader(request, response);
    final CharacterEventReader eventReader = pipelineEventReader.getEventReader();
    final JsonWrapperFilteringCharacterEventReader jsonWrapperFilteringCharacterEventReader = new JsonWrapperFilteringCharacterEventReader(eventReader);
    final Map<String, String> outputProperties = pipelineEventReader.getOutputProperties();
    return new PipelineEventReaderImpl<CharacterEventReader, CharacterEvent>(jsonWrapperFilteringCharacterEventReader, outputProperties);
}

/* (non-Javadoc)
 * @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
 */
@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    //GSON Conversion:
    Gson gson = new Gson();
    try {
        StringBuilder sb = new StringBuilder();
        String s;
        while ((s = req.getReader().readLine()) != null) {
            sb.append(s);
        }
        Cat lostCatInfo = (Cat) gson.fromJson(sb.toString(), Cat.class);
        String lostCatName = lostCatInfo.petname;
        //set up chip info:
        String chipped = "false";
        if (lostCatInfo.chip != null && !lostCatInfo.chip.isEmpty()) {
            if (lostCatInfo.chip.equals("chip")) {
                chipped = "true";
            }
        }
        //set up sex info:
        if (lostCatInfo.sex.equals("m")) {
            lostCatInfo.sex = "male";
        }
        if (lostCatInfo.sex.equals("f")) {
            lostCatInfo.sex = "female";
        }
        //Task Queue
        Queue queue = QueueFactory.getDefaultQueue();
        queue.add(withUrl("/lostcatadder").param("name", lostCatName).param("chip", chipped).param("age", lostCatInfo.age).param("sex", lostCatInfo.sex).param("breed", lostCatInfo.breed).param("color", lostCatInfo.color).param("area", lostCatInfo.area).param("contactname", lostCatInfo.contactname).param("contactemail", lostCatInfo.contactemail));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

/*
     * (non-Javadoc)
     * @see
     * org.fcrepo.server.security.xacml.pep.rest.filters.RESTFilter#handleRequest(javax.servlet
     * .http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
     */
@Override
public RequestCtx handleRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    RequestCtx req = null;
    Map<URI, AttributeValue> actions = new HashMap<URI, AttributeValue>();
    Map<URI, AttributeValue> resAttr;
    try {
        resAttr = ResourceAttributes.getRepositoryResources();
        // note - no API specified in legacy XACML, so none specified here
        /*
            actions.put(Constants.ACTION.API.getURI(),
                        Constants.ACTION.APIA.getStringAttribute()));
            */
        actions.put(Constants.ACTION.ID.getURI(), Constants.ACTION.UPLOAD.getStringAttribute());
        req = getContextHandler().buildRequest(getSubjects(request), actions, resAttr, getEnvironment(request));
        LogUtil.statLog(request.getRemoteUser(), Constants.ACTION.LIST_METHODS.uri, Constants.FEDORA_REPOSITORY_PID.uri, null);
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new ServletException(e);
    }
    return req;
}

/**
	 * This is called prior to displaying a form for the first time. It tells Spring the
	 * form/command object to load into the request
	 * 
	 * @see org.springframework.web.servlet.mvc.AbstractFormController#formBackingObject(javax.servlet.http.HttpServletRequest)
	 */
protected List<String> formBackingObject(HttpServletRequest request) throws ServletException {
    Appender appender = Logger.getRootLogger().getAppender("MEMORY_APPENDER");
    if (appender instanceof MemoryAppender) {
        MemoryAppender memoryAppender = (MemoryAppender) appender;
        return memoryAppender.getLogLines();
    } else {
        return new ArrayList<String>();
    }
}

/**
	 * This is called prior to displaying a form for the first time. It tells Spring the
	 * form/command object to load into the request
	 * 
	 * @see org.springframework.web.servlet.mvc.AbstractFormController#formBackingObject(javax.servlet.http.HttpServletRequest)
	 */
protected Object formBackingObject(HttpServletRequest request) throws ServletException {
    //default empty Object
    List<VisitType> visitTypeList = new Vector<VisitType>();
    //only fill the Object is the user has authenticated properly
    if (Context.isAuthenticated()) {
        VisitService es = Context.getVisitService();
        visitTypeList = es.getAllVisitTypes();
    }
    return visitTypeList;
}

/**
	 * This is called prior to displaying a form for the first time. It tells Spring the
	 * form/command object to load into the request
	 * 
	 * @see org.springframework.web.servlet.mvc.AbstractFormController#formBackingObject(javax.servlet.http.HttpServletRequest)
	 */
protected List<String> formBackingObject(HttpServletRequest request) throws ServletException {
    Appender appender = Logger.getRootLogger().getAppender("MEMORY_APPENDER");
    if (appender instanceof MemoryAppender) {
        MemoryAppender memoryAppender = (MemoryAppender) appender;
        return memoryAppender.getLogLines();
    } else {
        return new ArrayList<String>();
    }
}

/*
	 * (non-Javadoc)
	 * 
	 * @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest,
	 *      javax.servlet.http.HttpServletResponse)
	 */
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String searchText = request.getParameter("search");
    if ((searchText == null) || (searchText.length() == 0)) {
        request.getSession().setAttribute("Error", "You didn't specify search text");
        response.sendRedirect("index.jsp?notification=usermgmt");
        return;
    }
    String memberType = request.getParameter("type");
    if ((memberType == null) || (memberType.length() == 0)) {
        memberType = "user";
    }
    String redirectpage = "index.jsp?notification=usermgmt";
    int total = 0;
    Vector results = new Vector();
    if (memberType.equals("user")) {
        total = BrokerFactory.getUserMgmtBroker().getNumUsersLike(searchText);
        redirectpage = "index.jsp?notification=usermgmt&id=" + request.getParameter("id");
    } else {
        total = BrokerFactory.getGroupMgmtBroker().getNumGroupsLike(searchText);
        redirectpage = "index.jsp?notification=groupmgmt";
    }
    BrokerFactory.getLoggingBroker().logDebug("Search returned " + total + " " + memberType + "s");
    if (total > 150) {
        request.getSession().setAttribute("Error", "Your search return " + total + " results please specify a stricter search");
        response.sendRedirect(redirectpage);
        return;
    }
    if (memberType.equals("user")) {
        User[] users = new User[total];
        BrokerFactory.getUserMgmtBroker().getUsersLike(total, 0, searchText, users);
        for (int i = 0; i < users.length; i++) {
            BrokerFactory.getLoggingBroker().logDebug("Got user[" + i + "] = " + users[i]);
            results.addElement(users[i]);
        }
    } else {
        Group[] groups = new Group[total];
        BrokerFactory.getGroupMgmtBroker().getGroupsLike(total, 0, searchText, groups);
        for (int i = 0; i < groups.length; i++) {
            results.addElement(groups[i]);
        }
    }
    request.getSession().setAttribute("searchMembers", results);
    response.sendRedirect(redirectpage);
}

/**
   * Creates a {@link org.aitools.programd.Bot Bot} object if necessary, puts it in a session attribute, and forwards to
   * a JSP page.
   * 
   * @param req the request
   * @param resp the response
   * @throws ServletException
   */
@Override
protected void setupBot(HttpServletRequest req, HttpServletResponse resp) throws ServletException {
    try {
        super.setupBot(req, resp);
    } catch (ServletException e) {
        req.setAttribute("error", Errors.describe(e));
        try {
            JSPOrientedBotServlet.forward(this.errorPage, req, resp);
        } catch (IOException ee) {
            throw new ServletException(ee);
        }
        return;
    }
    // See if there is already a bot access object in the session.
    Object botAccessObject = this.session.getAttribute("bot");
    // If it's null, or if it is a bot but there's a bot id specified that doesn't match it, replace it.
    if (botAccessObject == null || !(botAccessObject instanceof BotAccess && ((BotAccess) botAccessObject).getBotId().equals(this.botid))) {
        BotAccess botAccess = new BotAccess(this.core, this.botid, this.userid);
        this.session.setAttribute("bot", botAccess);
    } else {
        this.bot = ((BotAccess) botAccessObject).getBot();
    }
    String botPage = this.bot.getServletPage();
    if (botPage == null || botPage.length() == 0) {
        botPage = this.defaultBotServletPage;
    }
    try {
        JSPOrientedBotServlet.forward(botPage, req, resp);
    } catch (IOException e) {
        throw new ServletException(e);
    }
}

/**
     * Test method for
     * {@link org.terasoluna.gfw.web.token.transaction.TransactionTokenRequestDataValueProcessor#getExtraHiddenFields(javax.servlet.http.HttpServletRequest)}
     * request has no next token.
     */
@Test
public void testGetExtraHiddenFields01() {
    // setup arguments
    TransactionTokenRequestDataValueProcessor processor = new TransactionTokenRequestDataValueProcessor();
    HttpServletRequest request = mock(HttpServletRequest.class);
    // mock behavior
    when((TransactionToken) request.getAttribute(TransactionTokenInterceptor.NEXT_TOKEN_REQUEST_ATTRIBUTE_NAME)).thenReturn(null);
    // run
    Map<String, String> result = processor.getExtraHiddenFields(request);
    // assert
    assertThat(result, nullValue());
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    if (response instanceof HttpServletResponse) {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        httpServletResponse.addHeader("Access-Control-Allow-Origin", "*");
        if ("OPTIONS".equals(httpServletRequest.getMethod())) {
            httpServletResponse.addHeader("Access-Control-Allow-Headers", "Content-Type");
        }
    }
    chain.doFilter(request, response);
}

public static Usuario getUsuario(HttpServletRequest req) {
    return WebUtil.getUsuario(req);
/*
		Usuario user = (Usuario) req.getSession().getAttribute(Constantes.getValue("USUARIO_SESSAO"));
		if (user == null){
				Usuario usr = new Usuario();
				usr.setIdUsuario("1");
				usr.setNomeUsuario("EMAURI GOMES GASPAR JUNIOR");
				usr.setMatricula("1");
				usr.setIdProfissional(new Integer(1));
				usr.setIdEmpresa(new Integer(123));
				
				String[] grupos = new String[] {"grupoteste"};
				usr.setGrupos(grupos);
				
				setUsuario(usr, req);
				user = usr;	
		}
		return user;
		*/
}

public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    BlobstoreService blobstoreService = BlobstoreServiceFactory.getBlobstoreService();
    Map<String, BlobKey> blobs = blobstoreService.getUploadedBlobs(req);
    BlobKey blobKey = blobs.get("data");
    if (blobKey == null) {
        resp.sendRedirect("/");
    } else {
        resp.sendRedirect("/upload-success?blob-key=" + blobKey.getKeyString());
    }
}

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) req;
    // grab messages from the session and put them into request
    // this is so they're not lost in a redirect
    Object message = request.getSession().getAttribute("message");
    if (message != null) {
        request.setAttribute("message", message);
        request.getSession().removeAttribute("message");
    }
    chain.doFilter(req, res);
}

@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
    Object user = httpServletRequest.getSession().getAttribute(SESSION_USER_KEY);
    if (null != user) {
        if (null == operatorType)
            operatorType = OperatorType.TYPE_01.getIndex();
        Operator operator = Operator.creat(operatorType, user.toString());
        ThreadLocalOperatorContext.getInstance().setOperator(operator);
    }
    return true;
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.setContentType("text/html");
    ServletOutputStream out = resp.getOutputStream();
    List<String> list = EnumerationUtils.toList(req.getHeaderNames());
    for (String key : list) {
        out.print(String.format("%s = %s <br>", key, req.getHeader(key)));
    }
    out.flush();
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    boolean tokenHeaderMatches = StringUtils.equals(krysseToken, request.getHeader("KrysseToken"));
    if (!tokenHeaderMatches) {
        log.warn("tokenheader did not match kryssetoken");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    }
    return tokenHeaderMatches;
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    String requestURI = httpRequest.getRequestURI();
    if ("/".equals(requestURI)) {
        requestURI = "/index.html";
    }
    String newURI = "/dist" + requestURI;
    request.getRequestDispatcher(newURI).forward(request, response);
}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String hash = request.getParameter("hash");
    final String CACHE_FOLDER = Configurations.getPathConfig().getCachedFilesDirectoryPath();
    File file = new File(CACHE_FOLDER + File.separator + hash);
    if (file.exists()) {
        // response.sendRedirect("/cache/" + hash);
        // TODO! ...
        response.setContentType("video/mp4");
        request.getRequestDispatcher("/cache/" + hash).forward(request, response);
    } else {
        int dot = hash.lastIndexOf(".");
        if (dot >= 0) {
            hash = hash.substring(0, dot);
        }
        FileSharing.getSingleton().downloadByHash(hash);
        response.sendError(503);
    }
}

@Override
public URI getUri() {
    HttpServletRequest httpServletRequest = request.raw();
    StringBuffer url = httpServletRequest.getRequestURL();
    if (httpServletRequest.getQueryString() != null && !httpServletRequest.getQueryString().isEmpty()) {
        url.append('?').append(httpServletRequest.getQueryString());
    }
    return URI.create(url.toString());
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    if (request instanceof HttpServletRequest) {
        // Wrap the original request
        SafeHeadersRequest safeRequest = new SafeHeadersRequest((HttpServletRequest) request);
        chain.doFilter(safeRequest, response);
    } else {
        // Use the originals
        chain.doFilter(request, response);
    }
}

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.setStatus(200);
    PrintWriter writer = resp.getWriter();
    writer.println("Method: " + req.getMethod());
    writer.println("Request Headers:");
    Enumeration headerNames = req.getHeaderNames();
    while (headerNames.hasMoreElements()) {
        String hdr = (String) headerNames.nextElement();
        Enumeration headers = req.getHeaders(hdr);
        while (headers.hasMoreElements()) {
            String val = (String) headers.nextElement();
            writer.println(hdr + ": " + val);
        }
    }
    writer.close();
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    if (request.getHeader("Access-Control-Request-Method") != null && "OPTIONS".equals(request.getMethod())) {
        // CORS "pre-flight" request
        response.addHeader("Access-Control-Allow-Origin", "*");
        response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
        response.addHeader("Access-Control-Allow-Headers", "Content-Type");
        //30 min
        response.addHeader("Access-Control-Max-Age", "1800");
        response.addHeader("Access-Control-Allow-Credentials", "true");
    }
    filterChain.doFilter(request, response);
}

public static String getIpAddr(HttpServletRequest request) {
    String ip = request.getHeader("x-forwarded-for");
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        ip = request.getRemoteAddr();
    }
    return ip;
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
    String name = req.getParameter("name");
    ServletOutputStream out = res.getOutputStream();
    if (name == null) {
        out.print("There is no name query parameter, try adding ?name=donald");
    } else {
        // call the Camel route
        String result = producer.requestBody("direct:hello", name, String.class);
        out.print(result);
    }
}

protected void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
    Principal principal = httpServletRequest.getUserPrincipal();
    Writer out = httpServletResponse.getWriter();
    httpServletResponse.setContentType("text/plain");
    if (principal == null) {
        out.write("no prinicipal");
    } else {
        out.write("principal name = " + principal.getName());
    }
    out.close();
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    if (handler instanceof DefaultServletHttpRequestHandler) {
        return true;
    }
    if (request.getMethod().equals("GET")) {
        return true;
    } else {
        String sessionToken = CSRFManager.getToken(request.getSession());
        String requestToken = CSRFManager.getToken(request);
        if (sessionToken.equals(requestToken)) {
            return true;
        } else {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Bad or missing CSRF value");
            return false;
        }
    }
}

@Override
protected Object lookupHandler(final String urlPath, final HttpServletRequest request) throws Exception {
    if (HttpMethod.POST.name().equals(request.getMethod()) && (OpenIdProtocolConstants.CHECK_AUTHENTICATION.equals(request.getParameter(OpenIdProtocolConstants.OPENID_MODE)) || OpenIdProtocolConstants.ASSOCIATE.equals(request.getParameter(OpenIdProtocolConstants.OPENID_MODE)))) {
        return super.lookupHandler(urlPath, request);
    }
    return null;
}

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    System.out.println("Calculation-Servlet invoked on port: " + req.getServerPort());
    HttpSession session = req.getSession();
    Result result = (Result) session.getAttribute(RESULT_ATTRIBUTE);
    if (result == null) {
        result = new Result(0);
    }
    result = new Result(result.getValue() + 1);
    session.setAttribute(RESULT_ATTRIBUTE, result);
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    if (logger.isTraceEnabled()) {
        boolean isFirstRequest = !isAsyncDispatch(request);
        if (isFirstRequest) {
            beforeRequest(request, createMessage(request, "Before[method=" + request.getMethod() + ";", "]"));
        }
    }
    try {
        filterChain.doFilter(request, response);
    } finally {
        if (logger.isTraceEnabled()) {
            if (!isAsyncStarted(request)) {
                afterRequest(request, createMessage(request, "After [method=" + request.getMethod() + ";", "]"));
            }
        }
    }
}