private void timer_Tick(object source, ElapsedEventArgs e)
{
//eventLog.WriteEntry("FNMPAS Notification Agent Timer Tick");
INotificacaoRepository notificacaoRepository = new NotificacaoRepository();
IValorSistemaRepository valoresSistemaRepository = new ValorSistemaRepository();
var smtpValues = valorSistemaRepository.All.Where(v => v.tipologia == "SMTP_SERVER" || v.tipologia == "SMTP_PORT" || v.tipologia == "SMTP_USER" || v.tipologia == "SMTP_PASSWORD").ToList();
string smtpServer = smtpValues.Where(s => s.tipologia == "SMTP_SERVER").Single().valor;
int smtpPort = int.Parse(smtpValues.Where(s => s.tipologia == "SMTP_PORT").Single().valor);
string smtpUser = smtpValues.Where(s => s.tipologia == "SMTP_USER").Single().valor;
string smtpPassword = smtpValues.Where(s => s.tipologia == "SMTP_PASSWORD").Single().valor;
IQueryable<Notificacao> query = null;
query = notificacaoRepository.All.Include("entidade").Where(n => n.email == true && n.enviadaEmail == false && n.dataEnvioEmail == null).OrderBy(notif => notif.dataCriacao);
foreach (Notificacao notif in query.ToList())
{
try
{
bool result = enviaNotificacao(notif, smtpServer, smtpPort, smtpUser, smtpPassword);
if (result)
{
notif.enviadaEmail = true;
notif.dataEnvioEmail = DateTime.Now;
}
notificacaoRepository.Save();
}
catch (ErroNotificacaoException ex)
{
notif.enviadaEmail = true;
notificacaoRepository.Save();
continue;
}
catch (Exception ex)
{
notificacaoRepository.Save();
continue;
}
}
}
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();
}
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 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();
}
}
