Пример #1
0
        /// <summary>
        /// Inicializar um novo monitoramento de um processo cujo progresso será controlado automaticamente, passando os dados para o monitor de tarefas.
        /// </summary>
        /// <param name="handleUsuario">Handle do usuário corrente</param>
        /// <param name="descricaoProcesso">Descrição amigável do processo, deve identificar o dado sendo processado. Ex: Liberação do PEG nº 167928</param>
        /// <returns>Instância da entidade responsável pelo monitoramento</returns>
        public static void NovoMonitoramentoProgressoAutomatico(long handleUsuario, string descricaoProcesso)
        {
            var mensagem = mensagemInicialAutomatica;
            MonitoramentoProcesso monitoramento = MonitoramentoProcessoHelper.Current as MonitoramentoProcesso;

            if ((monitoramento == null) || (!monitoramento.InstanciaAutomatica)) // Se não existe monitoramento corrente, ou se não é automático
            {
                monitoramento = NewMonitoramento(handleUsuario, descricaoProcesso, mensagem,
                                                 0, null, null, null, instanciaAutomatica: false, progressoAutomatico: true);
            }
            monitoramento.InicializarDados(descricaoProcesso, mensagem, 0, null, null);
        }
Пример #2
0
        /// <summary>
        /// Inicializar um novo monitoramento de um processo cujo progresso será controlado manualmente, passando os dados para o monitor de tarefas.
        /// </summary>
        /// <param name="handleUsuario">Handle do usuário corrente</param>
        /// <param name="descricaoProcesso">Descrição amigável do processo, deve identificar o dado sendo processado. Ex: Liberação do PEG nº 167928</param>
        /// <param name="mensagem">Mensagem inicial exibida no monitoramento</param>
        /// <param name="progressoMaximo">Valor que indica o valor máximo de progresso do processamento</param>
        /// <param name="handleRegistroRotina">Handle do registro da rotina, deve ser usado ao monitorar o processamento de uma rotina com tabela, situação e ocorrências.</param>
        /// <param name="nomeTabelaRotina">Nome da tabela da rotina, deve ser usado ao monitorar o processamento de uma rotina com tabela, situação e ocorrências.</param>
        /// <param name="pegarOcorrenciasNaTabelaInformada">Indica se deve pegar as ocorrências diretamente na tabela informada</param>
        /// <returns>Instância da entidade responsável pelo monitoramento</returns>
        public static IMonitoramentoProcesso NovoMonitoramentoProgressoManual(long handleUsuario, string descricaoProcesso, string mensagem,
                                                                              int progressoMaximo, long?handleRegistroRotina, string nomeTabelaRotina, bool pegarOcorrenciasNaTabelaInformada = true)
        {
            if (String.IsNullOrEmpty(mensagem))
            {
                mensagem = mensagemInicialAutomatica;
            }
            MonitoramentoProcesso monitoramento = MonitoramentoProcessoHelper.Current as MonitoramentoProcesso;

            if ((monitoramento == null) || (!monitoramento.InstanciaAutomatica)) // Se não existe monitoramento corrente, ou se não é automático
            {
                monitoramento = NewMonitoramento(handleUsuario, descricaoProcesso, mensagem,
                                                 progressoMaximo, handleRegistroRotina, nomeTabelaRotina, null, instanciaAutomatica: false, progressoAutomatico: false);
            }
            monitoramento.InicializarDados(descricaoProcesso, mensagem, progressoMaximo, handleRegistroRotina, nomeTabelaRotina);
            return(monitoramento);
        }
Пример #3
0
        /// <summary>
        /// Carrega um monitoramento existente com base no handle do registro da SIS_PROCESSO
        /// </summary>
        /// <param name="ProcedureInvoker">Instância de IProcedureInvoker</param>
        /// <param name="HandleUsuario">Handle do usuário corrente</param>
        /// <param name="idProcesso">Handle do registro da SIS_PROCESSO</param>
        /// <param name="repositorioRegistroProcesso">Instância do repositório da SIS_PROCESSO</param>
        /// <param name="pegarOcorrenciasNaTabelaInformada">Indica se deve pegar as ocorrências diretamente na tabela informada</param>
        /// <returns>Instância da entidade responsável pelo monitoramento</returns>
        public static IMonitoramentoProcesso CarregarMonitoramentoExistente(long HandleUsuario,
                                                                            long idProcesso, bool pegarOcorrenciasNaTabelaInformada = true)
        {
            if (logDebug)
            {
                logger.DebugFormat("CarregarMonitoramentoExistente");
                logger.DebugFormat(String.Format("HandleUsuario: {0}", HandleUsuario));
                logger.DebugFormat(String.Format("idProcesso: {0}", idProcesso));
            }
            //***** ESTA GAMBIARRA FOI DESENVOLVIDA PARA SOLUCIONAR TEMPORARIAMENTE UM PROBLEMA! =D ******//
            int tentativa = 0;

            while (tentativa < 3)
            {
                try
                {
                    MonitoramentoProcesso monitoramento = new MonitoramentoProcesso(HandleUsuario, null); // TODO: Pegar local
                    monitoramento.PegarOcorrenciasNaTabelaInformada = pegarOcorrenciasNaTabelaInformada;
                    monitoramento.InstanciaAutomatica = false;
                    monitoramento.HandleRegistro      = idProcesso;
                    monitoramento.RecarregarDoBanco();
                    MonitoramentoProcessoHelper.ForcarMonitoramentoContexto(monitoramento);

                    return(monitoramento);
                }
                catch (Exception Ex)
                {
                    tentativa++;
                    Thread.Sleep(150);
                    if (tentativa >= 3)
                    {
                        logger.ErrorFormat(MethodInfo.GetCurrentMethod().Name);
                        logger.ErrorFormat(String.Format("HandleUsuario: {0}", HandleUsuario));
                        logger.ErrorFormat(String.Format("idProcesso: {0}", idProcesso));
                        logger.ErrorFormat(String.Format("Erro: {0}", Ex.ToString()));
                        throw new Exception("Erro ao carregar monitoramento processo: " + Ex.ToString());
                    }
                }
            }

            return(null);
        }
Пример #4
0
        /// <summary>
        /// * Não deve ser chamado manualmente! Inicializar um novo monitoramento automático instanciado pelo Proxy.
        /// </summary>
        /// <param name="handleUsuario">Handle do usuário corrente</param>
        /// <param name="descricaoProcesso">Descrição amigável do processo, deve identificar o dado sendo processado. Ex: Liberação do PEG nº 167928</param>
        /// <returns>Instância da entidade responsável pelo monitoramento</returns>
        public static IMonitoramentoProcesso MonitoramentoAutomaticoProxy(long handleUsuario, MethodBase metodoChamada)
        {
            // Não inicializa monitoramento automático caso já exista um no contexto
            if (MonitoramentoProcessoHelper.Current != null)
            {
                return(null);
            }

            var mensagem          = mensagemInicialAutomatica;
            var descricaoProcesso = FormatarDescricaoProcesso(metodoChamada);
            MonitoramentoProcesso monitoramento = MonitoramentoProcessoHelper.Current as MonitoramentoProcesso;

            if ((monitoramento == null) || (!monitoramento.InstanciaAutomatica)) // Se não existe monitoramento corrente, ou se não é automático
            {
                monitoramento = NewMonitoramento(handleUsuario, descricaoProcesso, mensagem,
                                                 1, null, null, null, false, true);
            }
            monitoramento.InicializarDados(descricaoProcesso, mensagem, 1, null, null);
            return(monitoramento);
        }