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