public async Task <IHttpActionResult> PostFoodTruckAsync(FoodTruck foodTruck)
{
var searchResult = db.FoodTrucks.SingleOrDefault(i => string.Equals(foodTruck.Name.ToLower(), i.Name.ToLower()));
if (!ModelState.IsValid || searchResult != null)
{
return(BadRequest(ModelState));
}
foodTruck.Id = Guid.NewGuid().ToString();
db.FoodTrucks.Add(foodTruck);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (FoodTruckExists(foodTruck.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(Ok(""));
// return CreatedAtRoute("DefaultApi", new { id = foodTruck.Id }, foodTruck);
}
public async Task <IActionResult> Edit(int id, FoodTruck foodTruck)
{
if (id != foodTruck.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(foodTruck);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FoodTruckExists(foodTruck.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(foodTruck));
}
public IHttpActionResult PutFoodTruck(string id, FoodTruck foodTruck)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != foodTruck.Id)
{
return(BadRequest());
}
db.Entry(foodTruck).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!FoodTruckExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// We would like to manage our growing network of Food Trucks.
/// As the trucks park throughout the city, we need a way for them
/// to coordinate and communicate with each other so that they
/// don't occupy the same parking spots throughout the city.
/// We use a Mediator to eliminate mutual dependencies among our network of trucks.
/// </summary>
private static async Task Main()
{
var logger = new ConsoleLogger();
var bikeDatabase = new Database(Configuration.ConnectionString, logger);
var truckDatabase = new Database(Configuration.ConnectionString, logger);
var deliveryNetwork = new FoodCartMediator(logger);
var tacoTruck = new FoodTruck("Taco Truck", 4, 2, logger, truckDatabase);
var falafelCart = new BicycleCart("Falafel Bicycle", 4, 8, logger, bikeDatabase);
var sushiCart = new BicycleCart("Sushi Bike", 2, 8, logger, bikeDatabase);
var sandwichShop = new PopUpShop("Sandwich Pop-Up", 1, 8, logger);
await deliveryNetwork.Register(tacoTruck);
await deliveryNetwork.Register(falafelCart);
await deliveryNetwork.Register(sushiCart);
await deliveryNetwork.Register(sandwichShop);
await tacoTruck.Send(sushiCart, new NetworkMessage("Moving to the East Side."));
await sushiCart.Send(tacoTruck, new NetworkMessage("thanks trucks"));
await sandwichShop.Send(falafelCart, new NetworkMessage("All done here by the lake!"));
await falafelCart.Send(falafelCart, new NetworkMessage("thanks bikes!"));
await sandwichShop.Send(falafelCart, new NetworkMessage("where are you, Sandwich Shop?"));
await sandwichShop.Send(tacoTruck, new NetworkMessage("hey Taco Truck where are you?"));
}
public async Task ShouldReturnSingleFoodTruckWhenIdExists()
{
// Arrange
var testServer = TestUtil.CreateTestServer("GetFoodTruckById");
FoodTruck foodTruck = new FoodTruck(1, "Food Truck One", "Description of food truck one", "http://foodtruckone.com");
var context = testServer.GetDbContext <FoodTruckContext>();
context.FoodTrucks.Add(foodTruck);
context.SaveChanges();
var testClient = testServer.CreateClient();
// Act
var response = await testClient.GetAsync("/api/FoodTrucks/1");
// Assert
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
var model = await response.Content.ReadAsAsync <FoodTruckModel>();
model.FoodTruckId.Should().Be(1);
model.Name.Should().Be("Food Truck One");
}
private void CreateUser(Object sender, EventArgs arngs)
{
if (this.IsValidUser())
{
var foodTruck = new FoodTruck()
{
TradingName = TradingName.Text,
Cnpj = Cnpj.Text,
Email = Email.Text,
Password = Password.Text,
Descrption = "",
FoodTruckSpeciality = "",
IsOpen = false,
Latitude = 0,
Longitude = 0
};
var success = this.foodTruckRegisterPageVM.RegisterFoodTruck(foodTruck);
if (success == true)
{
DisplayAlert("Mensagem", "Bem vindo ao Truck My Food!", "OK");
App.Current.MainPage = new NavigationPage(new FoodTruckOwnerPage(foodTruck));
}
DisplayAlert("Alerta", "Food Truck já cadastrado, tente fazer o login.", "OK");
}
}
public void Delete(int id, string email)
{
using (TransactionScope scope = new TransactionScope())
{
FoodTruck item = db.FoodTruck.Find(id);
FuncionarioBusiness funcionarioBusiness = new FuncionarioBusiness(db);
var funcionario = funcionarioBusiness.GetFuncionarioByEmail(email);
if (funcionario == null)
{
throw new ExceptionBusiness("Ocorreu um erro ao salvar o FoodTruck favor tente mais tarde, caso o erro continue entre em contato a área responsável pelo sistema.");
}
if (funcionario.FoodTruckFuncionario.Count <= 1)
{
throw new ExceptionBusiness("Você deve possuir ao menos um FoodTruck cadastrato.");
}
foreach (var itemFF in item.FoodTruckFuncionario.ToList())
{
itemFF.Funcionario = null;
itemFF.FoodTruck = null;
db.FoodTruckFuncionario.Remove(itemFF);
}
db.FoodTruck.Remove(item);
db.SaveChanges();
scope.Complete();
}
}
public IActionResult Update(int foodTruckId, FoodTruck editedTruck)
{
if (ModelState.IsValid == false)
{
return(View("Edit", editedTruck));
}
FoodTruck selectedTruck = db.FoodTrucks.FirstOrDefault(truck => truck.FoodTruckId == foodTruckId);
if (selectedTruck == null)
{
return(RedirectToAction("All"));
}
selectedTruck.Name = editedTruck.Name;
selectedTruck.Style = editedTruck.Style;
selectedTruck.Description = editedTruck.Description;
selectedTruck.UpdatedAt = DateTime.Now;
db.FoodTrucks.Update(selectedTruck);
db.SaveChanges();
// new {} dictionary is full of paramName value pairs for Details action
// every param that the action needs, must be a key in the dictionary
return(RedirectToAction("Details", new { foodTruckId = selectedTruck.FoodTruckId }));
}
public Result <FoodTruck> CreateFoodTruck(CreateFoodTruckCommand foodTruckInfo)
{
// Creates our Food Truck object
var foodTruck = new FoodTruck(foodTruckInfo.Name, foodTruckInfo.Description, foodTruckInfo.Website);
// Converts tag strings into tag objects (including creating tags that don't exist)
var tagObjects = DecodeTags(foodTruckInfo.Tags);
// Attaches the tags to the Food Truck Object
tagObjects.ForEach(obj => foodTruck.AddTag(obj));
// Social Media Accounts
foreach (var accountInfo in foodTruckInfo.SocialMediaAccounts)
{
var platform = _socialMediaPlatformRepository.GetSocialMediaPlatform(accountInfo.SocialMediaPlatformId);
if (platform == null)
{
throw new InvalidDataException($"The id {accountInfo.SocialMediaPlatformId} is not a valid social media platform id");
}
SocialMediaAccount account = new SocialMediaAccount(platform, foodTruck, accountInfo.AccountName);
foodTruck.AddSocialMediaAccount(account);
}
// Persist to the database
_foodTruckRepository.Save(foodTruck);
UnitOfWork.SaveChanges();
return(Result.Success <FoodTruck>(foodTruck));
}
public FoodTruck CreateFoodTruck(CreateFoodTruckCommand foodTruckInfo)
{
try
{
// Creates our Food Truck object
var foodTruck = new FoodTruck(foodTruckInfo.Name, foodTruckInfo.Description, foodTruckInfo.Website);
// Converts tag strings into tag objects (including creating tags that don't exist)
var tagObjects = this.DecodeTags(foodTruckInfo.Tags);
// Attaches the tags to the Food Truck Object
tagObjects.ForEach(obj => foodTruck.AddTag(obj));
// Persist to the database
this.foodTruckRepository.Save(foodTruck);
this.UnitOfWork.SaveChanges();
return(foodTruck);
}
catch (Exception ex)
{
Logger.LogError(new EventId(104), ex, $"Error thrown while calling FoodTruckService.CreateFoodTruck()");
throw;
}
}
public IActionResult ReviewTruck(Review newReview, int foodTruckId)
{
// in case we need to return the view for error messages, we need to send the view model as well, which is the selected FoodTruck
FoodTruck selectedTruck = db.FoodTrucks
.Include(truck => truck.Reviews)
.ThenInclude(review => review.Author)
.FirstOrDefault(truck => truck.FoodTruckId == foodTruckId);
if (ModelState.IsValid == false)
{
return(View("Details", selectedTruck));
}
bool alreadyReviewed = db.Reviews.Any(review => review.UserId == uid && review.FoodTruckId == newReview.FoodTruckId);
if (alreadyReviewed)
{
ModelState.AddModelError("Body", "Already Reviewed");
return(View("Details", selectedTruck));
}
newReview.UserId = (int)uid;
db.Reviews.Add(newReview);
db.SaveChanges();
return(RedirectToAction("Details", new { foodTruckId = newReview.FoodTruckId }));
}
public async Task <IActionResult> Edit(int id, [Bind("FoodTruckId,FoodTruckName,ProfileViews,Latitude,Longitude,CuisineType,TruckHistory,TruckCrew,IdentityUserId")] FoodTruck foodTruck)
{
if (id != foodTruck.FoodTruckId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(foodTruck);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FoodTruckExists(foodTruck.FoodTruckId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdentityUserId"] = new SelectList(_context.Users, "Id", "Id", foodTruck.IdentityUserId);
return(View(foodTruck));
}
public async Task <IActionResult> Edit(int id, [Bind("FoodTruckID,Name,LocationID")] FoodTruck foodTruck)
{
if (id != foodTruck.FoodTruckID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(foodTruck);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FoodTruckExists(foodTruck.FoodTruckID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["LocationID"] = new SelectList(_context.Locations, "LocationID", "LocationID", foodTruck.LocationID);
return(View(foodTruck));
}
public HttpResponseMessage Insert(FoodTruck foodTruck)
{
var resultado = new HttpResponseMessage();
try
{
using (TransactionScope scope = new TransactionScope())
{
_business.Insert(foodTruck);
_businessFuncionario = new FuncionarioBusiness();
var entity = _businessFuncionario.GetFuncionarioByEmail(foodTruck.EmailFuncionario);
resultado = Request.CreateResponse(HttpStatusCode.OK, entity);
scope.Complete();
}
}
catch (ExceptionBusiness ex)
{
resultado = ProcessarExcecaoWeb(ex, true);
}
catch (Exception ex)
{
resultado = ProcessarExcecaoWeb(ex);
}
return(resultado);
}
public IActionResult Update(FoodTruck editedTruck, int foodTruckId)
{
if (ModelState.IsValid == false)
{
return(View("Edit", editedTruck)); // display error messages
}
FoodTruck dbTruck = db.FoodTrucks.FirstOrDefault(truck => truck.FoodTruckId == editedTruck.FoodTruckId);
// if the name is being changed
if (editedTruck.Name != dbTruck.Name)
{
bool isNameTaken = db.FoodTrucks.Any(truck => truck.Name == editedTruck.Name);
if (isNameTaken)
{
ModelState.AddModelError("Name", "is taken");
return(View("Edit", editedTruck)); // display error messages
}
}
// none of the above returns happened, safe to update
dbTruck.UpdatedAt = DateTime.Now;
dbTruck.Name = editedTruck.Name;
dbTruck.Style = editedTruck.Style;
dbTruck.Description = editedTruck.Description;
db.Update(dbTruck);
db.SaveChanges();
return(RedirectToAction("Dashboard"));
}
public IActionResult Review(int foodTruckId, Review newReview)
{
if (ModelState.IsValid == false)
{
FoodTruck selectedTruck = db.FoodTrucks
.Include(truck => truck.UploadedBy)
.Include(truck => truck.Reviews)
// then include because I want to include something from truck.Reviews, not from the truck itself
.ThenInclude(review => review.Author)
.FirstOrDefault(truck => truck.FoodTruckId == foodTruckId);
return(View("Details", selectedTruck));
}
// Associate the author of the review
newReview.UserId = (int)uid;
// this assignment happens automatically because they are named the same
// newReview.FoodTruckId = foodTruckId;
db.Reviews.Add(newReview);
db.SaveChanges();
// new {} dictionary is full of paramName value pairs for Details action
// every param that the action needs, must be a key in the dictionary
return(RedirectToAction("Details", new { foodTruckId = newReview.FoodTruckId }));
}
public IActionResult Put(int foodTruckId, [FromBody] List <string> tags)
{
FoodTruck foodTruck = this.foodTruckService.UpdateFoodTruckTags(foodTruckId, tags);
var model = this.mapper.Map <FoodTruck, FoodTruckModel>(foodTruck);
return(this.Ok(model));
}
public IActionResult Post(int foodTruckId, [FromBody] List <string> tags)
{
FoodTruck foodTruck = _foodTruckService.AddFoodTruckTags(foodTruckId, tags);
var model = _mapper.Map <FoodTruck, FoodTruckModel>(foodTruck);
return(Ok(model));
}
public int CreateFoodTruck(FoodTruck foodTruck)
{
if (_authenticatedUser.Role != UserRoleEnum.Admin)
{
throw new AuthenticationException("Invalid Role");
}
return(_foodTruckSqlAccess.CreateFoodTruck(foodTruck, _authenticatedUser.UserId));
}
public IActionResult Post([FromBody]CreateFoodTruckModel createModel)
{
var createCommand = this.mapper.Map<CreateFoodTruckModel, CreateFoodTruckCommand>(createModel);
FoodTruck foodTruck = this.foodTruckService.CreateFoodTruck(createCommand);
var model = this.mapper.Map<FoodTruck, FoodTruckModel>(foodTruck);
return this.CreatedAtRoute(GET_FOOD_TRUCK_BY_ID, new { id = model.FoodTruckId }, model);
}
public void UpdateFoodTruck(FoodTruck foodTruck)
{
if (_authenticatedUser.Role != UserRoleEnum.Admin)
{
throw new AuthenticationException("Invalid Role");
}
_foodTruckSqlAccess.UpdateFoodTruck(foodTruck, _authenticatedUser.UserId);
}
public FoodTruckOwnerInformation(FoodTruck foodTruck)
{
InitializeComponent();
this.foodTruck = foodTruck;
this.foodTruckOwnerInformationVM = new FoodTruckOwnerInformationViewModel();
BindingContext = foodTruckOwnerInformationVM.GetInformations(foodTruck.Cnpj);
}
public IActionResult Post([FromBody] FoodTruck FoodTruck)
{
if (ModelState.IsValid)
{
service.Save(FoodTruck);
return(Ok(new CreatedAtRouteResult("create FoodTruck", new { Id = FoodTruck.Id }, FoodTruck)));
}
return(BadRequest(ModelState));
}
public IActionResult Delete(int id)
{
foodTrucks = context.FoodTrucks.ToList();
FoodTruck foodTruck = foodTrucks.SingleOrDefault(f => f.ID == id);
context.Remove(foodTruck);
context.SaveChanges();
return(RedirectToAction(actionName: nameof(Index)));
}
public ActionResult Add(FoodTruck truck)
{
_session.Store(truck);
var user = _accountant.GetUser(HttpContext);
user.FoodTrucks.Add(new FoodTruckAccount { FoodTruckId = truck.Id });
_session.SaveChanges();
return RedirectToAction("Index");
}
public IActionResult PostV11([FromBody] CreateFoodTruckModelV11 createModel)
{
var createCommand = _mapper.Map <CreateFoodTruckModelV11, CreateFoodTruckCommand>(createModel);
FoodTruck foodTruck = _foodTruckService.CreateFoodTruck(createCommand);
var model = _mapper.Map <FoodTruck, FoodTruckModelV11>(foodTruck);
return(CreatedAtRoute(GET_FOOD_TRUCK_BY_ID, new { id = model.FoodTruckId }, model));
}
public IActionResult Put([FromBody] FoodTruck FoodTruck, int id)
{
if (FoodTruck.Id != id)
{
return(BadRequest());
}
service.Update(FoodTruck);
return(Ok());
}
public IActionResult Put(int id, [FromBody]UpdateFoodTruckModel updateModel)
{
var updateCommand = new UpdateFoodTruckCommand() { FoodTruckId = id };
this.mapper.Map<UpdateFoodTruckModel, UpdateFoodTruckCommand>(updateModel, updateCommand);
FoodTruck foodTruck = this.foodTruckService.UpdateFoodTruck(updateCommand);
var model = this.mapper.Map<FoodTruck, FoodTruckModel>(foodTruck);
return this.Ok(model);
}
public IActionResult Delete(int foodTruckId)
{
FoodTruck dbTruck = db.FoodTrucks.FirstOrDefault(truck => truck.FoodTruckId == foodTruckId);
db.FoodTrucks.Remove(dbTruck);
db.SaveChanges();
// succinct version
// db.FoodTrucks.Remove(db.FoodTrucks.FirstOrDefault(truck => truck.FoodTruckId == foodTruckId));
return(RedirectToAction("Dashboard"));
}
public async Task <IActionResult> Create(FoodTruck foodTruck)
{
if (ModelState.IsValid)
{
_context.Add(foodTruck);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(foodTruck));
}
public void FoodTruckModelCorrectlyMapsFoodTruckWithoutTags()
{
// Arrange
var foodTruck = new FoodTruck(1, "All American Burger", "Burgers, Brats, Hot Dogs and More", @"http://allamericanburger.foodtruck.com");
// Act
var model = mapper.Map <FoodTruckModel>(foodTruck);
// Assert
model.Tags.Should().BeEmpty();
}
public FoodTruckEx(FoodTruck truck)
{
mTruck = truck;
}
public static bool MoveToNewLot(FoodTruck ths)
{
/*
if ((ths.RoutingComponent != null) && ths.RoutingComponent.IsRouting)
{
return true;
}
*/
if (ths.ReferenceList.Count > 0x0)
{
return false;
}
return (SimClock.ElapsedTime(TimeUnit.Hours, ths.mTimeAtCurrentLot) >= ths.FoodTruckTuning.HoursToStayOnLot);
}
public static void AddMapTags(FoodTruck truck)
{
if (Household.ActiveHousehold != null)
{
foreach (Sim sim in Household.ActiveHousehold.Sims)
{
if (sim.IsHuman && sim.SimDescription.ChildOrAbove)
{
MapTagManager mapTagManager = sim.MapTagManager;
if (mapTagManager != null)
{
if (mapTagManager.HasTag(truck))
{
mapTagManager.RefreshTag(truck);
}
else
{
mapTagManager.AddTag(new FoodTruckMapTag(truck, sim));
}
}
}
}
}
}
public FoodTruckMapTag(FoodTruck vehicle, Sim owner)
: base(vehicle, owner)
{ }
public static void RouteToNewLot(FoodTruck ths, Lot lot)
{
ths.mDestinationLot = lot;
new FoodTruckEx(ths).RouteTruckToLot();
}
