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++;
            }
        }
示例#2
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);
        }
示例#3
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);
        }
示例#4
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);
        }
示例#5
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 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);
        }
示例#7
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));
        }