style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

problemas con ICEFaces - Barra de progreso

Buenos dias a todos.

Basandome en el ejemplo de ICEFaces ( Uso la version 1.8.0 ) para el uso del componente Barra de proceso que esta en esta pagina http://component-showcase.icefaces.org/component-showcase/showcase.iface

Hice una pagina que permite subir un archivo plano, y coloque una barra de proceso para mostrar el avance del procesamiento del archivo subido.

La clase que procesa el archivo es igual a la del ejemplo de ICEFaces. Es un clase que implementa Renderable, ServletContextListener, DisposableBean, Serializable.

Pero en la salido del log del JBoss ( Uso la version 5.1 ), me muestra un error de que pierde la comunicación con la pagina ( al menos eso es lo que yo entiendo del error ).

alguien me puede orientar como seria la forma mas correcta de lograr hacer lo que propongo?.

Mi clase que hace como de hilo.

/*
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * "The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * <a href="http://www.mozilla.org/MPL/
" title="http://www.mozilla.org/MPL/
">http://www.mozilla.org/MPL/
</a> *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations under
 * the License.
 *
 * The Original Code is ICEfaces 1.5 open source software code, released
 * November 5, 2006. The Initial Developer of the Original Code is ICEsoft
 * Technologies Canada, Corp. Portions created by ICEsoft are Copyright (C)
 * 2004-2006 ICEsoft Technologies Canada, Corp. All Rights Reserved.
 *
 * Contributor(s): _____________________.
 *
 * Alternatively, the contents of this file may be used under the terms of
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"
 * License), in which case the provisions of the LGPL License are
 * applicable instead of those above. If you wish to allow use of your
 * version of this file only under the terms of the LGPL License and not to
 * allow others to use your version of this file under the MPL, indicate
 * your decision by deleting the provisions above and replace them with
 * the notice and other provisions required by the LGPL License. If you do
 * not delete the provisions above, a recipient may use your version of
 * this file under either the MPL or the LGPL License."
 *
 */

package com.corptx.sit.sitweb.pagosiae.bean;

import com.corptx.sit.sitweb.vo.OutputProgressModel;
import com.corptx.sit.sitbase.entity.DetalleLogCargue;
import com.corptx.sit.sitbase.entity.DetalleProceso;
import com.corptx.sit.sitbase.entity.FormulaJava;
import com.corptx.sit.sitbase.entity.LogCargue;
import com.corptx.sit.sitbase.entity.Proceso;
import com.corptx.sit.sitbase.entity.Requisito;
import com.corptx.sit.sitbase.exception.SITException;
import com.corptx.sit.sitbase.formulajava.IFormulaJavaService;
import com.corptx.sit.sitbase.pojo.Constantes;
import com.corptx.sit.sitbase.servicelocator.ServiceLocator;
import com.corptx.sit.sitbase.utils.UtilReglaNegocio;
import com.corptx.sit.sitbase.vo.PagoArchivoPlanoVO;
import com.corptx.sit.sitweb.bean.BaseBean;
import com.corptx.sit.sitweb.utils.FacesUtils;
import com.corptx.sit.sitweb.vo.OutputProgressVO;
import com.corptx.utils.collections.UtilList;
import com.corptx.utils.file.UtilFile;
import com.corptx.utils.time.FormatDate;
import com.icesoft.faces.async.render.RenderManager;
import com.icesoft.faces.async.render.Renderable;
import com.icesoft.faces.component.inputfile.InputFile;
import com.icesoft.faces.context.DisposableBean;
import com.icesoft.faces.webapp.xmlhttp.FatalRenderingException;
import com.icesoft.faces.webapp.xmlhttp.PersistentFacesState;
import com.icesoft.faces.webapp.xmlhttp.RenderingException;
import com.icesoft.faces.webapp.xmlhttp.TransientRenderingException;

import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor;
import edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue;
import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.StringUtils;

/**
 * <p>The OutputProgressController is responsible for handling all user actions
 * for the OutputProgress demo.  This includes the the starting a long
 * running process to show how the progress bar can be used to monitor a
 * process on the server. </p>
 * <p>This class is especially interesting shows a usage scenario for the
 * Renderable and ServletContextListener interfaces.  The Renderable
 * interface is used for the server side pushes needed to update the
 * outputProgress state.  The ServletContextListener is used to showdown
 * the thread pool when the server shuts down. </p>
 *
 * @see com.icesoft.faces.async.render.RenderManager
 * @see javax.servlet.ServletContextListener
 * @since 1.7
 */

public class PagoArchivoPlanoIAEController extends BaseBean
        implements Renderable, ServletContextListener, DisposableBean, Serializable {

    // long running thread will sleep 10 times for this duration.
    public static final long PROCCESS_SLEEP_LENGTH = 300;

    // A thread pool is used to make this demo a little more scalable then
    // just creating a new thread for each user.
    protected static ThreadPoolExecutor longRunningTaskThreadPool =
            new ThreadPoolExecutor(1, 5, 30, TimeUnit.SECONDS,
            new LinkedBlockingQueue(20));

    // render manager for the application, uses session id for on demand
    // render group.
    private RenderManager renderManager;
    private PersistentFacesState persistentFacesState;
    private String sessionId;

    // Model where we store the dynamic properties associated with outputProgress
    private OutputProgressModel outputProgressModel;
    private Integer codigoProceso;
    private InputFile archivo;
    private LogCargue logCargue;
    private List<DetalleLogCargue> detalleLogCargueCollection;
    private int posProgreso = 0;
    private int cntRegistrosCargados = 0;
    private boolean errores = false;
    private List<OutputProgressVO> listaProceso = new ArrayList<OutputProgressVO>();
    private String lineaActual;
    private DetalleLogCargue detalleLogCargue = null;

    /**
     * Default constructor where a reference to the PersistentFacesState is made
     * as well as the creation of the OutputProgressModel.  A reference to
     * PersistentFacesState is needed when implementing the Renderable
     * interface.
     */

    public PagoArchivoPlanoIAEController() {
        log.info("Entro a OutputProgressController()");
        persistentFacesState = PersistentFacesState.getInstance();
        outputProgressModel = new OutputProgressModel();
//        outputProgressModel.setCompletedMessage("Proceso finalizado exitosamente");
        outputProgressModel.setCompletedMessageEnabled(true);
        outputProgressModel.setIntermediatMode(false);
        outputProgressModel.setLabelPosition("bottom");
        outputProgressModel.setPercentComplete(0);
        outputProgressModel.setProgressMessageEnabled(true);
        log.info("Saliendo de OutputProgressController()");
    }

    /**
     * A long running task is started when this method is called.  Actually not
     * that long around 10 seconds.   This long process {@link LongOperationRunner}
     * is responsible for updating the percent complete in the model class.
     *
     * @param event
     */

    public void startLongProcress(ActionEvent event) {

        longRunningTaskThreadPool.execute(
                new LongOperationRunner(outputProgressModel,
                persistentFacesState, renderManager));
    }

    /**
     * Callback method that is called if any exception occurs during an attempt
     * to render this Renderable.
     * <p/>
     * It is up to the application developer to implement appropriate policy
     * when a RenderingException occurs.  Different policies might be
     * appropriate based on the severity of the exception.  For example, if the
     * exception is fatal (the session has expired), no further attempts should
     * be made to render this Renderable and the application may want to remove
     * the Renderable from some or all of the
     * {@link com.icesoft.faces.async.render.GroupAsyncRenderer}s it
     * belongs to. If it is a transient exception (like a client's connection is
     * temporarily unavailable) then the application has the option of removing
     * the Renderable from GroupRenderers or leaving them and allowing another
     * render call to be attempted.
     *
     * @param renderingException The exception that occurred when attempting to
     *                           render this Renderable.
     */

    public void renderingException(RenderingException renderingException) {
        if (log.isTraceEnabled() &&
                renderingException instanceof TransientRenderingException) {
            log.trace("OutputProgressController Transient Rendering exception:", renderingException);
        } else if (renderingException instanceof FatalRenderingException) {
            if (log.isTraceEnabled()) {
                log.trace("OutputProgressController Fatal rendering exception: ", renderingException);
            }
            renderManager.getOnDemandRenderer(sessionId).remove(this);
            renderManager.getOnDemandRenderer(sessionId).dispose();
        }
    }

    /**
     * Return the reference to the
     * {@link com.icesoft.faces.webapp.xmlhttp.PersistentFacesState
     * PersistentFacesState} associated with this Renderable.
     * <p/>
     * The typical (and recommended usage) is to get and hold a reference to the
     * PersistentFacesState in the constructor of your managed bean and return
     * that reference from this method.
     *
     * @return the PersistentFacesState associated with this Renderable
     */

    public PersistentFacesState getState() {
        return persistentFacesState;
    }

    /**
     * Sets the application render manager reference and creates a new on
     * demand render for this session id.
     *
     * @param renderManager RenderManager reference for this application.
     *                      Usually called via the faces-config.xml using
     *                      chaining.
     */

    public void setRenderManager(RenderManager renderManager) {
        this.renderManager = renderManager;

        // Casting to HttpSession ruins it for portlets, in this case we only
        // need a unique reference so we use the object hash
        sessionId = FacesContext.getCurrentInstance().getExternalContext().getSession(false).toString();
        renderManager.getOnDemandRenderer(sessionId).add(this);
    }

    /**
     * Gets the outputProgressModel for this instance.
     *
     * @return OutputProgressModel which contains the state of various
     *         dynamic properties that are manipulated by this example.
     */

    public OutputProgressModel getOutputProgressModel() {
        return outputProgressModel;
    }

    /**
     * Called when the Servlet Context is created.
     * @param event servlet context event.
     */

    public void contextInitialized(ServletContextEvent event) {
    }

    /**
     * Called when the Servlet Context is about to be destroyed.  This method
     * calls shutdownNow on the thread pool.
     * @param event servlet context event.
     */

    public void contextDestroyed(ServletContextEvent event) {
        if (longRunningTaskThreadPool != null) {
            longRunningTaskThreadPool.shutdownNow();
            if (log.isDebugEnabled()) {
                log.debug("Shutting down thread pool...");
            }
        }
    }

    /**
     * @return the archivo
     */

    public InputFile getArchivo() {
        return archivo;
    }

    /**
     * @param archivo the archivo to set
     */

    public void setArchivo(InputFile archivo) {
        this.archivo = archivo;
    }

    /**
     * @return the logCargue
     */

    public LogCargue getLogCargue() {
        return logCargue;
    }

    /**
     * @return the detalleLogCargueCollection
     */

    public List<DetalleLogCargue> getDetalleLogCargueCollection() {
        return detalleLogCargueCollection;
    }

    /**
     * @return the listaProceso
     */

    public List<OutputProgressVO> getListaProceso() {
        return listaProceso;
    }

    /**
     * @return the codigoProceso
     */

    public Integer getCodigoProceso() {
        return codigoProceso;
    }

    /**
     * @param codigoProceso the codigoProceso to set
     */

    public void setCodigoProceso(Integer codigoProceso) {
        this.codigoProceso = codigoProceso;
    }

    /**
     * Utility class to represent some server process that we want to monitor
     * using ouputProgress and server push.
     */

    protected class LongOperationRunner implements Runnable {

        PersistentFacesState state = null;
        private OutputProgressModel ouputProgressModel;
        private Proceso entityProceso = null;
        private RenderManager renderManagerHilo;

        public LongOperationRunner(OutputProgressModel ouputProgressModel,
                PersistentFacesState state, RenderManager renderManagerHilo) {
            this.state = state;
            this.ouputProgressModel = ouputProgressModel;
            this.renderManagerHilo = renderManagerHilo;
        }

        /**
         * Routine that takes time and updates percentage as it runs.
         */

        public void run() {
            log.info("Entro a run() del hilo");

            ouputProgressModel.setPogressStarted(true);
            List<String> listaArchivo = null;

            //detalleLogCargueCollection = new ArrayList<DetalleLogCargue>();
            try {
                if (codigoProceso != null) {
                    entityProceso = FacesUtils.getBusinnesDelegate().getProcesoService().queryProcesoFindByCodigo(codigoProceso);
                    if (entityProceso != null) {
                        Thread.sleep(PROCCESS_SLEEP_LENGTH);
                        mostrarMensaje("Cargada la información del proceso", posProgreso += 10, false, null);
                        entityProceso.setPagoArchivoPlanoVO(new PagoArchivoPlanoVO());
                        entityProceso.getPagoArchivoPlanoVO().setUsuarioLogueado(getUsuarioLogueado());
                        // Cargar datos del archivo plano
                        if (archivo != null) {
                            logCargue = new LogCargue();
                            getLogCargue().setNombreArchivoPlano(archivo.getFileInfo().getFileName());
                            getLogCargue().setFechaCargue(new Date());
                            // Cargar datos del archivo plano
                            listaArchivo =
                                    UtilFile.ConverterFileToList(archivo.getFileInfo().getPhysicalPath());
                            entityProceso.getPagoArchivoPlanoVO().setListaArchivo(listaArchivo);
                            Thread.sleep(PROCCESS_SLEEP_LENGTH);
                            mostrarMensaje("Cargado los datos del archivo plano", posProgreso += 10, false, null);

                            // Obtiene todas las listas del proceso
                            List<DetalleProceso> listaDetalle = entityProceso.getDetalleProcesoCollection();
                            for (DetalleProceso detalleProceso : listaDetalle) {
                                List<Requisito> listaRequisito = detalleProceso.getRequisitoCollection();
                                if (UtilList.isNotEmpty(listaRequisito)) { // Ejecuta primero los requisitos
                                    log.debug("Tiene requisitos y los va a ejecutar");
                                    for (Requisito requisito : listaRequisito) {
                                        Object value = "";
                                        FormulaJava formulaJava = requisito.getCodigoFormulaJava();
                                        String mappedName = formulaJava.getClaseJava();
                                        IFormulaJavaService service = (IFormulaJavaService) ServiceLocator.getInstance().getService(mappedName);
                                        log.debug("mappedName = " + mappedName);
                                        log.debug("requisito.getNombre() = " + requisito.getNombre());
                                        Object[] param = null;
                                        List<Object[]> listaProceso = (List<Object[]>) service.ejecutar(entityProceso, param);
                                        log.debug("entityProceso.getPagoArchivoPlanoVO().getListaErrores() = " + entityProceso.getPagoArchivoPlanoVO().getListaErrores());
                                        log.debug("proceso.getListaErrores() = " + entityProceso.getListaErrores());
                                        log.debug("listaProceso = " + listaProceso);
                                        if (UtilList.isNotEmpty(listaProceso)) {
                                            String msg = "Errores al ejecutar la Formula Java " + mappedName + ": ";
                                            for (Object[] objects : listaProceso) {
                                                msg += "[" + (String)objects[0] + "]";
                                            }
                                            mostrarMensaje(msg, posProgreso, true, null);
                                            throw new SITException(msg);
                                        } else {
                                            mostrarMensaje("Requisito " + requisito.getNombre() + " ejecutado satisfactoriamente", posProgreso += 10, false, null);
                                        }
//                                        if (UtilList.isNotEmpty(entityProceso.getPagoArchivoPlanoVO().getListaErrores())) {
//                                            String msg = "Errores al ejecutar la Formula Java " + mappedName + ": ";
//                                            for (String error : entityProceso.getPagoArchivoPlanoVO().getListaErrores()) {
//                                                msg += "[" + error + "]";
//                                            }
//                                            mostrarMensaje(msg, posProgreso, true, null);
//                                            throw new SITException(msg);
//                                        } else {
//                                            mostrarMensaje("Requisito " + requisito.getNombre() + " ejecutado satisfactoriamente", posProgreso += 10, false, null);
//                                        }
                                    }
                                } // Ejecuta la regla
                                if (detalleProceso.getCodigoRegla() != null) {
                                    log.debug("Va a ejecutar la regla: " + detalleProceso.getCodigoRegla().getNombre());
                                    log.debug("Antes de llamar a la regla, ListaProceso = " + entityProceso.getPagoArchivoPlanoVO().getListaProceso());
                                    UtilReglaNegocio.ejecutarRegla(entityProceso, detalleProceso.getCodigoRegla().getRegla());
                                    log.debug("Resultado de la regla, ListaProceso = " + entityProceso.getPagoArchivoPlanoVO().getListaProceso());
                                    log.debug("Resultado de la regla, getListaErrores = " + entityProceso.getPagoArchivoPlanoVO().getListaErrores());

                                    if (UtilList.isNotEmpty(entityProceso.getPagoArchivoPlanoVO().getListaErrores())) {
                                        String msg = "Errores al ejecutar la Regla de negocio " + detalleProceso.getCodigoRegla().getNombre() + ": ";
                                        for (String error : entityProceso.getPagoArchivoPlanoVO().getListaErrores()) {
                                            msg += "[" + error + "]";
                                        }
                                        mostrarMensaje(msg, posProgreso, true, null);
                                        throw new SITException(msg);
                                    } else {
                                        mostrarMensaje("Regla de negocio " + detalleProceso.getCodigoRegla().getNombre() + " ejecutada satisfactoriamente", posProgreso += 10, false, null);
                                    }
                                }
                            }
                        } else {
                            mostrarMensaje("Error, no existe archivo a procesar", posProgreso, true, null);
                        }
                    } else {
                        mostrarMensaje("Error al consultar el proceso seleccionado", posProgreso, true, null);
                    }
                } else {
                    mostrarMensaje("Error, no se ah seleccionado el proceso", posProgreso, true, null);
                }
            } catch (SITException e) {
                log.debug("SITException ERROR ");
                mostrarMensaje(e.getMessage(), posProgreso, true, e);
            } catch (Exception e) {
                log.debug("Exception ERROR ");
                mostrarMensaje(e.getMessage(), posProgreso, true, e);
            }
            try {
                if (UtilList.isEmpty(detalleLogCargueCollection)) {
                    getLogCargue().setEstado(Constantes.ESTADO_LOGCARGUE_NO_CARGADO);
                } else if (detalleLogCargueCollection.size() == listaArchivo.size()) {
                    getLogCargue().setEstado(Constantes.ESTADO_LOGCARGUE_CARGADO_COMPLETO);
                } else {
                    errores = true;
                    getLogCargue().setEstado(Constantes.ESTADO_LOGCARGUE_CARGADO_CON_ERRORES);
                }
                logCargue = (LogCargue) FacesUtils.getBusinnesDelegate().getCargueArchivosService().persistEntity(logCargue);
                if (UtilList.isNotEmpty(detalleLogCargueCollection)) {
                    for (DetalleLogCargue detalleLogCargue1 : detalleLogCargueCollection) {
                        detalleLogCargue1.setLogCargue(logCargue);
                        FacesUtils.getBusinnesDelegate().getCargueArchivosService().persistEntity(detalleLogCargue1);
                    }
                }
            } catch (SITException e) {
                mostrarMensaje(e.getMessage(), 100, true, e);
            }
            if (!errores) {
                mostrarMensaje("Proceso terminado satisfactoriamente", 100, true, null);
            }

            log.info("Saliendo de run() del hilo");
        }

        private void mostrarMensaje(String msg, int valorProgreso, boolean progresoTerminado, Throwable excep) {
            log.info("Entro a mostrarMensaje(String msg, int valorProgreso, boolean progresoTerminado, Throwable excep)");
            try {
                ouputProgressModel.setPercentComplete(valorProgreso);
                OutputProgressVO outputProgressVO = new OutputProgressVO();
                if (progresoTerminado) {
                    outputProgressModel.setCompletedMessageEnabled(true);
                    if (!StringUtils.isBlank(msg)) {
                        ouputProgressModel.setCompletedMessage(msg);
                    }
                    ouputProgressModel.setPogressStarted(false);
                } else if (!StringUtils.isBlank(msg)) {
                    ouputProgressModel.setProgressMessage(msg);
                }
                if (excep != null) {
                    errores = true;
                    log.error(msg, excep);
                    outputProgressVO.setError(true);
                } else {
                    log.info(msg);
                }
                if (!StringUtils.isBlank(msg)) {
                    outputProgressVO.setMsg(msg);
                    listaProceso.add(outputProgressVO);
                }

                renderManagerHilo.getOnDemandRenderer(sessionId).requestRender();
            } catch (IllegalStateException e) {
                log.error("ERROR al renderizar pagina.", e);
            }
            log.info("Saliendo de mostrarMensaje(String msg, int valorProgreso, boolean progresoTerminado, Throwable excep)");
        }
    }

    /**
     * Dispose callback called due to a view closing or session
     * invalidation/timeout
     */

    public void dispose() throws Exception {
        log.info("Entro a dispose()");
        if (log.isTraceEnabled()) {
            log.trace("OutputProgressController dispose OnDemandRenderer for session: " + sessionId);
        }
        renderManager.getOnDemandRenderer(sessionId).remove(this);
        renderManager.getOnDemandRenderer(sessionId).dispose();
        log.info("Saliendo de dispose()");
    }

    private void codigoRegla(Proceso proceso) {
        /**CODIGO DE LA REGLA, SE TIENE AQUI PARA MEJORAR SU PRESENTACIÓN***/
        PagoArchivoPlanoVO pagoArchivoPlanoVO = proceso.getPagoArchivoPlanoVO();
        List<String> listaArchivoPlano = pagoArchivoPlanoVO.getListaArchivo();
        pagoArchivoPlanoVO.setListaErrores(new ArrayList<String>());
        if (UtilList.isNotEmpty(listaArchivoPlano)) {
            int totalDetalles = 0;
            double sumValorDetalles = 0;
            String strTotalDetalles = "0";
            String strValorTotalRecaudado = "0";
            int linea = 0;
            for (; linea < listaArchivoPlano.size(); linea++) {
                Object[] vctProceso = new Object[4];
                String datosArchivoPlano = listaArchivoPlano.get(linea);

                // Colocando la linea dentro del vector deproceso
                vctProceso[0] = datosArchivoPlano;

                // Obteniendo el tipo de registro
                String tipoRegistro = datosArchivoPlano.substring(0, 2);
                System.out.println("tipoRegistro = " + tipoRegistro);
                if (!StringUtils.isBlank(tipoRegistro)) {
                    // Seccion Encabezado de Archivo
                    if (StringUtils.equals(tipoRegistro, "01")) {
                        // Saca la fecha del recaudo
                        String strFecha = datosArchivoPlano.substring(12, 20);
                        System.out.println("strFecha = " + strFecha);
                        pagoArchivoPlanoVO.setFechaPago(FormatDate.formatStringToDate(strFecha, "yyyyMMdd"));
                    // Seccion de detalle
                    } else if (StringUtils.equals(tipoRegistro, "06")) {
                        // Verifica el tipo de pago:
                        // 1 => Liquidación IAE
                        // 2 => Liquidación Predial
                        // 3 => Cobros generales

                        String strReferenciaPago = datosArchivoPlano.substring(2, 50);
                        System.out.println("strReferenciaPago = " + strReferenciaPago);
                        String strValorPago = datosArchivoPlano.substring(50, 64);
                        System.out.println("strValorPago = " + strValorPago);
                        totalDetalles++;
                        sumValorDetalles += Double.parseDouble(strValorPago);

                        // Verifican el pago de que tipo es
                        String strTipoRefPago = strReferenciaPago.substring(0, 1);
                        System.out.println("strTipoRefPago = " + strTipoRefPago);
                        if (!StringUtils.isBlank(strTipoRefPago)) {
                            if (StringUtils.equals(strTipoRefPago, "1")) {
                                vctProceso[1] = "IAE";
                            } else if (StringUtils.equals(strTipoRefPago, "2")) {
                                vctProceso[1] = "PREDIAL";
                            } else if (StringUtils.equals(strTipoRefPago, "3")) {
                                vctProceso[1] = "COBRO_GENERAL";
                            } else {
                                pagoArchivoPlanoVO.getListaErrores().add("Error en la línea " + linea + ". El tipo de referencia de pago [" + strTipoRefPago + "] no esta soportado");
                            }
                        } else {
                            pagoArchivoPlanoVO.getListaErrores().add("Error en la línea " + linea + ". No se puede obtener el tipo de la referencia de pago");
                        }

                    // Seccion de Control de archivo
                    } else if (StringUtils.equals(tipoRegistro, "09")) {
                        strTotalDetalles = datosArchivoPlano.substring(2, 11);
                        System.out.println("strTotalDetalles = " + strTotalDetalles);
                        pagoArchivoPlanoVO.setTotalRegistrosArchivo(new Integer(strTotalDetalles));

                        strValorTotalRecaudado = datosArchivoPlano.substring(11, 29);
                        System.out.println("strValorTotalRecaudado = " + strValorTotalRecaudado);
                        pagoArchivoPlanoVO.setValorTotalArchivo(new BigDecimal(strValorTotalRecaudado));
                    }
                }
            }
            // Valida que el total recaudado sea igual a la suma de los detalles
            pagoArchivoPlanoVO.setTotalDetalles(new Integer(totalDetalles));
            pagoArchivoPlanoVO.setSumValorDetalles(new BigDecimal(sumValorDetalles));
            if (sumValorDetalles != Double.parseDouble(strValorTotalRecaudado)) {
                pagoArchivoPlanoVO.getListaErrores().add("Error en la línea " + linea + ". Diferencias en valor total recaudado, archivo: " + strValorTotalRecaudado + ", suma de detalles: " + sumValorDetalles);
            }
            if (Integer.parseInt(strTotalDetalles) != totalDetalles) {
                pagoArchivoPlanoVO.getListaErrores().add("Error en la línea " + linea + ". Diferencias en cantidad de pagos, archivo: " + strTotalDetalles + ", suma de detalles: " + totalDetalles);
            }
        }

    /***
    if (StringUtils.equals(tipoRegistro, "01")) {
    // Es Encabezado de archivo
    int posArchivo = 0;
    for (DetalleArchivoPlano detalle2 : listaEntityDetalle) {
    if (!StringUtils.isBlank(detalle2.getCampo())) {
    if (Integer.parseInt(detalle.getCampo()) == 3) {
    int cntChr = Integer.parseInt(detalle.getLongitud());

    }
    }
    posArchivo += Integer.parseInt(detalle.getLongitud());
    }
    } else if (StringUtils.equals(tipoRegistro, "06")) {
    // Es detalle
    } else if (StringUtils.equals(tipoRegistro, "09")) {
    // Es control de archivo
    }

     ***/
    }
}

Y este es le mensaje de error:

2009-09-18 15:54:58,506 SEVERE [javax.enterprise.resource.webcontainer.jsf.lifecycle] (Render Thread - 3) JSF1054: (Phase ID: RENDER_RESPONSE 6, View ID: /pages/pagos_iae/pag_arc_pln.jspx) Exception thrown during phase execution: javax.faces.event.PhaseEvent[source=com.sun.faces.lifecycle.LifecycleImpl@1fe8bbe]
2009-09-18 15:54:58,516 ERROR [com.icesoft.faces.facelets.D2DFaceletViewHandler] (Render Thread - 4) Problem in renderResponse: null
java.lang.NullPointerException
at java.util.ArrayList.(ArrayList.java:131)
at com.icesoft.faces.webapp.http.servlet.SessionDispatcher.inRole(SessionDispatcher.java:148)
at com.icesoft.faces.webapp.http.servlet.SessionDispatcher.access$300(SessionDispatcher.java:29)
at com.icesoft.faces.webapp.http.servlet.SessionDispatcher$2.isUserInRole(SessionDispatcher.java:98)
at com.icesoft.faces.context.BridgeExternalContext.isUserInRole(BridgeExternalContext.java:215)
at com.icesoft.faces.component.ext.taglib.Util.isEnabledOnUserRole(Util.java:155)
at com.icesoft.faces.component.menubar.MenuItem.isDisabled(MenuItem.java:289)
at com.icesoft.faces.component.menubar.MenuItem.getStyleClass(MenuItem.java:434)
at com.icesoft.faces.component.menubar.MenuItemRenderer.renderSubMenuItem(MenuItemRenderer.java:589)
at com.icesoft.faces.component.menubar.MenuItemRenderer.renderChildrenRecursive(MenuItemRenderer.java:479)
at com.icesoft.faces.component.menubar.MenuItemRenderer.encodeBegin(MenuItemRenderer.java:244)
at javax.faces.component.UIComponentBase.encodeBegin(UIComponentBase.java:813)
at com.icesoft.faces.renderkit.dom_html_basic.DomBasicRenderer.encodeParentAndChildren(DomBasicRenderer.java:356)
at com.icesoft.faces.component.menubar.MenuItemsRenderer.renderRecursive(MenuItemsRenderer.java:65)
at com.icesoft.faces.component.menubar.MenuItemsRenderer.encodeChildren(MenuItemsRenderer.java:55)
at javax.faces.component.UIComponentBase.encodeChildren(UIComponentBase.java:837)
at com.icesoft.faces.renderkit.dom_html_basic.DomBasicRenderer.encodeParentAndChildren(DomBasicRenderer.java:358)
at com.icesoft.faces.component.menubar.MenuBarRenderer.encodeChildren(MenuBarRenderer.java:116)
at javax.faces.component.UIComponentBase.encodeChildren(UIComponentBase.java:837)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:517)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:522)
at com.icesoft.faces.facelets.D2DFaceletViewHandler.renderResponse(D2DFaceletViewHandler.java:282)
at com.icesoft.faces.application.D2DViewHandler.renderView(D2DViewHandler.java:153)
at com.sun.faces.lifecycle.RenderResponsePhase.execute(RenderResponsePhase.java:110)
at com.sun.faces.lifecycle.Phase.doPhase(Phase.java:100)
at com.sun.faces.lifecycle.LifecycleImpl.render(LifecycleImpl.java:139)
at com.icesoft.faces.webapp.xmlhttp.PersistentFacesState.render(PersistentFacesState.java:176)
at com.icesoft.faces.webapp.xmlhttp.PersistentFacesState.executeAndRender(PersistentFacesState.java:301)
at com.icesoft.faces.async.render.RunnableRender.run(RunnableRender.java:143)
at edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1061)
at edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:575)
at java.lang.Thread.run(Thread.java:619)
2009-09-18 15:54:58,560 SEVERE [javax.enterprise.resource.webcontainer.jsf.lifecycle] (Render Thread - 4) JSF1054: (Phase ID: RENDER_RESPONSE 6, View ID: /pages/pagos_iae/pag_arc_pln.jspx) Exception thrown during phase execution: javax.faces.event.PhaseEvent[source=com.sun.faces.lifecycle.LifecycleImpl@1fe8bbe]

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Re: problemas con ICEFaces - Barra de progreso

Viendo el volcado de pila, parece un problema relacionado con roles (seguridad): se ve que la excepción se dispara al no encontrar un valor para verificar el rol del usuario.

Saludos

Javier Castañón

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">