Beispiel #1
0
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            var paginaViewModel = lote.ObterPagina(acao.PrimeiraPagina);
            var documentoId     = paginaViewModel.DocumentoAtualId();

            if (lote.EstaNaTriagem())
            {
                this.paginaRepositorio.AlterarStatus(paginaViewModel.Id, PaginaStatus.StatusParaReconhecimento);
                this.documentoRepositorio.AlterarStatus(documentoId, DocumentoStatus.TransmissaoOk);
            }

            switch (acao.Tipo)
            {
            case AcaoDeTriagemPreOcr.RessuscitarPagina:
                this.gravaLogDaPaginaServico.Executar(
                    LogPagina.AcaoPaginaRessucitada,
                    paginaViewModel.Id,
                    documentoId,
                    string.Format("Página {0} foi ressucitada {1}.", paginaViewModel.Id, lote.Fase));
                break;

            default:
                this.gravaLogDaPaginaServico.Executar(
                    LogPagina.AcaoFolhaRessucitada,
                    paginaViewModel.Id,
                    documentoId,
                    string.Format("Folha separadora {0} foi ressucitada {1}.", paginaViewModel.Id, lote.Fase));
                break;
            }

            this.documentoRepositorio.AlterarMarca(documentoId, Documento.MarcaDeAlteradoNaSeparacao);

            lote.MarcaDocumentoManipulado(documentoId);
        }
        public LoteTriagemViewModel ExecutarAcoes(int processoId, string textoDeAcoes, bool ignorarPaginasExcluidas, bool excluirDocumentosSemPaginas, string fase)
        {
            var acoes = AcaoDeTriagemPreOcr.MontarLista(textoDeAcoes);

            if (acoes.Any() == false)
            {
                return(null);
            }

            var lote = this.obtemLoteParaTriagemPreOcrServico.Obter(processoId, ignorarPaginasExcluidas, fase);

            var acoesDiferenteDeGiro = acoes.Where(x => x.Tipo != AcaoDeTriagemPreOcr.Girar180 && x.Tipo != AcaoDeTriagemPreOcr.GirarAntiHorario && x.Tipo != AcaoDeTriagemPreOcr.GirarHorario).ToList();
            var acoesDeGiro          = acoes.Where(x => x.Tipo == AcaoDeTriagemPreOcr.Girar180 || x.Tipo == AcaoDeTriagemPreOcr.GirarAntiHorario || x.Tipo == AcaoDeTriagemPreOcr.GirarHorario).ToList();

            this.ExecutaAcoes(acoesDiferenteDeGiro, lote);
            this.ExecutaAcoes(acoesDeGiro, lote);

            if (excluirDocumentosSemPaginas)
            {
                this.removeDocumentosSemPaginaServico.Executar(lote);
            }

            this.documentoRepositorio.LimparFraudes(lote.LoteId);

            return(lote);
        }
Beispiel #3
0
        private Documento CriarDocumento(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            var processo = new Processo
            {
                Id   = lote.ProcessoId,
                Lote = new Lote {
                    Id = lote.LoteId
                }
            };

            var tipoDocumento = new TipoDocumento {
                Id = acao.TipoDocumentoId
            };

            var documento = this.documentoFabrica.Criar(processo, tipoDocumento, "1");

            documento.Status = DocumentoStatus.TransmissaoOk;
            documento.Ordem  = acao.NovoDocumentoOrdem;
            documento.Marca  = Documento.MarcaDeCriadoNaSeparacao;
            documento.Versao = "0";
            this.documentoRepositorio.Salvar(documento);

            this.gravaLogDoDocumentoServico.Executar(
                LogDocumento.AcaoDocumentoNaTriagem,
                documento.Id,
                string.Format("Documento criado [{0}]. Tipo: {1}", lote.Fase, tipoDocumento.Id));

            return(documento);
        }
        private bool IgnorarAcao(AcaoDeTriagemPreOcr acao, IEnumerable <AcaoDeTriagemPreOcr> acoes)
        {
            switch (acao.Tipo)
            {
            case AcaoDeTriagemPreOcr.RessuscitarPagina:

                return(acoes.Any(x =>
                                 x.PrimeiraPagina == acao.PrimeiraPagina &&
                                 x.Tipo == AcaoDeSeparacao.ExcluirPagina &&
                                 x.Id > acao.Id));

            case AcaoDeTriagemPreOcr.ExcluirPagina:

                return(acoes.Any(x =>
                                 x.PrimeiraPagina == acao.PrimeiraPagina &&
                                 x.Tipo == AcaoDeSeparacao.RessuscitarPagina &&
                                 x.Id > acao.Id));

            case AcaoDeTriagemPreOcr.MudarPaginaDeDocumento:
                return(acoes.Any(x =>
                                 x.PrimeiraPagina == acao.PrimeiraPagina &&
                                 x.Tipo == AcaoDeTriagemPreOcr.MudarPaginaDeDocumento &&
                                 x.Id > acao.Id));
            }

            return(false);
        }
Beispiel #5
0
        public static IList <AcaoDeTriagemPreOcr> MontarLista(string textoDeAcoes)
        {
            var lista  = new List <AcaoDeTriagemPreOcr>();
            var linhas = textoDeAcoes.Split('|');

            foreach (var linha in linhas.Where(x => string.IsNullOrEmpty(x) == false))
            {
                var colunas = linha.Split(';');

                var acao = new AcaoDeTriagemPreOcr
                {
                    Id                 = lista.Count,
                    Tipo               = colunas[0],
                    NovoDocumentoId    = colunas[1].ToInt(),
                    TipoDocumentoId    = colunas[2].ToInt(),
                    TextoDePaginas     = colunas[3],
                    LoteId             = colunas[4].ToInt(),
                    DocumentoOrigemId  = colunas[5].ToInt(),
                    NovoDocumentoOrdem = colunas[6].ToInt()
                };

                if (string.IsNullOrEmpty(acao.TextoDePaginas) == false)
                {
                    acao.Paginas        = acao.TextoDePaginas.ToIntList(',');
                    acao.PrimeiraPagina = acao.Paginas.FirstOrDefault();
                }

                lista.Add(acao);
            }

            return(lista.OrderBy(x => x.Id).ToList());
        }
 public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
 {
     foreach (var paginaId in acao.Paginas)
     {
         this.GravarAjusteDeGiro(acao, paginaId, lote);
     }
 }
Beispiel #7
0
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            var documento = this.CriarDocumento(acao, lote);

            lote.Documentos.Add(DocumentoParaSeparacaoViewModel.Criar(documento));
            lote.DocumentosNovos.Add(documento);
            lote.MarcaDocumentoManipulado(documento.Id);

            this.SalvarPaginas(documento, acao, lote);
        }
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            var ordemPagina    = 1;
            var ordemDocumento = 1;
            var documentoAtual = new DocumentoParaSeparacaoViewModel();

            foreach (var paginaId in acao.Paginas)
            {
                var documentoDaPagina = lote.ObterDocumentoDaPagina(paginaId);
                var pagina            = lote.ObterPagina(paginaId);

                if (documentoAtual != documentoDaPagina)
                {
                    ordemDocumento++;
                    documentoAtual = documentoDaPagina;

                    if (ordemDocumento != documentoAtual.Ordem)
                    {
                        documentoAtual.NovaOrdem = ordemDocumento;
                        this.documentoRepositorio.AlterarOrdem(documentoAtual.Id, documentoAtual.NovaOrdem);
                        this.documentoRepositorio.AlterarOrdemPais(documentoAtual.Id, documentoAtual.NovaOrdem);

                        this.gravaLogDoDocumentoServico.Executar(LogDocumento.AcaoMudancaDeOrdem,
                                                                 documentoAtual.Id,
                                                                 string.Format("Mudança de ordem. De #{0} para #{1}. [{2}]", documentoAtual.Ordem, documentoAtual.NovaOrdem, lote.Fase));

                        lote.MarcaDocumentoManipulado(documentoAtual.Id);

                        this.AtualizarOrdemDocumentoNovo(lote, documentoAtual);
                    }
                }

                var ordemOriginal = pagina.Ordem;
                if (ordemOriginal != ordemPagina)
                {
                    pagina.Ordem = ordemPagina;
                    this.paginaRepositorio.AlterarOrdem(pagina.Id, ordemPagina);

                    this.gravaLogDaPaginaServico.Executar(LogPagina.AcaoMudarOrdem,
                                                          paginaId, pagina.DocumentoAtualId(),
                                                          string.Format("Mudança de ordem. De #{0} para #{1}. [{2}]", ordemOriginal, ordemPagina, lote.Fase));

                    lote.MarcaDocumentoManipulado(pagina.DocumentoAtualId());
                }

                ordemPagina++;
            }
        }
Beispiel #9
0
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            if (acao.NovoDocumentoId < 1)
            {
                return;
            }

            var paginaView = lote.ObterPagina(acao.PrimeiraPagina);

            paginaView.NovoDocumentoId = acao.NovoDocumentoId;

            this.paginaRepositorio.AlterarDocumento(paginaView.Id, acao.NovoDocumentoId);

            this.gravaLogDaPaginaServico.Executar(LogPagina.AcaoDocumentoCriadoNaSeparacao,
                                                  paginaView.Id,
                                                  paginaView.NovoDocumentoId,
                                                  string.Format("Página movida para documento #{0}, documento anterior era #{1}. {2}", acao.NovoDocumentoId, acao.DocumentoOrigemId, lote.Fase));

            lote.MarcaDocumentoManipulado(acao.NovoDocumentoId);
            lote.MarcaDocumentoManipulado(acao.DocumentoOrigemId);
        }
Beispiel #10
0
        private void SalvarPaginas(Documento documento, AcaoDeTriagemPreOcr acao, LoteTriagemViewModel loteViewModel)
        {
            foreach (var paginaId in acao.Paginas)
            {
                var pagina            = this.paginaRepositorio.ObterPorId(paginaId);
                var documentoOriginal = this.documentoRepositorio.ObterPorId(pagina.Documento.Id);

                var paginaViewModel = loteViewModel.ObterPagina(paginaId);

                var paginaEstavaExcluida = paginaViewModel == null ||
                                           paginaViewModel.Status == PaginaStatus.StatusExcluida;

                if (documentoOriginal.TipoDocumento.Id != TipoDocumento.CodigoDocumentoGeral)
                {
                    loteViewModel.MarcaDocumentoManipulado(documentoOriginal.Id);
                }

                if ((documentoOriginal.TipoDocumento.Id == TipoDocumento.CodigoDocumentoGeral &&
                     documentoOriginal.Status == DocumentoStatus.Excluido) ||
                    paginaEstavaExcluida)
                {
                    pagina.Status = PaginaStatus.StatusExcluida;
                }

                pagina.Documento = documento;
                this.paginaRepositorio.Salvar(pagina);

                documento.Paginas.Add(pagina);

                this.documentoRepositorio.AlterarMarca(documentoOriginal.Id, Documento.MarcaDeAlteradoNaSeparacao);
                loteViewModel.MarcaDocumentoManipulado(documentoOriginal.Id);

                this.gravaLogDaPaginaServico.Executar(LogPagina.AcaoDocumentoCriadoNaSeparacao,
                                                      pagina.Id,
                                                      pagina.Documento.Id,
                                                      string.Format("Página movida para documento #{0}, documento anterior era #{1}. [{2}]", documento.Id, documentoOriginal.Id, loteViewModel.Fase));

                loteViewModel.ObterPagina(paginaId).NovoDocumentoId = documento.Id;
            }
        }
        private void ExecutarAcao(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            switch (acao.Tipo)
            {
            case AcaoDeTriagemPreOcr.RessuscitarPagina:
            case AcaoDeTriagemPreOcr.RessuscitarFolha:
                this.ressuscitaPaginaNaTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.ExcluirPagina:
            case AcaoDeTriagemPreOcr.ExcluirFolha:
                this.excluiPaginaNaTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.NovoDocumento:
                this.criaDocumentoNaTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.ReclassificarDocumento:
                this.reclassificaDocumentoNaTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.MudarPaginaDeDocumento:
                this.mudaPaginaDeDocumentoNaTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.ReordenarPaginas:
                this.reordenaPaginasTriagemServico.Executar(acao, lote);
                break;

            case AcaoDeTriagemPreOcr.GirarHorario:
            case AcaoDeTriagemPreOcr.GirarAntiHorario:
            case AcaoDeTriagemPreOcr.Girar180:
                this.gravaGiroNaTriagemServico.Executar(acao, lote);
                break;

            default:
                throw new RegraDeNegocioException("Tipo de ação não esperada! #" + acao.Tipo);
            }
        }
        private void GravarAjusteDeGiro(AcaoDeTriagemPreOcr acao, int paginaId, LoteTriagemViewModel lote)
        {
            var documento = this.ObterDocumento(paginaId, lote);

            var ajuste = new AjusteDeDocumento
            {
                Acao            = AcaoAjusteDeDocumento.FromValue(acao.Tipo),
                Documento       = documento,
                Status          = AjusteDeDocumento.SituacaoAberto,
                DataRegistro    = DateTime.Now,
                UsuarioCadastro = (Usuario)this.userSession.UsuarioAtual,
                Pagina          = paginaId
            };

            this.ajusteDeDocumentoRepositorio.Salvar(ajuste);

            this.gravaLogDaPaginaServico.Executar(LogPagina.AcaoGiroManual,
                                                  paginaId,
                                                  documento.Id,
                                                  string.Format("Giro manual [{0}] [{1}]", acao.Tipo, lote.Fase));

            lote.MarcaDocumentoManipulado(documento.Id);
        }
Beispiel #13
0
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            var paginaViewModel = lote.ObterPagina(acao.PrimeiraPagina);

            paginaViewModel.Status = PaginaStatus.StatusExcluida;
            var documentoId = paginaViewModel.DocumentoAtualId();

            this.paginaRepositorio.AlterarStatus(paginaViewModel.Id, PaginaStatus.StatusExcluida);

            this.documentoRepositorio.AlterarMarca(documentoId, Documento.MarcaDeAlteradoNaSeparacao);
            lote.MarcaDocumentoManipulado(documentoId);

            switch (acao.Tipo)
            {
            case AcaoDeTriagemPreOcr.ExcluirPagina:
                this.gravaLogDaPaginaServico.Executar(
                    LogPagina.AcaoPaginaExcluida,
                    paginaViewModel.Id,
                    documentoId,
                    string.Format("Página removida. MDoc Anterior #{0} [{1}]", documentoId, lote.Fase));
                break;

            default:
                this.gravaLogDaPaginaServico.Executar(
                    LogPagina.AcaoFolhaExcluida,
                    paginaViewModel.Id,
                    documentoId,
                    string.Format("Folha separadora removida. MDoc Anterior #{0} [{1}]", documentoId, lote.Fase));
                break;
            }

            ////this.gravaLogDoDocumentoServico.Executar(
            ////    LogDocumento.AcaoPaginaRemovida,
            ////    documentoId,
            ////    string.Format("Página #{0} foi removida [{1}]", paginaViewModel.Id, lote.Fase));
        }
Beispiel #14
0
        public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
        {
            this.Reclassificar(acao.NovoDocumentoId, acao.TipoDocumentoId, lote);

            this.ClassificarFilhos(acao.NovoDocumentoId, acao.TipoDocumentoId, lote);
        }