public IActionResult Index()
{
ViewBag.ViewName = "StoreManagement";
var storesList = new List <StoreVM>();
var storesToDisplay = adminService.GetAllStores();
foreach (var store in storesToDisplay)
{
var storeToDisplay = new StoreVM();
storeToDisplay.Id = store.Id;
storeToDisplay.Name = store.Name;
storeToDisplay.IsActive = store.IsActive;
if (store.Menu != null)
{
if (store.Menu.Hyperlink != null)
{
storeToDisplay.Hyperlink = store.Menu.Hyperlink;
}
if (store.Menu.Image != null)
{
storeToDisplay.Image = store.Menu.Image;
}
}
storesList.Add(storeToDisplay);
}
return(View(storesList));
}
public ActionResult EditS(StoreVM store)
{
if (!IsAdmin())
{
return(Redirect("/"));
}
_storeService.Update(_storeMapper.ConvertFromStoreVM(store));
return(Redirect("/Admin/Stores"));
}
public ActionResult Stores(StoreVM store)
{
if (!IsAdmin())
{
return(Redirect("/"));
}
_storeService.Add(_storeMapper.ConvertFromStoreVM(store));
return(Redirect("Stores"));
}
public ActionResult Edit([Bind(Include = "ID,Name,Address")] StoreVM store)
{
if (ModelState.IsValid)
{
_storeService.Edit(StoreMappers.MapToModel(store));
return(RedirectToAction("Index"));
}
return(View(store));
}
public StoreVM Get(int ID)
{
var Store = db.Stores.Find(ID);
StoreVM StoreVM = new StoreVM();
StoreVM.ID = Store.ID;
StoreVM.Name = Store.Name;
return(StoreVM);
}
public static Store MapToModel(StoreVM storeVM)
{
return(new Store()
{
Address = storeVM.Address,
ID = storeVM.ID,
Name = storeVM.Name
});
}
public Store ConvertFromStoreVM(StoreVM store)
{
return(new Store()
{
Address = store.Address,
Id = store.Id,
Name = store.Name,
PhoneNumber = store.PhoneNumber
});
}
public JsonResult Save(StoreVM StoreVM)
{
if (ModelState.IsValid)
{
var check = StoreVM.ID > 0 ? service.Edit(StoreVM) : service.Save(StoreVM);
return(Json(new { status = check }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}
}
public static Store MapStoreVMToStore(StoreVM store)
{
return(new Store()
{
Id = store.Id,
Name = store.Name,
Address = store.Address,
City = store.City,
PhoneNumber = store.PhoneNumber,
ListOfPizzas = MapPizzasVMToPizzas(store.ListOfPizzas)
});
}
public bool CreateNewStore(StoreVM storeVM)
{
var storeDomain = MapperToDM.MapStoreVMToStore(storeVM);
var store = _storeRepo.GetAll().SingleOrDefault(x => x.Id == storeDomain.Id);
if (store == null)
{
_storeRepo.GetAll().Add(store);
return(true);
}
return(false);
}
public bool DeleteStore(StoreVM storeVM)
{
var storeDomain = MapperToDM.MapStoreVMToStore(storeVM);
var store = _storeRepo.GetAll().SingleOrDefault(x => x.Id == storeDomain.Id);
if (store == null)
{
return(false);
}
_storeRepo.GetAll().Remove(store);
return(true);
}
public bool UpdateStore(StoreVM storeVM)
{
var storeDomain = MapperToDM.MapStoreVMToStore(storeVM);
var store = _storeRepo.GetAll().SingleOrDefault(x => x.Id == storeDomain.Id);
if (store == null)
{
return(false);
}
int index = _storeRepo.GetAll().IndexOf(store);
_storeRepo.GetAll()[index] = storeDomain;
return(true);
}
public async Task <ActionResult <StoreVM> > Post(StoreVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors
}
try
{
if (model.Id == 0) // Insert logic
{
// Create and insert a new record
Store newRecord = _mapper.Map <StoreVM, Store>(model);
_context.Stores.Add(newRecord);
await _context.SaveChangesAsync();
// Map and return the newly created record in the same format as a GET request
var resultModel = await InternalGetAsync(newRecord.Id);
var resourceUrl = Url.Action(nameof(Get), nameof(StoresController)); // TODO: Fix this bug
return(Created(resourceUrl, resultModel));
}
else // Update logic
{
// Retrieve the record
Store dbRecord = await _context.Stores.FirstOrDefaultAsync(e => e.Id == model.Id);
if (dbRecord == null)
{
return(NotFound($"Could not find a record with id='{model.Id}'"));
}
// Update the record and save changes
_mapper.Map(model, dbRecord);
await _context.SaveChangesAsync();
// Finally return the same result you would get with a GET request
var resultModel = await InternalGetAsync(model.Id);
return(Ok(resultModel));
}
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
return(BadRequest(ex.Message));
}
}
public bool Edit(StoreVM StoreVM)
{
try
{
Store Store = db.Stores.Find(StoreVM.ID);
Store.Name = StoreVM.Name;
db.Entry(Store).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public bool Save(StoreVM StoreVM)
{
try
{
Store Store = new Store();
Store.Name = StoreVM.Name;
db.Stores.Add(Store);
db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public ActionResult Update(StoreVM data)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("List", "Store", new { area = "Member" }));
}
Store store = _storeService.GetById(data.ID);
store.Name = data.Name;
store.Address = data.Address;
store.Phone = data.Phone;
store.Email = data.Email;
_storeService.Update(store);
return(RedirectToAction("List", "Store", new { area = "Member" }));
}
public IActionResult StoreDetails(int id)
{
var allPizzas = StaticDb.Menu;
var store = StaticDb.Stores.SingleOrDefault(s => s.Id == id);
var storeVM = new StoreVM()
{
Id = store.Id,
City = store.City,
Name = store.Name,
Menu = allPizzas
};
return(View(storeVM));
}
public IList <StoreVM> GetStoreList(Guid userID)
{
IList <StoreVM> list = new List <StoreVM>();
StoreVM model = new StoreVM()
{
StoreID = Guid.NewGuid(),
StoreMark = "A001",
StoreCode = "B001",
StoreName = "天河店",
StoreArea = "GZ",
Address1 = "Address11"
};
list.Add(model);
return(list);
}
public IActionResult Add([FromForm] StoreVM newStore)
{
if (ModelState.IsValid)
{
var storeToAdd = new Store
{
Name = newStore.Name,
Menu = new Menu
{
Hyperlink = newStore.Hyperlink,
Image = newStore.Image
}
};
adminService.AddStore(storeToAdd);
}
return(RedirectToAction("Index"));
}
public ActionResult Update(Guid?id)
{
if (id == null)
{
RedirectToAction("List", "Store", new { area = "Member" });
}
Store data = _storeService.GetById((Guid)id);
StoreVM model = new StoreVM()
{
ID = data.ID,
Name = data.Name,
Address = data.Address,
Phone = data.Phone,
Email = data.Email,
};
return(View(model));
}
public ActionResult Index()
{
var model = svc.SelectOrEmpty(new StoreQuery()
{
IDs = new long[] { OwnerID }
}).FirstOrDefault();
var banQuery = new BannerPictureQuery
{
StoreIDs = new long[] { OwnerID },
PictureTypes = new int[] { (int)StorePicType.BannerPicture }
};
var banModel = svc.SelectOrEmpty(banQuery);
if (banModel != null && banModel.Any())
{
if (model != null)
{
Collection <BannerPicture> bCollection = new Collection <BannerPicture>();
foreach (var item in banModel.ToList())
{
item.Path = Path.Combine(ftp, item.Path, item.Name);
bCollection.Add(item);
}
model.BannerPictures = bCollection;
}
else
{
model = new WeChat.Models.Infrastructures.Store();
}
}
var vm = new StoreVM()
{
BannerPictures = model.BannerPictures,
Announcement = model.Announcement ?? "",
StoreName = model.Name
};
return(View(vm));
}
public ActionResult GetStoreByIdWithService(Guid StoreId)
{
var result = _serviceService.GetServices(s => s.StoreId == StoreId);
List <ServiceVM> listService = result.Adapt <List <ServiceVM> >();
List <ServiceTypeVM> listServiceType = new List <ServiceTypeVM>();
if (listService.Any())
{
foreach (ServiceVM services in listService)
{
ServiceTypeVM serviceTypes = _serviceTypeService.GetServiceType(services.ServiceTypeId).Adapt <ServiceTypeVM>();
bool flag = false;
foreach (ServiceTypeVM temp in listServiceType)
{
if (temp.Id == serviceTypes.Id)
{
flag = true;
}
}
if (!flag)
{
serviceTypes.listService = new List <ServiceVM>();
serviceTypes.listService.Add(services);
listServiceType.Add(serviceTypes);
}
else
{
foreach (ServiceTypeVM temp in listServiceType)
{
if (temp.Id == serviceTypes.Id)
{
temp.listService.Add(services.Adapt <ServiceVM>());
}
}
}
}
}
var stores = _storeService.GetStore(StoreId);
StoreVM store = stores.Adapt <StoreVM>();
store.ServiceTypes = listServiceType;
return(Ok(store));
}
public async Task <IActionResult> Store()
{
List <Product> products;
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync("http://localhost:52403/productapi/product/getallproducts/"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
products = JsonConvert.DeserializeObject <List <Product> >(apiResponse);
}
}
StoreVM vm = new StoreVM(products);
if (vm != null)
{
return(View(vm));
}
return(RedirectToAction("Home", "Index"));
}
public static Store ToEntity(this StoreVM model)
{
return(model.MapTo <StoreVM, Store>());
}
public static Store ToEntity(this StoreVM model, Store destination)
{
return(model.MapTo(destination));
}
protected override void InsertNew()
{
EditVM = new StoreVM();
IsInEditMode = true;
}
public ActionResult Index(StoreVM model)
{
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
public IActionResult Add()
{
var store = new StoreVM();
return(View(store));
}
public Store()
{
this.InitializeComponent();
_storeVm = DataContext as StoreVM;
_navigationHandler = NavigationHandler.Instance;
}
