private bool VerificarFavorito(int IdTitulo, int IdUsuario)
{
string query = "SELECT * FROM Favoritos WHERE IdTitulo = @IdTitulo AND IdUsuario = @IdUsuario";
using (SqlConnection con = new SqlConnection(path))
{
con.Open();
List <Favoritos> favoritos = new List <Favoritos>();
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.Parameters.AddWithValue("IdTitulo", IdTitulo);
cmd.Parameters.AddWithValue("IdUsuario", IdUsuario);
SqlDataReader sdr = cmd.ExecuteReader();
while (sdr.Read())
{
var fav = new Favoritos
{
IdTitulo = Convert.ToInt32(sdr["IdTitulo"]),
IdUsuario = Convert.ToInt32(sdr["IdUsuario"])
};
favoritos.Add(fav);
}
if (favoritos.Count == 0)
{
return(false);
}
return(true);
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Genero,Titulo,Autor,Paginas,Ilustracao,SerieDescricao")] Favoritos favoritos)
{
if (id != favoritos.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(favoritos);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FavoritosExists(favoritos.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(favoritos));
}
public static void Adicionar(Favoritos Afavorito)
{
DataBase db = GetDataBase();
db.Favoritosdb.InsertOnSubmit(Afavorito);
db.SubmitChanges();
}
public async Task Excluir(Favoritos objeto, string Token)
{
using (HttpClient client = new HttpClient())
{
try
{
client.BaseAddress = uri;
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
HttpResponseMessage response = await client.DeleteAsync("Favoritos/DeleteById/" + objeto.FkIdCliente + "/" + objeto.FkIdLivro);
await response.Content.ReadAsStringAsync();
string mensagem = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode && mensagem == "O livro de id " + objeto.FkIdLivro + " foi deletado com sucesso da sua lista")
{
return;
}
if (!string.IsNullOrWhiteSpace(mensagem))
{
throw new Exception(mensagem);
}
throw new Exception(response.StatusCode.ToString());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
public IHttpActionResult PostFavoritos(Favoritos favoritos)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Favoritos.Add(favoritos);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (FavoritosExists(favoritos.ClienteId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = favoritos.ClienteId }, favoritos));
}
public IHttpActionResult PutFavoritos(int id, Favoritos favoritos)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != favoritos.ClienteId)
{
return(BadRequest());
}
db.Entry(favoritos).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!FavoritosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IActionResult Deletar(Favoritos favorito)
{
int IdUsuario = int.Parse(User.FindFirst(JwtRegisteredClaimNames.Jti)?.Value);
FavoritosRepository.Deletar(favorito, IdUsuario);
return(Ok());
}
public void Cadastrar(Favoritos favorito)
{
using (OpflixContext ctx = new OpflixContext())
{
ctx.Favoritos.Add(favorito);
ctx.SaveChanges();
}
}
public Favoritos Cadastrar(Favoritos favorito)
{
using (OpFlixContext ctx = new OpFlixContext())
{
ctx.Favoritos.Add(favorito);
ctx.SaveChanges();
return(favorito);
}
}
public void Favoritar(Favoritos favoritos)
{
using (OpFlixContext ctx = new OpFlixContext())
{
// insert into favoritos(idusuario), (idlancamento) values(@idusuario), (@idlancamento);
ctx.Favoritos.Add(favoritos);
ctx.SaveChanges();
}
}
/// <summary>
/// Deleta Favorito
/// </summary>
/// <param name="id"></param>
public void Deletar(int id)
{
using (OpFlixContext ctx = new OpFlixContext())
{
Favoritos FavoritoBuscado = ctx.Favoritos.FirstOrDefault(item => item.IdLancamento == id);
ctx.Favoritos.Remove(FavoritoBuscado);
ctx.SaveChanges();
}
}
public void Deletar(Favoritos favorito, int IdUsuario)
{
using (OpflixContext ctx = new OpflixContext())
{
Favoritos FavoritoBuscado = ctx.Favoritos.FirstOrDefault(x => x.IdUsuario == IdUsuario && x.IdMidia == favorito.IdMidia);
ctx.Favoritos.Remove(FavoritoBuscado);
ctx.SaveChanges();
}
}
public void Cadastrar(Favoritos favorito, int IdUsuario)
{
using (OpFlixContext ctx = new OpFlixContext())
{
favorito.IdUsuario = IdUsuario;
ctx.Favoritos.Add(favorito);
ctx.SaveChanges();
}
}
public static void Delete(Favoritos Afavorito)
{
DataBase db = GetDataBase();
var query = from c in db.Favoritosdb
where c.idB == Afavorito.idB
select c;
db.Favoritosdb.DeleteOnSubmit(query.ToList()[0]);
db.SubmitChanges();
}
public void Atualizar(Favoritos favorito, int IdUsuario)
{
using (OpFlixContext ctx = new OpFlixContext())
{
Favoritos FavoritoBuscado = ctx.Favoritos.FirstOrDefault(x => x.IdUsuario == IdUsuario && x.IdLancamento == favorito.IdLancamento);
FavoritoBuscado.IdLancamento = favorito.IdLancamento;
ctx.Favoritos.Update(FavoritoBuscado);
ctx.SaveChanges();
}
}
public async Task <IActionResult> CreateFavorite_([Bind("Id,Genero,Titulo,Autor,Paginas,Ilustracao,SerieDescricao")] Favoritos favoritos)
{
if (ModelState.IsValid)
{
_context.Add(favoritos);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(favoritos));
}
public IHttpActionResult GetFavoritos(int id)
{
db.Configuration.LazyLoadingEnabled = false;
Favoritos favoritos = db.Favoritos.Find(id);
if (favoritos == null)
{
return(NotFound());
}
return(Ok(favoritos));
}
public IActionResult CadastrarFavorito(Favoritos favorito)
{
try
{
FavoritoRepository.Cadastrar(favorito);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = ex.Message }));
}
}
public IActionResult Deletar(Favoritos favorito)
{
try
{
int IdUsuario = int.Parse(User.FindFirst(JwtRegisteredClaimNames.Jti)?.Value);
FavoritoRepository.Deletar(favorito, IdUsuario);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Ih, deu erro." + ex.Message }));
}
}
public IActionResult CrearFavorito([FromBody] Favoritos favoritos)
{
try
{
FavoritosCore favoritosCore = new FavoritosCore(dbContext);
favoritosCore.CreateFavorito(favoritos);
return(Ok("Favorito Agregado"));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
public IActionResult Atualizar(Favoritos favorito, int id)
{
try
{
int IdUsuario = int.Parse(User.FindFirst(JwtRegisteredClaimNames.Jti)?.Value);
FavoritosRepository.Atualizar(favorito, IdUsuario);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Erro" + ex.Message }));
}
}
public IHttpActionResult DeleteFavoritos(int id)
{
Favoritos favoritos = db.Favoritos.Find(id);
if (favoritos == null)
{
return(NotFound());
}
db.Favoritos.Remove(favoritos);
db.SaveChanges();
return(Ok(favoritos));
}
public void SucessoAoIncluirUmNovoFavorito()
{
Favoritos favorito = new Favoritos()
{
id = 1,
repositorio = "cde",
usuario = "lganet"
};
git.Favoritos favoritos = new git.Favoritos(caminhoValido);
favoritos.Adicionar(favorito);
Assert.IsTrue(favoritos.EstaNoFavoritos(1L));
}
public void EliminarFavorito(int idusuario, int idpublicacion)
{
try
{
Favoritos favorito = dbContext.Favoritos.FirstOrDefault(x => x.IdUsuario == idusuario && x.IdPublicacion == idpublicacion);
dbContext.Remove(favorito);
dbContext.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Cadastrar(Favoritos favorito)
{
try
{
var currentUser = HttpContext.User;
int id = Convert.ToInt32(currentUser.Claims.First(x => x.Type == JwtRegisteredClaimNames.Jti).Value);
favorito.IdUsuario = id;
FavoritoRepository.Cadastrar(favorito);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Não foi possível favoritar " + ex.Message }));
}
}
public IActionResult Cadastrar(Favoritos favorito)
{
try
{
int IdUsuario = Convert.ToInt32(HttpContext.User.Claims.First(x => x.Type == JwtRegisteredClaimNames.Jti).Value);
favorito.IdUsuario = IdUsuario;
favoritoRepository.Cadastrar(favorito);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public IActionResult Cadastrar(Favoritos favorito)
{
try
{
var usuarioId = UsuarioRepository.Cadastrar(favorito.Usuario);
favorito.Usuario = null;
favorito.IdUsuario = Convert.ToInt32(HttpContext.User.Claims.First(item => item.Type == JwtRegisteredClaimNames.Jti).Value);
FavoritoRepository.Cadastrar(favorito);
return(Ok(favorito));
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Oops! Tem coisa errada aqui..." + ex.Message }));
}
}
public void CreateFavorito(Favoritos favorito)
{
try
{
bool validFavorito = ValidateFavorito(favorito.IdUsuario, favorito.IdPublicacion);
if (validFavorito)
{
dbContext.Add(favorito);
dbContext.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void AddFavorito(Favoritos fav)
{
try
{
using (var context = new AEPEntities())
{
context.Favoritos.AddObject(fav);
context.SaveChanges();
}
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("23505"))
throw new Exception("Error: no puede asignar dos veces el mismo favorito.");
}
}
public async Task <string> RemoverFavorito(int IdLivro)
{
Favoritos favorito = new Favoritos();
favorito.FkIdLivro = IdLivro;
favorito.FkIdCliente = Int32.Parse(HttpContext.User.Claims.ToList()[3].Value);
try
{
await _favoritos.Excluir(favorito, Token.GetToken(HttpContext));
}
catch (Exception ex)
{
return(ex.Message);
}
return("Removido");
}
public void SucessoAoCarregarListaDeFavoritos()
{
Favoritos favorito = new Favoritos()
{
id = 1,
repositorio = "cde",
usuario = "lganet"
};
git.Favoritos favoritos = new git.Favoritos(caminhoValido);
favoritos.Adicionar(favorito);
Assert.IsTrue(favoritos.EstaNoFavoritos(1L));
var listaFavoritos = favoritos.Listar();
Assert.IsTrue(listaFavoritos.Count > 0);
}
private void onSelecioChange(object sender, SelectionChangedEventArgs e)
{
favorito = (sender as ListBox).SelectedItem as Favoritos;
}
public void UpdateFavorito(Favoritos fav)
{
using (var context = new AEPEntities())
{
Favoritos fav2 = context.Favoritos.First(i => i.FavoritoId == fav.FavoritoId);
fav2.MenuId = fav.MenuId;
fav2.PersonaId = fav.PersonaId;
context.SaveChanges();
}
}
