public async Task <IActionResult> Put([FromRoute] int id, [FromBody] RestauranteViewModel restauranteViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != restauranteViewModel.RestauranteId)
{
return(BadRequest());
}
var restaurante = new Restaurante(restauranteViewModel.Nome, restauranteViewModel.RestauranteId);
db.Entry(restaurante).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RestauranteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void DadoUmNomeComMenosDeTresCaracteresDeveraRetornarUmaNotificacao()
{
var nome = "ab";
var restaurante = new Restaurante(nome);
Assert.AreEqual(1, restaurante.Notifications.Count);
}
public void DadoUmNomeComMenosDeTresCaracteresDeveraRetornarUmaNotificacaoQuandoAlterado()
{
var restaurante = new Restaurante("Nome válido");
restaurante.Alterar("ab");
Assert.AreEqual(1, restaurante.Notifications.Count);
}
public JsonResult DeleteRestaurante(int id)
{
if (id != 0)
{
try
{
Restaurante RestauranteParaDeletar = db.Restaurantes.Find(id);
if (RestauranteParaDeletar != null)
{
db.Restaurantes.Remove(RestauranteParaDeletar);
db.SaveChanges();
return(retornoEmJson("Restaurante deletado com sucesso"));
}
else
{
return(retornoEmJson("Restaurante não encontrado!"));
}
}
catch (Exception ex)
{
throw ex;
}
}
else
{
return(retornoEmJson("Requisição de deleção de Restaurante inválida."));
}
}
// PUT api/<controller>/5
public void Put([FromBody] Restaurante entity)
{
if (entity.Id_Restaurante > 0)
{
RestauranteRepository.Save(entity);
}
}
public Restaurante SaveWithoutLists(Restaurante obj)
{
Restaurante restaurante = (new RestauranteFactory()).Build(obj);
if (restaurante != null)
{
try
{
if (restaurante.Id == 0)
{
_context.Restaurantes.Add(restaurante);
}
else
{
_context.Restaurantes.Update(restaurante);
}
}
finally
{
ExecuteSaveChanges();
}
}
return(restaurante);
}
public ActionResult InsertRestaurante(Restaurante restaurante)
{
restaurante.Endereco.BuscarLatitudeLongitude(_service);
restaurante.InserirRestaurante(_repository);
return(Ok(restaurante));
}
public string Modificar(Restaurante restauranteNuevo)
{
try {
var restauranteViejo = _Context.Restaurantes.Find(restauranteNuevo.Nit);
if (restauranteViejo != null)
{
restauranteViejo.Nombre = restauranteNuevo.Nombre;
restauranteViejo.Pais = restauranteNuevo.Pais;
restauranteViejo.Ciudad = restauranteNuevo.Ciudad;
restauranteViejo.Direccion = restauranteNuevo.Direccion;
restauranteViejo.Barrio = restauranteNuevo.Barrio;
restauranteViejo.Telefono = restauranteNuevo.Telefono;
restauranteViejo.CorreoElectronico = restauranteNuevo.CorreoElectronico;
restauranteViejo.SitioWeb = restauranteNuevo.SitioWeb;
_Context.Restaurantes.Update(restauranteViejo);
_Context.SaveChanges();
return($"El registro {restauranteNuevo.Nombre} se ha modificado satisfactoriamente.");
}
else
{
return($"Lo sentimos, {restauranteNuevo.Nit} no se encuentra registrada.");
}
} catch (Exception e) {
return($"Error de la Aplicación: {e.Message}");
}
}
//PUT
public void Put([FromBody] Restaurante entity)
{
if (entity.RestauranteID > 0)
{
RestauranteRepository.Salvar(entity);
}
}
public IActionResult Create(Restaurante restaurante)
{
_context.Restaurantes.Add(restaurante);
_context.SaveChanges();
return(Json(restaurante));
}
public async Task <IActionResult> PutRestaurante([FromRoute] int id, [FromBody] Restaurante restaurante)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != restaurante.ID)
{
return(BadRequest());
}
_context.Entry(restaurante).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RestauranteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
static void Main()
{
Gestionador gestionador;
gestionador = new Gestionador();
if (gestionador.Locales.Count == 0)
{
List <Local> locales = new List <Local>();
Cine cine = new Cine(1, "16:30", "Cine", 20);
Tienda tienda = new Tienda(2, "12:30", "tienda", "ropa");
Restaurante restaurante = new Restaurante(3, "13:00", "restaurante", true);
Recreacion recreacion = new Recreacion(4, "22:00", "Disco", "Barra libre");
locales.Add(cine);
locales.Add(tienda);
locales.Add(restaurante);
locales.Add(recreacion);
gestionador.Locales = locales;
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(gestionador));
}
public async Task <IActionResult> Edit(int id, [Bind("CNPJ,Contato,Id,Nome,Email,Senha,Privilegio")] Restaurante restaurante)
{
if (id != restaurante.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(restaurante);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RestauranteExists(restaurante.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(restaurante));
}
public static void MyTesting()
{
var restaurante = new Restaurante(4);
//LlegaCliente(A(4))
Cliente A = new Cliente(4);
restaurante.LlegaCliente(A);
Cliente B = new Cliente(4);
restaurante.LlegaCliente(B);
Cliente C = new Cliente(4);
restaurante.LlegaCliente(C);
Cliente D = new Cliente(4);
restaurante.LlegaCliente(D);
Cliente E = new Cliente(4);
restaurante.LlegaCliente(E);
Console.WriteLine(restaurante.PlatosConsumidos(0));
Console.WriteLine(restaurante.ProximoAPagar());
Console.WriteLine(restaurante.EnLaCola);
Console.ReadLine();
}
public Restaurante CrearRestaurante(Restaurante restaurante)
{
var restauranteNuevo = db.Restaurantes.Add(restaurante);
db.SaveChanges();
return(restauranteNuevo);
}
public async Task <ActionResult> Create([Bind(Include = "Email,RestauranteId,RazonSocial,RUC,Direccion,Latitud,Longitud,AforoCompleto,Estado,MesaDisponible")] Restaurante restaurante)
{
if (ModelState.IsValid)
{
ApplicationDbContext context = new ApplicationDbContext();
var userStore = new UserStore <ApplicationUser>(context);
var UserManager = new UserManager <ApplicationUser>(userStore);
var user = new ApplicationUser {
UserName = restaurante.Email, Email = restaurante.Email
};
var result = await UserManager.CreateAsync(user, "password");
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "Restaurant");
db.Restaurantes.Add(restaurante);
db.SaveChanges();
return(RedirectToAction("Index"));
}
AddErrors(result);
}
return(View(restaurante));
}
public IHttpActionResult PutRestaurante(int id, Restaurante restaurante)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != restaurante.Id)
{
return(BadRequest());
}
db.Entry(restaurante).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RestauranteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <ResponseModel <Restaurante> > Get([FromRoute] long id)
{
Restaurante restaurante = null;
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:57659");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
HttpResponseMessage response = await client.GetAsync($"api/estabelecimento/{id}", token);
response.EnsureSuccessStatusCode();
var responseAsString = await response.Content.ReadAsStringAsync();
restaurante = JsonConvert.DeserializeObject <Restaurante>(responseAsString);
}
return(await Task.FromResult(new ResponseModel <Restaurante>(true, "", restaurante)));
}
catch (Exception)
{
return(await Task.FromResult(new ResponseModel <Restaurante>(false, "Ocorreu um erro interno ao salvar o registro", restaurante)));
}
}
public void Delete(Restaurante r)
{
var restauranteExcluir = c.restaurantes.First(x => x.idR == r.idR);
c.Set <Restaurante>().Remove(restauranteExcluir);
c.SaveChanges();
}
private void AtualizarRestPratos(string[] pratosSelecionados, Restaurante restaurantToUpdate)
{
if (pratosSelecionados == null)
{
restaurantToUpdate.Pratos = new List <Prato>();
return;
}
var selectedDishesHS = new HashSet <string>(pratosSelecionados);
var restPratos = new HashSet <int>
(restaurantToUpdate.Pratos.Select(r => r.ID));
foreach (var prato in db.Pratos)
{
if (selectedDishesHS.Contains(prato.ID.ToString()))
{
if (!restPratos.Contains(prato.ID))
{
restaurantToUpdate.Pratos.Add(prato);
}
}
else
{
if (restPratos.Contains(prato.ID))
{
restaurantToUpdate.Pratos.Remove(prato);
}
}
}
}
public JsonResult PutRestaurante(int id, Restaurante restaurante)
{
if (restaurante != null)
{
try
{
if (id == 0)
{
db.Restaurantes.Add(restaurante);
db.SaveChanges();
return(retornoEmJson("Restaurante inserido com sucesso"));
}
else
{
Restaurante restauranteParaAtualizar = db.Restaurantes.Where(prt => prt.id.Equals(id)).FirstOrDefault();
restauranteParaAtualizar.nome = (restaurante.nome != null ? restaurante.nome : restauranteParaAtualizar.nome);
db.SaveChanges();
return(retornoEmJson("Restaurante atualizado com sucesso!"));
}
}
catch (Exception ex)
{
throw ex;
}
}
else
{
return(retornoEmJson("Requisição de atualização de Restaurante inválida."));
}
}
public async Task <Dictionary <Restaurante, double> > ObterTop3_ComLookup()
{
var retorno = new Dictionary <Restaurante, double>();
var top3 = _avaliacoes.Aggregate()
.Group(_ => _.RestauranteId, g => new { RestauranteId = g.Key, MediaEstrelas = g.Average(a => a.Estrelas) })
.SortByDescending(_ => _.MediaEstrelas)
.Limit(3)
.Lookup <RestauranteSchema, RestauranteAvaliacaoSchema>("restaurantes", "RestauranteId", "Id", "Restaurante")
.Lookup <AvaliacaoSchema, RestauranteAvaliacaoSchema>("avaliacoes", "Id", "RestauranteId", "Avaliacoes");
await top3.ForEachAsync(_ =>
{
if (!_.Restaurante.Any())
{
return;
}
var restaurante = new Restaurante(_.Id, _.Restaurante[0].Nome, _.Restaurante[0].Cozinha);
var endereco = new Endereco(
_.Restaurante[0].Endereco.Logradouro,
_.Restaurante[0].Endereco.Numero,
_.Restaurante[0].Endereco.Cidade,
_.Restaurante[0].Endereco.UF,
_.Restaurante[0].Endereco.Cep);
restaurante.AtribuirEndereco(endereco);
_.Avaliacoes.ForEach(a => restaurante.InserirAvaliacao(a.ConverterParaDomain()));
retorno.Add(restaurante, _.MediaEstrelas);
});
return(retorno);
}
public void Post([FromBody] Restaurante entity)
{
if (!string.IsNullOrEmpty(entity.Nome_Restaurante))
{
RestauranteRepository.Save(entity);
}
}
public RestauranteViewModel(Restaurante restaurante)
{
Codigo = restaurante.Codigo;
Nombre = restaurante.Nombre;
Direccion = restaurante.Direccion;
Telefono = restaurante.Telefono;
}
public ActionResult IncluirRestaurante([FromBody] RestauranteInclusao restauranteInclusao)
{
var cozinha = ECozinhaHelper.ConverterDeInteiro(restauranteInclusao.Cozinha);
var restaurante = new Restaurante(restauranteInclusao.Nome, cozinha);
var endereco = new Endereco(
restauranteInclusao.Logradouro,
restauranteInclusao.Numero,
restauranteInclusao.Cidade,
restauranteInclusao.UF,
restauranteInclusao.Cep);
restaurante.AtribuirEndereco(endereco);
if (!restaurante.Validar())
{
return(BadRequest(
new
{
errors = restaurante.ValidationResult.Errors.Select(_ => _.ErrorMessage)
}));
}
_restauranteRepository.Inserir(restaurante);
return(Ok(
new
{
data = "Restaurante inserido com sucesso"
}
));
}
void SelecionarRestaurante(object r)
{
string restaurante = (string)r;
Restaurante rest = Restaurantes.Find(x => string.Equals(x.Nome, restaurante));
App.Current.MainPage.Navigation.PushAsync(new RestauranteView(rest));
}
public void DadoUmNomeNuloDeveraRetornarUmaNotificacaoQuandoAlterado()
{
var restaurante = new Restaurante("Nome válido");
restaurante.Alterar(null);
Assert.AreEqual(1, restaurante.Notifications.Count);
}
public EditarRestauranteResponse EditarRestaurante(Restaurante restaurante)
{
try
{
var response = _context.Restaurantes.Find(restaurante.NIT);
if (response != null)
{
response.Nombre = restaurante.Nombre;
response.Propietario = restaurante.Propietario;
response.Direccion = restaurante.Direccion;
response.CantidadPersonal = restaurante.CantidadPersonal;
response.Telefono = restaurante.Telefono;
response.Email = restaurante.Email;
response.Sedes = restaurante.Sedes;
response.AñoFuncionamiento = restaurante.AñoFuncionamiento;
response.Especialidad = restaurante.Especialidad;
_context.Restaurantes.Update(response);
_context.SaveChanges();
return(new EditarRestauranteResponse(response));
}
else
{
return(new EditarRestauranteResponse("No se encontro el Restaurante",
"NoExiste"));
}
}
catch (Exception e)
{
return(new EditarRestauranteResponse($"Error en la aplicacion: {e.Message}",
"Error"));
}
}
public RestauranteViewModel(Restaurante restaurante)
{
Nome = restaurante.Nome;
Morada = restaurante.Morada;
Classificacao = restaurante.Classificacao.ToString();
Imagem = restaurante.Imagem;
}
public IActionResult PutRestaurante([FromRoute] int id, [FromBody] Restaurante restaurante)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != restaurante.Id)
{
return(BadRequest());
}
try
{
_restauranteRepository.Update(restaurante);
}
catch (DbUpdateConcurrencyException)
{
if (!RestauranteExists(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}