public ActionResult Edit([Bind(Include = "Beer_ID,Beer_Name,Beer_Description,Beer_Rating,ImageName,Brewery_ID")] Beers beers)
{
if (ModelState.IsValid)
{
db.Entry(beers).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Brewery_ID = new SelectList(db.Breweries, "Brewery_ID", "Brewery_Name", beers.Brewery_ID);
return(View(beers));
}
public async Task <ActionResult> Edit([Bind(Include = "beerId,beerName,beerStyle,beerABV,beerCalories,beerIBU,beerDesc")] Beers beers)
{
if (ModelState.IsValid)
{
db.Entry(beers).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(beers));
}
public async Task<ActionResult> Create(Beers beers)
{
if (ModelState.IsValid)
{
db.Beers.Add(beers);
await db.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(beers);
}
public void OnGet()
{
var beer = new RestClient("https://localhost:44371/api/Beers");
var request = new RestRequest(Method.GET);
request.AddHeader("content-type", "application/json");
IRestResponse response = beer.Execute(request);
Beers = JsonConvert.DeserializeObject <List <Beer> >(response.Content);
Beers.Where(b => b.Marca == "Heineken").ToList();
}
public IActionResult CreateNewBeer([FromBody] Beers beer)
{
try
{
_beerService.AddNewBeer(beer);
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
return(Ok());
}
public async Task <ActionResult> Create(Beers beers)
{
if (ModelState.IsValid)
{
db.Beers.Add(beers);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(beers));
}
private async void PunkapiMainPage_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
Beers selected = PunkapiMainPage.SelectedItem as Beers;
if (selected != null)
{
Navigation.PushAsync(new OneBeer(selected.Id));
SingleBeer singleBeer = await PunkapiRepository.GetAllSingleBeersAsync(selected.Id);
PunkapiMainPage.SelectedItem = null;
}
}
public void QuestionTest()
{
var q = new Beers();
var beersStr = q.Question.Split(new[] { '?' })[1];
var beers = beersStr.Trim().Split(new[] { ' ' });
Console.WriteLine(string.Join(" ", beers));
var all = beers.All(beer => _beers[beer]);
Console.WriteLine(all);
Assert.IsTrue(q.Run("" + all));
Assert.IsFalse(q.Run("" + !all));
}
public static void ReadWriteStream(TcpClient client)
{
try
{
Stream ns = client.GetStream();
StreamReader sr = new StreamReader(ns);
StreamWriter sw = new StreamWriter(ns);
sw.AutoFlush = true;
string message = sr.ReadLine();
string answar = "";
while (message != " " && message != "stop")
{
Console.WriteLine("client: " + message);
switch (message)
{
case "GetAll":
Console.WriteLine(JsonConvert.SerializeObject(Beers.BeerList));
sw.WriteLine(JsonConvert.SerializeObject(Beers.BeerList));
break;
case "GetByID":
int id = Int32.Parse(sr.ReadLine());
answar = Beers.GetById(id).ToString();
Console.WriteLine(answar);
sw.WriteLine(answar);
break;
case "Save":
string JsonString = sr.ReadLine();
Beer beer = JsonConvert.DeserializeObject <Beer>(JsonString);
Beers.Addbeer(beer);
break;
default:
answar = "bad request";
Console.WriteLine(answar);
sw.WriteLine(answar);
break;
}
message = sr.ReadLine();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}
private async Task SearchBeer(string query)
{
IsBusy = true;
Beers.Clear();
var beers = await _untappdService.SearchBeer(query);
foreach (var beer in beers)
{
Beers.Add(beer);
}
IsBusy = false;
}
// GET: Beers/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Beers beers = await db.Beers.FindAsync(id);
if (beers == null)
{
return(HttpNotFound());
}
return(View(beers));
}
// GET: Beers2/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Beers beers = db.Beers.Find(id);
if (beers == null)
{
return(HttpNotFound());
}
return(View(beers));
}
// GET: Beers2/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Beers beers = db.Beers.Find(id);
if (beers == null)
{
return(HttpNotFound());
}
ViewBag.Brewery_ID = new SelectList(db.Breweries, "Brewery_ID", "Brewery_Name", beers.Brewery_ID);
return(View(beers));
}
async Task LoadMoreBeers()
{
LastLoadedPage++;
var resultFromApi = await ApiService.GetBeersByStyle(_style.Id, LastLoadedPage).SetIsLoading(this);
if (resultFromApi.Status == Status.Failure)
{
return;
}
LastLoadedPage = resultFromApi.CurrentPage;
TotalPages = resultFromApi.NumberOfPages;
resultFromApi.Data.ForEach(b => Beers.Add(b));
}
internal Keg AttachEntities(Keg kegItem)
{
if (kegItem != null && kegItem.kegSizeId != null)
{
var kegSize = KegSizes.Find(ks => ks.id == kegItem.kegSizeId).FirstOrDefault();
kegItem.kegSize = kegSize;
}
if (kegItem != null && kegItem.beerId != null)
{
var beer = Beers.Find(b => b.id == kegItem.beerId).FirstOrDefault();
beer = AttachEntities(beer);
kegItem.beer = beer;
}
return(kegItem);
}
public void GetBeersReturnResult(string param, string endpoint)
{
var mockRequestModel = new Request();
var mockBeersModel = new Beers();
var mockContextProvide = new Moq.Mock <IContextProvider>();
mockContextProvide.Setup(m => m.GetBeersAsync(param, endpoint)).Returns(mockBeersModel);
var provider = new BeerProvider(mockContextProvide.Object);
Beers beers = provider.GetBeers(mockRequestModel);
Assert.IsNotNull(beers, $"beer {provider}");
}
public void SearchBeersReturnError(string request)
{
var mockRequestModel = new Request();
var mockBeersModel = new Beers();
var mockContextProvide = new Moq.Mock <IContextProvider>();
mockContextProvide.Setup(x => x.GetBeersAsync($"&q={request}&type=beer", "search/")).Returns(mockBeersModel);
var provider = new BeerProvider(mockContextProvide.Object);
Beers beers = provider.SearchBeers(mockRequestModel);
Assert.IsNull(beers);
}
public async Task <HttpResponseMessage> GetBeers(int id)
{
try
{
Beers beers = await db.Beers.FindAsync(id);
if (beers == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
return(Request.CreateResponse(HttpStatusCode.Accepted, beers));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <inheritdoc />
public async Task <bool> CheckDatabaseConnectionAsync()
{
try
{
await Beers.AnyAsync();
return(true);
}
catch (SocketException)
{
return(false);
}
catch (InvalidOperationException)
{
return(false);
}
}
public Beer AddBeer(string name, double?alcoholByVolume = null, decimal price = 0, string description = null)
{
if (name != null && Beers.Any(b => b.Name == name))
{
throw new ArgumentException($"Brewer {Name} has already a beer by the name of {name}");
}
Beer newBeer = new Beer(name)
{
AlcoholByVolume = alcoholByVolume,
Description = description,
Price = price
};
Beers.Add(newBeer);
return(newBeer);
}
public void SearchBeersReturnResult(string queryRequest)
{
var mockRequestModel = new Request {
query = queryRequest
};
var mockBeersModel = new Beers();
var mockContextProvide = new Moq.Mock <IContextProvider>();
mockContextProvide.Setup(x => x.GetBeersAsync($"&q={queryRequest}&type=beer", "search/")).Returns(mockBeersModel);
var provider = new BeerProvider(mockContextProvide.Object);
Beers beers = provider.SearchBeers(mockRequestModel);
Assert.IsNotNull(beers);
Assert.IsTrue(beers.data.Count > 0, "beera.data should be greater than 0");
}
public async Task <HttpResponseMessage> PostBeers([Bind(Include = "Id,Name,AverageRatings,BeerTypeId")] Beers beer)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
db.Beers.Add(beer);
await db.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.Accepted, beer));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex));
}
}
public void GetBeersReturnResult()
{
var mockRequestModel = new Request();
var mockBeersModel = new Beers();
var mockBeerProvide = new Moq.Mock <IBeerProvider>();
mockBeerProvide.Setup(x => x.GetBeers(mockRequestModel)).Returns(mockBeersModel);
var controller = new BeerController(mockBeerProvide.Object);
//Act
IHttpActionResult actionResult = controller.GetBeers(mockRequestModel);
//Assert
Assert.IsNotNull(actionResult);
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <Beers>));
}
public void SetOrder(BeerSortOrder inSortOrder)
{
switch (inSortOrder)
{
case BeerSortOrder.AZ:
Beers = new ObservableCollection <BeerViewModel>(Beers
.OrderBy(X => X.Beer.BreweryName)
.ThenBy(X => X.Beer.BeerName));
break;
case BeerSortOrder.Fav:
Beers = new ObservableCollection <BeerViewModel>(Beers
.OrderByDescending(X => X.Beer.MetaData.IsFavorited)
.ThenBy(X => X.Beer.BreweryName)
.ThenBy(X => X.Beer.BeerName));
break;
}
}
public async Task <HttpResponseMessage> DeleteBeers(int id)
{
try
{
Beers beers = await db.Beers.FindAsync(id);
if (beers == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound, beers));
}
db.Beers.Remove(beers);
await db.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.Accepted, beers));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex));
}
}
private async Task ExecuteSearchBeersCommand()
{
if (IsBusy)
{
return;
}
using (Insights.TrackTime("BeerSearch", "searchTerm", SearchTerm))
{
_userDialogs.ShowLoading("Searching...");
IsBusy = true;
IsSearched = true;
try
{
var results = await _beerDrinkinClient.SearchBeersAsync(SearchTerm);
Beers.Clear();
if (results?.Count > 0)
{
foreach (var beer in results)
{
Beers.Add(beer);
}
}
_userDialogs.HideLoading();
}
catch (Exception ex)
{
_userDialogs.ShowError(ex.Message);
}
finally
{
IsBusy = false;
}
}
}
private async Task GetData()
{
BeersList.IsEnabled = false;
SalesList.IsEnabled = false;
SellButton.IsEnabled = false;
Beers = (await _client.GetBeers()).ToList();
Sales = (await _client.GetSales()).ToList();
foreach (var sale in Sales)
{
sale.Beer = Beers.Find(b => b.Id == sale.BeerId);
}
BeersList.ItemsSource = Beers;
BeerOrderList.ItemsSource = Beers;
BeerStatsList.ItemsSource = Beers;
SalesList.ItemsSource = Sales;
BeersList.IsEnabled = true;
SalesList.IsEnabled = true;
SellButton.IsEnabled = true;
}
internal IEnumerable <Keg> AttachEntities(IEnumerable <Keg> kegList)
{
//Load KegSizes
var kegSizeIdsToLoad = kegList.Select(k => k.kegSizeId).Distinct().ToList();
var kegSizes = KegSizes.Find(ks => kegSizeIdsToLoad.Contains(ks.id)).ToList();
//Load Beers
var beerIdsToLoad = kegList.Select(k => k.beerId).Distinct().ToList();
var beers = Beers.Find(b => beerIdsToLoad.Contains(b.id)).ToList();
beers = AttachEntities(beers).ToList();
kegList.ToList().ForEach(k => {
if (k.beerId != null)
{
var beer = beers.FirstOrDefault(b => b.id == k.beerId);
k.beer = beer;
}
if (k.kegSizeId != null)
{
k.kegSize = kegSizes.FirstOrDefault(ks => ks.id == k.kegSizeId);
}
});
return(kegList);
}
// GET: Beers
public async Task<ActionResult> Index()
{
Beers beerModel = new Beers();
//beerModel =
return View(BeersFactory.GetBeerList());
}
public string Delete(Beer item)
{
Beers.DeleteOne(b => b.id == item.id);
return(item.id);
}
public static void Start()
{
TcpListener Beerserver = null;
try
{
// Set the TcpListener on port 13000.
Int32 port = 4646;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
// TcpListener server = new TcpListener(port);
Beerserver = new TcpListener(localAddr, port);
Beerserver.Start();
while (true)
{
Console.WriteLine("Waiting for a connection...");
TcpClient client = Beerserver.AcceptTcpClient();
Console.WriteLine("Connected!");
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
Stream ns = client.GetStream();
StreamReader sr = new StreamReader(ns);
StreamWriter sw = new StreamWriter(ns);
sw.AutoFlush = true;
string message = sr.ReadLine();
Console.WriteLine(value: "Client: " + message);
if (message.Equals("Getall"))
{
sw.WriteLine("Getall");
sw.WriteLine(JsonConvert.SerializeObject(Beers).ToString());
}
else if (message.Equals("Getbyid"))
{
sw.WriteLine("Getbyid");
sw.WriteLine("Write you Prefered ID");
String lineid = sr.ReadLine();
int number = Int32.Parse(lineid);
sw.WriteLine(JsonConvert.SerializeObject(Beers.Find(Beers => Beers.ID==number)));
}
else if (message.Equals("Save"))
{
sw.WriteLine("Save");
sw.WriteLine("Write a new Beer");
string Beer = sr.ReadLine();
Beers.Add(JsonConvert.DeserializeObject<Beer>(Beer));
}
else
{
sw.WriteLine("Function not recognized");
}
client.Close();
Console.WriteLine("it has stopped");
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public override void OnNavigatingTo(INavigationParameters parameters)
{
base.OnNavigatingTo(parameters);
Beers = (Beers)parameters["model"];
}
