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);
}
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 void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
{
foreach (var paginaId in acao.Paginas)
{
this.GravarAjusteDeGiro(acao, paginaId, lote);
}
}
private void Reclassificar(int documentoId, int tipoDocumentoId, LoteTriagemViewModel lote)
{
this.documentoRepositorio.AlterarTipo(documentoId, tipoDocumentoId);
this.gravaLogDoDocumentoServico.Executar(LogDocumento.AcaoDocumentoReclassificadoNaTriagem,
documentoId,
string.Format("Documento reclassificado - Tipo: {0}. [{1}]", tipoDocumentoId, lote.Fase));
}
private DocumentoParaSeparacaoViewModel ObterDocumento(int documentoId, LoteTriagemViewModel loteParaSeparacao)
{
var documento = loteParaSeparacao.Documentos.FirstOrDefault(x => x.Id == documentoId);
return(documento ?? new DocumentoParaSeparacaoViewModel {
Id = documentoId
});
}
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);
}
private void ClassificarFilhos(int documentoId, int tipoDocumentoId, LoteTriagemViewModel lote)
{
var documentos = this.documentoRepositorio.ObterPorLoteComTipo(new Lote {
Id = lote.LoteId
});
foreach (var documento in documentos.Where(x => x.DocumentoPaiId == documentoId))
{
this.Reclassificar(documento.Id, tipoDocumentoId, lote);
}
}
private void ExecutaAcoes(IList <AcaoDeTriagemPreOcr> acoes, LoteTriagemViewModel lote)
{
foreach (var acao in acoes)
{
if (this.IgnorarAcao(acao, acoes))
{
continue;
}
this.ExecutarAcao(acao, lote);
}
}
private void AtualizarOrdemDocumentoNovo(LoteTriagemViewModel 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 LoteTriagemViewModel Obter(int processoId, bool ignorarExcluidas, string fase)
{
var processo = this.processoRepositorio.ObterComPacote(processoId);
this.processoRepositorio.AlterarResponsavel(processoId, this.userSession.UsuarioAtual.Id);
var lote = LoteTriagemViewModel.Criar(processo, fase);
lote.Documentos = this.montaDocumentosParaTriagemServico.Executar(processo.Lote, ignorarExcluidas);
return(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++;
}
}
public void Executar(LoteTriagemViewModel lote)
{
var documentosOrdenados = this.ObterDocumentosOrdenados(lote);
foreach (var documento in documentosOrdenados)
{
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(lote, documento);
}
}
private void Excluir(int documentoId, LoteTriagemViewModel lote)
{
this.documentoRepositorio.AlterarStatus(documentoId, DocumentoStatus.Excluido);
this.gravaLogDoDocumentoServico.Executar(LogDocumento.AcaoExcluidoNaClassificacao, documentoId, "Documento excluído porque ficou sem páginas. " + lote.Fase);
if (lote.DocumentosNovos == null)
{
return;
}
var documentoNovo = lote.DocumentosNovos.FirstOrDefault(x => x.Id == documentoId);
if (documentoNovo != null)
{
documentoNovo.Status = DocumentoStatus.Excluido;
}
}
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);
}
public void Executar(LoteTriagemViewModel lote)
{
var paginas = lote.ObterPaginas();
foreach (var documento in lote.Documentos)
{
if (paginas.Any(x => x.DocumentoAtualId() == documento.Id && x.Status != PaginaStatus.StatusExcluida))
{
continue;
}
this.Excluir(documento.Id, lote);
var documentosFilhos = this.documentoRepositorio.ObterFilhos(lote.LoteId, documento.Id);
foreach (var documentoFilho in documentosFilhos)
{
this.Excluir(documentoFilho.Id, lote);
}
}
}
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 Documento ObterDocumento(int paginaId, LoteTriagemViewModel lote)
{
var documentoViewModel = lote.ObterDocumentoDaPagina(paginaId);
if (documentoViewModel != null && documentoViewModel.Id > 0)
{
return(new Documento {
Id = documentoViewModel.Id
});
}
var pagina = this.paginaRepositorio.ObterPorId(paginaId);
if (pagina != null && pagina.Documento != null)
{
return(pagina.Documento);
}
return(new Documento {
Id = 0
});
}
private void AtualizarDocumentosManipulados(LoteTriagemViewModel loteTriagem)
{
if (loteTriagem != null)
{
//// seta status para 5B para novos mdocs
foreach (var documentosNovo in loteTriagem.DocumentosNovos)
{
documentosNovo.Marca = Documento.MarcaDeAlteradoNaSeparacao;
documentosNovo.Status = DocumentoStatus.StatusParaReconhecimentoPosAjuste;
this.documentoRepositorio.Salvar(documentosNovo);
this.documentoRepositorio.AlterarMarca(documentosNovo.Id, Documento.MarcaDeAlteradoNaSeparacao);
this.documentoRepositorio.AlterarStatus(documentosNovo.Id, DocumentoStatus.StatusParaReconhecimentoPosAjuste);
this.documentoRepositorio.AjusteFinalizado(documentosNovo.Id);
}
foreach (var documento in loteTriagem.Documentos.Where(x => x.Manipulado).Distinct())
{
this.documentoRepositorio.AlterarMarca(documento.Id, Documento.MarcaDeAlteradoNaSeparacao);
this.documentoRepositorio.AlterarStatus(documento.Id, DocumentoStatus.StatusParaReconhecimentoPosAjuste);
this.documentoRepositorio.AjusteFinalizado(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);
}
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));
}
private IEnumerable <DocumentoParaSeparacaoViewModel> ObterDocumentosOrdenados(LoteTriagemViewModel lote)
{
var paginas = lote.ObterPaginas();
var ordemDocumento = 1;
var documentosOrdenados = new List <DocumentoParaSeparacaoViewModel>();
var listaDeDocumentacaoGeral = this.documentoRepositorio
.ObterDocumentosDoLotePorTipo(lote.LoteId, TipoDocumento.CodigoDocumentoGeral);
foreach (var pagina in paginas.OrderBy(x => x.Ordem))
{
var documentoId = pagina.DocumentoAtualId();
if (documentosOrdenados.Any(x => x.Id == documentoId) ||
listaDeDocumentacaoGeral.Any(x => x.Id == documentoId))
{
continue;
}
var documento = this.ObterDocumento(documentoId, lote);
documento.NovaOrdem = ordemDocumento;
documentosOrdenados.Add(documento);
ordemDocumento++;
}
return(documentosOrdenados);
}
public void Executar(AcaoDeTriagemPreOcr acao, LoteTriagemViewModel lote)
{
this.Reclassificar(acao.NovoDocumentoId, acao.TipoDocumentoId, lote);
this.ClassificarFilhos(acao.NovoDocumentoId, acao.TipoDocumentoId, lote);
}
