private void RegClicked(object sender, EventArgs e)
{
var food = new
{
Id = tbId.Text,
Name = tbName.Text,
Quantity = Convert.ToInt32(tbQuantity.Text),
Price = Convert.ToInt32(tbPrice.Text),
RestId = tbRestId.Text
};
var RestResult = RestaurantController.GetRestaurant(tbRestId.Text);
if (RestResult != null)
{
var result = FoodController.AddFood(food);
if (result)
{
MessageBox.Show("Food Added", "Food Registration", MessageBoxButtons.OK, MessageBoxIcon.None);
}
else
{
MessageBox.Show("Could not Add Food", "Invalid Registration", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show("Could not Add Restaurant", "Invalid Registration", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void OnChooseSelectFood()
{
if (RestaurantController.Instance() == null)
{
return;
}
if (curSelectFoodItem == null)
{
MessageBoxLogic.OpenOKBox(3049, 1000);
return;
}
Tab_RestaurantFood curTabFood = TableManager.GetRestaurantFoodByID(curSelectFoodItem.FoodID, 0);
if (null == curTabFood)
{
LogModule.ErrorLog("cur food id is not defined in table");
return;
}
if (curTabFood.OpenLevel > RestaurantController.Instance().CurRestaurant().m_RestaurantLevel)
{
// 此菜品将在等级{0}开启
MessageBoxLogic.OpenOKBox(StrDictionary.GetClientDictionaryString("#{1989}", curTabFood.OpenLevel));
return;
}
RestaurantController.Instance().OnChooseFoodFinish(curSelectFoodItem.FoodID);
curSelectFoodItem = null;
}
public RestaurantControllerTest()
{
//mock setup
RestaurantMock = new Mock <IRestaurant>();
RestaurantsMock = new List <IRestaurant> {
RestaurantMock.Object
};
addRestaurantMock = new Mock <IAddRestaurant>();
updateRestaurantMock = new Mock <IUpdateRestaurant>();
Restaurant = new Restaurant();
Restaurants = new List <Restaurant>();
//viewmodels mock setup
//sample models
updateRestaurant = new UpdateRestaurant {
};
//controller setup
var RestaurantResultsMock = new Mock <IActionResult>();
mockRepo = new Mock <IRepositoryWrapper>();
var allRestaurants = GetRestaurants();
restaurantController = new RestaurantController(mockRepo.Object);
}
public void OnItemClick()
{
Tab_RestaurantFood curFood = TableManager.GetRestaurantFoodByID(m_foodID, 0);
if (null == curFood)
{
LogModule.ErrorLog("OnItemClick::curTabData is null");
return;
}
if (null == RestaurantData.m_PlayerRestaurantInfo)
{
LogModule.ErrorLog("OnItemClick::RestaurantData.m_PlayerRestaurantInfo is null");
return;
}
if (null == m_parentWindow)
{
LogModule.ErrorLog("OnItemClick::m_parentWindow is null");
return;
}
if (curFood.OpenLevel > RestaurantData.m_PlayerRestaurantInfo.m_RestaurantLevel)
{
return;
}
m_parentWindow.OnFoodItemClick(this);
if (RestaurantController.Instance().NewPlayerGuide_Step == 1 && m_foodID == 0)
{
RestaurantController.Instance().NewPlayerGuide(2);
}
}
private void btnSubmit_Click(object sender, EventArgs e)
{
var review = new
{
RestaurantId = tbRestId.Text,
RestaurantReview = tbReview.Text
};
var RestResult = RestaurantController.GetRestaurant(tbRestId.Text);
if (RestResult != null)
{
var result = ReviewController.AddReview(review);
if (result)
{
MessageBox.Show("Review Recorded");
}
else
{
MessageBox.Show("Review Recording failed");
}
}
else
{
MessageBox.Show("Restaurant Not Found");
}
}
void OpenUI(Tab_UIPath uiPath)
{
if (UIPathData.m_DicUIInfo.ContainsKey(uiPath.Path))
{
UIPathData curData = UIPathData.m_DicUIInfo[uiPath.Path];
// 科技院单独处理
if (uiPath.Path == "Prefab/UI/Restaurant")
{
RestaurantController.OpenWindow(true);
}
else
{
UIManager.ShowUI(curData, (bSuccess, param) =>
{
if (!string.IsNullOrEmpty(uiPath.Param))
{
switch (uiPath.Path)
{
case "Prefab/UI/ActivityController":
ActivityController.Instance().m_HuoDongControl.ChangeTab(uiPath.Param);
break;
case "Prefab/UI/PartnerFrameRoot":
PartnerFrameLogic.Instance().m_TabController.ChangeTab(uiPath.Param);
break;
}
}
});
}
}
}
void OnRestaurantClick(GameObject value)
{
if (!GameManager.gameManager.PlayerDataPool.IsServerFlagOpen(SERVER_FLAGS_ENUM.FLAG_KEJIYUAN))
{
GUIData.AddNotifyData("#{10830}");
return;
}
bool bRet = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_RESTAURANTFUNCTION_OPENFLAG);
if (bRet == false)
{
GUIData.AddNotifyData("#{10830}");
return;
}
// if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level < (int)GameDefine_Globe.NEWBUTTON_LEVEL.FARM)
// {
// GUIData.AddNotifyData("#{10830}");
// return;
// }
NewPlayerGuidLogic.CloseWindow();
if (m_NewButton != null && m_NewButton == value)
{
StopNewButtonEffect();
}
RestaurantController.OpenWindow(true);
}
public void IndexShouldReturnViewWithAllRestaurants()
{
// arrange
var restaurantsList = new List <Restaurant>
{
new Restaurant {
Id = 1, Name = "Nick's"
},
new Restaurant {
Id = 2, Name = "Fred's"
}
};
var mockRepo = new Mock <IRestaurantRepository>();
mockRepo.Setup(x => x.GetRestaurants("")).Returns(restaurantsList);
RestaurantController controller = new RestaurantController(mockRepo.Object);
// act
var actionResult = controller.Index();
// assert
var view = Assert.IsType <ViewResult>(actionResult);
var model = Assert.IsAssignableFrom <IEnumerable <WebModels.Restaurant> >
(view.Model).ToList();
Assert.Equal(restaurantsList.Count, model.Count);
for (int i = 0; i < model.Count; i++)
{
Assert.Equal(restaurantsList[i].Id, model[i].Id);
Assert.Equal(restaurantsList[i].Name, model[i].Name);
}
}
public void ReturnsAllRestaurantsInDB()
{
//Arrange
var restaurantRepository = Mock.Create <IRepository>();//Creating an instance of the mock database
Mock.Arrange(() => restaurantRepository.GetAll()).
Returns(new List <Restaurant>() //This will return a list containing two new restaurants
{
new Restaurant {
Name = "Cornacopia", City = "Dublin", Keyword = "Good"
},
new Restaurant {
Name = "Olive Garden", City = "Cork", Keyword = "Bad"
},
}).MustBeCalled(); //This part says that the test will fail if the getAll() method is not called.
//Act
RestaurantController controller = new RestaurantController(restaurantRepository);
ViewResult viewResult = controller.MyTestMethod();
var model = viewResult.Model as IEnumerable <Restaurant>;//Getting the model from the ViewResult
//which will be an IEnumerable<Restaurant>
//Assert
Assert.AreEqual(2, model.Count());
}
public void UpdateRestaurant()
{
// Arrange
var restaurantDto = new RestaurantDto
{
Address = "1 Avely Rd.",
City = "Girard",
Country = "USA",
EmailAddress = "*****@*****.**",
Name = "New Restaurant",
Phone = "(330) 454-4543",
PostalCode = "44420",
State = "OH",
WebsiteUrl = "http://www.NewRestaurant.com"
};
var restaurant = _mapper.Map <Restaurant>(restaurantDto);
Mock.Get(_repositoryWrapper.Restaurant).Setup(x => x.UpdateRestaurant(restaurant, restaurant));
Mock.Get(_repositoryWrapper.Restaurant).Setup(x => x.GetRestaurantById(restaurant.Id)).ReturnsAsync(restaurant);
var controller = new RestaurantController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.UpdateRestaurant(restaurant.Id, restaurantDto).Result;
// Assert
var noContentResult = actionResult as NoContentResult;
Assert.IsNotNull(noContentResult);
}
public RestaurantControllerTests()
{
var restaurantService = new Mock <IRestaurantService>();
restaurantService.Setup(x => x.Get()).Returns(new List <Restaurant> {
new Restaurant()
});
restaurantService.Setup(x => x.Get(It.IsAny <string>())).Returns(new List <Restaurant>());
restaurantService.Setup(x => x.Get(It.IsAny <Guid>())).Returns(new Restaurant {
Reviews = new List <Review>()
});
restaurantService.Setup(x => x.TopThreeRatedRestaurants()).Returns(new List <Restaurant> {
new Restaurant()
});
restaurantService.Setup(x => x.PartialSearch(It.IsAny <string>())).Returns(new List <Restaurant> {
new Restaurant()
});
restaurantService.Setup(x => x.CreateRestaurant(It.IsAny <Restaurant>()));
restaurantService.Setup(x => x.UpdateRestaurant(It.IsAny <Restaurant>()));
restaurantService.Setup(x => x.DeleteRestaurant(It.IsAny <Restaurant>()));
var container = Bootstrapper.RegisterTypes();
var mapper = container.Resolve <IMapper>();
_controller = new RestaurantController(restaurantService.Object, mapper);
}
public void TestMethod2()
{
var controller = new RestaurantController();
var result = controller.Delete(null);
Assert.IsInstanceOfType(result, typeof(HttpStatusCodeResult));
}
public static void Main()
{
var assembly = Assembly.GetCallingAssembly();
var controllerType = assembly.GetTypes().First(x => x.Name == "RestaurantController");
RestaurantController controller = new RestaurantController();
var controllerMethods = controller.GetType().GetMethods();
while (true)
{
string[] input = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (input[0] == "END")
{
Console.WriteLine(controller.GetSummary());
return;
}
var method = controllerMethods.First(x => x.Name == input[0]);
object[] args = getArgs(input, method);
try
{
Console.WriteLine(method.Invoke(controller, args));
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException.InnerException.Message);
}
}
}
public static bool Prefix(ref RestaurantController __instance, ref bool __result, Pawn pawn)
{
if (!__instance.IsOpenedRightNow)
{
return(true);
}
if (pawn.GetTenantComponent() == null)
{
return(true);
}
if (!pawn.GetTenantComponent().IsTenant)
{
return(true);
}
if (!pawn.GetTenantComponent().Contracted)
{
return(true);
}
var shouldCountAsGuest = SettingsHelper.LatestVersion.GastronomyGuest;
if (!__instance.allowColonists && !shouldCountAsGuest || !__instance.allowGuests && shouldCountAsGuest)
{
__result = false;
}
else
{
__result = true;
}
return(false);
}
public RestaurantList()
{
InitializeComponent();
var ds = RestaurantController.GetAllRestaurant();
dgView.DataSource = ds;
}
void OnNormalBtnClick()
{
if (null == m_curTabDesk || null == m_curDestData)
{
return;
}
if (null == RestaurantController.Instance())
{
LogModule.ErrorLog("OnNormalBtnClick::RestaurantController.Instance() is null ");
return;
}
if (m_curDestData.m_IsActive)
{
if (m_curDestData.m_DestState == RestaurantData.DeskState.None)
{
RestaurantController.Instance().OpenFoodWindow(this);
}
else if (m_curDestData.m_DestState == RestaurantData.DeskState.PrepareFood)
{
FinishPrepareDesk();
}
else if (m_curDestData.m_DestState == RestaurantData.DeskState.WaitBilling)
{
RestaurantController.Instance().BillingDesk(this);
}
return;
}
}
public async Task ServiceTestGetRestaurantsNoData()
{
SampleData Data = new SampleData(false);
Mock <BookingSystemDb> MockDb = Data.Context();
Mock <DbSet <Company> > MockCompanySet = data.Companies;
Mock <DbSet <Restaurant> > MockRestaurantsSet = data.Restaurants;
Mock <DbSet <RestaurantMenuItem> > MockRestaurantMenuItemsSet = data.RestaurantMenuItems;
Mock <DbSet <MenuItem> > MockMenuItemsSet = data.MenuItems;
Mock <DbSet <MenuItemDietInfo> > MockMenuItemDietInfoSet = data.MenuItemDietInfos;
Mock <DbSet <DietInfo> > MockDietInfoSet = data.DietInfos;
Mock <DbSet <MenuItemType> > MockMenuItemTypeSet = data.MenuItemTypes;
Mock <DbSet <DatabaseContext.Data.Type> > MockTypesSet = data.Types;
Mock <DbSet <Table> > MockTablesSet = data.Tables;
Mock <DbSet <TableBooking> > MockTableBookingSet = data.TableBookings;
Mock <DbSet <Booking> > MockBookingSet = data.Bookings;
Mock <DbSet <BookingMenuItem> > MockBookingMenuItemsSet = data.BookingMenuItems;
Mock <DbSet <Payment> > MockPaymentsSet = data.Payments;
Mock <DbSet <PaymentMethod> > MockPaymentMethodsSet = data.PaymentMethods;
Mock <DbSet <Customer> > MockCustomersSet = data.Customers;
RestaurantController Controller = new RestaurantController(MockDb.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
HttpResponseMessage response = await Controller.Get();
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.AreEqual(response.StatusCode, HttpStatusCode.NoContent);
}
public void Can_Get_Restaurant_By_ExternalId()
{
var context = TestingSetup.GetContext();
var restaurant = new Restaurant()
{
ExternalId = "31e045af-cc46-4e28-a783-71d456d86400",
Name = "New Restaurant"
};
context.Restaurants.Add(restaurant);
context.SaveChanges();
var controller =
new RestaurantController(
new RestaurantService(
new RestaurantRepository(context)));
var task = controller.GetRestaurantByExternalId("31e045af-cc46-4e28-a783-71d456d86400")
.ContinueWith(innerTask =>
{
var result = innerTask.Result;
Assert.IsType <RestaurantDTO>(result);
Assert.Equal("31e045af-cc46-4e28-a783-71d456d86400", result.ExternalId);
});
}
public static void Main()
{
RestaurantController rc = new RestaurantController();
Engine engine = new Engine(rc);
engine.Run();
}
public void AdminControllerTestInit()
{
RestaurantRepository = Substitute.For <IEntityRepository <Restaurant> >();
ReviewRepository = Substitute.For <IEntityRepository <Review> >();
RestaurantController = new RestaurantController(RestaurantRepository);
}
private void CheckMaps()
{
getReport = false;
if (!Settings.showAlertNoDedicatedWaiter)
{
return;
}
foreach (var map in Find.Maps)
{
if (!map.IsPlayerHome || !map.mapPawns.AnyColonistSpawned)
{
continue;
}
RestaurantController restaurant = map.GetComponent <RestaurantController>();
if (restaurant?.IsOpenedRightNow == false)
{
continue;
}
if (!MapHasDiningSpots(map))
{
continue;
}
if (!MapHasDedicatedWaiterRightNow(map))
{
getReport = true;
break;
}
}
}
public void Edit_Post_EditsRestaurantAndSavesToDb()
{
// Arrange
_context.Restaurants.Add(new Restaurant {
Name = "Brave Horse"
});
_context.SaveChanges();
var controller = new RestaurantController(_context);
var editableRestaurantId = _context.Restaurants.First().Id;
var restaurantEditGetResult = controller.Edit(editableRestaurantId) as ViewResult;
var restaurantToEdit = restaurantEditGetResult.Model as Restaurant;
restaurantToEdit.Name = "Linda's";
restaurantToEdit.Longitude = -5;
restaurantToEdit.Latitude = 5;
// Act
var result = controller.Edit(editableRestaurantId, restaurantToEdit) as RedirectToRouteResult;
// Assert
_context.Restaurants.First().Name.ShouldBe("Linda's");
result.RouteValues["action"].ShouldBe("Index");
}
public RestaurantControllerTest()
{
mockService = new Mock <IRestaurantService>();
mockCacheService = new Mock <ICacheService>();
ControllerUnderTest = new RestaurantController(mockService.Object, mockCacheService.Object);
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
//mock result
expectedRestaurants = new ReadOnlyCollection <Restaurant>(new List <Restaurant>
{
new Restaurant()
{
Id = "b1357cd1-2901-3e8c-9852-1e659bceae98",
Name = "JK. Rowling",
Rating = 4
},
new Restaurant()
{
Id = "a1357cd1-2901-3e8c-9852-1e659bceae51",
Name = "Microsoft",
Rating = 5
}
});
}
public void DetailsReturnsValidRestaurantDetailedViewModelId()
{
//Arrange
var restaurantId = Guid.NewGuid().ToString();
var resultDbRestaurant = new RestaurantUser
{
Id = restaurantId
};
var mockedRestaurantUserService = new Mock <IRestaurantUserService>();
mockedRestaurantUserService.Setup(x => x.GetById(restaurantId)).Returns(resultDbRestaurant);
var autoMapperConfig = new AutoMapperConfig();
autoMapperConfig.Execute(typeof(RestaurantController).Assembly);
var restaurantController = new RestaurantController(mockedRestaurantUserService.Object, null);
//Act
var actionResult = restaurantController.Details(restaurantId) as ViewResult;
var restaurantViewModel = (RestaurantDetailedViewModel)actionResult.ViewData.Model;
var expectedRestaurantViewModel = new RestaurantDetailedViewModel
{
Id = resultDbRestaurant.Id
};
//Assert
Assert.AreEqual(expectedRestaurantViewModel.Id, restaurantViewModel.Id, "Expected RestaurantDetailedViewModel Id doesn`t match actual Id.");
}
public async void GetRestaurants_API_Should_Return_All_Restaurants()
{
//Arrange
var services = BuildServices("GetRestaurants_API_Should_Return_All_Restaurants");
var context = services.GetRequiredService <FoodAppDbContext>();
var inputRestaurants = new List <Restaurant>
{
new Restaurant {
Id = Guid.NewGuid(), Name = "Res 1"
},
new Restaurant {
Id = Guid.NewGuid(), Name = "Res 2"
},
new Restaurant {
Id = Guid.NewGuid(), Name = "Res 3"
}
};
context.Restaurants.AddRange(inputRestaurants);
context.SaveChanges();
var restaurantService = services.GetRequiredService <IRestaurantService>();
var controller = new RestaurantController(restaurantService, new Mock <ILogger <RestaurantController> >().Object);
//Act
var result = await controller.GetRestaurants();
// Assert
var okResult = result as OkObjectResult;
var outputRestaurants = okResult.Value as List <Restaurant>;
Assert.NotNull(okResult);
Assert.Equal((int)HttpStatusCode.OK, okResult.StatusCode);
Assert.Equal(inputRestaurants.Count, outputRestaurants.Count);
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
if (!respawningAfterLoad)
{
restaurant = this.GetRestaurant();
}
}
public virtual void SetUp()
{
restaurantServiceMock = new Mock <IRestaurantService>();
restaurantServiceMock.Setup(i => i.SearchRestaurants(It.IsAny <string>())).ReturnsAsync(new List <Restaurant>());
restaurantViewModelBuilderMock = new Mock <IRestaurantViewModelBuilder>();
restaurantViewModelBuilderMock.Setup(i => i.Build(It.IsAny <IEnumerable <Restaurant> >())).Returns(new RestaurantViewModel());
restaurantController = new RestaurantController(restaurantServiceMock.Object, restaurantViewModelBuilderMock.Object);
}
public void RestaurantControllerTestDetailsNull()
{
RestaurantController controller = new RestaurantController();
ActionResult result = controller.Details(10);
Assert.IsTrue(result is RedirectToRouteResult);
}
public static float GetPrice(this ThingDef mealDef, RestaurantController restaurant)
{
if (mealDef == null)
{
return(0);
}
return(mealDef.BaseMarketValue * restaurant.guestPricePercentage);
}
public RestaurantControllerTest()
{
SetAutoMapper();
_service = new RestaurantServiceTest(_mapper);
_controller = new RestaurantController(_service);
_validator = new RestaurantValidator();
}
