public static async Task PublicarEventos <T>(this IMediatorHandler mediator, T ctx) where T : DbContext
{
var domainEntities = ctx.ChangeTracker //entidades em memoria (modificando)
.Entries <Entity>()
.Where(x => x.Entity.Notificacoes != null && x.Entity.Notificacoes.Any());
var domainEvents = domainEntities
.SelectMany(x => x.Entity.Notificacoes)
.ToList();
domainEntities.ToList()
.ForEach(entity => entity.Entity.LimparEventos());
var tasks = domainEvents
.Select(async(domainEvent) => {
await mediator.PublicarEvento(domainEvent);
});
await Task.WhenAll(tasks);
}
public static async Task PublicarEventos(this IMediatorHandler mediator, PagamentoContext ctx)
{
var domainEntities = ctx.ChangeTracker
.Entries <Entity>()
.Where(x => x.Entity.Notificacoes != null && x.Entity.Notificacoes.Any());
var domainEvents = domainEntities
.SelectMany(x => x.Entity.Notificacoes)
.ToList();
domainEntities.ToList()
.ForEach(entity => entity.Entity.LimparEventos());
var tasks = domainEvents
.Select(async(domainEvent) => {
await mediator.PublicarEvento(domainEvent);
});
await Task.WhenAll(tasks);
}
public Task Handle(RegistrarUsuarioCommand notification, CancellationToken cancellationToken)
{
var usuario = new ApplicationUser {
UserName = notification.Email, Email = notification.Email, Nome = notification.Nome
};
var result = _userManager.CreateAsync(usuario, notification.Senha).Result;
if (!result.Succeeded)
{
NotificarErro(notification.MessageType, $"Usuário já cadastrado com o e-mail: {notification.Email}");
return(Task.CompletedTask);
}
if (!HasNotificationsError())
{
_mediator.PublicarEvento(new UsuarioRegistradoEvent(usuario));
}
return(Task.CompletedTask);
}
public Task <bool> Handle(RegistrarEventoCommand message, CancellationToken cancellationToken)
{
var endereco = new Endereco(message.Endereco.Id, message.Endereco.Logradouro, message.Endereco.Numero, message.Endereco.Complemento, message.Endereco.Bairro, message.Endereco.CEP, message.Endereco.Cidade, message.Endereco.Estado, message.Endereco.EventoId.Value);
var evento = Evento.EventoFactory.NovoEvento(message.Id, message.Nome, message.DescricaoCurta, message.DescricaoLonga,
message.DataInicio, message.DataFim, message.Gratuito, message.Valor,
message.Online, message.NomeEmpresa, message.OrganizadorId, endereco, message.CategoriaId);
if (!EventoValido(evento))
{
return(Task.FromResult(false));
}
_eventoRepository.Incluir(evento);
if (Commit())
{
_mediator.PublicarEvento(new EventoRegistradoEvent(evento.Id, evento.Nome, evento.DataInicio, evento.DataFim, evento.Gratuito, evento.Valor, evento.Online, evento.NomeEmpresa));
}
return(Task.FromResult(true));
}
public async Task <bool> Contratar(Funcionario funcionario)
{
if (!funcionario.EhValido())
{
Notificar(funcionario.ValidationResult);
return(false);
}
var cargo = await _funcionarioRepository.ObterCargoPorId(funcionario.CargoId);
if (cargo == null)
{
Notificar("Cargo informado inválido");
return(false);
}
if (await FuncionarioContratado(funcionario))
{
Notificar($"{funcionario.Nome} já faz parte do quadro de funcionários");
return(false);
}
var senhaAutomatica = funcionario.Usuario.Senha;
var hash = _passwordHash.GetHashPassword(senhaAutomatica);
funcionario.Usuario.AdicionarHashSenha(hash);
if (await _funcionarioRepository.Contratar(funcionario))
{
await _mediatorHandler.PublicarEvento(
new NovoFuncionarioEvent(funcionario.Email.Endereco, funcionario.Nome, senhaAutomatica));
return(true);
}
Notificar("Erro ao contratar novo funcionário");
return(false);
}
public async Task <Transacao> RealizarPagamentoPedido(PagamentoPedido pagamentoPedido)
{
var pedido = new Pedido
{
ID = pagamentoPedido.PedidoID,
Valor = pagamentoPedido.Total
};
var pagamento = new Pagamento
{
Valor = pagamentoPedido.Total,
NomeCartao = pagamentoPedido.NomeCartao,
NumeroCartao = pagamentoPedido.NumeroCartao,
ExpiracaoCartao = pagamentoPedido.ExpiracaoCartao,
CvvCartao = pagamentoPedido.CvvCartao,
PedidoID = pagamentoPedido.PedidoID
};
var transacao = _pagamentoCartaoCreditoFacade.RealizarPagamento(pedido, pagamento);
if (transacao.StatusTransacao == EStatusTransacao.Pago)
{
pagamento.AdicionarEvento(new PagamentoRealizadoEvent(pedido.ID, pagamentoPedido.ClienteID, transacao.PagamentoID, transacao.ID, pedido.Valor));
_pagamentoRepository.Adicionar(pagamento);
_pagamentoRepository.AdicionarTransacao(transacao);
await _pagamentoRepository.UnityOfWork.Commit();
return(transacao);
}
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pagamento", "A operadora recusou o pagamento"));
await _mediatorHandler.PublicarEvento(new PagamentoRecusadoEvent(pedido.ID, pagamentoPedido.ClienteID, transacao.PagamentoID, transacao.ID, pedido.Valor));
return(transacao);
}
public async Task <bool> Commit()
{
foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("DataCadastro") != null))
{
if (entry.State == EntityState.Added)
{
entry.Property("DataCadastro").CurrentValue = DateTime.Now;
}
if (entry.State == EntityState.Modified)
{
entry.Property("DataCadastro").IsModified = false;
}
}
var sucesso = await base.SaveChangesAsync() > 0;
if (sucesso)
{
await _mediatorHandler.PublicarEvento(this);
}
return(sucesso);
}
public async Task <bool> Matricular(Cliente cliente, Guid planoId)
{
if (!cliente.EhValido())
{
Notificar(cliente.ValidationResult);
return(false);
}
if (await ClienteMatriculado(cliente))
{
Notificar("Cliente já matriculado !");
return(false);
}
var planoDesconto = await _planoRepository.ObterDescontoPlano(planoId);
if (planoDesconto == null)
{
Notificar("Plano sem desconto associado");
return(false);
}
cliente.AdicionarContrato(new Contrato(planoDesconto));
var hash = _passwordHash.GetHashPassword(cliente.Usuario.Senha);
cliente.Usuario.AdicionarHashSenha(hash);
if (await _clienteRepository.Adicionar(cliente))
{
await _mediator.PublicarEvento(
new CodigoConfirmacaoEvent(cliente.Usuario.Id, cliente.Email.Endereco, cliente.Nome));
}
return(true);
}
public async Task <bool> DebitarEstoque(Guid produtoId, int quantidade)
{
var produto = await _produtoRepository.ObterPorId(produtoId);
if (produto == null)
{
return(false);
}
if (!produto.PossuiEstoque(quantidade))
{
return(false);
}
produto.DebitarEstoque(quantidade);
if (produto.QuantidadeEstoque < 10)
{
await _bus.PublicarEvento(new ProdutoAbaixoEstoqueEvent(produto.Id, produto.QuantidadeEstoque));
}
_produtoRepository.Atualizar(produto);
return(await _produtoRepository.UnitOfWork.Commit());
}
public void Handle(ExcluirEventoCommand cmd)
{
Evento evento = _eventoRepository.ObterEventoCompletoPaginaPorId(cmd.Id);
if (evento == null)
{
return;
}
List <Atracao> atracoes = new List <Atracao>();
evento.AtracoesEventos.ToList().ForEach(x =>
{
atracoes.Add(x.Atracao);
_eventoRepository.RemoverAtracaoEvento(x.AtracaoId, x.EventoId);
});
foreach (var atracao in atracoes)
{
_eventoRepository.RemoverAtracao(atracao.Id);
}
_eventoRepository.RemoverEndereco(cmd.EnderecoId);
_eventoRepository.Remover(cmd.Id);
if (Commit())
{
_mediator.PublicarEvento(new AtracaoExcluidaEvent(cmd.Id));
}
}
private async Task <object> GerarTokenUsuario(LoginViewModel login)
{
Usuario usuario = _usuarioRepository.BuscarPorEmailSenha(login.Email, login.Senha);
var identity = await GetClaims(usuario);
if (identity == null)
{
await _mediator.PublicarEvento(new DomainNotification("Identity", "Usuário não encontrado."));
return(Response());
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.NomeRazaoSocial),
new Claim(JwtRegisteredClaimNames.Email, usuario.Email),
new Claim(JwtRegisteredClaimNames.Sub, usuario.Empresa != null ? usuario.EmpresaId.ToString() : usuario.ClienteId.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtTokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_jwtTokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("EventFinder")
};
var jwt = new JwtSecurityToken(
issuer: _jwtTokenOptions.Issuer,
audience: _jwtTokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _jwtTokenOptions.NotBefore,
expires: _jwtTokenOptions.Expiration,
signingCredentials: _jwtTokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
if (usuario.EmpresaId != null)
{
var empresa = _empresaRepository.BuscarPorEmail(login.Email);
var response = new
{
access_token = encodedJwt,
expires_in = (int)_jwtTokenOptions.ValidFor.TotalSeconds,
user = new
{
id = empresa.Id,
nome = empresa.RazaoSocial,
email = empresa.Email,
claims = claims.Select(x => new { x.Type, x.Value })
}
};
return(response);
}
else
{
var cliente = _clienteRepository.ObterPorId(usuario.ClienteId.Value);
var response = new
{
access_token = encodedJwt,
expires_in = (int)_jwtTokenOptions.ValidFor.TotalSeconds,
user = new
{
id = cliente.Id,
nome = cliente.Nome,
email = cliente.Email,
claims = claims.Select(x => new { x.Type, x.Value })
}
};
return(response);
}
}
public void Handle(IncluirFuncionarioCommand cmd)
{
Funcionario funcionario = new Funcionario(cmd.Id, cmd.Nome, cmd.Email, cmd.Telefone, cmd.Facebook, cmd.Cargo, cmd.Sexo, cmd.EmpresaId, cmd.EquipeId);
if (!funcionario.IsValid())
{
NotificarValidacoesErro(funcionario.ValidationResult);
return;
}
_repository.IncluirFuncionario(funcionario);
if (Commit())
{
_mediator.PublicarEvento(new FuncionarioAdicionadoEvent(funcionario.Id, funcionario.Nome, funcionario.Email, funcionario.Telefone, funcionario.Facebook, funcionario.Cargo, funcionario.Sexo, funcionario.EmpresaId, funcionario.EquipeId));
}
}
protected void NotifyError(string code, string message)
{
_bus.PublicarEvento(new DomainNotification(code, message));
}
protected void NotificarErro(string codigo, string mensagem)
{
_mediator.PublicarEvento(new NotificacaoDominio(codigo, mensagem));
}
public void Handle(ExcluirPublicacaoCommand cmd)
{
Publicacao publicacao = PublicacaoExistente(cmd.ClienteId, cmd.EventoId, cmd.MessageType);
if (publicacao != null)
{
_repository.RemoverPublicacao(publicacao.ClienteId, publicacao.EventoId);
if (Commit())
{
_mediator.PublicarEvento(new PublicacaoExcluidaEvent(publicacao.ClienteId, publicacao.EventoId));
}
}
}
protected void NotificarErro(string codigo, string mensagem)
{
_mediator.PublicarEvento(new DomainNotification(codigo, mensagem));
}
protected void NotificarErro(string propertyName, string errorMessage)
{
_mediator.PublicarEvento(new DomainNotification(propertyName, errorMessage));
}