Example #1
0
 public PratoDto(PratoModel Prato, RestauranteModel Restaurante)
 {
     this.PratoId     = Prato.PratoId;
     this.Nome        = Prato.Nome;
     this.Preco       = Prato.Preco;
     this.Restaurante = new RestauranteDto(Restaurante);
 }
Example #2
0
        public void AddRestaurante(RestauranteModel model)
        {
            var baseAddress = "http://localhost:8090/restaurante/registrarrestaurante";

            var json = JsonConvert.SerializeObject(model);

            var http = (HttpWebRequest)WebRequest.Create(new Uri(baseAddress));

            http.Accept      = "application/json";
            http.ContentType = "application/json";
            http.Method      = "POST";

            string        parsedContent = json;
            ASCIIEncoding encoding      = new ASCIIEncoding();

            Byte[] bytes = encoding.GetBytes(parsedContent);

            Stream newStream = http.GetRequestStream();

            newStream.Write(bytes, 0, bytes.Length);
            newStream.Close();

            var response = http.GetResponse();

            var stream  = response.GetResponseStream();
            var sr      = new StreamReader(stream);
            var content = sr.ReadToEnd();
        }
        public ActionResult Create()
        {
            var model = new RestauranteModel();

            ViewData["Action"] = "Crear Restaurante";
            ViewData["Btn"]    = "Crear";
            return(PartialView("Edit", model));
        }
        /// <summary>
        /// Obtenha os valores no banco.
        /// </summary>
        /// <returns>
        /// Objeto Prato ou Restaurante.
        /// </returns>
        public override List <Restaurante> Obtenha(string Nome)
        {
            using (RestauranteModel context = new RestauranteModel())
            {
                var restaurantes = !string.IsNullOrWhiteSpace(Nome) ? (from r in context.Restaurantes where r.Nome.Contains(Nome) select r)
                                              : (from r in context.Restaurantes select r);

                return(restaurantes.ToList());
            }
        }
Example #5
0
        /// <summary>
        /// Obtenha os valores no banco.
        /// </summary>
        /// <param name="Codigo"></param>
        /// <returns>
        /// Objeto Prato ou Restaurante.
        /// </returns>
        public override List <Prato> Obtenha(string Nome)
        {
            using (RestauranteModel context = new RestauranteModel())
            {
                var pratos = !string.IsNullOrWhiteSpace(Nome) ? (from r in context.Pratos where r.CodigoRestaurante == Convert.ToInt32(Nome) select r)
                                         : (from r in context.Pratos select r);

                return(pratos.ToList());
            }
        }
Example #6
0
        public async Task <ActionResult <IEnumerable <RestauranteModel> > > Get()
        {
            var restaurantes = await _restauranteRepo.GetRestaurantes();

            if (restaurantes == null)
            {
                return(new EmptyResult());
            }

            return(new ObjectResult(RestauranteModel.ToListModel(restaurantes)));
        }
Example #7
0
        public async Task <ActionResult <RestauranteModel> > Get(Guid id)
        {
            var restaurante = await _restauranteRepo.GetRestauranteById(id);

            if (restaurante == null)
            {
                return(new EmptyResult());
            }

            return(new ObjectResult(RestauranteModel.ToModel(restaurante)));
        }
Example #8
0
 /// <summary>
 /// Metódo responsável em salvar o objeto em banco.
 /// </summary>
 /// <param name="dados">Objeto Prato ou Restaurante.</param>
 public override void Salvar(Prato dados)
 {
     using (RestauranteModel context = new RestauranteModel())
     {
         if (dados != null)
         {
             context.Pratos.Remove(dados);
             context.Pratos.Add(dados);
             context.SaveChanges();
         }
     }
 }
Example #9
0
        public async Task <Restaurante> UpdateRestaurante(RestauranteModel restaurante)
        {
            var restauranteUptodate = await this.GetRestauranteById(restaurante.Id);

            restauranteUptodate.Nome     = restaurante.Nome;
            restauranteUptodate.Endereco = restaurante.Endereco;
            restauranteUptodate.Votos    = restaurante.Votos;

            await _context.SaveChangesAsync();

            return(restauranteUptodate);
        }
Example #10
0
 /// <summary>
 /// Metódo responsável em excluir o objeto em banco.
 /// </summary>
 /// <param name="dados">Objeto Prato ou Restaurante.</param>
 /// <exception cref="System.NotImplementedException"></exception>
 public override void Excluir(int Codigo)
 {
     using (RestauranteModel context = new RestauranteModel())
     {
         if (Codigo > 0)
         {
             var prato = Obtenha(Codigo.ToString()).FirstOrDefault();
             if (prato != null)
             {
                 context.Pratos.Remove(prato);
                 context.SaveChanges();
             }
         }
     }
 }
Example #11
0
        public async Task <ActionResult <RestauranteModel> > Put([FromBody] RestauranteModel restaurante)
        {
            if (restaurante == null)
            {
                return(new EmptyResult());
            }

            try
            {
                return(new ObjectResult(await _restauranteRepo.UpdateRestaurante(restaurante)));
            }
            catch (Exception)
            {
                return(new EmptyResult());
            }
        }
 /// <summary>
 /// Metódo responsável em excluir o objeto em banco.
 /// </summary>
 /// <param name="dados">Objeto Prato ou Restaurante.</param>
 public override void Excluir(int Codigo)
 {
     using (RestauranteModel context = new RestauranteModel())
     {
         if (Codigo > 0)
         {
             var restaurante = (from r in context.Restaurantes where r.Codigo == Codigo select r).FirstOrDefault();
             if (restaurante != null)
             {
                 new ServicoDePrato().Excluir(Codigo);
                 context.Restaurantes.Remove(restaurante);
                 context.SaveChanges();
             }
         }
     }
 }
        public IActionResult Post([FromBody] RestauranteModel model)
        {
            var restaurante = new Restaurante()
            {
                LinkImagem = model.LinkImagem,
                Nome       = model.Nome,
                Local      = new Point(model.Coords.Lat, model.Coords.Lng)
                {
                    SRID = 4326
                }
            };

            _context.Set <Restaurante>().Add(restaurante);
            _context.SaveChanges();

            return(Ok());
        }
Example #14
0
        public async Task <Restaurante> AddRestaurante(RestauranteModel restaurante)
        {
            Restaurante novoRestaurante = new Restaurante()
            {
                Id             = new Guid(),
                Nome           = restaurante.Nome,
                Endereco       = restaurante.Endereco,
                Votos          = 0,
                Escolhido      = false,
                VotadoNaSemana = false
            };

            await _context.Restaurante.AddAsync(novoRestaurante);

            await _context.SaveChangesAsync();

            return(novoRestaurante);
        }
        public IActionResult Put([FromRoute] Guid id, [FromBody] RestauranteModel model)
        {
            var restaurante = _context.Set <Restaurante>().FirstOrDefault(x => x.Id == id);

            if (restaurante == null)
            {
                return(NotFound());
            }
            restaurante.Nome       = model.Nome;
            restaurante.LinkImagem = model.LinkImagem;
            restaurante.Local      = new Point(model.Coords.Lat, model.Coords.Lng)
            {
                SRID = 4326
            };

            _context.Entry(restaurante).State = EntityState.Modified;
            _context.SaveChanges();

            return(Ok());
        }
        public ActionResult Edit(RestauranteModel model)
        {
            try
            {
                if (model.RestauranteId > 0)
                {
                    core.ModifyRestaurante(model);
                    LocalHelpers.ShowDataUpdateSuccessMessage();
                }
                else
                {
                    core.AddRestaurante(model);
                    LocalHelpers.ShowDataInsertSuccessMessage();
                }
            }
            catch (Exception ex)
            {
                LocalHelpers.ShowMessage(ex.Message, MessageType.Error);
            }

            return(RedirectToAction("Index"));
        }
Example #17
0
        public ActionResult <RestauranteDto> Post([FromBody] RestauranteDto RestauranteDto)
        {
            var Restaurante = new RestauranteModel(RestauranteDto);

            if (Restaurante.RestauranteId > 0)
            {
                _context.Restaurantes.Update(Restaurante);
            }
            else
            {
                _context.Restaurantes.Add(Restaurante);
            }

            _context.SaveChanges();

            var RestauranteRetorno = _context.Restaurantes.Select(x => new RestauranteDto(x)).Where(x => x.RestauranteId == Restaurante.RestauranteId).First();

            if (RestauranteRetorno == null)
            {
                return(NotFound());
            }
            return(RestauranteRetorno);
        }
Example #18
0
 public RestauranteDto(RestauranteModel Restaurante)
 {
     this.RestauranteId = Restaurante.RestauranteId;
     this.Nome          = Restaurante.Nome;
 }
Example #19
0
 public void ModifyRestaurante(RestauranteModel model)
 {
     //DAL.RestauranteDataAccess.ModifyRestaurante(model,user);
 }