public static EventoStagging duplicarEventoProducao(string matricula, int seguradoraId, string dtInicio, string hInicio, Mutex mutex = null) { ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO", mutex); List<ValorSistema> estadosEvento = valoresSistemaRepository.GetPorTipologia("ESTADO_EVENTO_STAGGING", mutex); DateTime dataInicio; TimeSpan horaInicio; DateTime dataHoraInicio; List<ErroEventoStagging> errosEventoStagging = new List<ErroEventoStagging>(); if (matricula == null || matricula == string.Empty) { errosEventoStagging.Add(new ErroEventoStagging { campo = "matricula", descricao = "Matrícula Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (!DateTime.TryParseExact(dtInicio, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataInicio)) { errosEventoStagging.Add(new ErroEventoStagging { campo = "dataInicio", descricao = "Data de início de período Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (!TimeSpan.TryParseExact(hInicio, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaInicio)) { errosEventoStagging.Add(new ErroEventoStagging { campo = "horaInicio", descricao = "Hora de início de período Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (errosEventoStagging.Count > 0) throw new ErroEventoStaggingException { errosEventoStagging = errosEventoStagging }; dataHoraInicio = dataInicio.Add(horaInicio); ApoliceRepository apolicesRepository = new ApoliceRepository(); List<Apolice> apolicesProducao = apolicesRepository.All.Include("veiculo").Include("veiculo.categoria").Include("tomador") .Include("concelho").Include("eventoHistorico").Where(e => e.veiculo.numeroMatricula == matricula && e.entidadeId == seguradoraId && e.dataInicio == dataHoraInicio).ToList(); if (apolicesProducao == null || apolicesProducao.Count == 0) { return new EventoStagging { entidadeId = seguradoraId}; //return new EventoStagging() - Construtor vazio nao tem base } if (apolicesProducao.Count > 1) { //Erro interno; Não deveria existir esta situação } return new EventoStagging(apolicesProducao.First(), estadosEvento.Where(e=>e.valor == "PENDENTE").Single().valorSistemaId); //return new EventoStagging(eventosProducao.First()) }
public static EventoStagging duplicarEventoStagging(string matricula, int seguradoraId, string dtInicio, string hInicio, string operacao, Mutex mutex = null) { ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO", mutex); List<ErroEventoStagging> errosEventoStagging = new List<ErroEventoStagging>(); if (matricula == null || matricula == string.Empty) { errosEventoStagging.Add(new ErroEventoStagging { campo = "matricula", descricao = "Matrícula Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (dtInicio == null || dtInicio == string.Empty) { errosEventoStagging.Add(new ErroEventoStagging { campo = "dataInicio", descricao = "Data de início de período Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (hInicio == null || hInicio == string.Empty) { errosEventoStagging.Add(new ErroEventoStagging { campo = "horaInicio", descricao = "Hora de início de período Inválida", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId }); } if (errosEventoStagging.Count > 0) throw new ErroEventoStaggingException { errosEventoStagging = errosEventoStagging}; EventoStaggingRepository eventosStaggingRepository = new EventoStaggingRepository(); List<EventoStagging> eventosStagging = eventosStaggingRepository.All.Where(e => e.matricula == matricula && e.entidadeId == seguradoraId && e.dataInicioCobertura == dtInicio && e.horaInicioCobertura == hInicio && e.estadoEvento.valor == "ERRO" && e.arquivado == false && e.codigoOperacao == operacao).ToList(); if (eventosStagging == null || eventosStagging.Count == 0) { return null; //return new EventoStagging() - Construtor vazio nao tem base } if (eventosStagging.Count > 1) { //Erro interno; Não deveria existir esta situação } return new EventoStagging(eventosStagging.First()); //new EventoStagging(eventosStagging.First()) //Adicionar Erros }
private void timer_Tick(object source, ElapsedEventArgs e) { //eventLog.WriteEntry("FNMPAS File Agent Timer Tick"); FicheiroIsentosRepository ficheiroIsentosRepository = new FicheiroIsentosRepository(); ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); List<ValorSistema> estadosFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO"); IQueryable<FicheiroIsentos> query = null; query = ficheiroIsentosRepository.All.Where(f => f.estado.valor == "PENDENTE").OrderBy(file => file.dataAlteracao); foreach (FicheiroIsentos file in query.ToList()) { //file.estadoId = estadosFicheiro.Where(ef => ef.valor == "EM_PROCESSAMENTO").Single().valorSistemaId; List<ErroFicheiro> errosFicheiro = new List<ErroFicheiro>(); try { file.validar(); ProcessadorFicheiros.processaFicheiroIsentos(file); //file.totalRegistos = file.Count(); } catch (ErroFicheiroException ex) { //file.errosFicheiro = ex.errosFicheiro; //file.estadoId = estadosFicheiro.Where(ef => ef.valor == "ERRO").Single().valorSistemaId; //ficheiroRepository.Save(); continue; } catch (Exception ex) { } ficheiroIsentosRepository.InsertOrUpdate(file); ficheiroIsentosRepository.Save(); } }
public static void processaFicheiroIsentos(FicheiroIsentos ficheiro) { //FicheiroIsentosRepository ficheirosIsentosRepository = new FicheiroIsentosRepository(); ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); ApoliceIsentoRepository apolicesIsentoRepository = new ApoliceIsentoRepository(); NotificacaoRepository notificacoesRepository = new NotificacaoRepository(); //List<ValorSistema> valoresSistema = valoresSistemaRepository.All.Where(v => v.tipologia == "TIPO_AVISO" || v.tipologia == "ESTADO_FICHEIRO").ToList(); //ValorSistema tipoNotificacao = valoresSistema.Where(v => v.tipologia == "TIPO_AVISO" && v.valor == "GENERICO").Single(); //ValorSistema valErroFicheiro = valoresSistema.Where(v => v.tipologia == "ESTADO_FICHEIRO" && v.valor == "ERRO").Single(); //ValorSistema valProcessadoFicheiro = valoresSistema.Where(v => v.tipologia == "ESTADO_FICHEIRO" && v.valor == "PROCESSADO").Single(); ValorSistema tipoNotificacao = valoresSistemaRepository.GetPorTipologia("TIPO_AVISO").Where(v => v.valor == "GENERICO").Single(); ValorSistema valErroFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO").Where(v => v.valor == "ERRO").Single(); ValorSistema valProcessadoFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO").Where(v => v.valor == "PROCESSADO").Single(); //Insere os novos registos de períodos isentos que são reportados no ficheiro bool erroFicheiro = false; DateTime dataRegisto = DateTime.Now; DateTime dataInicioTemp; DateTime? dataFimTemp; DateTime dataAux; var excel = new ExcelQueryFactory(ficheiro.localizacao); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.matricula, "MATRICULA"); // ou excel.AddMapping("matricula", "MATRICULA"); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.mensagem, "MENSAGEM"); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.entidadeResponsavel, "ENTIDADE"); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.dataInicio, "DATA_INICIO"); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.dataFim, "DATA_FIM"); excel.AddMapping<RegistoExcelMatriculaIsenta>(x => x.confidencial, "CONFIDENCIAL"); var matriculasIsentas = from m in excel.Worksheet<RegistoExcelMatriculaIsenta>("Resultados") select m; foreach (RegistoExcelMatriculaIsenta mat in matriculasIsentas) { if (mat.matricula == null || mat.matricula == string.Empty || ! DateTime.TryParseExact(mat.dataInicio, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataInicioTemp)) { erroFicheiro = true; break; } if (DateTime.TryParseExact(mat.dataFim, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataAux)) dataFimTemp = dataAux; else dataFimTemp = null; ApoliceIsento isento = new ApoliceIsento() { entidadeId = ficheiro.entidadeId.Value, matricula = mat.matricula, matriculaCorrigida = mat.matricula.Replace("-",""), entidadeResponsavel = mat.entidadeResponsavel, mensagem = mat.mensagem, dataInicio = dataInicioTemp, dataFim = dataFimTemp, confidencial = mat.confidencial, origemFicheiro = true, arquivo = false, dataReporte = ficheiro.dataUpload, dataCriacao = dataRegisto, dataModificacao = dataRegisto, }; ficheiro.apolicesIsentos.Add(isento); } Notificacao notif = new Notificacao(); if (!erroFicheiro) { //Coloca para arquivo todos os registos de períodos isentos que foram inseridos via ficheiro. List<ApoliceIsento> periodosAtivos = apolicesIsentoRepository.All.Where(m => m.arquivo == false && m.origemFicheiro == true && m.dataCriacao < dataRegisto).ToList(); if (periodosAtivos != null && periodosAtivos.Count > 0) { foreach(ApoliceIsento isento in periodosAtivos) { isento.arquivo = true; apolicesIsentoRepository.InsertOrUpdate(isento); } } apolicesIsentoRepository.Save(); string mensagemNotificacao = string.Format("O ficheiro de reporte e matriculas isentas de seguro com o nome {0} e submetido na data {1}, " + "foi processado com sucesso sendo registados {2} matriculas.", ficheiro.nomeFicheiro, ficheiro.dataUpload.ToString(), ficheiro.apolicesIsentos.Count); notif.dataCriacao = DateTime.Now; notif.email = false; notif.entidadeId = ficheiro.entidadeId; notif.mensagem = mensagemNotificacao; notif.tipologiaId = tipoNotificacao.valorSistemaId; ficheiro.estadoId = valProcessadoFicheiro.valorSistemaId; } else { string mensagemNotificacao = string.Format("O ficheiro de reporte e matriculas isentas de seguro com o nome {0} e submetido na data {1}, " + "não foi processado devido a um erro da informação relativa ao número de matrícula ou à data de início do período.", ficheiro.nomeFicheiro, ficheiro.dataUpload.ToString()); notif.dataCriacao = DateTime.Now; notif.email = false; notif.entidadeId = ficheiro.entidadeId; notif.mensagem = mensagemNotificacao; notif.tipologiaId = tipoNotificacao.valorSistemaId; ficheiro.estadoId = valErroFicheiro.valorSistemaId; } notificacoesRepository.InsertOrUpdate(notif); notificacoesRepository.Save(); //ficheirosIsentosRepository.InsertOrUpdate(ficheiro); //ficheirosIsentosRepository.Save(); }
public static void processaFicheiro(Ficheiro ficheiro){ ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); //List<ValorSistema> valSistema = valoresSistemaRepository.All.Where(v => v.tipologia == "ESTADO_EVENTO_STAGGING" || v.tipologia == "OPERACAO_EVENTO").ToList(); //List<ValorSistema> estadosEvento = valSistema.Where(v => v.tipologia == "ESTADO_EVENTO_STAGGING").ToList(); //List<ValorSistema> operacoesEvento = valSistema.Where(v => v.tipologia == "OPERACAO_EVENTO").ToList(); List<ValorSistema> estadosEvento = valoresSistemaRepository.GetPorTipologia("ESTADO_EVENTO_STAGGING"); List<ValorSistema> operacoesEvento = valoresSistemaRepository.GetPorTipologia("OPERACAO_EVENTO"); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO"); List<ValorSistema> estadosFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO"); ReporteOcorrenciasMatricula reporte; XmlSerializer serializer = new XmlSerializer(typeof(ReporteOcorrenciasMatricula)); using (FileStream fileStream = new FileStream(ficheiro.localizacao, FileMode.Open)) { reporte = (ReporteOcorrenciasMatricula)serializer.Deserialize(fileStream); } if (reporte.Cabecalho.CodigoEstatistico != ficheiro.entidade.codigoEntidade) { ErroFicheiro erroFicheiro = new ErroFicheiro(){ dataValidacao = DateTime.Now, tipologiaId = tiposErro.Single(e => e.valor == "GENERICO").valorSistemaId, descricao = "Ficheiro reportado pela entidade com código '" + ficheiro.entidade.codigoEntidade + "' e com registos relativos à entidade '" + reporte.Cabecalho.CodigoEstatistico + "'.", ficheiroId = ficheiro.ficheiroId }; ErroFicheiroException ex = new ErroFicheiroException(); ex.errosFicheiro.Add(erroFicheiro); throw ex; } ReporteOcorrenciasFNMPAS reporteOcorrenciasFNMPAS = new ReporteOcorrenciasFNMPAS(reporte); reporteOcorrenciasFNMPAS.ordenaOcorrencias(); for (int i = 0; i < reporteOcorrenciasFNMPAS.OcorrenciaOrdenada.Count(); i++) { ReporteOcorrenciasMatriculaOcorrenciaOrdenada ocorrencia = reporteOcorrenciasFNMPAS.OcorrenciaOrdenada[i]; //evento Duplicado e esmagado com os novos dados. (C M - stagging/producao) (A - producao/stagging) //Não foi ainda inserido na Base de dados nem houve delete logico do anterior. //Fazer deletes logicos, e inserções após verificações. //Anulações podem necessitar logica adicional caso a validação falhe. (duplicar registo em stagging) EventoStagging evento = new EventoStagging(); int codigoOperacaoId = 0; switch (ocorrencia.CodigoOperacao) { case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.C: codigoOperacaoId = operacoesEvento.Where(o=> o.valor =="C").Single().valorSistemaId; break; case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.M: codigoOperacaoId = operacoesEvento.Where(o=> o.valor =="M").Single().valorSistemaId; break; case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.A: codigoOperacaoId = operacoesEvento.Where(o=> o.valor =="A").Single().valorSistemaId; break; default: codigoOperacaoId = operacoesEvento.Where(o => o.valor == "C").Single().valorSistemaId; break; } evento.esmagaDados(ocorrencia, ficheiro, codigoOperacaoId); evento.estadoEventoId = estadosEvento.Where(e => e.valor == "PENDENTE").Single().valorSistemaId; ficheiro.eventosStagging.Add(evento); } //EventoStaggingRepository eventosStaggingRepository = new EventoStaggingRepository(); //eventosStaggingRepository.InsertOrUpdate(evento); //eventosStaggingRepository.Save(); }
public static bool validarNegocio(EventoStagging eventoStagging, Mutex mutex = null) { ApoliceRepository apolicesRepository = new ApoliceRepository(); ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO", mutex); List<ValorSistema> tiposAviso = valoresSistemaRepository.GetPorTipologia("TIPO_AVISO", mutex); int tipoErroGenerico = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId; int tipoAvisoGenerico = tiposAviso.Where(e => e.valor == "GENERICO").Single().valorSistemaId; List<Apolice> listaApolices; DateTime dataInicio; DateTime dataFim; TimeSpan horaInicio; TimeSpan horaFim; DateTime.TryParseExact(eventoStagging.dataInicioCobertura, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataInicio); DateTime.TryParseExact(eventoStagging.dataFimCobertura, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataFim); TimeSpan.TryParseExact(eventoStagging.horaInicioCobertura, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaInicio); TimeSpan.TryParseExact(eventoStagging.horaFimCobertura, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaFim); dataInicio = dataInicio.Add(horaInicio); dataFim = dataFim.Add(horaFim); listaApolices = apolicesRepository.All.Include("veiculo").Where(a => a.dataInicio == dataInicio && a.entidadeId == eventoStagging.entidadeId && a.veiculo.numeroMatricula == eventoStagging.matricula).ToList(); //ERROS //Criação para uma chave de registo já existente. - check if (listaApolices != null && listaApolices.Count > 0 && eventoStagging.codigoOperacao == "C") { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "Chave", descricao = "O registo de cobertura já existe. Não é possível efectuar nova criação.", tipologiaId = tipoErroGenerico , eventoStagging = eventoStagging }); } //Data Fim (data + hora) menor ou igual que data de início. - check if(dataFim <= dataInicio){ eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataFim", descricao = "A data/hora de fim da cobertura tem de ser posterior à data/hora de início de cobertura.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //Datas de início inferiores a 01-01-1900. - check if (dataInicio < new DateTime(1900, 01, 01)) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataInício", descricao = "A data de início da cobertura tem de ser posterior à data de 01-01-1900.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //Modificação e Anulação para uma chave de registo não existente - check if ((eventoStagging.codigoOperacao == "A" || eventoStagging.codigoOperacao == "M") && listaApolices.Count == 0) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "Chave", descricao = "O registo de cobertura não existe. Não é possível efectuar modificações ou anulações.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //Modificações com alteração de data/hora Fim. - check if (listaApolices.Count > 0) { if (eventoStagging.codigoOperacao == "M" && dataFim != listaApolices.First().dataFim) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataFim", descricao = "Operações de modificação não podem alterar a data/hora de fim de cobertura.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } } //Anulação para uma data posterior à data fim planeada. - check if (listaApolices.Count > 0) { if (eventoStagging.codigoOperacao == "A" && dataFim > listaApolices.First().dataFimPlaneada) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataFim", descricao = "Anulação não pode alterar a data/hora de fim de cobertura para data posterior à planeada na criação.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } } //AVISOS //Caso a matricula já se encontre associada a outra seguradora que se intercepte o periodo a reportar. - check //registos que originem mais que um seguro válido (inter ou intra seguradoras) if(eventoStagging.codigoOperacao == "C"){ listaApolices = apolicesRepository.All.Include("veiculo").Where(a => a.veiculo.numeroMatricula == eventoStagging.matricula).ToList(); List<Apolice> apolicesCruzadas = new List<Apolice>(); foreach (Apolice ap in listaApolices) { if ((dataInicio >= ap.dataInicio && dataInicio <= ap.dataFim) || (dataFim >= ap.dataInicio && dataFim <= ap.dataFim) || (dataInicio <= ap.dataInicio && dataFim >= ap.dataFim)) { if (!(dataInicio == ap.dataInicio && eventoStagging.entidadeId == ap.entidadeId && eventoStagging.matricula == ap.veiculo.numeroMatricula)) { apolicesCruzadas.Add(ap); } } } if (apolicesCruzadas.Count > 0) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "Matricula", descricao = "O periodo de cobertura apresenta registos cruzados.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } } if (eventoStagging.errosEventoStagging.Count > 0) { return false; } return true; }
public static bool validarCampos(EventoStagging eventoStagging, Mutex mutex = null) { ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); CategoriaRepository categoriasRepository = new CategoriaRepository(); ConcelhoRepository concelhosRepository = new ConcelhoRepository(); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO", mutex); List<ValorSistema> tiposAviso = valoresSistemaRepository.GetPorTipologia("TIPO_AVISO", mutex); int tipoErroGenerico = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId; int tipoAvisoGenerico = tiposAviso.Where(e => e.valor == "GENERICO").Single().valorSistemaId; DateTime aux; int intAux; //ERROS //tem Operação válida if (eventoStagging.codigoOperacao == null) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "CodigoOperacao", descricao = "Código de operação '" + eventoStagging.codigoOperacao + "' inválido.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //tem matrícula válida - check if (eventoStagging.matricula == null || !Regex.Match(eventoStagging.matricula, "[-\\/?#() A-Za-z0-9]+").Success) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "NumeroMatricula", descricao = "Número de matrícula '" + eventoStagging.matricula + "' inválido.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //tem data inicio válida - check if (eventoStagging.dataInicioCobertura == null || eventoStagging.dataInicioCobertura == string.Empty || !DateTime.TryParseExact(eventoStagging.dataInicioCobertura, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out aux)) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataInicio", descricao = "Data de início do período de cobertura '" + eventoStagging.dataInicioCobertura + "' inválida.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //tem data fim válida - check if (eventoStagging.dataFimCobertura == null || eventoStagging.dataFimCobertura == string.Empty || !DateTime.TryParseExact(eventoStagging.dataFimCobertura, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out aux)) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "DataFim", descricao = "Data de fim do período de cobertura '" + eventoStagging.dataInicioCobertura + "' inválida.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } //sem numero de apolice e sem certificado provisório - check if (eventoStagging.nrApolice == null || eventoStagging.nrApolice == string.Empty) { if (eventoStagging.nrCertificadoProvisorio == null || eventoStagging.nrCertificadoProvisorio == string.Empty) { eventoStagging.errosEventoStagging.Add(new ErroEventoStagging { campo = "NumeroApolice", descricao = "Número de apólice ou Número de certificado provisório em falta.", tipologiaId = tipoErroGenerico, eventoStagging = eventoStagging }); } } //AVISOS //tem marca - check if (eventoStagging.marca == null || eventoStagging.marca == string.Empty) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "MarcaVeiculo", descricao = "Marca de veiculo '"+eventoStagging.marca+"' inválida.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //tem modelo - check if (eventoStagging.modelo == null || eventoStagging.modelo == string.Empty) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "ModeloVeiculo", descricao = "Modelo de veiculo '"+eventoStagging.modelo+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //tem ano construção válido - check if (eventoStagging.anoConstrucao == null || eventoStagging.anoConstrucao == string.Empty || !int.TryParse(eventoStagging.anoConstrucao, out intAux) /*|| intAux < 0 || intAux > (DateTime.Now.Year+2)*/) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "AnoConstrucaoVeiculo", descricao = "Ano de construção do veiculo '"+eventoStagging.anoConstrucao+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //tem categoria válida - check if (eventoStagging.codigoCategoriaVeiculo == null || eventoStagging.codigoCategoriaVeiculo == string.Empty) { //TODO: verificar se a categoria existe. Forçar para categoria desconhecida caso não exista. eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "CódigoCategoriaVeiculo", descricao = "Código de categoria do veiculo '" + eventoStagging.codigoCategoriaVeiculo + "' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } else { List<Categoria> queryCategoria = categoriasRepository.All.Where(c => c.codigoCategoriaVeiculo == eventoStagging.codigoCategoriaVeiculo).ToList(); if (queryCategoria.Count == 0) { //TODO: verificar se a categoria existe. Forçar para categoria desconhecida caso não exista. eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "CódigoCategoriaVeiculo", descricao = "Código de categoria do veiculo '" + eventoStagging.codigoCategoriaVeiculo + "' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } } //tem concelho de circulação habitual válido - check if (eventoStagging.codigoConcelhoCirculacao == null || eventoStagging.codigoConcelhoCirculacao == string.Empty) { //TODO: verificar se o concelho existe. Forçar para concelho desconhecido caso não exista. eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "ConcelhoCirculacao", descricao = "Concelho de circulação '"+eventoStagging.codigoConcelhoCirculacao+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } else { List<Concelho> queryCategoria = concelhosRepository.All.Where(c => c.codigoConcelho == eventoStagging.codigoConcelhoCirculacao).ToList(); if (queryCategoria.Count == 0) { //TODO: verificar se a categoria existe. Forçar para categoria desconhecida caso não exista. eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "ConcelhoCirculacao", descricao = "Concelho de circulação '" + eventoStagging.codigoConcelhoCirculacao + "' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } } //tem nome de tomador de seguro - check if (eventoStagging.nomeTomadorSeguro == null || eventoStagging.nomeTomadorSeguro == string.Empty) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "NomeTomador", descricao = "Nome de tomador de seguro '"+eventoStagging.nomeTomadorSeguro+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //tem morada de tomador de seguro - check if (eventoStagging.moradaTomadorSeguro == null || eventoStagging.moradaTomadorSeguro == string.Empty) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "MoradaTomador", descricao = "Morada do tomador de seguro '"+eventoStagging.moradaTomadorSeguro+"' inválida.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //TODO: talvez remover visto não estar na lista de validações //tem codigo postal válido do tomador de seguro if (eventoStagging.codigoPostalTomador == null || eventoStagging.codigoPostalTomador == string.Empty) { //TODO: verificar se o código postal existe. eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "CodigoPostalTomador", descricao = "Código postal do tomador de seguro '" + eventoStagging.codigoPostalTomador + "' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //Tem NIF válido do tomador do seguro - check if (eventoStagging.nifTomadorSeguro == null || eventoStagging.nifTomadorSeguro == string.Empty || !ValidacaoEventos.NifValido(eventoStagging.nifTomadorSeguro)) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "NifTomador", descricao = "Nif do tomador de seguro '"+eventoStagging.nifTomadorSeguro+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } //Tem número de identificação do tomador de seguro - check if (eventoStagging.nrIdentificacaoTomadorSeguro == null || eventoStagging.nrIdentificacaoTomadorSeguro == string.Empty) { eventoStagging.avisosEventoStagging.Add(new Aviso { campo = "NumeroIdentificacaoTomador", descricao = "Número de identificação do tomador de seguro '"+eventoStagging.nrIdentificacaoTomadorSeguro+"' inválido.", tipologiaId = tipoAvisoGenerico, eventoStagging = eventoStagging }); } if (eventoStagging.errosEventoStagging.Count > 0) { return false; } return true; }
private void timer_Tick(object source, ElapsedEventArgs e) { //eventLog.WriteEntry("FNMPAS File Agent Timer Tick"); FicheiroRepository ficheiroRepository = new FicheiroRepository(); NotificacaoRepository notificacaoRepository = new NotificacaoRepository(); ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); UserProfileRepository userProfileRepository = new UserProfileRepository(); List<ValorSistema> estadosFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO"); List<ValorSistema> tiposNotificacao = valoresSistemaRepository.GetPorTipologia("TIPO_NOTIFICACAO"); IQueryable<Ficheiro> query = null; query = ficheiroRepository.All.Include("entidade").Where(f => f.estado.valor == "PENDENTE").OrderBy(file => file.dataAlteracao); foreach (Ficheiro file in query.ToList()) { file.estadoId = estadosFicheiro.Where(ef => ef.valor == "EM_PROCESSAMENTO").Single().valorSistemaId; //List<ErroFicheiro> errosFicheiro = new List<ErroFicheiro>(); try { file.validar(); ProcessadorFicheiros.processaFicheiro(file); file.totalRegistos = file.eventosStagging.Count(); } catch (ErroFicheiroException ex) { file.errosFicheiro = ex.errosFicheiro; file.estadoId = estadosFicheiro.Single(ef => ef.valor == "ERRO").valorSistemaId; string mensagemNotificacao = "O 'Ficheiro Nacional de Matrículas do Parque Automóvel Seguro' com nome '" + file.nomeFicheiro + "' e data de reporte '" + file.dataUpload.ToShortDateString() + "' foi processado com erro: \n"; foreach (ErroFicheiro erro in ex.errosFicheiro) { mensagemNotificacao += erro.descricao; } Notificacao notif = new Notificacao(){ dataCriacao = DateTime.Now, email = true, entidadeId = file.entidadeId, mensagem = mensagemNotificacao, tipologiaId = tiposNotificacao.Single(n => n.valor == "ERRO_PROCESSAMENTO_FICHEIRO").valorSistemaId}; notificacaoRepository.InsertOrUpdate(notif); UserProfile utilizadorFicheiro = userProfileRepository.All.Single(u => u.UserName == file.userName); if (utilizadorFicheiro.entidadeId != file.entidadeId) { Notificacao notif2 = new Notificacao() { dataCriacao = DateTime.Now, email = true, entidadeId = utilizadorFicheiro.entidadeId, mensagem = mensagemNotificacao, tipologiaId = tiposNotificacao.Single(n => n.valor == "ERRO_PROCESSAMENTO_FICHEIRO").valorSistemaId }; notificacaoRepository.InsertOrUpdate(notif2); } } catch (Exception ex) { } ficheiroRepository.InsertOrUpdate(file); ficheiroRepository.Save(); notificacaoRepository.Save(); } }
public static EventoStagging criarEventoStagging(EventoStagging eventoPendente, Mutex mutex = null) { ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); List<ValorSistema> tiposErro = valoresSistemaRepository.GetPorTipologia("TIPO_ERRO", mutex); EventoStagging novoEvento = null; if (eventoPendente.codigoOperacao == null) { throw new ErroEventoStaggingException { errosEventoStagging = new List<ErroEventoStagging> { new ErroEventoStagging { campo = "CodigoOperacao", descricao = "Código de Operação Inválido", tipologiaId = tiposErro.Where(e => e.valor == "GENERICO").Single().valorSistemaId } } }; } try { novoEvento = EventoStaggingFactory.duplicarEventoStagging(eventoPendente.matricula, (int)eventoPendente.entidadeId, eventoPendente.dataInicioCobertura, eventoPendente.horaInicioCobertura, eventoPendente.codigoOperacao, mutex); //Caso não exista registo em stagging duplica-se o Registo em Producao //novoEvento = EventoStaggingFactory.duplicarEventoProducao(eventoPendente.matricula, (int)eventoPendente.entidadeId, eventoPendente.dataInicioCobertura, eventoPendente.horaInicioCobertura); //Caso este também não exista, trata-se de uma nova ocorrência. //Poderiamos concluir que se não é uma criação é um erro, mas validemos isto juntamente com as validações de negócio. if (novoEvento == null) { novoEvento = new EventoStagging(); if (eventoPendente.ficheiroID != null) { novoEvento.dataReporte = eventoPendente.ficheiro.dataAlteracao; novoEvento.dataUltimaAlteracaoErro = eventoPendente.ficheiro.dataAlteracao; } } } catch (ErroEventoStaggingException erros) { novoEvento = new EventoStagging(); if (eventoPendente.ficheiroID != null) { novoEvento.dataReporte = eventoPendente.ficheiro.dataAlteracao; novoEvento.dataUltimaAlteracaoErro = eventoPendente.ficheiro.dataAlteracao; } foreach (ErroEventoStagging erro in erros.errosEventoStagging) { erro.eventoStagging = novoEvento; novoEvento.errosEventoStagging.Add(erro); } } novoEvento.esmagaDados(eventoPendente); return novoEvento; }
public void Worker() { EventoStaggingRepository eventosStaggingRepository = new EventoStaggingRepository(); ConcelhoRepository concelhosRepository = new ConcelhoRepository(); CategoriaRepository categoriasRepository = new CategoriaRepository(); ApoliceRepository apolicesRepository = new ApoliceRepository(); AvisoRepository avisosRepository = new AvisoRepository(); ApoliceHistoricoRepository apolicesHistoricoRepository = new ApoliceHistoricoRepository(); EntidadeRepository entidadesRepository = new EntidadeRepository(); NotificacaoRepository notificacoesRepository = new NotificacaoRepository(); ValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository(); UserProfileRepository userProfileRepository = new UserProfileRepository(); List<ValorSistema> estadosEvento = valoresSistemaRepository.GetPorTipologia("ESTADO_EVENTO_STAGGING", cacheMutex); List<ValorSistema> estadosFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO", cacheMutex); List<ValorSistema> tipoNotificacao = valoresSistemaRepository.GetPorTipologia("TIPO_NOTIFICACAO", cacheMutex); List<ValorSistema> operacoesEvento = valoresSistemaRepository.GetPorTipologia("OPERACAO_EVENTO", cacheMutex); List<Concelho> listaConcelhos = concelhosRepository.All.ToList(); List<Categoria> listaCategorias = categoriasRepository.All.ToList(); int horaLimiteSLA = int.Parse(valoresSistemaRepository.GetPorTipologia("PARAM_HORA_LIMITE_SLA", cacheMutex).Single().valor); int horaExtensaoSLA = int.Parse(valoresSistemaRepository.GetPorTipologia("PARAM_HORA_EXTENSAO_SLA", cacheMutex).Single().valor); int estadoEmProcessamento = estadosEvento.Where(e => e.valor == "EM_PROCESSAMENTO").Single().valorSistemaId; int estadoPendente = estadosEvento.Where(e => e.valor == "PENDENTE").Single().valorSistemaId; int estadoErro = estadosEvento.Where(e => e.valor == "ERRO").Single().valorSistemaId; int estadoProcessado = estadosEvento.Where(e => e.valor == "PROCESSADO").Single().valorSistemaId; int estadoFicheiroProcessado = estadosFicheiro.Where(e => e.valor == "PROCESSADO").Single().valorSistemaId; EventoStagging eventoPendente = null; int eventoPendenteId = default(int); while ((eventoPendenteId = adquireEventoPendente(estadoPendente, estadoEmProcessamento)) != default(int)) { eventoPendente = eventosStaggingRepository.Find(eventoPendenteId); if (isAgentStopping) { releaseEventoPendente(); return; } eventoPendente.estadoEventoId = estadoEmProcessamento; eventosStaggingRepository.InsertOrUpdate(eventoPendente); EventoStagging evento = EventoStaggingFactory.criarEventoStagging(eventoPendente, cacheMutex); EventoStagging eventoProcessar = null; if (evento.errosEventoStagging.Count == 0) { try { eventoProcessar = EventoStaggingFactory.duplicarEventoProducao(evento.matricula, (int)evento.entidadeId, evento.dataInicioCobertura, evento.horaInicioCobertura, cacheMutex); eventoProcessar.esmagaDados(evento); } catch (ErroEventoStaggingException e) { foreach (ErroEventoStagging erro in e.errosEventoStagging) { evento.errosEventoStagging.Add(new ErroEventoStagging { campo = erro.campo, descricao = erro.descricao, tipologiaId = erro.tipologiaId, eventoStaggingId = erro.eventoStaggingId }); } } } if (eventoProcessar == null || !ValidacaoEventos.validarEvento(eventoProcessar, cacheMutex)) { //if (evento.CodigoOperacao == EventoStagging.operacaoEventoStagging.A) //{ // //anulação foi testada em producao e falhou. // //esmaga evento em stagging e adiciona-se como erro. // evento = EventoStaggingFactory.duplicarEventoStagging(eventoPendente.matricula, (int)eventoPendente.entidadeId, eventoPendente.dataInicioCobertura, eventoPendente.horaInicioCobertura); // if (evento == null) // { // evento = new EventoStagging(); // evento.CodigoOperacao = EventoStagging.operacaoEventoStagging.A; // } // evento.esmagaDados(eventoPendente); // ValidacaoEventos.validarEvento(evento); //reconstruir avisos e erros. Sabemos que vai falhar. //} // validação falhou definitivamente evento.estadoEventoId = estadoErro; if (eventoProcessar != null) { foreach (ErroEventoStagging e in eventoProcessar.errosEventoStagging) { evento.errosEventoStagging.Add(new ErroEventoStagging { campo = e.campo, descricao = e.descricao, tipologiaId = e.tipologiaId, eventoStaggingId = e.eventoStaggingId }); } eventoProcessar.errosEventoStagging.Clear(); if (eventoProcessar.codigoOperacao != "A") { foreach (Aviso a in eventoProcessar.avisosEventoStagging) { evento.avisosEventoStagging.Add(new Aviso { campo = a.campo, descricao = a.descricao, tipologiaId = a.tipologiaId, eventoStaggingId = a.eventoStaggingId }); } } eventoProcessar.avisosEventoStagging.Clear(); } evento.totalAvisosCumulativo += evento.totalAvisosCumulativo + evento.avisosEventoStagging.Count; evento.totalErrosCumulativo += evento.totalErrosCumulativo + evento.errosEventoStagging.Count; List<EventoStagging> errosStagging = eventosStaggingRepository.All.Include("estadoEvento").Where(e => e.entidadeId == evento.entidadeId && e.dataInicioCobertura == evento.dataInicioCobertura && e.horaInicioCobertura == evento.horaInicioCobertura && e.matricula == evento.matricula && e.estadoEvento.valor == "ERRO" && e.codigoOperacao == evento.codigoOperacao && e.arquivado == false).ToList(); foreach (EventoStagging erro in errosStagging) { erro.arquivado = true; eventosStaggingRepository.InsertOrUpdate(erro); } eventosStaggingRepository.InsertOrUpdate(evento); } else { Concelho concelho = listaConcelhos.Where(c => c.codigoConcelho == eventoProcessar.codigoConcelhoCirculacao).FirstOrDefault(); Categoria categoria = listaCategorias.Where(c => c.codigoCategoriaVeiculo == eventoProcessar.codigoCategoriaVeiculo).FirstOrDefault(); int? concelhoId = concelho == null ? (int?)null : concelho.concelhoId; int? categoriaId = categoria == null ? (int?)null : categoria.categoriaId; ValorSistema operacao = operacoesEvento.Single(c => c.valor == eventoProcessar.codigoOperacao); Apolice apoliceValidada = new Apolice(eventoProcessar, concelhoId, categoriaId, operacao.valorSistemaId, horaLimiteSLA, horaExtensaoSLA); List<Apolice> apoliceAnterior = apolicesRepository.All.Include("avisosApolice").Where(a => a.dataInicio == apoliceValidada.dataInicio && a.entidadeId == apoliceValidada.entidadeId && a.veiculo.numeroMatricula == apoliceValidada.veiculo.numeroMatricula).ToList(); foreach (Apolice a in apoliceAnterior) { int avisosNum = a.avisosApolice.Count; foreach (Aviso aviso in a.avisosApolice) { avisosRepository.Delete(aviso.avisoId); } //a.avisosApolice.Clear(); ApoliceHistorico historico = new ApoliceHistorico(a); historico.dataArquivo = DateTime.Now; historico.utilizadorArquivo = apoliceValidada.utilizadorReporte; apolicesHistoricoRepository.InsertOrUpdate(historico); apolicesHistoricoRepository.Save(); int idApoliceHistorico = historico.apoliceId; a.avisosApolice.ForEach(aviso => aviso.apoliceHistoricoId = idApoliceHistorico); apolicesRepository.Delete(a.apoliceId); } apolicesRepository.InsertOrUpdate(apoliceValidada); apolicesRepository.Save(); List<EventoStagging> errosStagging = eventosStaggingRepository.All.Include("estadoEvento").Where(e => e.entidadeId == evento.entidadeId && e.dataInicioCobertura == evento.dataInicioCobertura && e.horaInicioCobertura == evento.horaInicioCobertura && e.matricula == evento.matricula && e.estadoEvento.valor == "ERRO" && e.codigoOperacao == eventoProcessar.codigoOperacao && e.arquivado == false).ToList(); foreach (EventoStagging erro in errosStagging) { erro.dataCorrecaoErro = DateTime.Now; erro.arquivado = true; eventosStaggingRepository.InsertOrUpdate(erro); } verificaOutrasOperacoes(eventoProcessar); } eventoPendente.estadoEventoId = estadoProcessado; eventosStaggingRepository.InsertOrUpdate(eventoPendente); eventosStaggingRepository.Save(); FicheiroRepository ficheirosRepository = null; Ficheiro ficheiro = null; if (eventoPendente.ficheiroID != null) { fileMutex.WaitOne(); try { ficheirosRepository = new FicheiroRepository(); ficheiro = ficheirosRepository.Find((int)eventoPendente.ficheiroID); if (evento.errosEventoStagging.Count > 0) { ficheiro.numEventosErro++; } if (eventoPendente == null || eventoPendente.avisosEventoStagging.Count > 0 || evento.avisosEventoStagging.Count > 0) { ficheiro.numEventosAviso++; } ficheiro.totalRegistosProcessados++; //int theadNumber = threadPool.IndexOf(Thread.CurrentThread); if (ficheiro.totalRegistos == ficheiro.totalRegistosProcessados) { ficheiro.estadoId = estadoFicheiroProcessado; int tipoNotificacaoId; string mensagemNotificacao; if (ficheiro.numEventosErro > 0) { tipoNotificacaoId = tipoNotificacao.Where(t => t.valor == "ERRO_PROCESSAMENTO_FICHEIRO").Single().valorSistemaId; mensagemNotificacao = "O 'Ficheiro Nacional de Matrículas do Parque Automóvel Seguro' com nome '" + ficheiro.nomeFicheiro + "' e data de reporte '" + ficheiro.dataUpload.ToShortDateString() + "' foi processado com " + ficheiro.numEventosErro + " ocorrências de erro e " + ficheiro.numEventosAviso + " de aviso " + "num total de " + ficheiro.totalRegistos + " registos."; } else { if (ficheiro.numEventosAviso > 0) { tipoNotificacaoId = tipoNotificacao.Where(t => t.valor == "AVISO_PROCESSAMENTO_FICHEIRO").Single().valorSistemaId; mensagemNotificacao = "O 'Ficheiro Nacional de Matrículas do Parque Automóvel Seguro' com nome '" + ficheiro.nomeFicheiro + "' e data de reporte '" + ficheiro.dataUpload.ToShortDateString() + "' foi processado com " + ficheiro.numEventosAviso + " ocorrências de aviso " + "num total de " + ficheiro.totalRegistos + " registos."; } else { tipoNotificacaoId = tipoNotificacao.Where(t => t.valor == "SUCESSO_PROCESSAMENTO_FICHEIRO").Single().valorSistemaId; mensagemNotificacao = "O 'Ficheiro Nacional de Matrículas do Parque Automóvel Seguro' com nome '" + ficheiro.nomeFicheiro + "' e data de reporte '" + ficheiro.dataUpload.ToShortDateString() + "' foi processado com sucesso em " + ficheiro.totalRegistos + " ocorrências."; } } Notificacao notificacao = new Notificacao { dataCriacao = DateTime.Now, email = true, entidadeId = ficheiro.entidadeId, tipologiaId = tipoNotificacaoId, mensagem = mensagemNotificacao, }; Entidade entidade = entidadesRepository.Find((int)notificacao.entidadeId); entidade.notificacoes.Add(notificacao); entidadesRepository.InsertOrUpdate(entidade); UserProfile utilizadorFicheiro = userProfileRepository.All.Single(u => u.UserName == ficheiro.userName); if (utilizadorFicheiro.entidadeId != ficheiro.entidadeId) { Notificacao notificacao2 = new Notificacao() { dataCriacao = DateTime.Now, email = true, entidadeId = utilizadorFicheiro.entidadeId, tipologiaId = tipoNotificacaoId, mensagem = mensagemNotificacao, }; notificacoesRepository.InsertOrUpdate(notificacao2); } entidadesRepository.Save(); notificacoesRepository.Save(); } ficheirosRepository.InsertOrUpdate(ficheiro); ficheirosRepository.Save(); } finally { fileMutex.ReleaseMutex(); } } releaseEventoPendente(); } }