public async Task <RequestInfo <Licao> > Handle(GetDetailLicaoQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var licao = await _db.Licoes.FindAsync(request.Id);

                if (licao == null)
                {
                    throw new NaoEncontradoException(nameof(Licao), request.Id);
                }

                _info.Sucess();
                _info.AddResponde(licao);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Licão não encontrada", ex);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
        public async Task <RequestInfo <UsuarioListViewModel> > Handle(GetAllUsuariosQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var vm = new UsuarioListViewModel
                {
                    Usuarios = await _db.Usuarios
                               .Select(u => new UsuarioDetailModel
                    {
                        Id           = u.Id,
                        PrimeiroNome = u.FirstName,
                        UltimoNome   = u.LastName,
                        UserName     = u.UserName
                    })
                               .ToListAsync()
                };

                _info.Sucess();
                _info.AddResponde(vm);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
Ejemplo n.º 3
0
        public async Task <RequestInfo <AlunoListViewModel> > Handle(GetAllAlunosQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var vm = new AlunoListViewModel
                {
                    Alunos = await _db.Alunos
                             .Include(a => a.DadosPublicador)
                             .Select(a => new AlunoDetailsModel
                    {
                        AlunoId         = a.AlunoId,
                        NomePublicador  = a.DadosPublicador.NomeCompleto,
                        FazDemonstracao = a.FazDemonstracao,
                        FazDiscurso     = a.FazDiscurso,
                        FazLeitura      = a.FazLeitura
                    })
                             .ToListAsync()
                };

                _info.Sucess();
                _info.AddResponde(vm);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }

            return(_info);
        }
Ejemplo n.º 4
0
        public async Task <RequestInfo <UsuarioDto> > Handle(AutenticarUsuarioCommand request, CancellationToken cancellationToken)
        {
            try
            {
                var user = await _userService.AuthenticateAsync(request.UserName, request.Password);

                if (user == null)
                {
                    throw new NaoEncontradoException("Usuário ou senha não encontrados", request.UserName);
                }

                _info.Sucess();
                _info.AddResponde(user);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Autenticação falhou", ex);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
        public async Task <RequestInfo <DesignacaoDetailModel> > Handle(GetDetailDesignacaoQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var designacao = await _db.Designacoes
                                 .Include(q => q.AlunoPrincipal)
                                 .ThenInclude(a => a.DadosPublicador)
                                 .Include(q => q.AlunoAjudante)
                                 .ThenInclude(a => a.DadosPublicador)
                                 .Select(d => new DesignacaoDetailModel
                {
                    Id            = d.DesignacaoId,
                    NomePrincipal = d.AlunoPrincipal.DadosPublicador.NomeCompleto,
                    NomeAjudante  = (d.AlunoAjudante != null)
                                        ? d.AlunoAjudante.DadosPublicador.NomeCompleto
                                        : " ",
                    Licao = d.LicaoId,
                    Data  = d.Data.ToShortDateString(),
                    Local = d.Local.ToString(),
                    Tipo  = d.Tipo.ToString()
                })
                                 .FirstAsync(q => q.Id == request.Id);

                if (designacao == null || designacao.Id != request.Id)
                {
                    throw new NaoEncontradoException(nameof(Designacao), request.Id);
                }

                _info.Sucess();
                _info.AddResponde(designacao);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Designacao não encontrado", ex);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }

            return(_info);
        }
        public async Task <RequestInfo <PublicadorDetailModel> > Handle(GetDetailPublicadorQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var publicador = await _db.Publicadores
                                 .Include(p => p.Aluno)
                                 .Include(p => p.Dirigente)
                                 .Include(p => p.Orador)
                                 .Select(p => new PublicadorDetailModel
                {
                    PublicadorId = p.PublicadorId,
                    PrimeiroNome = p.PrimeiroNome,
                    UltimoNome   = p.UltimoNome,
                    NomeCompleto = p.NomeCompleto,
                    Sexo         = p.Sexo.ToString(),
                    Privilegio   = p.Privilegio.ToString(),
                    Telefone     = p.Telefone,
                    Email        = p.Email,
                    IsAluno      = (p.Aluno != null),
                    IsOrador     = (p.Orador != null),
                    IsDirigente  = (p.Dirigente != null)
                })
                                 .FirstAsync(p => p.PublicadorId == request.PublicadorId);

                if (publicador == null)
                {
                    throw new NaoEncontradoException(nameof(Publicador), request.PublicadorId);
                }

                _info.Sucess();
                _info.AddResponde(publicador);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Publicador não encontrada", ex);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
Ejemplo n.º 7
0
        public async Task <RequestInfo <AlunoDetailsModel> > Handle(GetAlunoDetailsQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var aluno = await _db.Alunos
                            .Include(a => a.DadosPublicador)
                            .Select(a => new AlunoDetailsModel
                {
                    AlunoId         = a.AlunoId,
                    NomePublicador  = a.DadosPublicador.NomeCompleto,
                    FazDemonstracao = a.FazDemonstracao,
                    FazDiscurso     = a.FazDiscurso,
                    FazLeitura      = a.FazLeitura
                })
                            .SingleAsync(a => a.AlunoId == request.AlunoId);

                if (aluno == null)
                {
                    throw new NaoEncontradoException(nameof(Aluno), request.AlunoId);
                }


                _info.Sucess();
                _info.AddResponde(aluno);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Aluno não encontrado", ex);
            }
            catch (InvalidOperationException)
            {
                _info.AddFailure("Aluno não encontrado", new NaoEncontradoException(nameof(Aluno), request.AlunoId));
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }

            return(_info);
        }
        public async Task <RequestInfo <DesignacaoListViewModel> > Handle(GetAllDesignacoesQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var vm = new DesignacaoListViewModel
                {
                    Designacoes = await _db.Designacoes
                                  .Include(q => q.AlunoPrincipal)
                                  .ThenInclude(a => a.DadosPublicador)
                                  .Include(q => q.AlunoAjudante)
                                  .ThenInclude(a => a.DadosPublicador)
                                  .Select(d => new DesignacaoDetailModel
                    {
                        Id            = d.DesignacaoId,
                        NomePrincipal = d.AlunoPrincipal.DadosPublicador.NomeCompleto,
                        NomeAjudante  = (d.AlunoAjudante != null)
                                        ? d.AlunoAjudante.DadosPublicador.NomeCompleto
                                        : " ",
                        Data  = d.Data.ToShortDateString(),
                        Licao = d.LicaoId,
                        Local = d.Local.ToString(),
                        Tipo  = d.Tipo.ToString()
                    })
                                  .ToListAsync()
                };

                _info.Sucess();
                _info.AddResponde(vm);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }

            return(_info);
        }
Ejemplo n.º 9
0
        public async Task <RequestInfo <LicaoListViewModel> > Handle(GetAllLicoesQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var vm = new LicaoListViewModel
                {
                    Licoes = await _db.Licoes.ToListAsync()
                };

                _info.Sucess();
                _info.AddResponde(vm);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
        public async Task <RequestInfo <PublicadorListViewModel> > Handle(GetAllPublicadorQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var vm = new PublicadorListViewModel
                {
                    Publicadores = await _db.Publicadores
                                   .Include(p => p.Aluno)
                                   .Include(p => p.Dirigente)
                                   .Include(p => p.Orador)
                                   .Select(p => new PublicadorDetailModel
                    {
                        PublicadorId = p.PublicadorId,
                        NomeCompleto = p.NomeCompleto,
                        Sexo         = p.Sexo.ToString(),
                        Privilegio   = p.Privilegio.ToString(),
                        Telefone     = p.Telefone,
                        Email        = p.Email,
                        IsAluno      = (p.Aluno != null),
                        IsOrador     = (p.Orador != null),
                        IsDirigente  = (p.Dirigente != null)
                    })
                                   .ToListAsync()
                };

                _info.Sucess();
                _info.AddResponde(vm);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }
        public async Task <RequestInfo <UsuarioDetailModel> > Handle(GetDetailUsuariosQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var user = await _db.Usuarios
                           .Where(u => u.Id == request.Id)
                           .Select(u => new UsuarioDetailModel
                {
                    Id           = u.Id,
                    PrimeiroNome = u.FirstName,
                    UltimoNome   = u.LastName,
                    UserName     = u.UserName
                })
                           .SingleOrDefaultAsync();

                if (user == null)
                {
                    throw new NaoEncontradoException(nameof(Usuario), request.Id);
                }

                _info.Sucess();
                _info.AddResponde(user);
            }
            catch (NaoEncontradoException ex)
            {
                _info.AddFailure("Licão não encontrada", ex);
            }
            catch (DbException ex)
            {
                _info.AddFailure("Erro ocorrido ao fazer conexão com banco de dados", ex);
            }
            catch (Exception ex)
            {
                _info.AddFailure($"Erro! Conferir descrição. ", ex);
            }
            return(_info);
        }