public async Task <IActionResult> Create(CreateStoreViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var store = new StoreModel()
{
Name = model.Name,
Description = model.Description,
DateCreated = DateTime.Now,
Images = new List <ImageModel>()
};
foreach (var formFile in model.Images)
{
if (formFile.Length > 0)
{
var image = ImageUpload.ImageToByte(formFile);
image.Store = store;
store.Images.Add(image);
}
}
await Db.Images.AddRangeAsync(store.Images);
await Db.Stores.AddAsync(store);
await Db.SaveChangesAsync();
return(RedirectToAction("List"));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var store = await _context.Store.Include("User").Include("SalesRep").Include("State").Include("Status").SingleOrDefaultAsync(m => m.StoreId == id);
if (store == null)
{
return(NotFound());
}
CreateStoreViewModel createStoreViewModel = new CreateStoreViewModel();
if (store.SalesRep != null)
{
createStoreViewModel.SalesRepId = store.SalesRep.Id;
}
else
{
createStoreViewModel.SalesRepId = null;
}
createStoreViewModel.Store = store;
ViewBag.SalesReps = _context.Users.OrderBy(u => u.FirstName).Select(u => new SelectListItem()
{
Text = $"{ u.FirstName} { u.LastName}", Value = u.Id
}).ToList();
ViewData["StateId"] = new SelectList(_context.State.OrderBy(s => s.Name), "StateId", "Name", store.StateId);
ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "Color", store.StatusId);
return(View(createStoreViewModel));
}
public ActionResult Create([Bind(Include = "Store, ProductIds")] CreateStoreViewModel viewModel)
{
var currentUser = (User)HttpContext.Session["user"];
if (currentUser != null)
{
// Set the current user as the owner of the Store
viewModel.Store.StoreAdmin = db.Users.Where(r => r.Id == currentUser.Id).Include(r => r.FavoriteProduct.FoodSource).FirstOrDefault();
// So the validation wont fail as it was null before we set it.
ModelState.Remove("Store.StoreAdmin");
if (ModelState.IsValid)
{
viewModel.Store.Products = new List <Product>();
foreach (var ProductId in viewModel.ProductIds)
{
var productToAdd = db.Products.Where(r => r.Id == ProductId).Include(r => r.FoodSource).FirstOrDefault();
viewModel.Store.Products.Add(productToAdd);
}
db.Stores.Add(viewModel.Store);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Error"));
}
return(RedirectToAction("Index", "Error"));
}
public IActionResult CreateStore()
{
var vm = new CreateStoreViewModel
{
DefaultCurrency = StoreBlob.StandardDefaultCurrency,
Exchanges = GetExchangesSelectList(CoinGeckoRateProvider.CoinGeckoName)
};
return(View(vm));
}
public async Task <IActionResult> Create()
{
CreateStoreViewModel ccvm = new CreateStoreViewModel();
ccvm.CompanyList = await _companiesService.All();
ViewBag.API_Key = _appConfig.GoogleAPIkey;
return(View(ccvm));
}
public async Task <IActionResult> CreateStore(CreateStoreViewModel storeViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
await _storeApplicationService.CreateStore(storeViewModel);
return(Created("api/store/create", storeViewModel));
}
public async Task <IActionResult> Edit(int id, CreateStoreViewModel storeModel)
{
if (id != storeModel.Store.StoreId)
{
return(NotFound());
}
ModelState.Remove("store.User");
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
storeModel.Store.User = user;
// add salesRep if info changed
if (storeModel.Store.SalesRep == null)
{
var AddedSalesRep = await _context.Users.OrderBy(u => u.FirstName).Where(u => u.Id == storeModel.SalesRepId).SingleOrDefaultAsync();
storeModel.Store.SalesRep = AddedSalesRep;
}
try
{
_context.Update(storeModel.Store);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StoreExists(storeModel.Store.StoreId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
CreateStoreViewModel createStoreViewModel = new CreateStoreViewModel();
createStoreViewModel.Store = storeModel.Store;
ViewBag.SalesReps = _context.Users.OrderBy(u => u.FirstName)
.Select(u => new SelectListItem()
{
Text = $"{ u.FirstName} { u.LastName}", Value = u.Id
}).ToList();
ViewData["StateId"] = new SelectList(_context.State.OrderBy(st => st.Name), "StateId", "Name", storeModel.Store.StateId);
ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "Color", storeModel.Store.StatusId);
return(View(createStoreViewModel));
}
public async Task <IActionResult> CreateStore(CreateStoreViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var store = await _Repo.CreateStore(GetUserId(), vm.Name);
CreatedStoreId = store.Id;
StatusMessage = "Store successfully created";
return(RedirectToAction(nameof(ListStores)));
}
public IActionResult CreateStore(CreateStoreViewModel storeViewModel)
{
if (!ModelState.IsValid)
{
return(View(storeViewModel));
}
var store = new Store(Guid.NewGuid(), storeViewModel.Name, storeViewModel.Location, 0, null);
_storeRepository.AddOne(store);
return(RedirectToAction("StoreDetails", new { id = store.Id }));
}
public ActionResult Create([Bind(Include = "Name, DisplayOrder, Line1, Line2, Line3, Zip, State, Country")]
CreateStoreViewModel model)
{
if (ModelState.IsValid)
{
var addr = new Address {
Line1 = model.Line1, Line2 = model.Line2, Line3 = model.Line3,
Zip = model.Zip, State = model.State, Country = model.Country, DisplayOrder = 0
};
return(View("Index"));
}
return(View(model));
}
public async Task <IActionResult> CreateStore(CreateStoreViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var store = await _Repo.CreateStore(GetUserId(), vm.Name);
CreatedStoreId = store.Id;
TempData[WellKnownTempData.SuccessMessage] = "Store successfully created";
return(RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
{
storeId = store.Id
}));
}
public async Task <IActionResult> CreateStore(CreateStoreViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var store = await _Repo.CreateStore(GetUserId(), vm.Name);
CreatedStoreId = store.Id;
StatusMessage = "Tienda creada correctamente";
return(RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
{
storeId = store.Id
}));
}
public async Task <IActionResult> Edit(Guid id)
{
Stores store = await _storesService.FindBy(id);
CreateStoreViewModel ccvm = new CreateStoreViewModel(store);
ccvm.CompanyList = await _companiesService.All();
if (store == null)
{
return(RedirectToAction(nameof(Index)));
}
return(View(ccvm));
}
public async Task <IActionResult> Create()
{
var viewModel = new CreateStoreViewModel()
{
Store = new Store()
{
Active = true,
OpeningHours = new List <OpeningHours>(7)
{
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Sunday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Monday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Tuesday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Wednesday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Thursday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Friday
},
new OpeningHours()
{
OpeningTime = new TimeSpan(00, 00, 00), ClosingTime = new TimeSpan(23, 59, 00), DayOfWeek = DayOfWeek.Saturday
}
},
Address = new Address()
{
Country = "Israel"
}
}
};
return(View(viewModel));
}
public async Task <IActionResult> Create(CreateStoreViewModel storeModel)
{
ModelState.Remove("store.user");
if (ModelState.IsValid)
{
// Get the current user
ApplicationUser user = await GetCurrentUserAsync();
if (storeModel.SalesRepId != null)
{
// find matching user for SalesRep in system
ApplicationUser SalesRep = _context.Users.Single(u => u.Id == storeModel.SalesRepId);
// store the sales rep on the store
storeModel.Store.SalesRep = SalesRep;
}
// Add current user to store listing
storeModel.Store.User = user;
// save store to context
_context.Add(storeModel.Store);
// save context file to database
await _context.SaveChangesAsync();
// redirect user to list of all stores
return(RedirectToAction(nameof(Index)));
}
CreateStoreViewModel createStoreViewModel = new CreateStoreViewModel();
// get current user
var CurrentUser = await GetCurrentUserAsync();
// populate SaleReps dropdown list by retrieving all users that are not the current user.
// Only administrator will be allowed to create a new store listing, so they will be current User.
ViewBag.SalesReps = _context.Users.OrderBy(u => u.FirstName)
.Select(u => new SelectListItem()
{
Text = u.FirstName, Value = u.Id
}).ToList();
ViewData["StateId"] = new SelectList(_context.State, "StateId", "Name", storeModel.Store.StateId);
ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "Color", storeModel.Store.StatusId);
return(View(createStoreViewModel));
}
public async Task <Stores> Edit(Guid id, CreateStoreViewModel store)
{
Stores editedStore = await FindBy(id);
editedStore.CompanyId = store.CompanyId;
editedStore.Name = store.Name;
editedStore.Address = store.Address;
editedStore.City = store.City;
editedStore.Zip = store.Zip;
editedStore.Country = store.Country;
editedStore.Longitude = store.Longitude;
editedStore.Latitude = store.Latitude;
await _storesRepo.Update(editedStore);
return(editedStore);
}
public async Task <IActionResult> Create(CreateStoreViewModel createStoreViewModel)
{
Companies company = await _companiesService.FindBy(createStoreViewModel.Company.Id);
createStoreViewModel.CompanyId = company.Id;
if (ModelState.IsValid)
{
await _storesService.Add(createStoreViewModel);
return(RedirectToAction(nameof(Index)));
}
createStoreViewModel.CompanyList = await _companiesService.All();
return(View(createStoreViewModel));
}
public async Task <IActionResult> Edit(Guid id, CreateStoreViewModel createStoreViewModel)
{
Companies company = await _companiesService.FindBy(createStoreViewModel.Company.Id);
createStoreViewModel.CompanyId = company.Id;
if (ModelState.IsValid)
{
if (await _storesService.Edit(id, createStoreViewModel) != null)
{
return(RedirectToAction(nameof(Index)));
}
ModelState.AddModelError("System", "Failed to edit");
}
return(View(createStoreViewModel));
}
public ActionResult Edit([Bind(Include = "Store, ProductIds")] CreateStoreViewModel viewModel)
{
var curUser = ((User)HttpContext.Session["user"]);
if (curUser != null)
{
if (curUser.IsAdmin)
{
// So the validation wont fail as it was null before we set it.
ModelState.Remove("Store.StoreAdmin");
ModelState.Remove("Store.StoreAdmin.Password");
ModelState.Remove("Store.StoreAdmin.Username");
if (ModelState.IsValid)
{
Store store = db.Stores.Where(r => r.Id == viewModel.Store.Id).Include(r => r.Products).Include(r => r.StoreAdmin).FirstOrDefault();
store.City = viewModel.Store.City;
store.StreetAddress = viewModel.Store.StreetAddress;
var StoreAdmin = db.Users.Where(r => r.Id == viewModel.Store.StoreAdmin.Id).Include(r => r.FavoriteProduct.FoodSource).FirstOrDefault();
store.StoreAdmin = StoreAdmin;
store.Products = new List <Product>();
foreach (var ProductId in viewModel.ProductIds)
{
var ringToAdd = db.Products.Find(ProductId);
store.Products.Add(ringToAdd);
}
db.Entry(store).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
else
{
return(RedirectToAction("Index", "Error", new { message = "Missing permissions" }));
}
}
else
{
return(RedirectToAction("Index", "Error"));
}
}
public async Task <IActionResult> CreateStore(CreateStoreViewModel vm)
{
if (!ModelState.IsValid)
{
vm.Exchanges = GetExchangesSelectList(vm.PreferredExchange);
return(View(vm));
}
var store = await _repo.CreateStore(GetUserId(), vm.Name, vm.DefaultCurrency, vm.PreferredExchange);
CreatedStoreId = store.Id;
TempData[WellKnownTempData.SuccessMessage] = "Store successfully created";
return(RedirectToAction(nameof(UIStoresController.Dashboard), "UIStores", new
{
storeId = store.Id
}));
}
public async Task <IActionResult> Create()
{
CreateStoreViewModel createStoreViewModel = new CreateStoreViewModel();
createStoreViewModel.Store = new Store();
// set the store status to 1 for new stores. The input field is hidden for this. Site will control this status based on the store's Last Order.
createStoreViewModel.Store.StatusId = 1;
ViewBag.SalesReps = _context.Users.OrderBy(u => u.FirstName)
.Select(u => new SelectListItem()
{
Text = $"{ u.FirstName} { u.LastName}", Value = u.Id
}).ToList();
ViewData["StateId"] = new SelectList(_context.State.OrderBy(s => s.Name), "StateId", "Name");
ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "Name");
return(View(createStoreViewModel));
}
public async Task <IActionResult> Create([Bind("Name,Address,Active")] CreateStoreViewModel model)
{
if (ModelState.IsValid)
{
var MerchantId = await _userService.GetCurrentMerchantId(User);
var store = new Store
{
Name = model.Name,
Address = model.Address,
Status = model.Status,
MerchantId = MerchantId
};
_context.Add(store);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
// GET: Stores/Edit/5
public ActionResult Edit(int?id)
{
var curUser = ((User)HttpContext.Session["user"]);
if (curUser != null)
{
if (curUser.IsAdmin)
{
if (id == null)
{
return(RedirectToAction("Index", "Error"));
}
Store store = db.Stores.Where(r => r.Id == id).Include(r => r.Products).Include(r => r.StoreAdmin).FirstOrDefault();
if (store == null)
{
return(HttpNotFound());
}
ViewBag.ProductList = new MultiSelectList(db.Products.Select(i => new { Id = i.Id, Name = i.Name }), "Id", "Name");
CreateStoreViewModel viewModel = new CreateStoreViewModel();
viewModel.Store = store;
foreach (var ring in store.Products)
{
viewModel.ProductIds.Add(ring.Id);
}
return(View(viewModel));
}
else
{
return(RedirectToAction("Index", "Error", new { message = "Missing permissions" }));
}
}
else
{
return(RedirectToAction("Index", "Error"));
}
}
public async Task <IActionResult> Create([Bind("Id,Name,Address,PhoneNumber,Email,OpeningHours")] Store store)
{
var viewModel = new CreateStoreViewModel()
{
Store = store,
};
if (store.OpeningHours.Any(openingHour => openingHour.ClosingTime <= openingHour.OpeningTime))
{
_flashMessage.Danger("Store opening hours invalid. Store cannot be closed before it was opened");
return(RedirectToAction("ListStores", "Administration"));
}
if (!ModelState.IsValid)
{
_flashMessage.Danger("Form is not valid");
return(View(viewModel));
}
Context.Add(store);
await Context.SaveChangesAsync();
return(RedirectToAction("ListStores", "Administration"));
}
public ActionResult Create([Bind(Include = "Name, DisplayOrder, Line1, Line2, Line3, Zip, State, Country")]
CreateStoreViewModel model)
{
if (ModelState.IsValid)
{
var addr = new Address
{
Line1 = model.Line1,
Line2 = model.Line2,
Line3 = model.Line3,
Zip = model.Zip,
State = model.State,
Country = model.Country,
DisplayOrder = 0
};
var store = new Store {
Name = model.Name, Address = addr
};
db.Stores.Add(store);
db.SaveChanges();
return(View("Index"));
}
return(View(model));
}
public async Task CreateStore(CreateStoreViewModel storeViewModel)
{
var store = _mapper.Map <Store>(storeViewModel);
await _mediator.Send(new CreateStoreCommand(store.Name, store.Address, store.Region, store.City));
}
public void Can_create_storeviewmodel_in_wizardmode()
{
var overviewVmFactory = new TestFulfillmentViewModelFactory <IStoreOverviewStepViewModel>(
ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));
var navigationVmFactory = new TestFulfillmentViewModelFactory <IStoreNavigationStepViewModel>(
ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));
var localizationVmFactory = new TestFulfillmentViewModelFactory <IStoreLocalizationStepViewModel>(
ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));
var taxesVmFactory = new TestFulfillmentViewModelFactory <IStoreTaxesStepViewModel>(
ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));
var paymentsVmFactory = new TestFulfillmentViewModelFactory <IStorePaymentsStepViewModel>(
ServManager.GetUri(ServiceNameEnum.Store), ServManager.GetUri(ServiceNameEnum.Catalog),
ServManager.GetUri(ServiceNameEnum.Order), ServManager.GetUri(ServiceNameEnum.AppConfig));
var repositoryFactory =
new DSRepositoryFactory <IStoreRepository, DSStoreClient, StoreEntityFactory>(
ServManager.GetUri(ServiceNameEnum.Store));
//create item using entity factory
var entityFactory = new StoreEntityFactory();
var item = entityFactory.CreateEntity <Store>();
var createStoreViewModel = new CreateStoreViewModel(overviewVmFactory, localizationVmFactory, taxesVmFactory, paymentsVmFactory, navigationVmFactory, item);
//check the default values in stepViewModel
Assert.False(createStoreViewModel.AllRegisteredSteps[0].IsValid);
Assert.False(createStoreViewModel.AllRegisteredSteps[1].IsValid);
Assert.True(createStoreViewModel.AllRegisteredSteps[2].IsValid);
Assert.True(createStoreViewModel.AllRegisteredSteps[3].IsValid);
Assert.True(createStoreViewModel.AllRegisteredSteps[4].IsValid);
//1 step
//fill the properties in first step
var overviewViewModel = createStoreViewModel.AllRegisteredSteps[0] as StoreViewModel;
Assert.NotNull(overviewViewModel);
overviewViewModel.InnerItem.Name = "TestName";
overviewViewModel.InnerItem.Catalog = "TestCatalog";
overviewViewModel.InitializeForOpen();
Assert.True(createStoreViewModel.AllRegisteredSteps[0].IsValid);
//2 step
//fill the properties in second step
var localizationStep = createStoreViewModel.AllRegisteredSteps[1] as StoreViewModel;
Assert.NotNull(localizationStep);
localizationStep.InnerItem.Languages.Add(new StoreLanguage()
{
LanguageCode = "ru-ru",
StoreId = localizationStep.InnerItem.StoreId
});
localizationStep.InnerItem.DefaultLanguage = "ru-ru";
localizationStep.InnerItem.Currencies.Add(new StoreCurrency()
{
CurrencyCode = "RUR",
StoreId = localizationStep.InnerItem.StoreId
});
localizationStep.InnerItem.DefaultCurrency = "RUR";
Assert.True(createStoreViewModel.AllRegisteredSteps[1].IsValid);
//3 step
//fill the properties in third step
var taxesStep = createStoreViewModel.AllRegisteredSteps[2] as StoreTaxesStepViewModel;
Assert.NotNull(taxesStep);
taxesStep.InitializeForOpen();
taxesStep.AvailableTaxCodes[0].IsChecked = true;
taxesStep.AvailableTaxJurisdictions[0].IsChecked = true;
Assert.True(taxesStep.IsValid);
//4 step
//fill the properties in 4 step
var paymentsStep = createStoreViewModel.AllRegisteredSteps[3] as StorePaymentsStepViewModel;
Assert.NotNull(paymentsStep);
paymentsStep.InitializeForOpen();
paymentsStep.AvailableStoreCardTypes[0].IsChecked = true;
Assert.True(paymentsStep.IsValid);
//5 step
//fill the properties in 5 step
var navigationStep = createStoreViewModel.AllRegisteredSteps[4] as StoreNavigationStepViewModel;
Assert.NotNull(navigationStep);
navigationStep.InitializeForOpen();
navigationStep.SettingFilteredNavigation.LongTextValue = "TestnavigationText";
Assert.True(navigationStep.IsValid);
createStoreViewModel.PrepareAndSave();
using (var repository = repositoryFactory.GetRepositoryInstance())
{
var itemFromDb =
repository.Stores.Where(s => s.StoreId == item.StoreId).ExpandAll().SingleOrDefault();
Assert.NotNull(itemFromDb);
Assert.True(itemFromDb.Name == "TestName");
Assert.True(itemFromDb.Catalog == "TestCatalog");
Assert.True(itemFromDb.Languages.Any(x => x.LanguageCode == "ru-ru"));
Assert.True(itemFromDb.Currencies.Any(x => x.CurrencyCode == "RUR"));
}
}
public IActionResult Create()
{
var model = new CreateStoreViewModel();
return(View(model));
}
public async Task <Stores> Add(CreateStoreViewModel createStoreViewModel)
{
Stores store = await _storesRepo.Create(createStoreViewModel.CompanyId, createStoreViewModel.Name, createStoreViewModel.Address, createStoreViewModel.City, createStoreViewModel.Zip, createStoreViewModel.Country, createStoreViewModel.Longitude, createStoreViewModel.Latitude);
return(store);
}
public CreateStorePage(CreateStoreViewModel viewModel)
{
InitializeComponent();
BindingContext = viewModel;
}
