Java Examples for javax.servlet.http.HttpServletResponse

@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");
}

public static void sendJsonStr(String json) {
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setContentType("application/json;charset=utf-8");
    try {
        PrintWriter writer = response.getWriter();
        writer.write(json);
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@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;
}

private static String getResponseStatusMessage(int status) {
    switch(status) {
        case HttpServletResponse.SC_OK:
            return "OK";
        case HttpServletResponse.SC_ACCEPTED:
            return "Accepted";
        case HttpServletResponse.SC_BAD_GATEWAY:
            return "Bad Gateway";
        case HttpServletResponse.SC_BAD_REQUEST:
            return "Bad Request";
        case HttpServletResponse.SC_CONFLICT:
            return "Conflict";
        case HttpServletResponse.SC_CONTINUE:
            return "Continue";
        case HttpServletResponse.SC_CREATED:
            return "Created";
        case HttpServletResponse.SC_EXPECTATION_FAILED:
            return "Expectation Failed";
        case HttpServletResponse.SC_FORBIDDEN:
            return "Forbidden";
        case HttpServletResponse.SC_GATEWAY_TIMEOUT:
            return "Gateway Timeout";
        case HttpServletResponse.SC_GONE:
            return "Gone";
        case HttpServletResponse.SC_HTTP_VERSION_NOT_SUPPORTED:
            return "HTTP Version Not Supported";
        case HttpServletResponse.SC_INTERNAL_SERVER_ERROR:
            return "Internal Server Error";
        case HttpServletResponse.SC_LENGTH_REQUIRED:
            return "Length Required";
        case HttpServletResponse.SC_METHOD_NOT_ALLOWED:
            return "Method Not Allowed";
        case HttpServletResponse.SC_MOVED_PERMANENTLY:
            return "Moved Permanently";
        case HttpServletResponse.SC_MOVED_TEMPORARILY:
            return "Moved Temporarily";
        case HttpServletResponse.SC_MULTIPLE_CHOICES:
            return "Multiple Choices";
        case HttpServletResponse.SC_NO_CONTENT:
            return "No Content";
        case HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION:
            return "Non-Authoritative Information";
        case HttpServletResponse.SC_NOT_ACCEPTABLE:
            return "Not Acceptable";
        case HttpServletResponse.SC_NOT_FOUND:
            return "Not Found";
        case HttpServletResponse.SC_NOT_IMPLEMENTED:
            return "Not Implemented";
        case HttpServletResponse.SC_NOT_MODIFIED:
            return "Not Modified";
        case HttpServletResponse.SC_PARTIAL_CONTENT:
            return "Partial Content";
        case HttpServletResponse.SC_PAYMENT_REQUIRED:
            return "Payment Required";
        case HttpServletResponse.SC_PRECONDITION_FAILED:
            return "Precondition Failed";
        case HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED:
            return "Proxy Authentication Required";
        case HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE:
            return "Request Entity Too Large";
        case HttpServletResponse.SC_REQUEST_TIMEOUT:
            return "Request Timeout";
        case HttpServletResponse.SC_REQUEST_URI_TOO_LONG:
            return "Request URI Too Long";
        case HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE:
            return "Requested Range Not Satisfiable";
        case HttpServletResponse.SC_RESET_CONTENT:
            return "Reset Content";
        case HttpServletResponse.SC_SEE_OTHER:
            return "See Other";
        case HttpServletResponse.SC_SERVICE_UNAVAILABLE:
            return "Service Unavailable";
        case HttpServletResponse.SC_SWITCHING_PROTOCOLS:
            return "Switching Protocols";
        case HttpServletResponse.SC_UNAUTHORIZED:
            return "Unauthorized";
        case HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE:
            return "Unsupported Media Type";
        case HttpServletResponse.SC_USE_PROXY:
            return "Use Proxy";
        case 207:
            return "Multi-Status";
        case 422:
            return "Unprocessable Entity";
        case 423:
            return "Locked";
        case 507:
            return "Insufficient Storage";
        default:
            return "HTTP Response Status " + status;
    }
}

private void process(Context context, HttpServletRequest request, HttpServletResponse response, DSpaceObject scope) {
    DiscoverQuery queryArgs = DiscoverUtility.getTagCloudDiscoverQuery(context, request, scope, true);
    queryArgs.setMaxResults(0);
    DiscoverResult qResults;
    try {
        qResults = SearchUtils.getSearchService().search(context, scope, queryArgs);
        request.setAttribute("tagcloud.fresults", qResults.getFacetResults());
        DiscoveryConfiguration discoveryConfiguration = SearchUtils.getDiscoveryConfiguration(scope);
        List<DiscoverySearchFilterFacet> availableFacet = discoveryConfiguration.getTagCloudFacetConfiguration().getTagCloudFacets();
        request.setAttribute("tagCloudFacetsConfig", availableFacet != null ? availableFacet : new ArrayList<DiscoverySearchFilterFacet>());
        TagCloudConfiguration tagCloudConfiguration = discoveryConfiguration.getTagCloudFacetConfiguration().getTagCloudConfiguration();
        request.setAttribute("tagCloudConfig", tagCloudConfiguration);
        if (scope != null) {
            request.setAttribute("tagcloud.searchScope", "/handle/" + scope.getHandle());
        }
    } catch (SearchServiceException e) {
        log.error(LogManager.getHeader(context, "tagcloud-process", "scope=" + scope));
    }
}

/* (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;
}

@Override
protected void sendRedirect(HttpServletRequest request, HttpServletResponse response, String targetUrl, boolean http10Compatible) throws IOException {
    if (http10Compatible) {
        // Send status code 302 by default.
        response.sendRedirect(targetUrl);
    } else {
        HttpStatus statusCode = getHttp11StatusCode(request, response, targetUrl);
        response.setStatus(statusCode.value());
        response.setHeader("Location", targetUrl);
    }
}

/*
	 *  (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"));
    }
}

/**
	 * 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());
}

/**
     * @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;
}

/* (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());
}

@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 doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse response = (HttpServletResponse) res;
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
    response.setHeader("Access-Control-Max-Age", "3600");
    response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
    chain.doFilter(req, res);
}

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 void execute(ActionInvocation ai) throws Exception {
    ImageAction action = (ImageAction) ai.getAction();
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setHeader("Cash", "no cash");
    response.setContentType(action.getContentType());
    response.setContentLength(action.getContentLength());
    response.getOutputStream().write(action.getImageBytes());
    response.getOutputStream().flush();
}

@Override
public void render(HttpServletResponse response) throws Exception {
    try {
        StringBuilder b = new StringBuilder();
        b.append(html);
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        response.setStatus(200);
        response.getWriter().print(b.toString());
    } catch (Exception e) {
        throw new WebDriverException(e);
    }
}

public void testCacheStrategyAction() {
    HttpServletResponse response = new MockHttpServletResponse();
    Context.setResponse(response);
    CacheStrategyAction cacheStrategyAction = new CacheStrategyAction();
    cacheStrategyAction.getAllCacheStrategy4Tree();
    cacheStrategyAction.setCode("threadpool");
    cacheStrategyAction.getCacheStrategyInfo();
    cacheStrategyAction.setCode(CacheConstants.XFORM_TEMPLATE_POOL);
    cacheStrategyAction.setKey("template/cache/xform/CacheStrategyXForm.xml");
    cacheStrategyAction.viewCachedItem();
}

@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);
    }
}

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);
}

public void execute(ActionInvocation invocation) throws Exception {
    LatestVersionSource source = (LatestVersionSource) invocation.getAction();
    double latestVersion = source.getLatestVersion();
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setContentType("text/xml");
    OutputStream out = response.getOutputStream();
    out.write(String.valueOf(latestVersion).getBytes());
    out.close();
}

@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 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 execute() throws Exception {
    Page<Tag> page = getDomain().getTagRepository().orderByName(this.pageSize, this.pi);
    HttpServletResponse response = getContext().getResponse();
    response.setContentType(JsonUtils.CONTENT_TYPE);
    PrintWriter out = response.getWriter();
    out.println("[");
    JsonUtils.printPageInfo(page, out);
    out.println(",");
    JsonUtils.printTags(page, null, out);
    out.println("]");
    response.flushBuffer();
}

@Test
public void return404ForInvalidDocumentIds() throws Exception {
    ServletRequestForTest request = new ServletRequestForTest("");
    request.setPathInfo("bogus");
    HttpServletResponse response = mock(HttpServletResponse.class);
    new DocumentStorageService(new ReadAllBytesFromInputStream(), new DocumentStorage(new DocumentIdGenerator()), new PathInfoToDocumentId()).doGet(request, response);
    verify(response).setStatus(404);
}

@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 void execute(ActionInvocation invocation) throws Exception {
    LatestVersionSource source = (LatestVersionSource) invocation.getAction();
    double latestVersion = source.getLatestVersion();
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setContentType("text/xml");
    OutputStream out = response.getOutputStream();
    out.write(String.valueOf(latestVersion).getBytes());
    out.close();
}

public void execute(ActionInvocation invocation) throws Exception {
    LatestVersionSource source = (LatestVersionSource) invocation.getAction();
    double latestVersion = source.getLatestVersion();
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setContentType("text/xml");
    OutputStream out = response.getOutputStream();
    out.write(String.valueOf(latestVersion).getBytes());
    out.close();
}

@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
    HttpServletResponse httpResponse = WebUtils.toHttp(response);
    httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    String jwt = TokenManager.extractToken(request);
    if (TokenManager.invalidate(jwt))
        httpResponse.setStatus(HttpServletResponse.SC_NO_CONTENT);
    return true;
}

@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);
    }
}

public static ModelAndView createFileView(File file, String sha) throws Exception {
    boolean hasChanged = isFileChanged(file, sha);
    if (!hasChanged) {
        return new ModelAndView(new AbstractView() {

            protected void renderMergedOutputModel(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {
                response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                response.getWriter().close();
            }
        });
    } else {
        HashMap model = new HashMap();
        if (file instanceof ZippedArtifact) {
            model.put(FileView.NEED_TO_ZIP, true);
        }
        model.put("targetFile", file);
        return new ModelAndView("fileView", model);
    }
}

/**
	 * @param servletResponse
	 * @throws IOException
	 */
public void writeTo(HttpServletResponse servletResponse) throws IOException {
    if (status != -1) {
        servletResponse.setStatus(status);
    }
    if (headers != null) {
        for (Entry<String, List<Object>> stringObjectEntry : headers.entrySet()) {
            String name = stringObjectEntry.getKey();
            List<Object> values = stringObjectEntry.getValue();
            for (Object value : values) {
                addHeader(name, value, servletResponse);
            }
        }
    }
    if (cookies != null) {
        for (Cookie cookie : cookies) {
            servletResponse.addCookie(cookie);
        }
    }
    if (locale != null) {
        servletResponse.setLocale(locale);
    }
    // got a buffered response; now write it
    servletResponse.setContentLength(byteBuffer.length);
    servletResponse.setContentType(contentType);
    final OutputStream out = servletResponse.getOutputStream();
    out.write(byteBuffer);
    out.close();
}

/**
	 * 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 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;
}

@Override
public final void doFilter(@Nonnull final ServletRequest req, @Nonnull final ServletResponse res) throws IOException, ServletException {
    if (this.index == -1) {
        final HttpServletRequest hReq = (HttpServletRequest) req;
        final HttpServletResponse hRes = (HttpServletResponse) res;
        // invoke security
        if (!servletHandler.getContext().handleSecurity(hReq, hRes)) {
            // status, we're going to override this and send an error instead.
            if (!res.isCommitted() && (hRes.getStatus() == SC_OK || hRes.getStatus() == 0)) {
                hRes.sendError(SC_FORBIDDEN);
            }
            // we're done
            return;
        }
    }
    this.index++;
    if (this.index < this.filterHandlers.length) {
        this.filterHandlers[this.index].handle(req, res, this);
    } else {
        // Last entry in the chain...
        this.servletHandler.handle(req, res);
    }
}

@Override
public void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
    try {
        String repo = ViewFilter.trimLeadingSlash(getRegexGroup(req, 1));
        try (Repository git = resolver.open(req, repo)) {
            req.setAttribute(ATTRIBUTE_REPOSITORY, git);
            chain.doFilter(req, res);
        } catch (RepositoryNotFoundException e) {
            chain.doFilter(req, res);
        } catch (ServiceMayNotContinueException e) {
            sendError(req, res, e.getStatusCode(), e.getMessage());
        } finally {
            req.removeAttribute(ATTRIBUTE_REPOSITORY);
        }
    } catch (ServiceNotEnabledException e) {
        sendError(req, res, SC_FORBIDDEN);
    } catch (ServiceNotAuthorizedException e) {
        res.sendError(SC_UNAUTHORIZED);
    }
}

/**
     * Override the parent's commence so that the returned status is not
     * 403.
     */
@Override
public void commence(ServletRequest request, ServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse rsp = (HttpServletResponse) response;
    String requestedWith = req.getHeader("X-Requested-With");
    if ("XMLHttpRequest".equals(requestedWith)) {
        // container authentication normally relies on session attribute to
        // remember where the user came from, so concurrent AJAX requests
        // often ends up sending users back to AJAX pages after successful login.
        // this is not desirable, so don't redirect AJAX requests to the user.
        // this header value is sent from Prototype.
        rsp.sendError(SC_FORBIDDEN);
    } else {
        // give the opportunity to include the target URL
        String loginForm = req.getContextPath() + getLoginFormUrl();
        loginForm = MessageFormat.format(loginForm, URLEncoder.encode(req.getRequestURI(), "UTF-8"));
        req.setAttribute("loginForm", loginForm);
        rsp.setStatus(SC_OK);
        rsp.setContentType("text/html;charset=UTF-8");
        PrintWriter out;
        try {
            ServletOutputStream sout = rsp.getOutputStream();
            out = new PrintWriter(new OutputStreamWriter(sout));
        } catch (IllegalStateException e) {
            out = rsp.getWriter();
        }
        out.printf("<html><head>" + "<meta http-equiv='refresh' content='1;url=%1$s'/>" + "<script>window.location.replace('%1$s');</script>" + "</head>" + "<body style='background-color:white; color:white;'>" + "Authentication required</body></html>", loginForm);
        out.flush();
    }
}

@SuppressWarnings("unchecked")
public void render(Map model, HttpServletRequest request, HttpServletResponse response) throws IOException {
    TupleQueryResultWriterFactory qrWriterFactory = (TupleQueryResultWriterFactory) model.get(FACTORY_KEY);
    TupleQueryResultFormat qrFormat = qrWriterFactory.getTupleQueryResultFormat();
    response.setStatus(SC_OK);
    setContentType(response, qrFormat);
    setContentDisposition(model, response, qrFormat);
    OutputStream out = response.getOutputStream();
    try {
        TupleQueryResultWriter qrWriter = qrWriterFactory.getWriter(out);
        TupleQueryResult tupleQueryResult = (TupleQueryResult) model.get(QUERY_RESULT_KEY);
        QueryResultUtil.report(tupleQueryResult, qrWriter);
    } catch (QueryEvaluationException e) {
        logger.error("Query evaluation error", e);
        response.sendError(SC_INTERNAL_SERVER_ERROR, "Query evaluation error: " + e.getMessage());
    } catch (TupleQueryResultHandlerException e) {
        logger.error("Serialization error", e);
        response.sendError(SC_INTERNAL_SERVER_ERROR, "Serialization error: " + e.getMessage());
    } finally {
        out.close();
    }
}

public static void executeFirst(general body, Hashtable _tagLibrary, Hashtable _beanLibrary) {
    try {
        Boolean included = (Boolean) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_SYSTEM_Included)).getContent());
        Boolean noGenerate = (Boolean) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_SYSTEM_NOGENERATE)).getContent());
        if (included != null && included.booleanValue() == true) {
        } else {
            if (body.getSOURCE_DOCUMENT() == null)
                body.setSOURCE_DOCUMENT("");
            javax.servlet.http.HttpServletResponse response = null;
            try {
                response = (javax.servlet.http.HttpServletResponse) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_SYSTEM_Response)).getContent());
            } catch (Exception e) {
            }
            if (body.getORIENTATION() != null && body.getORIENTATION().trim().equalsIgnoreCase("LANDSCAPE"))
                body.setDocument(new Document(PageSize.A4.rotate()));
            else
                body.setDocument(new Document(PageSize.A4));
            try {
                int p1 = 30;
                int p2 = 30;
                int p3 = 30;
                int p4 = 30;
                java.util.StringTokenizer st = new java.util.StringTokenizer(body.getMARGINS(), ",");
                p1 = Integer.valueOf(st.nextToken()).intValue();
                p2 = Integer.valueOf(st.nextToken()).intValue();
                p3 = Integer.valueOf(st.nextToken()).intValue();
                p4 = Integer.valueOf(st.nextToken()).intValue();
                body.getDocument().setMargins(p1, p2, p3, p4);
            } catch (Exception e) {
                body.getDocument().setMargins(30, 30, 30, 30);
            }
            if (body.getTYPE_DOCUMENT() != null && body.getTYPE_DOCUMENT().trim().equalsIgnoreCase("FIXED") && !body.getSOURCE_DOCUMENT().equals("")) {
                //					body.setWriter(PdfWriter.getInstance(body.getDocument(), new java.io.FileOutputStream(body.getSOURCE_DOCUMENT())));
                if (!body.getSOURCE_BEFORE_FIXED().equals("")) {
                    try {
                        javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_SYSTEM_Request)).getContent());
                        if (body.motore != null && ((OutputRunTime) body.motore).getAnotherServletConfig() != null)
                            ((OutputRunTime) body.motore).getAnotherServletConfig().getServletContext().getRequestDispatcher(body.getSOURCE_BEFORE_FIXED()).include(request, response);
                    } catch (Exception e) {
                        e.toString();
                    }
                }
            }
            if (body.getTYPE_DOCUMENT() != null && !body.getTYPE_DOCUMENT().trim().equalsIgnoreCase("FIXED") && !body.getSOURCE_DOCUMENT().equals("")) {
                //					body.setWriter(PdfWriter.getInstance(body.getDocument(), new java.io.FileOutputStream(body.getSOURCE_DOCUMENT())));
                if (!body.getSOURCE_BEFORE_FIXED().equals("")) {
                    try {
                        javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_SYSTEM_Request)).getContent());
                        if (body.motore != null && ((OutputRunTime) body.motore).getAnotherServletConfig() != null)
                            ((OutputRunTime) body.motore).getAnotherServletConfig().getServletContext().getRequestDispatcher(body.getSOURCE_BEFORE_FIXED()).include(request, response);
                    } catch (Exception e) {
                        e.toString();
                    }
                }
            }
            if (response != null) {
                if (body.getTYPE_DOCUMENT() != null && body.getTYPE_DOCUMENT().trim().equalsIgnoreCase("ATTACHMENT") && body.getSOURCE_DOCUMENT().equals("")) {
                    response.setHeader("Content-Disposition", "attachment; filename=" + body.ID + ".pdf");
                    response.setHeader("Content-Transfer-Encoding", "base64");
                    response.setContentType("Application/pdf");
                    if (!noGenerate.booleanValue())
                        body.setWriter(PdfWriter.getInstance(body.getDocument(), response.getOutputStream()));
                }
                if (body.getTYPE_DOCUMENT() != null && body.getTYPE_DOCUMENT().trim().equalsIgnoreCase("STREAM") && body.getSOURCE_DOCUMENT().equals("")) {
                    response.setHeader("Content-Type", "Application/pdf");
                    if (!noGenerate.booleanValue())
                        body.setWriter(PdfWriter.getInstance(body.getDocument(), response.getOutputStream()));
                }
            } else {
                if (_beanLibrary.get("SYSTEM:" + iConst.iHORT_INPUT_$external_output_stream) != null)
                    if (!noGenerate.booleanValue())
                        body.setWriter(PdfWriter.getInstance(body.getDocument(), (OutputStream) (((report_element_base) _beanLibrary.get("SYSTEM:" + iConst.iHORT_INPUT_$external_output_stream)).getContent())));
            }
            if (body.getWriter() != null) {
                body._beanLibrary = _beanLibrary;
                general.PageEvent_0 pev = body.new PageEvent_0();
                body.getWriter().setPageEvent(pev);
                if (!body.getDIRECTION().equals("") && body.getDIRECTION().equalsIgnoreCase("RTL")) {
                    body.getWriter().setRunDirection(PdfWriter.RUN_DIRECTION_RTL);
                }
            }
            bean _sysDocument = new bean();
            _sysDocument.setContent(body.getDocument());
            _sysDocument.setName("SYSTEM");
            _sysDocument.setID(iConst.iHORT_SYSTEM_Document);
            _beanLibrary.put(_sysDocument.getName() + ":" + _sysDocument.getID(), _sysDocument);
            bean _sysPdfWriter = new bean();
            _sysPdfWriter.setContent(body.getWriter());
            _sysPdfWriter.setName("SYSTEM");
            _sysPdfWriter.setID(iConst.iHORT_SYSTEM_Writer);
            _beanLibrary.put(_sysPdfWriter.getName() + ":" + _sysPdfWriter.getID(), _sysPdfWriter);
            bean _sysPdfPN = new bean();
            _sysPdfPN.setContent(new Integer("0"));
            _sysPdfPN.setName("SYSTEM");
            _sysPdfPN.setID(iConst.iHORT_SYSTEM_Document_PageNumber);
            _beanLibrary.put(_sysPdfPN.getName() + ":" + _sysPdfPN.getID(), _sysPdfPN);
        }
    } catch (Exception e) {
        body.setError(e);
    }
}

/*
	 * (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);
    }
}

/* (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);
}

@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);
}

@Override
public void load(final DocumentHTML document, final HttpServletRequest request, final HttpServletResponse response) throws Exception {
    document.focusInFirstActivateField(null);
    final Connection connection = ConnectionProvider.getConnection(Constantes.getValue("DATABASE_ALIAS"));
    final DatabaseMetaData meta = connection.getMetaData();
    request.setAttribute("versao_driver_jdbc", meta.getDriverVersion());
    connection.close();
}

@Override
public void execute(final ActionInvocation invocation) throws Exception {
    ImageAction action = (ImageAction) invocation.getAction();
    HttpServletResponse response = ServletActionContext.getResponse();
    response.setContentType(action.getCustomContentType());
    response.getOutputStream().write(action.getCustomImageInBytes());
    response.getOutputStream().flush();
}

private void addHeadersFor200Response(HttpServletResponse response) {
    response.addHeader("Access-Control-Allow-Origin", "*");
    response.addHeader("Access-Control-Allow-Methods", "*, Cache-Control, Pragma, Origin, Authorization, X-Requested-With, PUT, DELETE");
    response.addHeader("Access-Control-Allow-Headers", "*, Content-Type, GET, OPTIONS, X-XSRF-TOKEN");
}

private void addHeadersFor200Response(HttpServletResponse response) {
    response.addHeader("Access-Control-Allow-Origin", "*");
    response.addHeader("Access-Control-Allow-Methods", "*, Cache-Control, Pragma, Origin, Authorization, X-Requested-With, PUT, DELETE");
    response.addHeader("Access-Control-Allow-Headers", "*, Content-Type, GET, OPTIONS, X-XSRF-TOKEN");
}

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());
    }
}

@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 SemanticURLHandler getSemanticURLHandler() {
    return ( functionality,  request,  response,  chain) -> {
        String forwardUrl = "/" + functionality.getParent().getPath() + "/" + (functionality.getPath().startsWith("#") ? "" : functionality.getPath());
        RequestDispatcher requestDispatcher = request.getRequestDispatcher(forwardUrl);
        if (requestDispatcher != null) {
            requestDispatcher.forward(request, response);
        } else {
            response.sendError(HttpServletResponse.SC_NOT_FOUND, "No forward url could be processed");
        }
    };
}

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);
    }
}

/* (non-Javadoc)
     * @see org.broadleafcommerce.profile.web.CookieUtils#setCookieValue(javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String, java.lang.Integer)
     */
public void setCookieValue(HttpServletResponse response, String cookieName, String cookieValue, String path, Integer maxAge, Boolean isSecure) {
    Cookie cookie = new Cookie(cookieName, cookieValue);
    cookie.setPath(path);
    if (maxAge != null) {
        cookie.setMaxAge(maxAge);
    }
    cookie.setSecure(isSecure);
    final StringBuffer sb = new StringBuffer();
    ServerCookie.appendCookieValue(sb, cookie.getVersion(), cookie.getName(), cookie.getValue(), cookie.getPath(), cookie.getDomain(), cookie.getComment(), cookie.getMaxAge(), cookie.getSecure(), true);
    //if we reached here, no exception, cookie is valid
    // the header name is Set-Cookie for both "old" and v.1 ( RFC2109 )
    // RFC2965 is not supported by browsers and the Servlet spec
    // asks for 2109.
    response.addHeader("Set-Cookie", sb.toString());
}

/* (non-Javadoc)
     * @see org.broadleafcommerce.profile.web.CookieUtils#setCookieValue(javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String, java.lang.Integer)
     */
public void setCookieValue(HttpServletResponse response, String cookieName, String cookieValue, String path, Integer maxAge, Boolean isSecure) {
    Cookie cookie = new Cookie(cookieName, cookieValue);
    cookie.setPath(path);
    if (maxAge != null) {
        cookie.setMaxAge(maxAge);
    }
    cookie.setSecure(isSecure);
    final StringBuffer sb = new StringBuffer();
    ServerCookie.appendCookieValue(sb, cookie.getVersion(), cookie.getName(), cookie.getValue(), cookie.getPath(), cookie.getDomain(), cookie.getComment(), cookie.getMaxAge(), cookie.getSecure(), true);
    //if we reached here, no exception, cookie is valid
    // the header name is Set-Cookie for both "old" and v.1 ( RFC2109 )
    // RFC2965 is not supported by browsers and the Servlet spec
    // asks for 2109.
    response.addHeader("Set-Cookie", sb.toString());
}

@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);
}

@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 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
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse httpResponse = (HttpServletResponse) response;
    httpResponse.addDateHeader("Expire", 0L);
    httpResponse.addHeader("Pragma", "no-cache");
    httpResponse.addHeader("Cache-Control", "no-cache, must-revalidate, post-check=0, pre-check=0");
    chain.doFilter(request, response);
}

@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() + ";", "]"));
            }
        }
    }
}

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse response = (HttpServletResponse) res;
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
    response.setHeader("Access-Control-Max-Age", "3600");
    response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
    chain.doFilter(req, res);
}

@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse response = (HttpServletResponse) res;
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
    response.setHeader("Access-Control-Max-Age", "3600");
    response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
    chain.doFilter(req, res);
}

public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    String[] lines = { "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "14", "15", "17", "20", "22", "23", "24" };
    Queue queue = QueueFactory.getDefaultQueue();
    for (String line : lines) {
        queue.add(url("/internal/readschedule?line=" + line).method(Method.GET));
    }
}

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    HttpServletResponse response = (HttpServletResponse) servletResponse;
    ServletContext context = request.getSession().getServletContext();
    RequestDispatcher dispatcher = context.getRequestDispatcher("/upgrade.jsp");
    dispatcher.forward(request, response);
}

protected void service(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException {
    httpServletResponse.getWriter().write("<center>\n");
    try {
        String name = this.getServletName();
        clearcut.Ini.app(name);
        injector = new clearcut.Injector();
        example.biz.IMember member = (example.biz.IMember) injector.implement("member");
        String memberName = member.name();
        String actorType = member.actorType();
        httpServletResponse.getWriter().write(name + "<br />" + actorType + " " + memberName + "\n");
    } catch (clearcut.InjectionException x) {
        httpServletResponse.getWriter().write(x.getMessage());
    }
    httpServletResponse.getWriter().write("</center>\n");
}

@Override
public void doFilter(ServletRequest req, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) req;
    if (request.getPathInfo().startsWith(CAMPAIGNS_ENTITIES_PATH) && !request.isUserInRole(AppRole.ANALYZER.getRoleName())) {
        ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_FORBIDDEN);
        return;
    }
    chain.doFilter(request, response);
}

@SuppressWarnings({ "unchecked" })
protected void renderMergedOutputModel(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {
    Map<String, String[]> params = (Map<String, String[]>) model.get("requestParams");
    HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapper(request, params);
    String path = (String) model.get("path");
    request.getRequestDispatcher(path).forward(wrappedRequest, response);
}

@Override
protected void myGet(HttpServletRequest request, HttpServletResponse response) {
    String projectName = getParameter(request, Constants.UrlParameters.PROJECT_NAME);
    List<NodeWithMonitorsInfo> nodes = nodesGetter.getNodes(projectName, Constants.ALL_VERSION);
    List<String> $ = Lists.newArrayList();
    for (NodeWithMonitorsInfo nodeWithMonitorsInfo : nodes) {
        $.add(nodeWithMonitorsInfo.alias());
    }
    writeResponseGzipJson($, request, response);
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    addResponseOptions(resp);
    PrintWriter out = resp.getWriter();
    out.println("CORS allow-origin: " + serverURL);
    String[] activeLanguages = CollaboroBackendFactory.getActiveLanguages();
    String languages = "";
    for (String language : activeLanguages) languages = languages + " " + language;
    out.println("Active languages: " + languages);
}

@Override
protected void doFilterInternal(final HttpServletRequest request, final HttpServletResponse response, final FilterChain filterChain) throws ServletException, IOException {
    final HttpServletRequest savedRequest = HttpServletUtils.getRequest();
    final HttpServletResponse savedResponse = HttpServletUtils.getResponse();
    try {
        HttpServletUtils.setRequestAndResponse(request, response);
        filterChain.doFilter(request, response);
    } finally {
        if (savedRequest == null) {
            HttpServletUtils.clearRequestAndResponse();
        } else {
            HttpServletUtils.setRequestAndResponse(savedRequest, savedResponse);
        }
    }
}

/* (non-Javadoc)
     * @see org.broadleafcommerce.profile.web.CookieUtils#setCookieValue(javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String, java.lang.Integer)
     */
public void setCookieValue(HttpServletResponse response, String cookieName, String cookieValue, String path, Integer maxAge, Boolean isSecure) {
    Cookie cookie = new Cookie(cookieName, cookieValue);
    cookie.setPath(path);
    if (maxAge != null) {
        cookie.setMaxAge(maxAge);
    }
    cookie.setSecure(isSecure);
    final StringBuffer sb = new StringBuffer();
    ServerCookie.appendCookieValue(sb, cookie.getVersion(), cookie.getName(), cookie.getValue(), cookie.getPath(), cookie.getDomain(), cookie.getComment(), cookie.getMaxAge(), cookie.getSecure(), true);
    //if we reached here, no exception, cookie is valid
    // the header name is Set-Cookie for both "old" and v.1 ( RFC2109 )
    // RFC2965 is not supported by browsers and the Servlet spec
    // asks for 2109.
    response.addHeader("Set-Cookie", sb.toString());
}

public static void writeJson(HttpServletResponse response, String json) {
    response.setContentType("text/plain;charset=UTF-8");
    //		response.setContentType("application/x-javascript");
    // response.setContentType("text/html;charset=UTF-8");
    // 没有缓存，立�返回�应
    response.setHeader("Cache-Control", "no-cache");
    PrintWriter out;
    try {
        out = response.getWriter();
        // �能用println
        out.print(json);
        // System.out.println("jsonArray ====== " + jsonArray);
        out.flush();
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
    response.setContentType(CommonConstant.APPLICATION_JSON);
    PrintWriter out = null;
    try {
        out = response.getWriter();
        Map<String, Object> json = ResponseUtil.jsonSucceed(null);
        out.append(JsonUtil.serialize(json));
    } finally {
        if (out != null) {
            out.close();
        }
    }
}

public static void writeData(Object data) {
    HttpServletResponse response = get();
    response.setCharacterEncoding("utf-8");
    try {
        if (data instanceof String || data instanceof StringBuffer || data instanceof StringBuilder) {
            response.getWriter().print(data.toString());
        } else {
            response.getWriter().print(JSON.toJSON(data));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public boolean performAction(HttpServletRequest req, HttpServletResponse res, ServletContext context) {
    try {
        HttpSession session = req.getSession();
        /** The navigator handles list behavior. Display a number of 
             * entries in a table. Not all at once.
             */
        Navigator nav = (Navigator) session.getAttribute("navigator");
        if (nav == null) {
            nav = new Navigator();
        }
        nav.setNavigator(req);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return true;
}

@Override
public void service(final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException {
    final String accept = request.getHeader("accept") == null ? "text" : request.getHeader("accept");
    if (accept.contains("html")) {
        request.setAttribute("page", "Feature Not Yet Implemented");
        forwardTo(request, response, "nyi.vm");
    } else {
        response.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, "Feature Not Yet Implemented");
    }
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest sRequest = (HttpServletRequest) request;
    HttpServletResponse sResponse = (HttpServletResponse) response;
    long now = System.currentTimeMillis();
    try {
        //chain.doFilter(request, wrapper);
        chain.doFilter(request, sResponse);
    } finally {
        sResponse.addHeader("X-Timing", Long.toString(System.currentTimeMillis() - now) + "-ms");
    }
}

@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) {
    try {
        if (request.getMethod().equals(getMethod().toString())) {
            String userName = request.getParameter("userName");
            String result = "userName:" + userName;
            System.out.println(result);
            response.setCharacterEncoding("UTF-8");
            response.getWriter().print(result);
            baseRequest.setHandled(true);
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
public String intercept(ActionInvocation invocation) throws Exception {
    ActionContext context = invocation.getInvocationContext();
    HttpServletResponse response = (HttpServletResponse) context.get(StrutsStatics.HTTP_RESPONSE);
    if (response != null) {
        response.setHeader("Cache-control", "no-cache, no-store");
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Expires", "-1");
    }
    return invocation.invoke();
}

@SuppressWarnings("unchecked")
public int doEndTag() throws JspException {
    if (value instanceof List) {
        value = JsonUtil.listToJson((List) value);
    } else if (value instanceof Map) {
        value = JsonUtil.mapToJson((Map) value);
    }
    WebWriter.jsonWriter((HttpServletResponse) pageContext.getResponse(), value.toString());
    return SKIP_PAGE;
}

public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    resp.setContentType("text/plain");
    resp.getWriter().println("Hello, world");
    FormDataExtractor extractor = new FormDataExtractor(req);
    extractor.extractFormData();
    // List<String[]> attributes = extractor.getFormAttributes();
    // for (String[] str : attributes) {
    // System.out.print(str[0] + "\t");
    // System.out.println(str[1]);
    // }
    List<FormImage> images = extractor.getFormImageData();
    for (FormImage image : images) {
        System.out.print(image.getAttributeName() + "\t");
        System.out.print(image.getFileName() + "\t");
        System.out.println(image.getEnd() - image.getStart());
    }
}

@Override
protected void processPath(String path, HttpServletRequest req, HttpServletResponse res) throws Exception {
    req.setAttribute("domain", path);
    Collection<Story> stories = di.getStoriesForDomain(path);
    if (stories.isEmpty()) {
        req.getRequestDispatcher("/nodomain.jsp").forward(req, res);
    } else {
        req.setAttribute("stories", stories);
        req.getRequestDispatcher("/domain.jsp").forward(req, res);
    }
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    if (modelAndView != null && ArrayUtils.isNotEmpty(request.getCookies())) {
        HashMap<String, Cookie> cookieMap = new HashMap<String, Cookie>();
        for (Cookie ck : request.getCookies()) {
            cookieMap.put(ck.getName(), ck);
        }
        modelAndView.addObject("cookieMap", cookieMap);
    }
    super.postHandle(request, response, handler, modelAndView);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse resp = (HttpServletResponse) response;
    if (custhttp != null) {
        for (String k : custhttp.keySet()) {
            String v = custhttp.getString(k);
            if (v != null) {
                resp.setHeader(k, v);
            }
        }
    }
    chain.doFilter(request, response);
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
    Employee user = (Employee) ((HttpServletRequest) request).getSession().getAttribute("CURRENT_USER");
    String path = ((HttpServletRequest) request).getServletPath();
    if (user == null && !path.equals("/login.ejf")) {
        ((HttpServletResponse) response).sendRedirect("login.html");
    } else
        filterChain.doFilter(request, response);
}

@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
    if (accessDeniedException instanceof InvalidCsrfTokenException || accessDeniedException instanceof MissingCsrfTokenException) {
        new DefaultRedirectStrategy().sendRedirect(request, response, "/editar/autenticar?sessao");
    }
    super.handle(request, response, accessDeniedException);
}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    PrintWriter writer = response.getWriter();
    for (Enumeration e = request.getParameterNames(); e.hasMoreElements(); ) {
        String parameter = String.valueOf(e.nextElement());
        String[] values = request.getParameterValues(parameter);
        for (int i = 0; i < values.length; i++) {
            writer.write(parameter + "=" + values[i]);
            writer.write("\n");
        }
    }
    writer.close();
}

protected void onService(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    logger_.info("start processing...");
    String back = server_.processRequest(req, resp);
    if (back != null) {
        logger_.info("processing not null :" + back);
        PrintWriter out = resp.getWriter();
        if (back.startsWith("http")) {
            resp.setContentType("text/html");
            out.write("<html><body><a href='" + back + "' id='login'>Login</a></body></html>");
        } else {
            out.write(back);
        }
    }
}

@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
    if (isXmlHttpRequest(request) && e instanceof InsufficientAuthenticationException) {
        response.setContentType("application/json;charset=UTF-8");
        response.setStatus(401);
        response.getWriter().write("{\"loginMode\":\"SSO\"}");
        return;
    }
    super.commence(request, response, e);
}

@Override
public void execute(HttpServletRequest req, HttpServletResponse resp, ConfigService configService) throws IOException {
    try (InputStream is = configService.getPolicyText()) {
        resp.setContentType("text/plain");
        try (OutputStream os = resp.getOutputStream()) {
            byte[] buf = new byte[10 * 1024];
            int bytesRead = is.read(buf);
            while (bytesRead > 0) {
                os.write(buf, 0, bytesRead);
                bytesRead = is.read(buf);
            }
        }
    }
}