public async Task <IHttpActionResult> PutFavorito(int id, Favorito favorito)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != favorito.Id_Favorito)
{
return(BadRequest());
}
db.Entry(favorito).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FavoritoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Favoritar(int id)
{
Usuario usuario = (Usuario)Session["usuarioLogado"];
Restaurante restaurante = rep.Busca(id);
Favorito Favorito = new Favorito();
Favorito.RestauranteId = restaurante.RestauranteId;
Favorito.UsuarioId = usuario.UsuarioId;
var favoritos = frep.Lista();
Boolean JaExiste = false;
foreach (var fav in favoritos)
{
if ((fav.UsuarioId == Favorito.UsuarioId) && (fav.RestauranteId == Favorito.RestauranteId))
{
JaExiste = true;
break;
}
}
if (!JaExiste)
{
frep.Adiciona(Favorito);
}
return(RedirectToAction("Index"));
}
public void mustUpdateAModel()
{
Favorito _Favorito = new Favorito(_workspace);
_Favorito.CodigoEmpreiteira = 9;
_Favorito.CodigoUsuario = 7;
_Favorito.ehPonto = false;
_Favorito.Nome = "Incluído pelo ArcEasy";
ModConstrutivo _modConstrutivo = new ModConstrutivo(_workspace);
var _listModConstrutivo = _modConstrutivo.Search("ModConstrutivo.Identificador in (544,285,284,283)");
_Favorito.ModulosConstrutivos = new List <ModConstrutivo>();
foreach (ModConstrutivo _item in _listModConstrutivo)
{
_Favorito.ModulosConstrutivos.Add(_item);
}
_Favorito.Save();
_Favorito.Load(_Favorito.Identificador);
_listModConstrutivo = _modConstrutivo.Search("ModConstrutivo.Identificador in (256, 258, 259)");
foreach (ModConstrutivo _item in _listModConstrutivo)
{
_Favorito.ModulosConstrutivos.Add(_item);
}
_Favorito.Update();
}
public static Favorito selecionar(long id)
{
Favorito retorno = null;
using (SqlConnection conexao = new SqlConnection(conexaoBanco))
{
conexao.Open();
SqlCommand comando = new SqlCommand("select ID, USUARIO, FILME, SERIE from FAVORITO where ID = @id;", conexao);
comando.Parameters.AddWithValue("@id", id);
SqlDataReader resultado = comando.ExecuteReader();
if (resultado.Read())
{
retorno = new Favorito();
retorno.id = resultado.GetInt64(0);
retorno.usuario = UsuarioBD.selecionar(resultado.GetInt64(1));
retorno.filme = FilmeBD.selecionar(resultado.GetInt64(2));
retorno.serie = SerieBD.selecionar(resultado.GetInt64(3));
}
conexao.Close();
}
return(retorno);
}
public List <Favorito> BuscarFavoritosPorUsuario(Int64 _idUsuario)
{
List <Favorito> listaFavoritos = new List <Favorito>();
try
{
String SQL = String.Format("SELECT * FROM Favorito WHERE id_usuario = {0};", _idUsuario);
SqlCeDataReader data = BD.ExecutarSelect(SQL);
while (data.Read())
{
Favorito f = new Favorito();
UsuarioDAO daoUsuario = new UsuarioDAO();
f.Usuario = daoUsuario.BuscarPorID(_idUsuario);
HistoriaDAO daoHistoria = new HistoriaDAO();
f.Historia = daoHistoria.BuscarPorID(data.GetInt32(0));
listaFavoritos.Add(f);
}
data.Close();
BD.FecharConexao();
return(listaFavoritos);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public static Favorito inserir(Favorito registro)
{
Favorito retorno = null;
using (SqlConnection conexao = new SqlConnection(conexaoBanco))
{
conexao.Open();
SqlCommand comando = new SqlCommand("insert into FAVORITO values(NEWID(), @USUARIO, @FILME, @SERIE);", conexao);
comando.Parameters.AddWithValue("@USUARIO", registro.usuario.id);
comando.Parameters.AddWithValue("@FILME", registro.filme.id);
comando.Parameters.AddWithValue("@SERIE", registro.serie.id);
SqlDataReader resultado = comando.ExecuteReader();
if (resultado.Read())
{
retorno = new Favorito();
retorno.id = resultado.GetInt64(0);
retorno.usuario = UsuarioBD.selecionar(resultado.GetInt64(1));
retorno.filme = FilmeBD.selecionar(resultado.GetInt64(2));
retorno.serie = SerieBD.selecionar(resultado.GetInt64(3));
}
conexao.Close();
}
return(retorno);
}
public Boolean InserirBD(Favorito _objeto)
{
try
{
String SQL = "INSERT INTO Favorito (usuario_id, historia_id)"
+ "VALUES (@usuario_id, @historia_id);";
List <SqlCeParameter> parametros = new List <SqlCeParameter>();
parametros.Add(new SqlCeParameter("@usuario_id", _objeto.Usuario.Id));
parametros.Add(new SqlCeParameter("@historia_id", _objeto.Historia.id));
Int32 idInserido = BD.ExecutarInsertComRetornoID(SQL, parametros);
if (idInserido != 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IHttpActionResult> PostFavorito(Favorito favorito)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (db.Favoritoes.Count(x => x.Id_Quadra == favorito.Id_Quadra) > 0)
{
return(BadRequest("Esta quadra já foi favoritada."));
}
const string queryTransaction = "INSERT INTO FAVORITOS (Id_Quadra, Id_Cliente) VALUES (@Id_Quadra, @Id_Cliente)";
var constr = System.Configuration.ConfigurationManager.ConnectionStrings["JogaJuntoDBContext"].ConnectionString;
using (var con = new SqlConnection(constr))
{
con.Open();
using (var cmd = new SqlCommand(queryTransaction, con))
{
cmd.Parameters.AddWithValue("@Id_Quadra", favorito.Id_Quadra);
cmd.Parameters.AddWithValue("@Id_Cliente", favorito.Id_Cliente);
cmd.ExecuteNonQuery();
}
con.Close();
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UsuarioId,VendedorId,ProductoId,FechaMeGusta")] Favorito favorito)
{
if (id != favorito.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _favoritosService.EditFavoritoPost(favorito);
}
catch (DbUpdateConcurrencyException)
{
if (!FavoritoExists(favorito.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProductoId"] = new SelectList(await _productosService.GetProductos(), "Id", "Descripcion", favorito.ProductoId);
ViewData["UsuarioId"] = new SelectList(await _usuariosService.GetUsuario(), "Id", "Apellido", favorito.UsuarioId);
ViewData["VendedorId"] = new SelectList(await _vendedoresService.GetVendedor(), "Id", "Ciudad", favorito.VendedorId);
return(View(favorito));
}
public JsonResult CambiarFavorito(int idSubasta)
{
user_sitio = Session["usuario"] as UsuarioSite;
var idUsuario = usuIBL.ObtenerIdByEmail(user_sitio.Dominio, user_sitio.Email);
valor_tenant = user_sitio.Dominio.ToString();
var esfavorito = favIBL.esFavorito(valor_tenant, idSubasta, idUsuario);
Boolean modelList;
if (esfavorito)
{
favIBL.EliminarFavorito(valor_tenant, idSubasta, idUsuario);
modelList = false;
}
else
{
Favorito favorito = new Favorito();
favorito.id_Subasta = idSubasta;
favorito.id_Usuario = idUsuario;
favIBL.AgregarFavorito(valor_tenant, favorito);
modelList = true;
}
return(Json(modelList, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Edit(int id, [Bind("FavoritosId,EventosId,UserId")] Favorito favorito)
{
if (id != favorito.FavoritosId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(favorito);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FavoritoExists(favorito.FavoritosId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.AspNetUsers, "Id", "Id", favorito.UserId);
return(View(favorito));
}
public Boolean NovoFavorito(Favorito favorito)
{
String mensagem;
try
{
// Grava os dados do novo favorito no dispositivo
IList <Favorito> listaFavoritos;
Data.FavoritosData favoritoData = new Data.FavoritosData();
listaFavoritos = favoritoData.GetList();
if (listaFavoritos.Count == 0)
{
new FavoritosData().Insert(favorito);
return(true);
}
foreach (var favoritoTemp in listaFavoritos)
{
if (favorito.km == favoritoTemp.km && favorito.nome == favoritoTemp.nome)
{
return(false);
}
}
new FavoritosData().Insert(favorito);
}
catch (Exception ex)
{
mensagem = "Não foi possível cadastrar o favorito. \n Detalhe: " +
ex.Message;
}
return(true);
}
public static List <Favorito> selecionarPorUsuario(long idUsuario)
{
List <Favorito> lista = new List <Favorito>();
using (SqlConnection conexao = new SqlConnection(conexaoBanco))
{
conexao.Open();
SqlCommand comando = new SqlCommand("select ID, USUARIO, FILME, SERIE from FAVORITO where USUARIO = @usuario;", conexao);
comando.Parameters.AddWithValue("@usuario", idUsuario);
SqlDataReader resultado = comando.ExecuteReader();
while (resultado.Read())
{
Favorito retorno = new Favorito();
retorno.id = resultado.GetInt64(0);
retorno.usuario = UsuarioBD.selecionar(resultado.GetInt64(1));
retorno.filme = FilmeBD.selecionar(resultado.GetInt64(2));
retorno.serie = SerieBD.selecionar(resultado.GetInt64(3));
lista.Add(retorno);
}
conexao.Close();
}
return(lista);
}
private void configurarFavoritoRepository(Mock <IFavoritoRepository> favoritoRepository)
{
List <Favorito> listaMock = new List <Favorito>();
Favorito itemMock = new Favorito
{
Isbn = "123456",
IdUsuario = "1",
DataInclusao = DateTime.Now
};
listaMock.Add(itemMock);
favoritoRepository
.Setup(s => s.Obter())
.ReturnsAsync(listaMock);
favoritoRepository
.Setup(s => s.Remover("123456"))
.ReturnsAsync(true);
favoritoRepository
.Setup(s => s.Adicionar(It.IsAny <Favorito>()))
.ReturnsAsync(true);
}
public async Task DeleteFavoritoPost(int id)
{
Favorito favorito = await _context.Favorito.FindAsync(id);
_context.Favorito.Remove(favorito);
await _context.SaveChangesAsync();
}
protected void btnAgregarFav_Click(object sender, EventArgs e)
{
try
{
ServFavoritos servicioFavoritos = new ServFavoritos();
Usuario usuario = (Usuario)Session["usuario"];
int id = Convert.ToInt16(Page.Request.Form[txtcodigo.UniqueID]);
Favorito favorito = new Favorito()
{
Id = 1,
IdLibro = id,
CorreoUsuario = usuario.Email
};
if (servicioFavoritos.ConsultarFavoritos(usuario, favorito.IdLibro) == false)
{
servicioFavoritos.GuardarFavoritos(favorito);
ScriptManager.RegisterStartupScript(this, this.GetType(), "script", "mostrarMensaje('Se agrego correctamente a Favoritos');", true);
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "script", "mostrarMensaje('El libro ya esta en favoritos');", true);
}
}
catch (Exception)
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "script", "mostrarMensaje('Ocurrio un error al agregar a Favoritos');", true);
}
}
public void mustSearchAllFavoritsFromAUser()
{
Favorito _favorito = new Favorito(_workspace);
var _Favoritos = _favorito.Search("Favorito.CodigoUsuario = " + 7, ArcEasyObjects.BaseModel.LoadMethod.Lazy);
Assert.IsTrue(_Favoritos.Count > 0);
}
/// <summary>
/// Adicionar um novo lançamento para o usuário
/// </summary>
/// <param name="favorito"></param>
public void Cadastrar(Favorito favorito)
{
using (OpFlixContext ctx = new OpFlixContext())
{
ctx.Favorito.Add(favorito);
ctx.SaveChanges();
}
}
public Favorito ObtenerFavoritoUsuarioUltimo(int idUsu)
{
List <Favorito> favoritos = ListarFavoritoUsuario(idUsu);
Favorito favoritoUltimo = favoritos.Last();
return(favoritoUltimo);
}
public void GetNumberOfFavoritosByUserProfileIdTest()
{
UserProfile userProfile = CreateTestUserProfile();
Favorito favorito = opinadorService.AddFavorito(userProfile.usrId, PRODUCTO_ID, "bookmark", "interesante");
Assert.IsTrue(opinadorService.GetNumberOfFavoritosByUsrId(userProfile.usrId) == 1);
}
/// <exception cref="InstanceNotFoundException">If usrId doesn't match an existing UserProfile</exception>
public Favorito AddFavorito(long usrId, long productoId, string bookmark, string comentario)
{
Favorito favorito = Favorito.CreateFavorito(-1, bookmark, DateTime.Now, comentario, usrId, productoId);
favorito.UserProfile = UserProfileDao.Find(usrId);
FavoritoDao.Create(favorito);
return(favorito);
}
public async Task <bool> Adicionar(Favorito item)
{
_virtualRepository.Add(item);
WriteListInFile();
return(true);
}
/// <summary>
/// Deletar um lançamento da lista de favoritos de um usuário
/// </summary>
/// <param name="IdLancamento"></param>
/// <param name="IdUsuario"></param>
public void Deletar(int IdLancamento, int IdUsuario)
{
using (OpFlixContext ctx = new OpFlixContext())
{
Favorito FavoritoBuscado = ctx.Favorito.FirstOrDefault(x => x.IdLancamento == IdLancamento && x.IdUsuario == IdUsuario);
ctx.Favorito.Remove(FavoritoBuscado);
ctx.SaveChanges();
}
}
public void AddFavoritoTest()
{
UserProfile userProfile = CreateTestUserProfile();
Favorito favorito = opinadorService.AddFavorito(userProfile.usrId, PRODUCTO_ID, "bookmark", "interesante");
List <Favorito> favoritos = opinadorService.FindFavoritosByUsrId(userProfile.usrId, START_INDEX, COUNT);
Assert.IsTrue(favoritos.Count == 1);
Assert.IsTrue(favoritos.Contains(favorito));
}
public async Task <IHttpActionResult> GetFavorito(int id)
{
Favorito favorito = await db.Favoritoes.FindAsync(id);
if (favorito == null)
{
return(NotFound());
}
return(Ok(favorito));
}
public void GuardarFavoritos(Favorito favorito)
{
Conexion conexion = new Conexion();
List <SqlParameter> param = new List <SqlParameter>();
param.Add(new SqlParameter("IdLibro", favorito.IdLibro));
param.Add(new SqlParameter("CorreoUsuario", favorito.CorreoUsuario));
conexion.ExecuteProcedure("spGuardarFavoritos", param);
}
public IHttpActionResult GetFavorito(int id)
{
Favorito favorito = db.Favoritos.Find(id);
if (favorito == null)
{
return(NotFound());
}
return(Ok(favorito));
}
public async Task <IHttpActionResult> PostFavorito(Favorito favorito)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Favoritoes.Add(favorito);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = favorito.Id_Favorito }, favorito));
}
public async Task <IActionResult> Create([Bind("FavoritosId,EventosId,UserId")] Favorito favorito)
{
if (ModelState.IsValid)
{
_context.Add(favorito);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.AspNetUsers, "Id", "Id", favorito.UserId);
return(View(favorito));
}
public IHttpActionResult PostFavorito(Favorito favorito)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Favoritos.Add(favorito);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = favorito.Id }, favorito));
}
