コード例 #1
0
        public async Task <ActionResult> Votar(VotoViewModel votoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            var filme = await ObterFilmePorId(votoViewModel.FilmeId);

            if (filme == null)
            {
                return(NotFound("Filme não cadastrado"));
            }

            var usuario = await _usuarioRepository.BuscarPorId(votoViewModel.UsuarioId);

            if (usuario == null)
            {
                return(NotFound("Usuário não cadastrado"));
            }

            await _votoRepository.Adicionar(_mapper.Map <Voto>(votoViewModel));

            return(CustomResponse(votoViewModel));
        }
コード例 #2
0
        public async Task <IActionResult> Votacao(int recursoId)
        {
            HttpContext.Session.TryGetValue("token", out byte[] tokenBytes);
            HttpContext.Session.TryGetValue("usuario.email", out byte[] emailBytes);
            HttpContext.Session.TryGetValue("usuario.id", out byte[] idBytes);

            var token     = Encoding.Default.GetString(tokenBytes);
            var email     = Encoding.Default.GetString(emailBytes);
            var usuarioId = Encoding.Default.GetString(idBytes);

            var recursoService = new RecursoService();
            var recursos       = await recursoService.ObterApresentacao(token);

            var recurso = recursos.FirstOrDefault(r => r.Id == recursoId);

            var votoViewModel = new VotoViewModel
            {
                UsuarioId    = Convert.ToInt32(usuarioId),
                UsuarioEmail = email,
                Comentario   = string.Empty,
                Recurso      = recurso
            };

            return(View(votoViewModel));
        }
コード例 #3
0
        public async Task <VotoViewModel> Adicionar(VotoViewModel votoViewModel)
        {
            var voto = new Voto(votoViewModel.IdVoto, votoViewModel.IdFilme,
                                votoViewModel.IdUsuario, votoViewModel.Pontuacao,
                                votoViewModel.Ativo);

            BeginTransaction();
            var votoServiceRetorno = await _votoService.Adicionar(voto);

            votoViewModel = _votoServiceMapper.MapToVotoViewModel(votoServiceRetorno);
            if (!votoServiceRetorno.ValidationResult.IsValid)
            {
                return(votoViewModel);
            }

            var sucessoCommit = await Commit();

            if (!sucessoCommit)
            {
                if (!sucessoCommit)
                {
                    votoViewModel.ValidationResult.Errors.Add(new ValidationFailure("Commit", "Ocorreu um erro ao salvar as informações no banco de dados. Por favor, tente novamente"));
                }
            }

            return(votoViewModel);
        }
コード例 #4
0
        public void MoreThanOneVote()
        {
            var repository = TestsEscolhaRestauranteRepository.SharedRepository;

            var votoVM = new VotoViewModel
            {
                Nome        = "Felipe",
                Email       = "*****@*****.**",
                Restaurante = "Sabor Família",
                DataVoto    = DateTime.Now
            };

            var quantidadeVoto1 = (from vt in repository.Votos
                                   where vt.Nome == votoVM.Nome && vt.DataVoto.Date == DateTime.Today
                                   select vt)
                                  .Count();

            var controller = new RestauranteController(repository);
            var model      = controller.Votar(votoVM) as ViewResult;

            var quantidadeVoto2 = (from vt in repository.Votos
                                   where vt.Nome == votoVM.Nome && vt.DataVoto.Date == DateTime.Today
                                   select vt)
                                  .Count();

            Assert.Equal(quantidadeVoto1, quantidadeVoto2);
        }
コード例 #5
0
        public async Task <IActionResult> ConfirmarVoto(VotoViewModel votoViewModel)
        {
            var mensagem = string.Empty;

            var tokenValido = HttpContext.Session.TryGetValue("token", out byte[] tokenBytes);

            if (tokenValido)
            {
                var votoService = new VotoService();
                var token       = Encoding.Default.GetString(tokenBytes);

                mensagem = await votoService.RealizarVoto(token, votoViewModel);
            }

            return(RedirectToAction("Index", "Home", new { mensagem = mensagem }));
        }
コード例 #6
0
        public async Task <IActionResult> PostVoto(VotoViewModel voto)
        {
            var retornoVoto = await _votoAppService.Adicionar(voto);

            if (!retornoVoto.ValidationResult.IsValid)
            {
                foreach (var item in retornoVoto.ValidationResult.Errors)
                {
                    ModelState.AddModelError(string.Empty, item.ErrorMessage);
                }

                return(Conflict(ModelState.Values.Select(x => x.Errors)));
            }

            return(CreatedAtAction("GetVoto", new { id = retornoVoto.IdVoto }, retornoVoto));
        }
コード例 #7
0
        public void VotarActionIsComplete()
        {
            var repository = TestsEscolhaRestauranteRepository.SharedRepository;

            var votoVM = new VotoViewModel
            {
                Nome        = "Anderson",
                Email       = "*****@*****.**",
                DataVoto    = DateTime.Now,
                Restaurante = "Subway"
            };

            var controller = new RestauranteController(repository);
            var viewResult = controller.Votar(votoVM) as ViewResult;

            Assert.NotNull(viewResult.ViewName);
        }
コード例 #8
0
        public async Task <ActionResult <VotoViewModel> > Incluir(VotoViewModel votoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            var votoValido = await _votoRepositorio.ObterVotoValido(votoViewModel.UsuarioId, votoViewModel.RecursoId);

            if (!votoValido)
            {
                return(Conflict("Só é possível votar uma vez em cada recurso."));
            }

            var voto = _mapper.Map <Voto>(votoViewModel);
            await _votoService.Incluir(voto);

            return(Ok(votoViewModel));
        }
コード例 #9
0
        public async Task <IActionResult> PutVoto(Guid id, VotoViewModel voto)
        {
            if (id != voto.IdVoto)
            {
                return(NotFound());
            }

            var retornoVoto = await _votoAppService.Atualizar(voto);

            if (!retornoVoto.ValidationResult.IsValid)
            {
                foreach (var item in retornoVoto.ValidationResult.Errors)
                {
                    ModelState.AddModelError(string.Empty, item.ErrorMessage);
                }

                return(Conflict(ModelState.Values));
            }

            return(CreatedAtAction("GetVoto", new { id = retornoVoto.IdVoto }, retornoVoto));
        }
コード例 #10
0
        public async Task <string> RealizarVoto(string token, VotoViewModel votoViewModel)
        {
            var httpClient = new HttpClient();

            httpClient.BaseAddress = new Uri(BaseUri);
            httpClient.Timeout     = TimeSpan.FromSeconds(60);
            httpClient.DefaultRequestHeaders.Accept.Clear();
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

            var voto = new
            {
                Id         = 0,
                UsuarioId  = votoViewModel.UsuarioId,
                RecursoId  = votoViewModel.Recurso.Id,
                Comentario = votoViewModel.Comentario
            };

            var conteudo     = JsonConvert.SerializeObject(voto);
            var httpconteudo = new StringContent(conteudo, Encoding.UTF8, "application/json");

            var mensagem = string.Empty;
            var response = await httpClient.PostAsync("api/voto", httpconteudo);

            switch (response.StatusCode)
            {
            case HttpStatusCode.OK:
                mensagem = "Voto realizado com sucesso, obrigado pela participação!";
                break;

            case HttpStatusCode.Conflict:
                mensagem = "A regra é clara, só é possível votar uma vez em cada ideia.";
                break;

            default:
                mensagem = "Desculpe, falha ao registrar o voto, tente novamente mais tarde.";
                break;
            }

            return(mensagem);
        }
コード例 #11
0
        public ViewResult Votar(VotoViewModel votoVM)
        {
            var QuantidadeVotos = (from vt in repository.Votos
                                   where vt.Nome.Contains(votoVM.Nome) && vt.DataVoto.Date == DateTime.Today
                                   select vt)
                                  .ToList()
                                  .Count();

            if (QuantidadeVotos > 0)
            {
                ModelState.AddModelError(string.Empty, "É permitido somente um voto por dia");
            }

            if (ModelState.IsValid)
            {
                var restaurante = repository.Restaurantes.FirstOrDefault(r => r.Nome == votoVM.Restaurante);
                if (restaurante == null)
                {
                    restaurante = new Restaurante {
                        Nome = votoVM.Restaurante
                    }
                }
                ;

                var voto = new Voto
                {
                    Nome        = votoVM.Nome,
                    Email       = votoVM.Email,
                    DataVoto    = DateTime.Now,
                    Restaurante = restaurante
                };

                repository.SaveVoto(voto);
                return(View("Obrigado", votoVM));
            }
            else
            {
                return(View());
            }
        }
コード例 #12
0
 public Task <VotoViewModel> Atualizar(VotoViewModel voto)
 {
     throw new NotImplementedException();
 }