Example usage for javax.servlet.http HttpServletRequest setCharacterEncoding

Introduction

In this page you can find the example usage for javax.servlet.http HttpServletRequest setCharacterEncoding.

Prototype

public void setCharacterEncoding(String env) throws UnsupportedEncodingException;

Source Link

Document

Overrides the name of the character encoding used in the body of this request.

Usage

From source file:org.opencms.workplace.CmsWorkplaceManager.java

/**
 * @see org.opencms.i18n.I_CmsLocaleHandler#getI18nInfo(javax.servlet.http.HttpServletRequest, org.opencms.file.CmsUser, org.opencms.file.CmsProject, java.lang.String)
 *///from ww w . jav  a 2s .c o m
public CmsI18nInfo getI18nInfo(HttpServletRequest req, CmsUser user, CmsProject project, String resource) {

    Locale locale = null;
    // try to read locale from session
    if (req != null) {
        // set the request character encoding
        try {
            req.setCharacterEncoding(m_encoding);
        } catch (UnsupportedEncodingException e) {
            // should not ever really happen
            LOG.error(Messages.get().getBundle().key(Messages.LOG_UNSUPPORTED_ENCODING_SET_1, m_encoding), e);
        }
        // read workplace settings
        HttpSession session = req.getSession(false);
        if (session != null) {
            CmsWorkplaceSettings settings = (CmsWorkplaceSettings) session
                    .getAttribute(CmsWorkplaceManager.SESSION_WORKPLACE_SETTINGS);
            if (settings != null) {
                locale = settings.getUserSettings().getLocale();
            }
        }
    }

    if (locale == null) {
        // no session available, try to read the locale form the user additional info
        if (!user.isGuestUser()) {
            // check user settings only for "real" users
            CmsUserSettings settings = new CmsUserSettings(user);
            locale = settings.getLocale();

        }
        if (req != null) {
            List<Locale> acceptedLocales = (new CmsAcceptLanguageHeaderParser(req, getDefaultLocale()))
                    .getAcceptedLocales();
            if ((locale != null) && (!acceptedLocales.contains(locale))) {
                acceptedLocales.add(0, locale);
            }
            locale = OpenCms.getLocaleManager().getFirstMatchingLocale(acceptedLocales, m_locales);
        }

        // if no locale was found, use the default
        if (locale == null) {
            locale = getDefaultLocale();
        }
    }

    return new CmsI18nInfo(locale, m_encoding);
}

---

From source file:org.eclipse.birt.report.utility.ParameterAccessor.java

/**
 * Gets a named parameter from the http request. The given parameter name
 * must be in UTF-8.//  w w w  .  j a v  a 2s.  c  om
 * 
 * @param request
 *            incoming http request
 * @param parameterName
 *            parameter name
 * @return
 */

public static String getParameter(HttpServletRequest request, String parameterName) {

    if (request.getCharacterEncoding() == null) {
        try {
            request.setCharacterEncoding(UTF_8_ENCODE);
        } catch (UnsupportedEncodingException e) {
        }
    }
    return request.getParameter(parameterName);
}

---

From source file:Controlador.Contr_Help.java

/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.//www .jav a  2  s .  c  o  m
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    /*Se detalla el contenido que tendra el servlet*/
    response.setContentType("text/html;charset=UTF-8");
    request.setCharacterEncoding("UTF-8");

    /*Se declaran las variables necesarias*/
    PrintWriter out = response.getWriter();
    try {
        /*Se evelua la peticion que se realizo al servidor*/
        if (request.getParameter("accion").equals("vermas")) {
            /*Si se realiza la peticion de ver mas comentarios*/
            /*Se declaran las variables necesarias*/
            Cls_Satisfaccion sat = new Cls_Satisfaccion();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos del metodo de modelo de los comentarios, se le pone un
             limite y una cantidad para solo traer los datos que faltan*/
            String[][] Datos = sat.BuscarComentariosEvento(request.getParameter("codigoevento"),
                    Integer.parseInt(request.getParameter("limite")),
                    Integer.parseInt(request.getParameter("cantidad")));
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("usuario", row[0]);
                ob.put("empresa", row[1]);
                ob.put("comentario", row[2]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprimen los datos*/
            out.println(obj);
        } else if (request.getParameter("accion").equals("total")) {
            /*Si se realiza la peticion de total de  comentarios*/
            /*Se declaran las variables necesarias*/
            Cls_Satisfaccion sat = new Cls_Satisfaccion();
            /*Se obtiene el total de comentarios de un evento, del metodo de modelo*/
            int row = sat.getCantidadComentariosEvento(request.getParameter("codigoevento"));
            /*Se imprime el resultado*/
            out.println(row);
        } else if (request.getParameter("accion").equals("totalevento")) {
            /*Si se realiza la peticion de total de eventos*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();

            /*Se obtiene el todal de comentarios de un evento, del metodo de modelo*/
            int row = eve.CantidadRegistroEvento();
            /*Se imprime el resultado*/
            out.println(row - 1);

        } else if (request.getParameter("accion").equals("totaleventorecomendado")) {
            /*Si se realiza la peticion de total de eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            String codigoUsuario = request.getParameter("idusuario");
            int row = eve.getcantidadeventosRecomendados(codigoUsuario);
            /*Se imprime el resultado*/
            out.println(row);
        } else if (request.getParameter("accion").equals("getciudad")) {
            /*Si se realiza la peticion de ver todas las ciudades*/
            /*Se declaran las variables necesarias*/
            Cls_Ciudad ciu = new Cls_Ciudad();
            JSONObject obj = new JSONObject();
            /*Se obtiene los datos de la ciudad, del metodo de modelo*/
            String[][] Datos = ciu.BuscarDatosCiudadTodos(request.getParameter("codigodepartamento"));

            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("ciudad", row[1]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.println(obj);
        } else if (request.getParameter("accion").equals("getdepartamentos")) {
            /*Si se realiza la peticion de ver todos los departamentos*/
            /*Se declaran las variables necesarias*/
            Cls_Departamento dep = new Cls_Departamento();
            JSONObject obj = new JSONObject();
            /*Se obtiene los datos de los departamentos, del metodo de modelo*/
            String[][] Datos = dep.BuscarDatosDepartamentoTodos();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("departamento", row[1]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.println(obj);
        } else if (request.getParameter("accion").equals("getciudades")) {
            /*Si se realiza la peticion de ver todos los datos de la ciudad*/
            /*Se declaran las variables necesarias*/
            Cls_Ciudad ciu = new Cls_Ciudad();
            JSONObject obj = new JSONObject();
            /*Se obtiene los datos de la ciudad, del metodo de modelo*/
            String[][] Datos = ciu.BuscarDatosCiudadTodos();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("ciudad", row[1]);
                ob.put("iddepto", row[2]);
                ob.put("nomdepto", row[3]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.println(obj);
        } else if (request.getParameter("accion").equals("aprobarevento")) {
            /*Si se realiza la peticion de aprobar un evento*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            Cls_Mensajeria sms = new Cls_Mensajeria();
            JSONObject obj = new JSONObject();
            JSONObject ob = new JSONObject();
            String Codigo = request.getParameter("codigoevento");
            /*Se cambia el estado del evento, en el metodo de modelo*/
            boolean b = eve.setCambioEstadoEvento(Codigo, "Aprobado");
            if (b) {
                String[] Datos = eve.BuscarEventoParaMensaje(Codigo);
                if (sms.EnviarMensajeCambioEstadoEvento(Datos, "Aprobado")) {
                    /*Se encodifican los datos en JSON*/
                    ob.put("mensaje", "Se aprob el evento satisfactoriamente.");
                    ob.put("tipomensaje", "Dio");
                } else {
                    /*Se encodifican los datos en JSON*/
                    ob.put("mensaje",
                            "Se aprob el evento, pero no se logr enviar la notificacin al correo electrnico de la empresa.");
                    ob.put("tipomensaje", "NODio");
                }
            } else {
                ob.put("mensaje",
                        "Ocurri un error al agregar el gusto a su cuenta. Estamos trabajando para solucionar este problema.");
                ob.put("tipomensaje", "NODio");
            }
            obj.put("1", ob);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("geteventospendientes")) {
            /*Si se realiza la peticion de obtener los datos de los eventos pendientes*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos del evento, en el metodo de modelo*/
            String[][] Datos = eve.BuscarDatosPrincipalesEventosPendientes();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("creador", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("hora", row[5]);
                ob.put("image", row[0] + row[6]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getmiseventos")) {
            /*Si se realiza la peticion de ver todos los eventos de una empresa*/
            /*Se declaran las variables necesarias*/
            String nit = request.getParameter("nit");
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de los eventos de una empresa, en el metodo de modelo*/
            String[][] Datos = eve.BuscarDatosMisEventos(nit);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("creador", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("estado", row[5]);
                ob.put("hora", row[6]);
                ob.put("image", row[0] + row[7]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getmiseventostodos")) {
            /*Si se realiza la peticion de obtener todos los datos de los eventos propios*/
            /*Se declaran las variables necesarias*/
            String nit = request.getParameter("nit");
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            String[][] Datos = eve.BuscarDatosTodosEventos();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("creador", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("estado", row[5]);
                ob.put("hora", row[6]);
                ob.put("image", row[0] + row[7]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("agregargusto")) {
            /*Si se realiza la peticion de agregar un gusto*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            String Codigo = request.getParameter("codigo");
            String CodigoUsuario = request.getParameter("idusuario");
            boolean b;
            /*Se agrega el gusto, en el metodo de modelo*/
            b = sel.AddGusto(Codigo, CodigoUsuario);
            if (b) {
                /*Se encodifican los datos en JSON*/
                obj.put("1", "Se agreg el gusto satisfactoriamente.");
            } else {
                /*Se encodifican los datos en JSON*/
                obj.put("0",
                        "Ocurri un error al agregar el gusto de su cuenta. Estamos trabajando para solucionar este problema.");
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("removergusto")) {
            /*Si se realiza la peticion de remover un gusto*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            String Codigo = request.getParameter("codigo");
            String CodigoUsuario = request.getParameter("idusuario");
            boolean b;
            /*Se verifica que se pueda remover un gusto, en el metodo de modelo*/
            b = sel.CantidadGustosAmbientesPreRemove(Codigo, CodigoUsuario);
            if (b) {
                /*Se remueve el gusto, en el metodo de modelo*/
                b = sel.RemoveGusto(Codigo, CodigoUsuario);
                if (b) {
                    /*Se encodifican los datos en JSON*/
                    obj.put("1", "Se quit el gusto de tus gustos existosamente.");
                } else {
                    /*Se encodifican los datos en JSON*/
                    obj.put("0",
                            "Ocurri un error al remover el gusto de su cuenta. Estamos trabajando para solucionar este problema.");
                }
            } else {
                obj.put("0", sel.getMensaje());
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getgustosnuevos")) {
            /*Si se realiza la peticion de obtener los gustos nuevos*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de los gustos nuevos, en el metodo de modelo*/
            String[][] Datos = sel.getGustosNuevos(Codigo);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("tipo", row[2]);
                ob.put("image", row[0] + row[3]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getgustos")) {
            /*Si se realiza la peticion de obtener los gustos del usuario*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de los gustos de un usuario, en el metodo de modelo*/
            String[][] Datos = sel.getMisGustos(Codigo);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("tipo", row[2]);
                ob.put("image", row[0] + row[3]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getseleccion")) {
            /*Si se realiza la peticion de obtener los datos de la seleccion*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de la seleccion, en el metodo de modelo*/
            String[][] Datos = sel.getDatosSeleccion();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("tipo", row[2]);
                ob.put("estado", row[3]);
                ob.put("image", row[0] + row[4]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getclasificacion")) {
            /*Si se realiza la peticion de obtener la califiacion de un evento*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("idevento");
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de la clasificacion de un evento, en el metodo de modelo*/
            String Datos[][] = sel.getClasificacionEvento(Codigo);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("tipo", row[2]);
                ob.put("image", row[0] + row[3]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("getclasificacionnuevos")) {
            /*Si se realiza la peticion de obtener nuevos datos para la calificacion de un evento*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            String Codigo = request.getParameter("idevento");
            JSONObject obj = new JSONObject();
            /*Se obtienen los nuevos datos para la clasficicacion de un evento, en el metodo de modelo*/
            String[][] Datos = sel.getClasificacionNuevos(Codigo);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("tipo", row[2]);
                ob.put("image", row[0] + row[3]);
                obj.put(Integer.toString(i), ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("aprobarseleccion")) {
            /*Si se realiza la peticion de aprobar una seleccion*/
            /*Se declaran las variables necesarias*/
            JSONObject obj = new JSONObject();
            Cls_Seleccion sel = new Cls_Seleccion();
            String CodigoSeleccion = request.getParameter("idseleccion");
            boolean b;
            /*Se aprueba la seleccion, en el metodo de modelo*/
            b = sel.AprobarSeleccion(CodigoSeleccion);
            if (b) {
                obj.put("1", "Se aprob el gusto/ambiente satisfactoriamente.");
            } else {
                obj.put("0", sel.getMensaje());
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("desaprobarseleccion")) {
            /*Si se realiza la peticion de desaprobar una seleccion*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            String CodigoSeleccion = request.getParameter("idseleccion");
            /*Se verifica que los usuarios no tengan este gustos o ambientes seleccionado, en el metodo de modelo*/
            boolean b = sel.CantidadUsoAmbienteGusto(CodigoSeleccion);
            if (b) {
                /*Se desapruba la seleccion, en el metodo de modelo*/
                b = sel.DesaprobarSeleccion(CodigoSeleccion);
                if (b) {
                    /*Se encodifican los datos en JSON*/
                    obj.put("1", "El gusto o ambiente ha sido desaprobado satisfactoriamente.");
                } else {
                    /*Se encodifican los datos en JSON*/
                    obj.put("0", sel.getMensaje());
                }
            } else {
                obj.put("0",
                        "No se puede desaprobar, porque hay usuarios o eventos usando este ambiente o gusto.");
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("agregarclasificacion")) {
            /*Si se realiza la peticion de agregar una clasificacion a un evento*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            String CodigoSeleccion = request.getParameter("idseleccion");
            String CodigoEvento = request.getParameter("idevento");
            /*Se agrega la clasficacion de un evento, en el metodo de modelo*/
            boolean b = sel.AddClasificacionEvento(CodigoSeleccion, CodigoEvento);
            if (b) {
                /*Se encodifican los datos en JSON*/
                obj.put("1", "Se agreg el gusto/ambiente a la calificacin satisfactoriamente.");
                if (sel.ComprobarRegistroCompletoUSuario(CodigoEvento)) {
                    Cls_Evento eve = new Cls_Evento();
                    if (eve.setEstadoPendiente(CodigoEvento)) {
                        /*Se encodifican los datos en JSON*/
                        String mensaje = "Se han cumplido los requisitos mnimos para el registro y el evento est en la lista de espera por aprobacin.";
                        obj.put("1", mensaje);
                        obj.put("2", "true");
                    }
                }
            } else {
                /*Se encodifican los datos en JSON*/
                obj.put("1", sel.getMensaje());
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("comprobarregistroevento")) {
            /*Si se realiza la peticion de comprobar el registro de un evento*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            String CodigoEvento = request.getParameter("idevento");
            /*Se comprueba el registro de un evento, en el metodo de modelo*/
            boolean dato = sel.ComprobarRegistroCompletoUSuario(CodigoEvento);
            /*Se imprime el resultado*/
            out.print(dato);
        } else if (request.getParameter("accion").equals("eventodatosprincipales")) {
            /*Si se realiza la peticion de obtener todos los datos de los eventos principales*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            int limite = Integer.parseInt(request.getParameter("limite"));
            int cantidad = Integer.parseInt(request.getParameter("cantidad"));
            /*Se ontienen todos los datos de los eventos principales con limtie y cantidad, 
             en el metodo de modelo*/
            String[][] Datos = eve.BuscarDatosPrincipalesEventos(limite, cantidad);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("creador", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("hora", row[5]);
                ob.put("calificacion", row[6]);
                ob.put("comentario", row[7]);
                ob.put("image", row[0] + row[8]);
                obj.put(Integer.toString(i), ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("eventodatosrecomendados")) {
            /*Si se realiza la peticion de obtener los datos de los eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            int limite = Integer.parseInt(request.getParameter("limite"));
            int cantidad = Integer.parseInt(request.getParameter("cantidad"));
            String codigoUsuario = request.getParameter("idusuario");
            /*Se obtienen los datos de los eventos recomendados, en el metodo de modelo*/
            String[][] Datos = eve.geteventosRecomendados(codigoUsuario, limite, cantidad);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("creador", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("hora", row[5]);
                ob.put("calificacion", row[6]);
                ob.put("comentario", row[7]);
                ob.put("image", row[0] + row[8]);
                obj.put(Integer.toString(i), ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("ubicacioneventos")) {
            /*Si se realiza la peticion de obtener los datos de la ubicacion de los eventos*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de la ubicacion de los eventos, en el metodo de modelo*/
            String[][] Datos = eve.getubicacioneventos();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("latitud", row[2]);
                ob.put("longitud", row[3]);
                obj.put(Integer.toString(i), ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("datos_evento_detalle")) {
            /*Si se realiza la peticion de obtener los datos de la ubicacion de los eventos*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            String codigo = request.getParameter("idevento");
            JSONObject obj = new JSONObject();
            /*Se obtienen los datos de la ubicacion de los eventos, en el metodo de modelo*/
            String[] row = eve.BuscarDatosDetalladosEventos(codigo);
            /*Se encodifican los datos en JSON*/
            JSONObject ob = new JSONObject();

            ob.put("empresa", row[0]);
            ob.put("evento", row[1]);
            ob.put("rango", row[2]);
            ob.put("codigo_departamento", row[3]);
            ob.put("nombre_departamento", row[4]);
            ob.put("codigo_ciudad", row[5]);
            ob.put("nombre_ciudad", row[6]);
            ob.put("direccion", row[7]);
            ob.put("fecha", row[8]);
            ob.put("descripcion", row[9]);
            ob.put("hora", row[10]);
            ob.put("latitud", row[11]);
            ob.put("longitud", row[12]);
            ob.put("imagen", codigo + row[13]);

            obj.put(1, ob);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("eventos_destacados")) {
            Cls_Evento eve = new Cls_Evento();
            String Datos[][] = eve.BuscarDatosEventosDestacados();
            JSONObject obj = new JSONObject();
            int i = 0;
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("empresa", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("calificacion", row[5]);
                ob.put("hora", row[6]);
                ob.put("comentario", row[7]);
                ob.put("imagen", row[0] + row[8]);
                obj.put(i, ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("eventos_comentados")) {
            Cls_Evento eve = new Cls_Evento();
            String Datos[][] = eve.BuscarDatosEventosComentado();
            JSONObject obj = new JSONObject();
            int i = 0;
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("empresa", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("comentario", row[5]);
                ob.put("hora", row[6]);
                ob.put("calificacion", row[7]);
                ob.put("imagen", row[0] + row[8]);
                obj.put(i, ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("eventos_proximos")) {
            Cls_Evento eve = new Cls_Evento();
            String Datos[][] = eve.BuscarDatosEventosProximos();
            JSONObject obj = new JSONObject();
            int i = 0;
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("nombre", row[1]);
                ob.put("fecha", row[2]);
                ob.put("empresa", row[3]);
                ob.put("ciudad", row[4]);
                ob.put("comentario", row[7]);
                ob.put("hora", row[5]);
                ob.put("calificacion", row[6]);
                ob.put("imagen", row[0] + row[8]);
                obj.put(i, ob);
                i++;
            }
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("cantidad_evento_pendiente")) {
            Cls_Evento eve = new Cls_Evento();
            int Dato = eve.CantidadEventoPendiente();
            out.print(Dato);
        } else if (request.getParameter("accion").equals("ciudades_android")) {
            /*Si se realiza la peticion de ver todas las ciudades*/
            /*Se declaran las variables necesarias*/
            Cls_Ciudad ciu = new Cls_Ciudad();
            JSONArray list = new JSONArray();
            /*Se obtiene los datos de la ciudad, del metodo de modelo*/
            String[][] Datos = ciu.BuscarDatosCiudadTodos(request.getParameter("codigo_dept"));

            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("ciudad", row[1]);
                list.add(ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.println(list);
        } else if (request.getParameter("accion").equals("departamentos_android")) {
            /*Si se realiza la peticion de ver todos los departamentos*/
            /*Se declaran las variables necesarias*/
            Cls_Departamento dep = new Cls_Departamento();
            JSONArray list = new JSONArray();
            /*Se obtiene los datos de los departamentos, del metodo de modelo*/
            String[][] Datos = dep.BuscarDatosDepartamentoAndroid();
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                ob.put("codigo", row[0]);
                ob.put("departamento", row[1]);
                list.add(ob);

                i++;
            }
            /*Se imprime el resultado*/
            out.println(list);
        } else if (request.getParameter("accion").equals("gustos_nuevos_android")) {
            /*Si se realiza la peticion de obtener los gustos nuevos*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            int Cantidad = Integer.parseInt(request.getParameter("limite"));
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();
            BufferedImage img;

            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Seleccion");
            /*Se obtienen los datos de los gustos nuevos, en el metodo de modelo*/
            String[][] Datos = sel.getGustosNuevosAndroid(Codigo, Cantidad);
            int i = 0;
            try {
                /*Se encodifican los datos en JSON*/
                for (String row[] : Datos) {
                    JSONObject ob = new JSONObject();

                    img = ImageIO.read(new File(urlimgservidor + "/" + row[0] + row[3]));
                    String typeimg = row[3].substring(1, row[3].length());

                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    ImageIO.write(img, typeimg, bos);
                    byte[] imageBytes = bos.toByteArray();

                    BASE64Encoder encoder = new BASE64Encoder();
                    String imageSTring = encoder.encode(imageBytes);

                    bos.close();

                    ob.put("Codigo", row[0]);
                    ob.put("Nombre", row[1]);
                    ob.put("Tipo", row[2]);
                    ob.put("Imagen", imageSTring);
                    list.add(ob);

                    i++;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            obj.put("gustos", list);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("mis_gustos_android")) {

            /*Si se realiza la peticion de obtener los gustos del usuario*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            int Cantidad = Integer.parseInt(request.getParameter("cantidad"));
            Cls_Seleccion sel = new Cls_Seleccion();
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();

            BufferedImage img;

            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Seleccion");

            /*Se obtienen los datos de los gustos de un usuario, en el metodo de modelo*/
            String[][] Datos = sel.getMisGustosAndroid(Codigo, Cantidad);
            int i = 0;

            try {
                /*Se encodifican los datos en JSON*/
                for (String row[] : Datos) {

                    JSONObject ob = new JSONObject();

                    img = ImageIO.read(new File(urlimgservidor + "/" + row[0] + row[3]));
                    String typeimg = row[3].substring(1, row[3].length());

                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    ImageIO.write(img, typeimg, bos);
                    byte[] imageBytes = bos.toByteArray();

                    BASE64Encoder encoder = new BASE64Encoder();
                    String imageSTring = encoder.encode(imageBytes);

                    bos.close();

                    ob.put("Codigo", row[0]);
                    ob.put("Nombre", row[1]);
                    ob.put("Tipo", row[2]);
                    ob.put("Imagen", imageSTring);
                    list.add(ob);

                    i++;
                }
                obj.put("gustos", list);
                /*Se imprime el resultado*/
                out.print(obj);
            } catch (IOException e) {
                e.printStackTrace();
            }

        } else if (request.getParameter("accion").equals("cantidad_gustos_nuevos_android")) {
            /*Si se realiza la peticion de obtener la cantidad de gustos que puede tener el usuario*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            Cls_Seleccion sel = new Cls_Seleccion();
            /*Se obtienen los datos de la cantidad de gustos de un usuario, en el mtodo de modelo*/
            int Datos = sel.CantidadGustosNuevosAndroid(Codigo);
            /*Se imprime el resultado*/
            out.print(Datos);
        } else if (request.getParameter("accion").equals("cantidad_gustos_android")) {
            /*Si se realiza la peticion de obtener la cantidad de gustos del usuario*/
            /*Se declaran las variables necesarias*/
            String Codigo = request.getParameter("codigo");
            Cls_Seleccion sel = new Cls_Seleccion();
            /*Se obtienen los datos de la cantidad de gustos de un usuario, en el mtodo de modelo*/
            int Datos = sel.CantidadGustosAndroid(Codigo);
            /*Se imprime el resultado*/
            out.print(Datos);
        } else if (request.getParameter("accion").equals("agregar_gusto_android")) {
            /*Si se realiza la peticion de agregar un gusto*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            String Mensaje;
            String Codigo = request.getParameter("codigo");
            String CodigoUsuario = request.getParameter("codigousuario");
            boolean b;
            /*Se agrega el gusto, en el metodo de modelo*/
            b = sel.AddGusto(Codigo, CodigoUsuario);
            if (b) {
                /*Se encodifican los datos en JSON*/
                Mensaje = "Se agreg el gusto satisfactoriamente.";
            } else {
                /*Se encodifican los datos en JSON*/
                Mensaje = "Ocurri un error al agregar el gusto de su cuenta. Estamos trabajando para solucionar este problema.";
            }
            /*Se imprime el resultado*/
            out.print(Mensaje);
        } else if (request.getParameter("accion").equals("remover_gusto_android")) {
            /*Si se realiza la peticion de remover un gusto*/
            /*Se declaran las variables necesarias*/
            Cls_Seleccion sel = new Cls_Seleccion();
            String Mensaje;
            String Codigo = request.getParameter("codigo");
            String CodigoUsuario = request.getParameter("codigousuario");
            boolean b;
            /*Se verifica que se pueda remover un gusto, en el metodo de modelo*/
            b = sel.CantidadGustosAmbientesPreRemove(Codigo, CodigoUsuario);
            if (b) {
                /*Se remueve el gusto, en el metodo de modelo*/
                b = sel.RemoveGusto(Codigo, CodigoUsuario);
                if (b) {
                    /*Se encodifican los datos en JSON*/
                    Mensaje = "Se quit el gusto de tus gustos existosamente.";
                } else {
                    /*Se encodifican los datos en JSON*/
                    Mensaje = "Ocurri un error al remover el gusto de su cuenta. Estamos trabajando para solucionar este problema.";
                }
            } else {
                Mensaje = sel.getMensaje();
            }
            /*Se imprime el resultado*/
            out.print(Mensaje);
        } else if (request.getParameter("accion").equals("cantidad_eventos_recomendados_android")) {
            /*Si se realiza la peticion de total de eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            String codigoUsuario = request.getParameter("codigo");
            int row = eve.getcantidadeventosRecomendados(codigoUsuario);
            /*Se imprime el resultado*/
            out.println(row);
        } else if (request.getParameter("accion").equals("eventos_recomendados_android")) {
            /*Si se realiza la peticion de obtener los datos de los eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();
            int cantidad = Integer.parseInt(request.getParameter("cantidad"));
            String codigoUsuario = request.getParameter("codigo");

            BufferedImage img;

            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Evento");
            /*Se obtienen los datos de los eventos recomendados, en el metodo de modelo*/
            String[][] Datos = eve.geteventosRecomendadosAndroid(codigoUsuario, cantidad);
            int i = 0;
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                img = ImageIO.read(new File(urlimgservidor + "/" + row[0] + row[1]));
                String typeimg = row[1].substring(1, row[1].length());

                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ImageIO.write(img, typeimg, bos);
                byte[] imageBytes = bos.toByteArray();

                BASE64Encoder encoder = new BASE64Encoder();
                String imageSTring = encoder.encode(imageBytes);

                bos.close();
                ob.put("Codigo", row[0]);
                ob.put("Imagen", imageSTring);
                ob.put("Nombre", row[2]);
                ob.put("Fecha", row[3]);
                ob.put("NombreCiudad", row[4]);
                ob.put("NombreDepto", row[5]);
                list.add(ob);
                i++;
            }
            obj.put("eventos", list);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("cantidad_eventos_general_android")) {
            /*Si se realiza la peticion de total de eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            int row = eve.getcantidadeventosGeneralAndroid();
            /*Se imprime el resultado*/
            out.println(row);
        } else if (request.getParameter("accion").equals("eventos_general_android")) {
            /*Si se realiza la peticion de obtener los datos de los eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();
            int cantidad = Integer.parseInt(request.getParameter("cantidad"));

            BufferedImage img;

            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Evento");
            /*Se obtienen los datos de los eventos recomendados, en el metodo de modelo*/
            String[][] Datos = eve.geteventosGeneralAndroid(cantidad);
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                img = ImageIO.read(new File(urlimgservidor + "/" + row[0] + row[1]));
                String typeimg = row[1].substring(1, row[1].length());

                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ImageIO.write(img, typeimg, bos);
                byte[] imageBytes = bos.toByteArray();

                BASE64Encoder encoder = new BASE64Encoder();
                String imageSTring = encoder.encode(imageBytes);

                bos.close();
                ob.put("Codigo", row[0]);
                ob.put("Imagen", imageSTring);
                ob.put("Nombre", row[2]);
                ob.put("Fecha", row[3]);
                ob.put("NombreCiudad", row[4]);
                ob.put("NombreDepto", row[5]);
                list.add(ob);
            }
            obj.put("eventos", list);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("cantidad_mis_eventos_android")) {
            /*Si se realiza la peticion de total de eventos recomendados*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            String codigo = request.getParameter("codigo");
            int row = eve.getcantidadMisEventosAndroid(codigo);
            /*Se imprime el resultado*/
            out.println(row);
        } else if (request.getParameter("accion").equals("mis_eventos_android")) {
            /*Si se realiza la peticion de ver todos los eventos de una empresa*/
            /*Se declaran las variables necesarias*/
            String codigo = request.getParameter("codigo");
            int cantidad = Integer.parseInt(request.getParameter("cantidad"));
            Cls_Evento eve = new Cls_Evento();
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();
            /*Se obtienen los datos de los eventos de una empresa, en el metodo de modelo*/
            String[][] Datos = eve.BuscarDatosMisEventosAndroid(codigo, cantidad);
            int i = 0;
            BufferedImage img;

            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Evento");
            /*Se encodifican los datos en JSON*/
            for (String row[] : Datos) {
                JSONObject ob = new JSONObject();

                img = ImageIO.read(new File(urlimgservidor + "/" + row[0] + row[1]));
                String typeimg = row[1].substring(1, row[1].length());

                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ImageIO.write(img, typeimg, bos);
                byte[] imageBytes = bos.toByteArray();

                BASE64Encoder encoder = new BASE64Encoder();
                String imageSTring = encoder.encode(imageBytes);

                bos.close();
                ob.put("Codigo", row[0]);
                ob.put("Imagen", imageSTring);
                ob.put("Nombre", row[2]);
                ob.put("Fecha", row[3]);
                ob.put("NombreCiudad", row[4]);
                ob.put("NombreDepto", row[5]);
                list.add(ob);
                i++;
            }
            obj.put("eventos", list);
            /*Se imprime el resultado*/
            out.print(obj);
        } else if (request.getParameter("accion").equals("ubicacion_evento_android")) {
            Cls_Evento eve = new Cls_Evento();
            JSONObject ob = new JSONObject();
            String codigo = request.getParameter("codigo");

            String[] Dato = eve.getUbicacionAndroid(codigo);

            ob.put("Latitud", Dato[0]);
            ob.put("Longitud", Dato[1]);
            ob.put("Nombre", Dato[2]);

            out.print(ob);
        } else if (request.getParameter("accion").equals("datos_evento_detalle_android")) {
            /*Si se realiza la peticion de obtener los datos de la ubicacion de los eventos*/
            /*Se declaran las variables necesarias*/
            Cls_Evento eve = new Cls_Evento();
            String codigo = request.getParameter("idevento");
            JSONObject obj = new JSONObject();
            JSONArray list = new JSONArray();
            JSONObject ob = new JSONObject();
            BufferedImage img;
            String urlimgservidor = this.getServletContext().getRealPath("/Libs/Customs/images/Evento");

            /*Se obtienen los datos de la ubicacion de los eventos, en el metodo de modelo*/
            String[] row = eve.BuscarDatosDetalleEventoAndroid(codigo);

            img = ImageIO.read(new File(urlimgservidor + "/" + codigo + row[0]));
            String typeimg = row[0].substring(1, row[0].length());

            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ImageIO.write(img, typeimg, bos);
            byte[] imageBytes = bos.toByteArray();

            BASE64Encoder encoder = new BASE64Encoder();
            String imageSTring = encoder.encode(imageBytes);
            /*Se encodifican los datos en JSON*/
            ob.put("Imagen", imageSTring);
            ob.put("Fecha", row[1]);
            ob.put("NombreEvento", row[2]);
            ob.put("NombreEmpresa", row[3]);
            ob.put("NombreCiudad", row[5]);
            ob.put("NombreDepartamento", row[4]);
            ob.put("Direccion", row[6]);
            ob.put("Rango_Precios", row[7]);
            ob.put("Descripcion", row[8]);
            ob.put("Cinco", row[9]);
            ob.put("Cuatro", row[10]);
            ob.put("Tres", row[11]);
            ob.put("Dos", row[12]);
            ob.put("Uno", row[13]);
            list.add(ob);
            obj.put("eventos", list);
            /*Se imprime el resultado*/
            out.print(obj);
        } else {
            /*Si no se recibe alguna de las anteriores peticiones se retorna la vista de indece*/
            response.sendRedirect("View/index.jsp");
        }

    } finally {
        /*Se ciera todo*/
        out.close();
    }
}

---

From source file:com.glaf.core.util.ResponseUtils.java

public static void output(HttpServletRequest request, HttpServletResponse response, InputStream inputStream,
        String filename, String contentType) {
    BufferedInputStream bis = null;
    OutputStream outputStream = null;
    String contentDisposition = null;
    String fileOrgName = filename;

    filename = filename.trim();/*from ww w. j a v  a 2  s . c o  m*/
    String userAgent = request.getHeader("User-Agent");
    logger.debug("filename:" + filename);
    logger.debug("User-Agent:" + userAgent);
    try {
        if (userAgent != null) {
            if (userAgent.indexOf("MSIE") != -1) {
                filename = new String(filename.getBytes("GBK"), "ISO8859_1");
            } else {
                filename = new String(filename.getBytes("UTF-8"), "ISO8859_1");
            }
        } else {
            filename = new String(filename.getBytes("GBK"), "ISO8859_1");
        }

        if (userAgent != null) {
            if (userAgent.indexOf("MSIE 5.5") != -1) {
                contentDisposition = "attachment;filename=\"" + filename + "\"";
            } else if (userAgent.indexOf("MSIE 6.0b") != -1) {
                filename = new String(fileOrgName.getBytes("GBK"), "ISO8859_1");
                contentDisposition = "attachment;filename=\"" + filename + "\"";
            } else if (userAgent.indexOf("Gecko") != -1) {
                filename = new String(fileOrgName.getBytes("GBK"), "ISO8859_1");
                contentDisposition = "attachment;filename=\"" + filename + "\"";
            }
        }
        if (contentDisposition == null) {
            contentDisposition = "attachment;filename=\"" + filename + "\"";
        }

    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }

    logger.debug("convert filename:" + filename);
    logger.debug("content disposition:" + contentDisposition);

    response.setHeader("Content-Transfer-Encoding", "base64");
    response.setHeader("Content-Disposition", contentDisposition);
    if (contentType != null) {
        response.setContentType(contentType);
    } else {
        response.setContentType("application/octet-stream");
    }

    String encoding = request.getHeader("Accept-Encoding");

    if (encoding != null) {
        encoding = encoding.toLowerCase();
    }

    try {
        if (encoding != null && encoding.indexOf("gzip") != -1) {
            response.setHeader("Content-Encoding", "gzip");
            outputStream = new java.util.zip.GZIPOutputStream(response.getOutputStream());
        } else if (encoding != null && encoding.indexOf("compress") != -1) {
            response.setHeader("Content-Encoding", "compress");
            outputStream = new java.util.zip.ZipOutputStream(response.getOutputStream());
        } else {
            outputStream = response.getOutputStream();
        }
        request.setCharacterEncoding("UTF-8");
        bis = new BufferedInputStream(inputStream);
        int bytesRead = 0;
        byte[] buffer = new byte[256];
        while ((bytesRead = bis.read(buffer, 0, 256)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
        }
        outputStream.flush();
        outputStream.close();
        inputStream.close();
        bis.close();
        bis = null;
        inputStream = null;
        outputStream = null;

    } catch (Exception ex) {
        throw new RuntimeException(ex);
    } finally {
        try {
            if (bis != null) {
                bis.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        } catch (IOException ex) {
        }
    }
}

---

From source file:edu.slu.action.ObjectAction.java

/**
 * All actions come here to process the request body. We check if it is JSON.
 * DELETE is a special case because the content could be JSON or just the @id string and it only has to specify a content type if passing a JSONy object.  
 * and pretty format it. Returns pretty stringified JSON or fail to null.
 * Methods that call this should handle requestBody==null as unexpected.
 * @param http_request Incoming request to check.
 * @param supportStringID The request may be allowed to pass the @id as the body.
 * @return String of anticipated JSON format.
 * @throws java.io.IOException//  w  w  w  . j a va2 s. com
 * @throws javax.servlet.ServletException
 * @throws java.lang.Exception
 */
public String processRequestBody(HttpServletRequest http_request, boolean supportStringID)
        throws IOException, ServletException, Exception {
    String cType = http_request.getContentType();
    http_request.setCharacterEncoding("UTF-8");
    String requestBody;
    JSONObject complianceInfo = new JSONObject();
    /* UTF-8 special character support for requests */
    //http://biercoff.com/malformedinputexception-input-length-1-exception-solution-for-scala-and-java/
    ServletInputStream input = http_request.getInputStream();
    //CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();
    //decoder.onMalformedInput(CodingErrorAction.REPLACE);
    InputStreamReader reader = new InputStreamReader(input, "utf-8");
    //bodyReader = new BufferedReader( reader );
    //System.out.println("Process req body...");
    bodyReader = new BufferedReader(reader);
    //System.out.println("...got reader");
    bodyString = new StringBuilder();
    String line;
    JSONObject test;
    JSONArray test2;
    if (null != cType && (cType.contains("application/json") || cType.contains("application/ld+json"))) {
        //System.out.println("Processing because it was jsony");
        //Note special characters cause this to break right here. 
        try {
            while ((line = bodyReader.readLine()) != null) {
                bodyString.append(line);
            }
        } catch (Exception e) {
            System.out.println("Couldn't access body to read");
            System.out.println(e);
        }

        //System.out.println("built body string");
        requestBody = bodyString.toString();
        //System.out.println("here is the bodyString");
        //System.out.println(requestBody);
        try {
            //JSONObject test
            test = JSONObject.fromObject(requestBody);
        } catch (Exception ex) {
            System.out.println("not a json object for processing");
            if (supportStringID) {
                //We do not allow arrays of ID's for DELETE, so if it failed JSONObject parsing then this is a hard fail for DELETE.
                //They attempted to provide a JSON object for DELETE but it was not valid JSON
                writeErrorResponse("The data passed was not valid JSON.  Could not get @id: " + requestBody,
                        HttpServletResponse.SC_BAD_REQUEST);
                requestBody = null;
            } else {
                //Maybe it was an action on a JSONArray, check that before failing JSON parse test.
                try {
                    //JSONArray test
                    test2 = JSONArray.fromObject(requestBody);
                } catch (Exception ex2) {
                    // not a JSONObject or a JSONArray. 
                    writeErrorResponse("The data passed was not valid JSON:\n" + requestBody,
                            HttpServletResponse.SC_BAD_REQUEST);
                    requestBody = null;
                }
            }
        }
        // no-catch: Is either JSONObject or JSON Array
    } else {
        if (supportStringID) { //Content type is not JSONy, looking for @id string as body
            while ((line = bodyReader.readLine()) != null) {
                bodyString.append(line);
            }
            requestBody = bodyString.toString();
            try {
                test = JSONObject.fromObject(requestBody);
                if (test.containsKey("@id")) {
                    requestBody = test.getString("@id");
                    if ("".equals(requestBody)) {
                        //No ID provided
                        writeErrorResponse(
                                "Must provide an id or a JSON object containing @id of object to perform this action.",
                                HttpServletResponse.SC_BAD_REQUEST);
                        requestBody = null;
                    } else {
                        // This string could be ANYTHING.  ANY string is valid at this point.  Create a wrapper JSONObject for elegant handling in deleteObject().  
                        // We will check against the string for existing objects in deleteObject(), processing the body is completed as far as this method is concerned.
                        JSONObject modifiedDeleteRequest = new JSONObject();
                        modifiedDeleteRequest.element("@id", requestBody);
                        requestBody = modifiedDeleteRequest.toString();
                    }
                }
            } catch (Exception e) {
                //This is good, they should not be using a JSONObject
                if ("".equals(requestBody)) {
                    //No ID provided
                    writeErrorResponse(
                            "Must provide an id or a JSON object containing @id of object to delete.",
                            HttpServletResponse.SC_BAD_REQUEST);
                    requestBody = null;
                } else {
                    // This string could be ANYTHING.  ANY string is valid at this point.  Create a wrapper JSONObject for elegant handling in deleteObject().  
                    // We will check against the string for existing objects in deleteObject(), processing the body is completed as far as this method is concerned.
                    JSONObject modifiedDeleteRequest = new JSONObject();
                    modifiedDeleteRequest.element("@id", requestBody);
                    requestBody = modifiedDeleteRequest.toString();
                }
            }
        } else { //This is an error, actions must use the correct content type
            writeErrorResponse("Invalid Content-Type. Please use 'application/json' or 'application/ld+json'",
                    HttpServletResponse.SC_BAD_REQUEST);
            requestBody = null;
        }
    }
    //@cubap @theHabes TODO IIIF compliance handling on action objects
    /*
    if(null != requestBody){
    complianceInfo = checkIIIFCompliance(requestBody, "2.1");
    if(complianceInfo.getInt("okay") < 1){
        writeErrorResponse(complianceInfo.toString(), HttpServletResponse.SC_CONFLICT);
        requestBody = null;
    }
    }
    */
    reader.close();
    input.close();
    content = requestBody;
    response.setContentType("application/json; charset=utf-8"); // We create JSON objects for the return body in most cases.  
    response.addHeader("Access-Control-Allow-Headers", "Content-Type");
    response.addHeader("Access-Control-Allow-Methods", "GET,OPTIONS,HEAD,PUT,PATCH,DELETE,POST"); // Must have OPTIONS for @webanno 
    return requestBody;
}

---

From source file:org.jpublish.servlet.JPublishServlet.java

/**
 * Called when the HTTP request method is POST.  This method provides the
 * main control logic.//w  w  w  .  java  2s. co  m
 *
 * @param request  The HTTP request
 * @param response The HTTP response
 * @throws ServletException
 * @throws IOException
 */

public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    ServletContext servletContext = getServletContext();

    String pathInfo = request.getPathInfo();
    if (log.isDebugEnabled())
        log.debug("Path info: " + pathInfo);

    //OLAT: PATCH BEGIN
    if (pathInfo == null) {
        // we have a direct mapping rule in web.xml like /kurs/bridge.html -> jpublish servlet
        // so we use servletPath
        //String servletPath = request.getServletPath();
        pathInfo = request.getServletPath();
    } //TODO: make more generic (use JPublish with other servlets..) and post it.

    if (log.isDebugEnabled())
        log.debug("calculated Path info: " + pathInfo);
    //OLAT: PATCH END

    String contextPath = request.getContextPath();

    if (log.isDebugEnabled())
        log.debug("Context path: " + contextPath);

    // get the real path
    String path = getRealPath(pathInfo);

    if (siteContext.getPathDispatcherManager().canDispatch(path)) {

        //only one from below ones should react
        String dispatcherName = siteContext.getPathDispatcherManager().canForwardDispatch(path);

        if (dispatcherName != null) {
            siteContext.getPathDispatcherManager().forward(request, response, dispatcherName);
        }

        dispatcherName = siteContext.getPathDispatcherManager().canIncludeDispatch(path);
        if (dispatcherName != null) {
            siteContext.getPathDispatcherManager().include(request, response, dispatcherName);
        }

        return;
    }

    if (log.isDebugEnabled())
        log.debug("Real path: " + path);

    // create the session if enabled
    HttpSession session = null;

    if (isSessionEnabled(path)) {
        session = request.getSession(true);
    }

    // get the character encoding map
    CharacterEncodingMap characterEncodingMap = siteContext.getCharacterEncodingManager().getMap(path);

    // set the request character encoding for parameter data
    if (requireVersion(2, 3)) {
        request.setCharacterEncoding(characterEncodingMap.getRequestEncoding());
    }

    // put standard servlet stuff into the context
    JPublishContext context = new JPublishContext(this);
    context.put("request", request);
    context.put("response", response);
    context.put("session", session);
    context.put("application", servletContext);

    // add the character encoding map to the context
    context.put("characterEncodingMap", characterEncodingMap);

    // add the URLUtilities to the context
    URLUtilities urlUtilities = new URLUtilities(request, response);
    context.put("urlUtilities", urlUtilities);
    // deprecated
    context.put("url_util", urlUtilities);
    context.put("url_utils", urlUtilities);

    // add the DateUtilities to the context
    context.put("dateUtilities", DateUtilities.getInstance());

    // add the NumberUtilities to the context
    context.put("numberUtilities", NumberUtilities.getInstance());

    // add the messages log to the context
    context.put("syslog", SiteContext.syslog);

    // expose the SiteContext
    context.put("site", siteContext);

    // expose the context itself for debugging purposes
    if (siteContext.isDebug()) {
        context.put("context", context);
    }

    // switch from merge to eval, while rendering Velocity templates [hack for utf8]
    if (siteContext.isEval()) {
        context.put("evaluateVelocityTemplates", "true");
    }

    if (siteContext.isProtectReservedNames()) {
        context.enableCheckReservedNames(this);
    }

    // add the repositories to the context
    Iterator repositories = siteContext.getRepositories().iterator();
    while (repositories.hasNext()) {
        Repository repository = (Repository) repositories.next();
        if (log.isDebugEnabled())
            log.debug("Adding " + repository.getClass().getName() + " as " + repository.getName());

        context.put(repository.getName(), new RepositoryWrapper(repository, context));
    }

    Writer out = null;
    try {

        if (executePreEvaluationActions(request, response, context, path))
            return;

        if (context.getStopProcessing() != null) {
            return;
        }

        // if the page is static
        StaticResourceManager staticResourceManager = siteContext.getStaticResourceManager();

        if (staticResourceManager.resourceExists(path)) {

            long ifModifiedSince = request.getDateHeader(HEADER_IF_MODIFIED);
            // will round the file's lastModified down to the nearest second by dividing by 1000 and then
            // multiplying it by 1000; florin
            long lastUpdatedTime = -1;
            try {
                lastUpdatedTime = (staticResourceManager.getLastModified(path) / 1000) * 1000;
            } catch (Exception e) {
                log.warn("Cannot read the LastModified for: " + path);
            }
            //log.info(String.format("%s: if modified since: %d, file time:%d, modified? %s", path, ifModifiedSince, lastUpdatedTime, (ifModifiedSince < lastUpdatedTime)));

            if (ifModifiedSince < lastUpdatedTime) {
                // execute the global actions
                if (executeGlobalActions(request, response, context, path))
                    return;

                if (context.getStopProcessing() != null)
                    return;

                // execute path actions
                if (executePathActions(request, response, context, path))
                    return;
                if (context.getStopProcessing() != null)
                    return;

                // execute parameter actions
                if (executeParameterActions(request, response, context, path))
                    return;
                if (context.getStopProcessing() != null)
                    return;

                // load and return the static resource
                setResponseContentType(request, response, path, characterEncodingMap);
                response.setDateHeader(HEADER_LAST_MODIFIED, lastUpdatedTime);
                response.setContentLength((int) staticResourceManager.getContentLength(path));
                try {
                    staticResourceManager.load(path, response.getOutputStream());
                } catch (SocketException e) {
                    log.warn("Error writing to output stream: " + e.getMessage());
                }
                // OLAT: PATCH: Ignore org.apache.catalina.connector.ClientAbortException
                // that is produced by InternetExplorer (6.0) browser caching.
                catch (IOException e) {
                    if (e instanceof FileNotFoundException) {
                        throw e;
                    }
                }
            } else {
                //If the browser has current version of the file, don't send it. Just say it has not changed
                response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            }
            return;
        } else {
            if (log.isDebugEnabled())
                log.debug("Static resource '" + path + "' not found");
        }

        // load the page
        if (log.isDebugEnabled())
            log.debug("Loading the page.");

        PageInstance pageInstance = siteContext.getPageManager().getPage(path);
        Page page = new Page(pageInstance);

        context.disableCheckReservedNames(this);

        // expose the page in the context
        context.put("page", page);

        // expose components in the context
        context.put("components", new ComponentMap(context));

        if (siteContext.isProtectReservedNames()) {
            context.enableCheckReservedNames(this);
        }

        request.setAttribute(JPUBLISH_CONTEXT, context);

        // execute the global actions
        if (executeGlobalActions(request, response, context, path))
            return;
        if (context.getStopProcessing() != null)
            return;

        // execute path actions
        if (executePathActions(request, response, context, path))
            return;
        if (context.getStopProcessing() != null)
            return;

        // execute parameter actions
        if (executeParameterActions(request, response, context, path))
            return;
        if (context.getStopProcessing() != null)
            return;

        // execute the page actions
        if (log.isDebugEnabled())
            log.debug("Executing page actions.");

        if (optionalRedirect(page.executeActions(context), path, response))
            return;
        if (context.getStopProcessing() != null) {
            return;
        }
        setResponseContentType(request, response, path, characterEncodingMap);

        // get the template
        // OLAT: PATCH using context.getPage() instead of page object
        // since page can be changed in internal forward and page points
        // still to the original page
        Template template = siteContext.getTemplateManager()
                .getTemplate(context.getPage().getFullTemplateName());

        // get the Servlet writer
        out = response.getWriter();

        // merge the template
        if (log.isDebugEnabled())
            log.debug("Merging with template " + template.getPath());
        // OLAT: PATCH using context.getPage() instead of page object
        // since page can be changed in internal forward and page points
        // still to the original page
        template.merge(context, context.getPage(), out);

    } catch (FileNotFoundException e) {
        log.error("[404] " + path);
        if (!response.isCommitted()) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND, path);
        }
    } catch (Exception e) {
        // Allow Jetty RequestRetry exception to propogate to container!
        if ("org.mortbay.jetty.RetryRequest".equals(e.getClass().getName())) {
            throw (RuntimeException) e;
        }

        JPublishError error = new JPublishError(e, context);
        Iterator errorHandlers = siteContext.getErrorHandlers(path).iterator();
        while (errorHandlers.hasNext()) {
            ((ErrorHandler) errorHandlers.next()).handleError(error);
        }

        if (!error.isConsumed()) {
            log.error("Execution error: " + MessageUtilities.format(e.getMessage()));
            if (!response.isCommitted()) {
                throw new ServletException(e);
            }
        }
    } finally {
        try {
            executePostEvaluationActions(request, response, context, path);
        } catch (Exception e) {
            log.error("Error executing post evaluation actions: " + MessageUtilities.format(e.getMessage()));
        }
    }
}

---

From source file:org.opencms.i18n.CmsDefaultLocaleHandler.java

/**
 * @see org.opencms.i18n.I_CmsLocaleHandler#getI18nInfo(javax.servlet.http.HttpServletRequest, org.opencms.file.CmsUser, org.opencms.file.CmsProject, java.lang.String)
 *//*from  w w w. jav a  2s  . c  o m*/
public CmsI18nInfo getI18nInfo(HttpServletRequest req, CmsUser user, CmsProject project, String resourceName) {

    CmsLocaleManager localeManager = OpenCms.getLocaleManager();
    List<Locale> defaultLocales = null;
    String encoding = null;

    CmsObject adminCms = null;
    try {
        // create a copy of the Admin context to avoid concurrent modification
        adminCms = OpenCms.initCmsObject(m_adminCmsObject);
    } catch (CmsException e) {
        // unable to copy Admin context - this should never happen
    }

    if (adminCms != null) {

        // must switch project id in stored Admin context to match current project
        adminCms.getRequestContext().setCurrentProject(project);
        adminCms.getRequestContext().setUri(resourceName);

        // now get default m_locale names
        CmsResource res = null;
        try {
            res = adminCms.readResource(resourceName, CmsResourceFilter.IGNORE_EXPIRATION);
        } catch (CmsException e) {
            // unable to read the resource - maybe we need the init handlers                
        }
        if (res == null) {
            try {
                res = OpenCms.initResource(adminCms, resourceName, req, null);
            } catch (CmsException e) {
                // unable to resolve the resource, use default locale
            }
        }

        String defaultNames = null;

        if (res != null) {
            // the resource may not exist at all (e.g. if an unknown resource was requested by the user in the browser)
            try {
                defaultNames = adminCms.readPropertyObject(res, CmsPropertyDefinition.PROPERTY_LOCALE, true)
                        .getValue();
            } catch (CmsException e) {
                LOG.warn(Messages.get().getBundle().key(Messages.ERR_READ_ENCODING_PROP_1, resourceName), e);
            }
            if (defaultNames != null) {
                defaultLocales = localeManager.getAvailableLocales(defaultNames);
            }

            // get the encoding
            try {
                encoding = adminCms
                        .readPropertyObject(res, CmsPropertyDefinition.PROPERTY_CONTENT_ENCODING, true)
                        .getValue(OpenCms.getSystemInfo().getDefaultEncoding());
            } catch (CmsException e) {
                if (LOG.isInfoEnabled()) {
                    LOG.info(Messages.get().getBundle().key(Messages.ERR_READ_ENCODING_PROP_1, resourceName),
                            e);
                }
            }
        }
    }

    if ((defaultLocales == null) || (defaultLocales.isEmpty())) {
        // no default locales could be determined
        defaultLocales = localeManager.getDefaultLocales();
    }
    if (encoding == null) {
        // no special encoding could be determined
        encoding = OpenCms.getSystemInfo().getDefaultEncoding();
    }

    // set the request character encoding
    if (req != null) {
        try {
            req.setCharacterEncoding(encoding);
        } catch (UnsupportedEncodingException e) {
            LOG.error(Messages.get().getBundle().key(Messages.ERR_UNSUPPORTED_REQUEST_ENCODING_1, encoding), e);
        }
    }

    Locale locale;
    // return the first default locale name 
    if ((defaultLocales != null) && (defaultLocales.size() > 0)) {
        locale = defaultLocales.get(0);
    } else {
        locale = CmsLocaleManager.getDefaultLocale();
    }

    return new CmsI18nInfo(locale, encoding);
}

---

From source file:de.zib.scalaris.examples.wikipedia.bliki.WikiServlet.java

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    long startTime = System.currentTimeMillis();
    Connection connection = getConnection(request);
    final String serviceUser = getParam(request, "service_user");
    if (connection == null) {
        showEmptyPage(request, response, connection, new WikiPageBean(serviceUser, startTime)); // should forward to another page
        return; // return just in case
    }//  www. ja v  a  2s. co m

    for (WikiEventHandler handler : eventHandlers) {
        if (!handler.checkAccess(serviceUser, request, connection)) {
            // access not allowed
            showEmptyPage(request, response, connection, new WikiPageBean(serviceUser, startTime));
            return;
        }
    }

    try {
        if (!initialized && !loadSiteInfo() || !currentImport.isEmpty()) {
            showImportPage(request, response, connection, new WikiPageBean(serviceUser, startTime)); // should forward to another page
            return; // return just in case
        }
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");

        String req_title = request.getParameter("title");
        if (!MyWikiModel.isValidTitle(req_title)) {
            handleViewPageBadTitle(request, response, connection, new WikiPageBean(serviceUser, startTime));
        } else {
            handleEditPageSubmitted(request, response, request.getParameter("title"), connection,
                    new WikiPageEditBean(serviceUser, startTime));
        }

        // if the request has not been forwarded, print a general error
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.write("An unknown error occured, please contact your administrator. "
                + "A server restart may be required.");
        out.close();
    } finally {
        releaseConnection(request, connection);
    }
}

---

From source file:com.zeroio.webdav.WebdavServlet.java

/**
 * Handles the special WebDAV methods./*from   w w w .j a  v  a 2 s.  c o m*/
 *
 * @param req  Description of the Parameter
 * @param resp Description of the Parameter
 * @throws ServletException Description of the Exception
 * @throws IOException      Description of the Exception
 */
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    //showRequestInfo(req);
    //Set the encoding scheme to be used
    try {
        req.setCharacterEncoding("UTF-8");
    } catch (Exception e) {
        if (System.getProperty("DEBUG") != null) {
            System.out.println("WebdavServlet-> Unsupported encoding");
        }
    }

    ActionContext context = new ActionContext(this, req, resp);
    if (!systemInitialized(context)) {
        // initialize the SystemStatus, WebdavManager and ConnectionElement for this server
        initializeSystem(context);
    }
    // Authentication Check
    String argHeader = req.getHeader("Authorization");
    if (!allowUser(context, argHeader)) {
        System.out.println("Unauthorized access");
        if (context.getRequest().getHeader("user-agent").toLowerCase().startsWith("microsoft")
                || context.getRequest().getHeader("user-agent").toLowerCase().indexOf("windows") > -1) {
            //Microsoft Client. Hence use Basic Authentication
            //Basic Authentication
            //System.out.println("Authentication Scheme-> BASIC");
            resp.setHeader("WWW-Authenticate", "BASIC realm=\"" + CFS_USER_REALM + "\"");
        } else {
            //Any othe client use Digest Authentication
            // Digest Authentication
            // determine the 'number once' value that is unique for this auth
            //System.out.println("Authentication Scheme-> DIGEST");
            String nonce = generateNonce();
            // determine the 'opaque' value which should be returned as is by the client
            String opaque = generateOpaque();
            resp.setHeader("WWW-Authenticate", "Digest realm=\"" + CFS_USER_REALM + "\", " + "nonce=\"" + nonce
                    + "\", " + "opaque=\"" + opaque + "\"");
        }
        resp.sendError(HttpServletResponse.SC_UNAUTHORIZED);
        return;
    }

    //Fix for MACOSX finder. Do not allow requests for files starting with a period
    String path = getRelativePath(context.getRequest());
    if (path.indexOf("/.") > -1 || path.indexOf(".DS_Store") > -1) {
        return;
    }

    String method = req.getMethod();
    //System.out.println("METHOD: " + method + ", Path: " + path);
    if (method.equals(METHOD_PROPFIND)) {
        doPropfind(context);
    } else if (method.equals(METHOD_OPTIONS)) {
        doOptions(context);
    } else if (method.equals(METHOD_PROPPATCH)) {
        doProppatch(req, resp);
    } else if (method.equals(METHOD_MKCOL)) {
        doMkcol(context);
    } else if (method.equals(METHOD_COPY)) {
        doCopy(context);
    } else if (method.equals(METHOD_MOVE)) {
        doMove(context);
    } else if (method.equals(METHOD_LOCK)) {
        doLock(context);
    } else if (method.equals(METHOD_UNLOCK)) {
        doUnlock(context);
    } else if (method.equals(METHOD_DELETE)) {
        doDelete(context);
    } else {
        // DefaultServlet processing
        super.service(req, resp);
    }
}

---

From source file:de.zib.scalaris.examples.wikipedia.bliki.WikiServlet.java

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    long startTime = System.currentTimeMillis();
    String image = request.getParameter("get_image");
    if (image != null) {
        showImage(request, response, image);
        return;/*w  w w  . j  av a2  s . com*/
    }

    final String serviceUser = getParam(request, "service_user");

    Connection connection = getConnection(request);
    if (connection == null) {
        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        showEmptyPage(request, response, connection, new WikiPageBean(serviceUser, startTime)); // should forward to another page
        return; // return just in case
    }

    for (WikiEventHandler handler : eventHandlers) {
        if (!handler.checkAccess(serviceUser, request, connection)) {
            // access not allowed
            showEmptyPage(request, response, connection, new WikiPageBean(serviceUser, startTime));
            return;
        }
    }

    try {
        if (!initialized && !loadSiteInfo() || !currentImport.isEmpty()) {
            showImportPage(request, response, connection, new WikiPageBean(serviceUser, startTime)); // should forward to another page
            return; // return just in case
        }
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");

        // show empty page for testing purposes if a parameter called "test" exists:
        if (request.getParameter("test") != null) {
            showEmptyPage(request, response, connection, new WikiPageBean(serviceUser, startTime));
            return;
        }

        // if the "search" parameter exists, show the search
        String req_search = request.getParameter("search");
        if (req_search != null) {
            handleSearch(request, response, null, req_search, connection,
                    new WikiPageListBean(serviceUser, startTime));
            return;
        }

        // get parameters:
        String req_title = request.getParameter("title");
        if (req_title == null) {
            req_title = MAIN_PAGE;
        }

        String req_action = request.getParameter("action");

        if (!MyWikiModel.isValidTitle(req_title)) {
            handleViewPageBadTitle(request, response, connection, new WikiPageBean(serviceUser, startTime));
        } else if (req_title.startsWith("Special:")) {
            handleViewSpecialPage(request, response, req_title, req_search, "Special:".length(), connection,
                    startTime, serviceUser);
        } else if (req_title.startsWith(namespace.getSpecial() + ":")) {
            handleViewSpecialPage(request, response, req_title, req_search, namespace.getSpecial().length() + 1,
                    connection, startTime, serviceUser);
        } else if (req_action == null || req_action.equals("view")) {
            handleViewPage(request, response, req_title, connection, new WikiPageBean(serviceUser, startTime));
        } else if (req_action.equals("history")) {
            handleViewPageHistory(request, response, req_title, connection,
                    new WikiPageBean(serviceUser, startTime));
        } else if (req_action.equals("edit")) {
            handleEditPage(request, response, req_title, connection,
                    new WikiPageEditBean(serviceUser, startTime));
        } else {
            // default: show page
            handleViewPage(request, response, req_title, connection, new WikiPageBean(serviceUser, startTime));
        }

        // if the request has not been forwarded, print a general error
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.write(
                "An unknown error occured, please contact your administrator. A server restart may be required.");
        out.close();
    } finally {
        releaseConnection(request, connection);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »