public async void MakeBuilding(MappingViewModel mvmBuilding)
{
Building building = new Building { buildingName = mvmBuilding.building.buildingName };
if (ModelState.IsValid)
{
db.Building.Add(building);
await db.SaveChangesAsync();
}
AddRowsToBuilding(mvmBuilding, building);
}
private async void AddRowsToBuilding(MappingViewModel mvmCount, Building building)
{
for (int i = mvmCount.countHolder; i > 0; i--)
{
Row row = new Row { Building = building };
if (ModelState.IsValid)
{
db.Row.Add(row);
await db.SaveChangesAsync();
}
}
}
public async Task<List<Height>> AddHeightsToBay(MappingViewModel mvm, ApplicationDbContext db)
{
List<Height> heights = new List<Height>();
for(int i = 0; i < mvm.bays.numberOfHeights; i++)
{
Height height = new Height { heightNumber = i + 1, Bay = mvm.bays };
if (ModelState.IsValid)
{
db.Height.Add(height);
await db.SaveChangesAsync();
}
heights.Add(height);
}
return heights;
}
public static List<MappingViewModel> BuildBayMap(List<Bay> bays, ApplicationDbContext db)
{
List<MappingViewModel> mvmItems = new List<MappingViewModel>();
foreach (Bay bay in bays)
{
List<Slot> slotCount = db.Slot.Where(s => s.heightID == db.Height.Where(h => h.BayID == bay.bayID).FirstOrDefault().heightID).ToList();
List<Height> heightCount = db.Height.Where(h => h.BayID == bay.bayID).ToList();
bay.numberOfHeights = heightCount.Count();
bay.numberOfSlots = slotCount.Count();
MappingViewModel mapped = new MappingViewModel { bays = bay };
// mapped.bays.numberOfHeights = heightCount.Count();
// mapped.bays.numberOfSlots = slotCount.Count();
mvmItems.Add(mapped);
}
return mvmItems;
}
public async Task<ActionResult> BuildingDetail(int? id)
{
Building building;
if (id == null)
{
return RedirectToAction("SelectBuilding");
}
building = await db.Building.FindAsync(id);
List<MappingViewModel> mvmItems = new List<MappingViewModel>();
List<Row> rows = db.Row.Where(r => r.BuildingID == id).ToList();
for (int i = 0; i < rows.Count; i++)
{
MappingViewModel mapItem = new MappingViewModel { building = building, row = rows[i] };
mvmItems.Add(mapItem);
}
return View(mvmItems);
}
public async Task<List<Slot>> AddSlotToHeight(List<Height> heights, MappingViewModel mvm, ApplicationDbContext db)
{
List<Slot> slots = new List<Slot>();
foreach(Height h in heights)
{
for(int i = 0; i < mvm.bays.numberOfSlots; i++)
{
Slot slot = new Slot { Height = h, slotID = i + 1 };
if (ModelState.IsValid)
{
db.Slot.Add(slot);
await db.SaveChangesAsync();
}
slots.Add(slot);
}
}
return slots;
}
// POST: CreateBuilding
public async Task<ActionResult> CreateBuilding(MappingViewModel mvmItem)
{
Building building = new Building { buildingName = mvmItem.building.buildingName };
Dock dock = new Dock { Building = building };
if (ModelState.IsValid)
{
db.Building.Add(building);
db.Dock.Add(dock);
await db.SaveChangesAsync();
}
for (int i = mvmItem.countHolder; i > 0; i--)
{
Row row = new Row { Building = building, rowNumber = i };
if (ModelState.IsValid)
{
db.Row.Add(row);
await db.SaveChangesAsync();
}
}
return RedirectToAction("BuildingDetail", new { id = building.buildingID });
}
// GET: Mapping
public async Task<ActionResult> SelectBuilding()
{
int buildingCount = db.Building.Count();
if (buildingCount < 1)
return RedirectToAction("CreateBuilding");
else if (buildingCount == 1)
{
Building building = await db.Building.FindAsync(db.Building.First().buildingID);
// MappingViewModel mvmBuilding = new MappingViewModel { building = building };
return RedirectToAction("BuildingDetail", new { id = building.buildingID });
}
List<Building> buildingList = new List<Building>();
buildingList = await db.Building.ToListAsync();
List<MappingViewModel> mvm = new List<MappingViewModel>(buildingList.Count);
for (int i = 1; i <= buildingList.Count; i++)
{
MappingViewModel mapping = new MappingViewModel { building = buildingList[i - 1] };
mvm.Add(mapping);
}
return View(mvm);
}
public async Task<ActionResult> PopulateBays(int? id, MappingViewModel mvm)
{
if (id == null || mvm == null)
return View("SelectBuilding");
PopulateBayLogic pbl = new PopulateBayLogic();
Bay bay = await db.Bay.FindAsync(id);
bay.numberOfHeights = mvm.bays.numberOfHeights;
bay.numberOfSlots = mvm.bays.numberOfSlots;
mvm.bays = bay;
List<Height> heights = await pbl.AddHeightsToBay(mvm, db);
List<Slot> slots = await pbl.AddSlotToHeight(heights, mvm, db);
return RedirectToAction("RowDetail", new { id = bay.rowID});
}
public async Task<ActionResult> PopulateBays(int? id)
{
if (id == null)
return View("SelectBuilding");
// Bay bay = await db.Bay.FindAsync(id);
MappingViewModel mvm = new MappingViewModel { bays = await db.Bay.FindAsync(id) };
return View(mvm);
}
private List<Bay> BayMaker(Row row, MappingViewModel mapItem)
{
List<Bay> bays = new List<Bay>();
for (int i = 0; i < mapItem.countHolder; i++)
{
Bay bay = new Bay { rowID = row.rowID, bayNumber = i + 1 };
bays.Add(bay);
}
return bays;
}
private List<MappingViewModel> BayMapper(List<Bay> bays)
{
List<MappingViewModel> mapReturnItems = new List<MappingViewModel>();
foreach (Bay bay in bays)
{
MappingViewModel map = new MappingViewModel { bays = bay };
mapReturnItems.Add(map);
}
return mapReturnItems;
}
public async Task<ActionResult> AddBays(int? id, MappingViewModel mvm)
{
if (id == null)
RedirectToAction("SelectBuilding");
Row row = db.Row.Find(id);
row.numberOfBays = mvm.row.numberOfBays;
List<Bay> bays = new List<Bay>();
for (int i = 0; i < mvm.row.numberOfBays; i++)
{
Bay bay = new Bay { bayNumber = i + 1, Row = row };
if (ModelState.IsValid)
{
db.Bay.Add(bay);
await db.SaveChangesAsync();
}
}
return RedirectToAction("BuildingDetail", new { id = row.BuildingID });
}
public async Task<ActionResult> AddBays(int? id)
{
if (id == null)
return RedirectToAction("SelectBuilding");
Row row = await db.Row.FindAsync(id);
MappingViewModel mvm = new MappingViewModel { row = row };
return View("AddBays", mvm);
}
public async Task<ActionResult> Delete(int? id)
{
if (id == null)
{
View("SelectBuilding");
}
Building building = await db.Building.FindAsync(id);
if (building == null)
{
return HttpNotFound();
}
MappingViewModel mapItem = new MappingViewModel { building = building };
return View(mapItem);
}
