예제 #1
0
        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"));
        }
예제 #3
0
        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();
        }
예제 #4
0
        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);
        }
예제 #5
0
        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);
            }
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
            }
        }
예제 #8
0
        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));
        }
예제 #9
0
        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));
        }
예제 #10
0
        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));
        }
예제 #11
0
        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));
        }
예제 #12
0
        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);
        }
예제 #13
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
        public async Task DeleteFavoritoPost(int id)
        {
            Favorito favorito = await _context.Favorito.FindAsync(id);

            _context.Favorito.Remove(favorito);
            await _context.SaveChangesAsync();
        }
예제 #16
0
        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);
            }
        }
예제 #17
0
        public void mustSearchAllFavoritsFromAUser()
        {
            Favorito _favorito  = new Favorito(_workspace);
            var      _Favoritos = _favorito.Search("Favorito.CodigoUsuario = " + 7, ArcEasyObjects.BaseModel.LoadMethod.Lazy);

            Assert.IsTrue(_Favoritos.Count > 0);
        }
예제 #18
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();
     }
 }
예제 #19
0
        public Favorito ObtenerFavoritoUsuarioUltimo(int idUsu)
        {
            List <Favorito> favoritos = ListarFavoritoUsuario(idUsu);

            Favorito favoritoUltimo = favoritos.Last();

            return(favoritoUltimo);
        }
예제 #20
0
        public void GetNumberOfFavoritosByUserProfileIdTest()
        {
            UserProfile userProfile = CreateTestUserProfile();

            Favorito favorito = opinadorService.AddFavorito(userProfile.usrId, PRODUCTO_ID, "bookmark", "interesante");

            Assert.IsTrue(opinadorService.GetNumberOfFavoritosByUsrId(userProfile.usrId) == 1);
        }
예제 #21
0
        /// <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);
        }
예제 #22
0
        public async Task <bool> Adicionar(Favorito item)
        {
            _virtualRepository.Add(item);

            WriteListInFile();

            return(true);
        }
예제 #23
0
 /// <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();
     }
 }
예제 #24
0
        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));
        }
예제 #25
0
        public async Task <IHttpActionResult> GetFavorito(int id)
        {
            Favorito favorito = await db.Favoritoes.FindAsync(id);

            if (favorito == null)
            {
                return(NotFound());
            }

            return(Ok(favorito));
        }
예제 #26
0
        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);
        }
예제 #27
0
        public IHttpActionResult GetFavorito(int id)
        {
            Favorito favorito = db.Favoritos.Find(id);

            if (favorito == null)
            {
                return(NotFound());
            }

            return(Ok(favorito));
        }
예제 #28
0
        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));
        }
예제 #29
0
        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));
        }
예제 #30
0
        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));
        }