public Resultado <Digital, Falha> IdentificarDigital(byte[] digitalLida, Digital digitalParaComparar)
{
var encontrou = false;
var payload = new NBioAPI.Type.FIR_PAYLOAD();
NBioAPI.Type.HFIR digitalLidaConvertida;
_apiConversor.FDxToNBioBSPEx(digitalLida, (uint)digitalLida.Length, NBioAPI.Type.MINCONV_DATA_TYPE.MINCONV_TYPE_ISO, NBioAPI.Type.FIR_PURPOSE.ENROLL_FOR_IDENTIFICATION_ONLY, out digitalLidaConvertida);
NBioAPI.Type.HFIR digitalParaCompararConvertida;
_apiConversor.FDxToNBioBSPEx(digitalParaComparar.TemplateIso, (uint)digitalParaComparar.TemplateIso.Length, NBioAPI.Type.MINCONV_DATA_TYPE.MINCONV_TYPE_ISO, NBioAPI.Type.FIR_PURPOSE.ENROLL_FOR_IDENTIFICATION_ONLY, out digitalParaCompararConvertida);
var retorno = _api.VerifyMatch(digitalLidaConvertida, digitalParaCompararConvertida, out encontrou, payload);
if (encontrou)
{
var cbInfo = new NBioAPI.IndexSearch.CALLBACK_INFO_0();
NBioAPI.IndexSearch.FP_INFO[] informacaoBiometria;
NBioAPI.IndexSearch.FP_INFO nitgenBiometria;
var resultadoAddFir = _apiBusca.AddFIR(digitalLidaConvertida, (uint)digitalParaComparar.Id, out informacaoBiometria);
retorno = _apiBusca.IdentifyData(digitalLidaConvertida, NBioAPI.Type.FIR_SECURITY_LEVEL.HIGHEST, out nitgenBiometria, cbInfo);
var idEncontrado = nitgenBiometria.ID;
_apiBusca.RemoveUser((uint)digitalParaComparar.Id);
if (idEncontrado > 0)
{
return(digitalParaComparar);
}
}
Debug.WriteLine($"digital {digitalParaComparar.Id}");
return(Falha.Nova(404, "Digital não encontrada"));
}
public Resultado <Aluno, Falha> Recuperar(string id)
{
var sqlAluno = @"SELECT Id, Nome, Email, DataNascimento FROM Alunos WHERE Id = @id;";
var sqlInscricao = "SELECT Id, AlunoId, TurmaId, InscritoEm FROM Inscricoes WHERE AlunoId IN (SELECT Id FROM Alunos WHERE Id = @id)";
var sqlTurmas = "SELECT Id, Descricao, LimiteAlunos, TotalInscritos, LimiteIdade FROM Turmas WHERE Id IN (SELECT TurmaId FROM Inscricoes WHERE AlunoId = (SELECT Id FROM Alunos WHERE Id = @id))";
using (var conexao = new SqlConnection(_AppSettingsHelper.GetConnectionString()))
{
var alunoQuery = conexao.Query <dynamic>(sqlAluno, new { id }).ToList();
if (!alunoQuery.Any())
{
return(Falha.Nova(404, "Nenhum aluno encontrado"));
}
var turmas = conexao
.Query <dynamic>(sqlTurmas, new { id })
.Select(t => new Turma((string)t.Id, (string)t.Descricao, (int)t.LimiteIdade, (int)t.LimiteAlunos, (int)t.TotalInscritos))
.ToList();
var inscricoes = conexao
.Query <dynamic>(sqlInscricao, new { id })
.Select(i => new Aluno.Inscricao((string)i.Id, (string)i.AlunoId, turmas.FirstOrDefault(t => t.Id.Equals((string)i.TurmaId)), (DateTime)i.InscritoEm))
.ToList();
return(alunoQuery.Select(a => new Aluno((string)a.Id, (string)a.Nome, (string)a.Email, (DateTime)a.DataNascimento, inscricoes))
.FirstOrDefault());
}
}
public IActionResult Criar([FromBody] AlunoInputModel novoAluno)
{
try
{
if (Aluno.Novo(novoAluno.Nome, novoAluno.Email, novoAluno.DataNascimento) is var aluno && aluno.EhFalha)
{
return(StatusCode(aluno.Falha.Codigo, aluno.Falha));
}
if (_alunosRepositorio.RecuperarPorEmail(aluno.Sucesso.Email).EhSucesso)
{
return(BadRequest(Falha.Nova(400, "Email já está em uso: " + novoAluno.Email)));
}
if (_alunosRepositorio.IncluirESalvar(aluno.Sucesso) is var resultado && resultado.EhFalha)
{
return(StatusCode(resultado.Falha.Codigo, resultado.Falha));
}
return(CreatedAtAction(nameof(Recuperar), new { aluno.Sucesso.Id },
new AlunoViewModel(aluno.Sucesso.Id, aluno.Sucesso.Nome, aluno.Sucesso.Email, aluno.Sucesso.Idade(DateTime.Now),
aluno.Sucesso.Inscricoes.Select(a => new InscricaoViewModel(aluno.Sucesso.Id, new InscricaoViewModel.TurmaViewModel(a.Turma.Id, a.Turma.Descricao), a.InscritoEm)).ToList())));
}
catch (Exception e)
{
return(StatusCode(500, new { error = e.Message }));
}
}
public Resultado <Aluno.Inscricao, Falha> Executar(RealizarInscricaoComando comando)
{
try
{
if (_alunosRepositorio.Recuperar(comando.AlunoId) is var aluno && aluno.EhFalha)
{
return(aluno.Falha);
}
if (_turmasRepositorio.Recuperar(comando.TurmaId) is var turma && turma.EhFalha)
{
return(turma.Falha);
}
if (aluno.Sucesso.RealizarInscricao(turma.Sucesso) is var inscricao && inscricao.EhFalha)
{
return(inscricao.Falha);
}
if (_alunosRepositorio.Atualizar(aluno.Sucesso) is var resultado && resultado.EhFalha)
{
return(resultado.Falha);
}
return(resultado.Sucesso.Inscricoes.FirstOrDefault(i => i.Id.Equals(inscricao.Sucesso.Id)));
}
catch (Exception e)
{
return(Falha.Nova(500, "Erro ao realizar inscrição"));
}
}
public async Task <Resultado <Digital, Falha> > IdentificarAsync(byte[] digitalNaoIdentificacada)
{
var contextoParaTask = new ContextoTask(_bancoDigitais.ToList(), digitalNaoIdentificacada, _motorBusca);
_cancelamentoTask = new CancellationTokenSource();
var token = _cancelamentoTask.Token;
var task = await new TaskFactory <Resultado <Digital, Falha> >().StartNew((contextoRecebido) => {
var tempoLocalizacao = new Stopwatch();
tempoLocalizacao.Start();
var contexto = contextoRecebido as ContextoTask;
var resultado = Resultado <Digital, Falha> .NovaFalha(Falha.Nova(404, "Digital não encontrada"));
foreach (var digital in contexto.BancoDigitais)
{
if (token.IsCancellationRequested)
{
break;
}
if (contexto.MotorBusca.IdentificarDigital(contexto.DigitalNaoIdentificacada, digital) is var resultadoIdentificacao && resultadoIdentificacao.EhSucesso)
{
resultado = resultadoIdentificacao.Sucesso;
break;
}
}
tempoLocalizacao.Stop();
return(resultado);
}, contextoParaTask, token);
return(task);
}
public Resultado <IMotorBuscaBiometrica, Falha> CriarMotorDeBuscaBiometrica(string parceiro)
{
if (parceiro.ToLower().Equals("nitgen"))
{
return(new SdkNitgen());
}
return(Falha.Nova(400, $"SDK {parceiro} não é reconhecido"));
}
public Resultado <Digital, Falha> Executar(IdentificarSocioPorDigitalComando comando)
{
var tempoIdentificacao = new Stopwatch();
tempoIdentificacao.Start();
if (_identificadoresDeDigital == null)
{
_identificadoresDeDigital = new ConcurrentBag <ServicoIdentificacaoDigital>();
}
if (_identificadoresDeDigital.Count == 0)
{
if (_configuracoesBiometriaRepositorio.Recuperar(comando.Estacao) is var configuracaoBiometria && configuracaoBiometria.EhFalha)
{
return(configuracaoBiometria.Falha);
}
if (_fabricaMotorBuscaBiometrica.CriarMotorDeBuscaBiometrica(configuracaoBiometria.Sucesso.ParceiroSdkDigital) is var motorBusca && motorBusca.EhFalha)
{
return(motorBusca.Falha);
}
if (_digitaisRepositorio.RecuperarNumeroTotalDigitais() is var quantidadeDigitais && quantidadeDigitais.EhFalha)
{
return(quantidadeDigitais.Falha);
}
var digitaisPorPagina = (quantidadeDigitais.Sucesso / configuracaoBiometria.Sucesso.QuantidadeThreadsIdentificacaoDigital) + configuracaoBiometria.Sucesso.QuantidadeThreadsIdentificacaoDigital;
for (int pagina = 1; pagina <= configuracaoBiometria.Sucesso.QuantidadeThreadsIdentificacaoDigital; pagina++)
{
if (_digitaisRepositorio.RecuperarPagina(pagina, digitaisPorPagina) is var digitais && digitais.EhFalha)
{
return(digitais.Falha);
}
if (digitais.Sucesso.Count() > 0)
{
_identificadoresDeDigital.Add(new ServicoIdentificacaoDigital(motorBusca.Sucesso, digitais.Sucesso));
}
}
}
var digital = Digital.NovaNaoEncontrada();
Parallel.ForEach(_identificadoresDeDigital, async(identificadorDigital, estadoLoop) =>
{
var resultado = await identificadorDigital.IdentificarAsync(comando.Template);
if (resultado.EhSucesso)
{
digital = resultado.Sucesso;
estadoLoop.Break();
}
});
tempoIdentificacao.Stop();
return(digital.Id == 0
? Resultado <Digital, Falha> .NovaFalha(Falha.Nova(404, "Digitão não encontrada"))
: Resultado <Digital, Falha> .NovoSucesso(digital));
}
internal static Resultado <Inscricao, Falha> Nova(string alunoId, Turma turma)
{
if (turma.VagasDisponiveis <= 0)
{
return(Falha.Nova(400, "Sem vagas disponiveis"));
}
turma.IncrementarInscricao();
return(new Inscricao(Guid.NewGuid().ToString(), alunoId, turma, DateTime.Now));
}
public void ShowFalha(Falha f)
{
Debug.Log("Exibindo tela de falha");
mudarParaTela(viewFalhaAcessibilidade);
TitleField.text = f.Title;
DescField.text = f.Desciption;// "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum quis purus vitae quam tempor blandit vel nec orci. Fusce euismod turpis vel orci facilisis, eget bibendum lectus congue.";
Time.timeScale = 0;
}
public Resultado <ConfiguracaoBiometria, Falha> Recuperar(int estacao)
{
using (var conexao = new SqlConnection(_connectionString))
{
var resultado = conexao.Query <ConfiguracaoBiometria>(@"SELECT QuantidadeThreadsIdentificacaoDigital, ParceiroSdkDigital FROM ConfiguracoesBiometria WHERE Estacao = @estacao", new { estacao }).FirstOrDefault();
if (resultado == null)
{
return(Falha.Nova(404, $"Nenhuma configuração para estação {estacao}"));
}
return(resultado);
}
}
public static Resultado <Turma, Falha> Nova(string descricao, int limiteIdade, int limiteAlunos)
{
if (String.IsNullOrEmpty(descricao) || (descricao.Length <= 5 && descricao.Length > 100))
{
return(Falha.Nova(400, "Descrição deve ter 5 a 100 letras"));
}
if (limiteAlunos <= 0 || limiteAlunos > 100)
{
return(Falha.Nova(400, "Limite de alunos deve ser entre 1 e 99"));
}
return(new Turma(Guid.NewGuid().ToString(), descricao, limiteIdade, limiteAlunos, 0));
}
public Resultado <Aluno, Falha> IncluirESalvar(Aluno aluno)
{
var sucesso = false;
var sqlAluno = "INSERT INTO Alunos (Id, Nome, Email, DataNascimento) VALUES (@Id, @Nome, @Email, @DataNascimento)";
var sqlInscricao = "INSERT INTO Inscricoes (Id, AlunoId, TurmaId, InscritoEm) VALUES (@Id, @AlunoId, @TurmaId, @InscritoEm)";
var updateTurma = "UPDATE Turmas SET TotalInscritos = @TotalInscritos WHERE Id = @Id";
using (var conexao = new SqlConnection(_AppSettingsHelper.GetConnectionString()))
{
conexao.Open();
using (var transacao = conexao.BeginTransaction())
{
try
{
var resultado = conexao.Execute(sqlAluno, new { aluno.Id, aluno.Nome, aluno.Email, aluno.DataNascimento }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível incluir o aluno"));
}
foreach (var inscricao in aluno.Inscricoes)
{
resultado = conexao.Execute(sqlInscricao, new { inscricao.Id, AlunoId = aluno.Id, TurmaId = inscricao.Turma.Id, inscricao.InscritoEm }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível incluir inscrição para o aluno"));
}
resultado = conexao.Execute(updateTurma, new { inscricao.Turma.Id, inscricao.Turma.TotalInscritos }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível atualizar a turma"));
}
}
transacao.Commit();
sucesso = true;
return(aluno);
}
catch (Exception ex)
{
return(Falha.NovaComException(ex));
}
finally
{
if (!sucesso)
{
transacao.Rollback();
}
conexao.Close();
}
}
}
}
public void Dado_Uma_Turma_Com_Limite_De_Idade_Nao_Posso_Fazer_Inscricao_De_Aluno_Com_Idade_Superior()
{
var alunoResultado = Aluno.Novo("Gabriel Schmitt Kohlrausch", "*****@*****.**", DateTime.Now.AddYears(-20));
alunoResultado.EhSucesso.ShouldBeTrue();
var turmaResultado = Turma.Nova("Turma de Futsal Junior", 15, 20);
turmaResultado.EhSucesso.ShouldBeTrue();
var inscricaoResultado = alunoResultado.Sucesso.RealizarInscricao(turmaResultado.Sucesso);
inscricaoResultado.EhFalha.ShouldBeTrue();
inscricaoResultado.Falha.ShouldBe(Falha.Nova(400, "Idade superior ao limite da turma"));
alunoResultado.Sucesso.Inscricoes.Count().ShouldBe(0);
}
public Resultado <Inscricao, Falha> RealizarInscricao(Turma turma)
{
if (Idade(DateTime.Now) > turma.LimiteIdade)
{
return(Falha.Nova(400, "Idade superior ao limite da turma"));
}
var inscricao = Inscricao.Nova(Id, turma);
if (inscricao.EhFalha)
{
return(inscricao.Falha);
}
_inscricoes.Add(inscricao.Sucesso);
return(inscricao.Sucesso);
}
private Entidades.FalhaIntegracao CriarFalha(Falha falha)
{
var falha1 = SourceContext.Instance.Create <Entidades.FalhaIntegracao>();
falha1.Tipo = falha.Tipo;
falha1.Mensagem = falha.Mensagem;
falha1.PilhaChamada = falha.PilhaChamada;
if (falha.FalhaInterna != null)
{
falha1.FalhaInterna = this.CriarFalha(falha.FalhaInterna);
}
return(falha1);
}
public Resultado <Turma, Falha> Recuperar(string id)
{
var sql = "SELECT Id, Descricao, LimiteAlunos, TotalInscritos, LimiteIdade FROM Turmas WHERE Id = @id";
using (var conexao = new SqlConnection(_AppSettingsHelper.GetConnectionString()))
{
var query = conexao.Query <dynamic>(sql, new { id }).ToList();
if (!query.Any())
{
return(Falha.Nova(404, "Nenhuma turma encontrada"));
}
return(query.Select(a => new Turma((string)a.Id, (string)a.Descricao, (int)a.LimiteIdade, (int)a.LimiteAlunos, (int)a.TotalInscritos))
.FirstOrDefault());
}
}
public async Task <Resultado <Pedido> > Run(
[ActivityTrigger] FecharPedidoComando comando,
ExecutionContext context,
ILogger log)
{
try
{
log.LogInformation("Processo {0} solicitando fechamento do pedido {1}", comando.ProcessoId, comando.PedidoId);
return(await _gerenciadorComando.ExecutarAsync(comando));
}
catch (Exception ex)
{
log.LogCritical(ex, "Falha catrastrófica no processo {0} ao fechar pedido {1}", comando.ProcessoId, comando.PedidoId);
return(Falha.NovaFalha(Motivo.Novo("FalhaAoFecharPedido", "Falha ao fechar pedido")));
}
}
public async Task <Resultado <Pedido> > Run(
[ActivityTrigger] CriarPedidoComando comando,
ExecutionContext context,
ILogger log)
{
try
{
log.LogInformation("Criando pedido para socio {0}", comando.SocioId);
return(await _gerenciadorComando.ExecutarAsync(comando));
}
catch (Exception ex)
{
log.LogCritical(ex, "Falha catrastrófica ao criar pedido para socio {0}", comando.SocioId);
return(Falha.NovaFalha(Motivo.Novo("FalhaAoCriarPedido", "Falha ao criar pedido")));
}
}
public void Dado_Uma_Turma_Cheia_Nao_Posso_Fazer_Inscricao_De_Aluno()
{
var alunoResultado = Aluno.Novo("Gabriel Schmitt Kohlrausch", "*****@*****.**", DateTime.Now.AddYears(-20));
alunoResultado.EhSucesso.ShouldBeTrue();
var turmaResultado = Turma.Nova("Turma de Futsal Junior", 45, 2);
turmaResultado.EhSucesso.ShouldBeTrue();
turmaResultado.Sucesso.IncrementarInscricao();
turmaResultado.Sucesso.IncrementarInscricao();
var inscricaoResultado = alunoResultado.Sucesso.RealizarInscricao(turmaResultado.Sucesso);
inscricaoResultado.EhFalha.ShouldBeTrue();
inscricaoResultado.Falha.ShouldBe(Falha.Nova(400, "Sem vagas disponiveis"));
alunoResultado.Sucesso.Inscricoes.Count().ShouldBe(0);
}
public Item CriarItem(ItemEsquema itemEsquema)
{
if (this.Tipo == Glass.Data.Model.TipoEventoItemIntegracao.Falha)
{
Falha falha = null;
if (!string.IsNullOrEmpty(this.TipoFalha))
{
falha = new Falha(this.TipoFalha, this.MensagemFalha, this.PilhaChamadaFalha);
}
return(new Item(itemEsquema, this.Mensagem, falha, this.ObterIdentificadores(itemEsquema), this.Data));
}
else
{
return(new Item(itemEsquema, ObterTipoItemHistorico(this.Tipo), this.Mensagem, this.ObterIdentificadores(itemEsquema), this.Data));
}
}
public static Resultado <Aluno, Falha> Novo(string nome, string email, DateTime dataNascimento)
{
if (String.IsNullOrEmpty(nome) || (nome.Length <= 5 && nome.Length > 100))
{
return(Falha.Nova(400, "Nome deve ter 5 a 100 letras"));
}
email = (email ?? string.Empty).Trim();
if (email.Length == 0)
{
return(Falha.Nova(400, "Email não pode ser vazio"));
}
if (!Regex.IsMatch(email, @"^(.+)@(.+)$"))
{
return(Falha.Nova(400, "Email inválido"));
}
if (dataNascimento >= DateTime.Now)
{
return(Falha.Nova(400, "Data de nascimento deve ser menor que hoje"));
}
return(new Aluno(Guid.NewGuid().ToString(), nome, email, dataNascimento, null));
}
public async Task <Resultado <Pedido> > ExecutarAsync(FecharPedidoComando comando)
{
var pedido = await _contextoSql.Pedidos.Include(c => c.Itens).FirstOrDefaultAsync(c => c.Id == comando.PedidoId);
var pagamento = await _contextoSql.Pagamentos.FindAsync(comando.PagamentoId);
if (pagamento.Status == Pagamento.EStatus.EmAnalise)
{
return(Falha.NovaFalha(Motivo.Novo("ErroAoFecharPedido", "Pagamento está em análise")));
}
if (pagamento.Status == Pagamento.EStatus.Aprovado)
{
pedido.Pago();
}
if (pagamento.Status == Pagamento.EStatus.Negado)
{
pedido.Cancelado();
}
await _contextoSql.SaveChangesAsync();
return(pedido);
}
public Resultado <Aluno, Falha> Executar(NovoAlunoComando comando)
{
try
{
if (Aluno.Novo(comando.Nome, comando.Email, comando.DataNascimento) is var aluno && aluno.EhFalha)
{
return(aluno.Falha);
}
if (_alunosRepositorio.RecuperarPorEmail(aluno.Sucesso.Email).EhSucesso)
{
return(Falha.Nova(400, "Email já está em uso: " + comando.Email));
}
if (_alunosRepositorio.IncluirESalvar(aluno.Sucesso) is var resultado && resultado.EhFalha)
{
return(resultado.Falha);
}
return(resultado.Sucesso);
}
catch (Exception e)
{
return(Falha.Nova(500, "Erro ao incluir novo aluno"));
}
}
public async Task <Resultado <Pagamento> > RealizarPagamentoAsync(Pagamento pagamento, Pagador pagador)
{
try
{
_cliente.DefaultRequestHeaders.Accept.Clear();
var dto = new
{
Pagador = pagador,
Valor = pagamento.Valor,
PedidoId = pagamento.PedidoId
};
var conteudo = new StringContent(JsonConvert.SerializeObject(dto), Encoding.UTF8);
conteudo.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var resposta = await _cliente.PostAsync("/api/Cobrancas", conteudo);
if (!resposta.IsSuccessStatusCode)
{
return(Falha.NovaFalha(Motivo.Novo("", "")));
}
var json = await resposta.Content.ReadAsStringAsync();
var retorno = JsonConvert.DeserializeObject <RetornoDTO>(json);
if (retorno.Status == 0)
{
return(pagamento.Aprovado(retorno.TransacaoId));
}
if (retorno.Status == 1)
{
return(pagamento.Negado(retorno.TransacaoId));
}
return(pagamento.EmAnalise(retorno.TransacaoId));
}
catch (Exception ex)
{
return(Falha.NovaFalha(Motivo.Novo("FalhaAoRealizarCobranca", "Não foi possível realizar a transação")));
}
}
public void Devo_Identificar_Digital_No_Banco_Quando_Informo_Template_Existente()
{
var digitais = _digitaisDataAccessTestes.CarregarDigitaisParaIdentificacao().ToList();
var digitalLida = _digitaisDataAccessTestes.CarregarDigitalEncontrada();
digitais.Add(digitalLida);
var resultado = Resultado <Digital, Falha> .NovaFalha(Falha.Nova(404, ""));
var tempo = new Stopwatch();
tempo.Start();
foreach (var digital in digitais)
{
resultado = _sdk.IdentificarDigital(digitalLida.TemplateIso, digital);
if (resultado.EhSucesso)
{
break;
}
}
tempo.Stop();
Assert.IsTrue(tempo.Elapsed.TotalSeconds < 5);
Assert.AreEqual(resultado.Sucesso.Id, digitalLida.Id);
}
public Resultado(bool ehSucesso, T sucesso, Falha falha)
{
EhSucesso = ehSucesso;
Sucesso = sucesso;
Falha = falha;
}
public FalhaAoRealizarPagamentoComando(string codigoTenant, int pedidoId, Falha falha)
{
CodigoTenant = codigoTenant;
PedidoId = pedidoId;
Falha = falha;
}
public Resultado <Aluno, Falha> Atualizar(Aluno aluno)
{
var sucesso = false;
var sqlAluno = "UPDATE Alunos SET Nome = @Nome, Email = @Email, DataNascimento = @DataNascimento WHERE Id = @Id";
var sqlInscricaoInsert = "INSERT INTO Inscricoes (Id, AlunoId, TurmaId, InscritoEm) VALUES (@Id, @AlunoId, @TurmaId, @InscritoEm)";
var sqlInscricaoDelete = "DELETE FROM Inscricoes WHERE Id = @Id";
var updateTurma = "UPDATE Turmas SET TotalInscritos = @TotalInscritos WHERE Id = @Id";
using (var conexao = new SqlConnection(_AppSettingsHelper.GetConnectionString()))
{
conexao.Open();
using (var transacao = conexao.BeginTransaction())
{
try
{
var alunoPreAlteracao = Recuperar(aluno.Id);
if (alunoPreAlteracao.EhFalha)
{
return(alunoPreAlteracao.Falha);
}
var resultado = conexao.Execute(sqlAluno, new { aluno.Id, aluno.Nome, aluno.Email, aluno.DataNascimento }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível atualizar o aluno"));
}
foreach (var inscricao in aluno.Inscricoes)
{
if (!alunoPreAlteracao.Sucesso.Inscricoes.Any(a => a.Id == inscricao.Id))
{
resultado = conexao.Execute(sqlInscricaoInsert, new { inscricao.Id, AlunoId = aluno.Id, TurmaId = inscricao.Turma.Id, inscricao.InscritoEm }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível incluir inscrição"));
}
resultado = conexao.Execute(updateTurma, new { inscricao.Turma.Id, inscricao.Turma.TotalInscritos }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível atualizar a turma"));
}
}
}
foreach (var inscricao in alunoPreAlteracao.Sucesso.Inscricoes)
{
if (!aluno.Inscricoes.Any(a => a.Id == inscricao.Id))
{
resultado = conexao.Execute(sqlInscricaoDelete, new { inscricao.Id }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível excluir inscrição"));
}
resultado = conexao.Execute(updateTurma, new { inscricao.Turma.Id, inscricao.Turma.TotalInscritos }, transacao);
if (resultado <= 0)
{
return(Falha.Nova(400, "Não foi possível atualizar a turma"));
}
}
}
transacao.Commit();
sucesso = true;
return(aluno);
}
catch (Exception ex)
{
return(Falha.NovaComException(ex));
}
finally
{
if (!sucesso)
{
transacao.Rollback();
}
conexao.Close();
}
}
}
}
public FalhaAoRealizarPagamentoEvento(string processoId, int pedidoId, Falha falha)
{
PedidoId = pedidoId;
Falha = falha;
ProcessoId = processoId;
}
