예제 #1
0
        public void Executar(LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var paginas = loteParaSeparacao.ObterPaginas();
            var listaDocumentacaoGeral = this.documentoRepositorio.ObterDocumentosDoLotePorTipo(loteParaSeparacao.LoteId, TipoDocumento.CodigoDocumentoGeral).Select(x => x.Id).ToList();

            foreach (var documento in loteParaSeparacao.Documentos)
            {
                if (paginas.Any(x => x.DocumentoAtualId() == documento.Id))
                {
                    if (documento.Manipulado && listaDocumentacaoGeral.Any(x => x == documento.Id) == false)
                    {
                        this.documentoRepositorio.AlterarRecognitionService(documento.Id, DocumentoStatus.TransmissaoOk, false);
                    }

                    continue;
                }

                this.Excluir(documento.Id);

                var documentosFilhos = this.documentoRepositorio.ObterFilhos(loteParaSeparacao.LoteId, documento.Id);

                foreach (var documentoFilho in documentosFilhos)
                {
                    this.Excluir(documentoFilho.Id);
                }
            }
        }
        public void Executar(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var documentacaoGeral = this.documentoRepositorio
                                    .ObterPorProcessoETipo(loteParaSeparacao.ProcessoId, TipoDocumento.CodigoDocumentoGeral)
                                    .FirstOrDefault();

            if (documentacaoGeral == null || documentacaoGeral.Id < 1)
            {
                return;
            }

            var pagina            = this.paginaRepositorio.ObterPorId(acao.PrimeiraPagina);
            var documentoOriginal = this.documentoRepositorio.ObterPorId(pagina.Documento.Id);

            pagina.Status    = PaginaStatus.StatusExcluida;
            pagina.Documento = new Documento {
                Id = documentacaoGeral.Id
            };

            this.paginaRepositorio.Salvar(pagina);

            this.documentoRepositorio.AlterarMarca(documentoOriginal.Id, Documento.MarcaDeAlteradoNaSeparacao);
            ////this.documentoRepositorio.AlterarStatus(documentoOriginal.Id, DocumentoStatus.TransmissaoOk);
            loteParaSeparacao.MarcaDocumentoManipulado(documentoOriginal.Id);

            this.gravaLogDaPaginaServico.Executar(LogPagina.AcaoPaginaExcluida,
                                                  pagina.Id,
                                                  pagina.Documento.Id,
                                                  "Página removida na separação. MDoc Anterior #" + documentoOriginal.Id);

            this.gravaLogDoDocumentoServico.Executar(
                LogDocumento.AcaoPaginaRemovida,
                documentoOriginal.Id,
                string.Format("Página #{0} foi removida na separação manual", pagina.Id));
        }
        public void Executar(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var novoDocumentoId = this.ObterDocumentoDaPagina(acao.PrimeiraPagina, loteParaSeparacao);

            var pagina            = this.paginaRepositorio.ObterPorId(acao.PrimeiraPagina);
            var documentoAnterior = this.documentoRepositorio.ObterPorId(pagina.Documento.Id);

            var novoDocumento = documentoAnterior.Id == novoDocumentoId ?
                                documentoAnterior :
                                this.documentoRepositorio.ObterPorId(novoDocumentoId);

            if (novoDocumento.TipoDocumento.Id == TipoDocumento.CodigoDocumentoGeral)
            {
                novoDocumentoId = loteParaSeparacao.ObterDocumentoDaPagina(pagina.Id).Id;
                novoDocumento   = this.documentoRepositorio.ObterPorId(novoDocumentoId);
            }

            pagina.Status    = PaginaStatus.StatusParaReconhecimento;
            pagina.Documento = novoDocumento;
            this.paginaRepositorio.Salvar(pagina);

            this.MarcaDocumentoAlterado(novoDocumento, loteParaSeparacao);

            if (documentoAnterior.Id != novoDocumento.Id)
            {
                this.MarcaDocumentoAlterado(documentoAnterior, loteParaSeparacao);
            }

            this.gravaLogDoDocumentoServico.Executar(
                LogDocumento.AcaoPaginaRessucitada,
                pagina.Documento.Id,
                string.Format("Página {0} foi ressucitada na separação manual. Doc anterior #{1}", pagina.Id, documentoAnterior.Id));
        }
예제 #4
0
        private Documento CriarDocumento(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var processo = new Processo
            {
                Id   = loteParaSeparacao.ProcessoId,
                Lote = new Lote {
                    Id = loteParaSeparacao.LoteId
                }
            };

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

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

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

            this.gravaLogDoDocumentoServico.Executar(
                LogDocumento.AcaoDocumentoCriadoNaSeparacao,
                documento.Id,
                "Documento criado na separação");

            return(documento);
        }
        private DocumentoParaSeparacaoViewModel ObterDocumento(int documentoId, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var documento = loteParaSeparacao.Documentos.FirstOrDefault(x => x.Id == documentoId);

            return(documento ?? new DocumentoParaSeparacaoViewModel {
                Id = documentoId
            });
        }
예제 #6
0
        public void Executar(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var documento = this.CriarDocumento(acao, loteParaSeparacao);

            loteParaSeparacao.Documentos.Add(DocumentoParaSeparacaoViewModel.Criar(documento));
            loteParaSeparacao.DocumentosNovos.Add(documento);

            this.SalvarPaginas(documento, acao, loteParaSeparacao);
        }
        public LoteParaSeparacaoViewModel Executar(int processoId)
        {
            var processo = this.processoRepositorio.ObterComPacote(processoId);

            var lote = LoteParaSeparacaoViewModel.Criar(processo);

            lote.Documentos = this.montaDocumentosParaSeparacaoServico.Executar(processo.Lote);

            return(lote);
        }
        private void MarcaDocumentoAlterado(Documento documento, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            this.documentoRepositorio.AlterarMarca(documento.Id, Documento.MarcaDeAlteradoNaSeparacao);

            if (documento.TipoDocumento.Id != TipoDocumento.CodigoDocumentoGeral)
            {
                this.documentoRepositorio.AlterarStatus(documento.Id, DocumentoStatus.StatusParaReconhecimento);
            }

            loteParaSeparacao.MarcaDocumentoManipulado(documento.Id);
        }
        private void AtualizarOrdemDocumentoNovo(LoteParaSeparacaoViewModel loteParaSeparacao, DocumentoParaSeparacaoViewModel documento)
        {
            var documentoNovo = loteParaSeparacao.DocumentosNovos.FirstOrDefault(x => x.Id == documento.Id);

            if (documentoNovo == null)
            {
                return;
            }

            documentoNovo.Ordem = documento.NovaOrdem;
            this.documentoRepositorio.Salvar(documentoNovo);
        }
        public void Executar(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var tipoDocumento = this.tipoDocumentoRepositorio.ObterPorId(acao.TipoDocumentoId);

            var documento = this.documentoRepositorio.ObterPorId(acao.NovoDocumentoId);

            this.Reclassificar(documento, tipoDocumento);

            var documentosFilhos = this.documentoRepositorio.ObterFilhos(documento.Lote.Id, documento.Id);

            foreach (var documentoFilho in documentosFilhos)
            {
                this.Reclassificar(documentoFilho, tipoDocumento);
            }
        }
        public void Executar(LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var documentosOrdenados = this.ObterDocumentosOrdenados(loteParaSeparacao);

            foreach (var documento in documentosOrdenados.Where(x => x.Ordem != x.NovaOrdem))
            {
                this.documentoRepositorio.AlterarOrdem(documento.Id, documento.NovaOrdem);
                this.documentoRepositorio.AlterarOrdemPais(documento.Id, documento.NovaOrdem);

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

                this.AtualizarOrdemDocumentoNovo(loteParaSeparacao, documento);
            }
        }
예제 #12
0
        public void Executar(LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var documentosDoProcesso = this.documentoRepositorio.ObterPorProcesso(loteParaSeparacao.ProcessoId);
            var documentosAlterados  = loteParaSeparacao.ObterDocumentosAlterados();

            foreach (var documentoId in documentosAlterados)
            {
                var documentosFilhos = this.ObterFilhos(documentosDoProcesso, documentoId);

                if (documentosFilhos == null || documentosFilhos.Any() == false)
                {
                    continue;
                }

                this.ExcluirDocumentos(documentosDoProcesso, documentosFilhos);
            }
        }
예제 #13
0
        private void SalvarPaginas(Documento documento, AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var listaDocumentacaoGeral = this.documentoRepositorio.ObterDocumentosDoLotePorTipo(documento.Lote.Id, TipoDocumento.CodigoDocumentoGeral).Select(x => x.Id).ToList();

            foreach (var paginaId in acao.Paginas)
            {
                var pagina            = this.paginaRepositorio.ObterPorId(paginaId);
                var documentoOriginal = this.documentoRepositorio.ObterPorId(pagina.Documento.Id);

                //// manda refazer o PDF do documento original, se for diferente de 27
                if (listaDocumentacaoGeral.Any(x => x == documentoOriginal.Id) == false)
                {
                    loteParaSeparacao.MarcaDocumentoManipulado(documentoOriginal.Id);
                }

                var paginaParaSeparacaoAtual = loteParaSeparacao.ObterPagina(paginaId).Status;
                var paginaEstavaExcluida     = paginaParaSeparacaoAtual == null ||
                                               loteParaSeparacao.ObterPagina(paginaId).Status == PaginaStatus.StatusExcluida;

                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);

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

                loteParaSeparacao.ObterPagina(paginaId).NovoDocumentoId = documento.Id;
            }
        }
예제 #14
0
        private void ExecutarAcao(AcaoDeSeparacao acao, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            switch (acao.Tipo)
            {
            case AcaoDeSeparacao.RessuscitarPagina:
                this.ressuscitaPaginaNaSeparacaoServico.Executar(acao, loteParaSeparacao);
                break;

            case AcaoDeSeparacao.ExcluirPagina:
                this.excluiPaginaNaSeparacaoServico.Executar(acao, loteParaSeparacao);
                break;

            case AcaoDeSeparacao.NovoDocumento:
                this.criaDocumentoNaSeparacaoServico.Executar(acao, loteParaSeparacao);
                break;

            case AcaoDeSeparacao.ReclassificarDocumento:
                this.reclassificaDocumentoNaSeparacaoServico.Executar(acao, loteParaSeparacao);
                break;
            }
        }
        private int ObterDocumentoDaPagina(int paginaId, LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var paginaParaSeparacao = loteParaSeparacao.ObterPagina(paginaId);

            return(paginaParaSeparacao.DocumentoAtualId());
        }
        private IEnumerable <DocumentoParaSeparacaoViewModel> ObterDocumentosOrdenados(LoteParaSeparacaoViewModel loteParaSeparacao)
        {
            var paginas = loteParaSeparacao.ObterPaginas();
            //// começa sempre na 2 (a primeira é capa m2sys)
            var ordemDocumento    = 2;
            var listaDeDocumentos = new List <DocumentoParaSeparacaoViewModel>();

            var listaDeDocumentacaoGeral = this.documentoRepositorio
                                           .ObterDocumentosDoLotePorTipo(loteParaSeparacao.LoteId, TipoDocumento.CodigoDocumentoGeral);

            foreach (var pagina in paginas.OrderBy(x => x.Ordem))
            {
                var documentoId = pagina.DocumentoAtualId();

                if (listaDeDocumentos.Any(x => x.Id == documentoId) ||
                    listaDeDocumentacaoGeral.Any(x => x.Id == documentoId))
                {
                    continue;
                }

                var documento = this.ObterDocumento(documentoId, loteParaSeparacao);
                documento.NovaOrdem = ordemDocumento;

                listaDeDocumentos.Add(documento);
                ordemDocumento++;
            }

            return(listaDeDocumentos);
        }