public async Task <JsonResult> GetAll()
{
try {
var data = ItemCategoryService.GetAll();
return(Success(ItemCategoryVM.MsToVMs(data)));
} catch { return(Failed(MessageUtility.ServerError())); }
}
public ActionResult Add(ItemCategoryVM categoryVM)
{
try
{
if (categoryVM.ImageFile != null)
{
string fileName = Path.GetFileNameWithoutExtension(categoryVM.ImageFile.FileName);
string extension = Path.GetExtension(categoryVM.ImageFile.FileName);
categoryVM.ImagePath = fileName + extension;
fileName = Path.Combine(Server.MapPath("~/images/"), categoryVM.ImagePath);
categoryVM.ImageFile.SaveAs(fileName);
}
ItemCategory category = Mapper.Map <ItemCategory>(categoryVM);
if (ModelState.IsValid)
{
if (_categoryManager.Add(category))
{
TempData["success"] = "Added Sussessfully";
return(RedirectToAction("Add"));
}
}
}
catch (Exception e)
{
TempData["exception"] = "Failed to Add. " + e.Message;
}
return(Add());
}
public async Task <JsonResult> GetByID(string id)
{
try {
var data = ItemCategoryService.GetByID(Guid.Parse(id));
return(Success(ItemCategoryVM.MToVM(data)));
} catch { return(Failed(MessageUtility.ServerError())); }
}
public ActionResult Update(ItemCategoryVM categoryVM)
{
try
{
if (categoryVM.ImageFile != null)
{
string fileName = Path.GetFileNameWithoutExtension(categoryVM.ImageFile.FileName);
string extension = Path.GetExtension(categoryVM.ImageFile.FileName);
categoryVM.ImagePath = fileName + extension;
fileName = Path.Combine(Server.MapPath("~/images/"), categoryVM.ImagePath);
categoryVM.ImageFile.SaveAs(fileName);
}
ItemCategory category = Mapper.Map <ItemCategory>(categoryVM);
;
bool isUpdate = _categoryManager.Update(category, categoryVM.PrevName, categoryVM.PrevCode);
if (isUpdate)
{
TempData["success"] = "Updated successfully";
return(RedirectToAction("Add"));
}
}
catch (Exception e)
{
TempData["exception"] = "Failed to Update. " + e.Message;
}
return(View("Add"));
}
public async Task <WrapperItemCategoryListVM> Delete(ItemCategoryVM itemTemp)
{
IEnumerable <ItemCategory> itemTask = await _repositoryWrapper.ItemCategory.FindByConditionAsync(x => x.Id == itemTemp.Id && x.FactoryId == itemTemp.FactoryId);
var item = itemTask.ToList().FirstOrDefault();
if (item == null)
{
return(new WrapperItemCategoryListVM());
}
_repositoryWrapper.ItemCategory.Delete(item);
await _repositoryWrapper.ItemCategory.SaveChangesAsync();
this._utilService.LogInfo("Successful In Deleting Item Cateory");
var dataParam = new GetDataListVM()
{
FactoryId = itemTemp.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperItemCategoryListVM data = await GetListPaged(dataParam);
return(data);
}
private void UpdateSelectedCategory(ItemCategoryVM oldSelectedCategory)
{
if (oldSelectedCategory == null)
{
return;
}
SelectedCategory = Categories.FirstOrDefault(category => category.ID.Equals(oldSelectedCategory.ID));
}
public static bool Insert(Guid id, string name)
{
try {
using (var context = new GeopersonContext()) {
var model = ItemCategoryVM.Set(id, name);
context.ItemCategoryDB.Add(model);
context.SaveChanges();
return(true);
}
} catch { return(false); }
}
// GET: ItemCategory
public ActionResult Add()
{
ItemCategoryVM categoryVM = new ItemCategoryVM();
categoryVM.CategoryList = _categoryManager.GetAll();
//var DropDown = new List<SelectListItem>();
//DropDown.AddRange(categoryVM.CategoryList.Select(c=>new SelectListItem {Value=c.Id.ToString(), Text = c.Name.ToString()}));
//categoryVM.CategoryDropDown = DropDown;
ViewBag.ParentId = new List <SelectListItem>();
return(View(categoryVM));
}
public void CreateItemCategory(ItemCategoryVM itemCategory, string userID)
{
ItemCategory c = new ItemCategory();
c.ItemCategoryName = itemCategory.ItemCategoryName;
c.ItemCategoryID = 0;
c.UserID = userID;
OneListEntitiesCore Core = new OneListEntitiesCore();
Core.ItemCategories.Add(c);
Core.SaveChanges();
}
public ActionResult Edit(ItemCategoryVM itemVm)
{
if (ModelState.IsValid)
{
if (itemCategoryDa.IsItemCategoryUpdated(itemVm))
{
return(RedirectToAction("Index"));
}
}
return(View(itemVm));
}
public bool UpdateItemCategory(ItemCategoryVM itemCategory)
{
OneListEntitiesCore db = new OneListEntitiesCore();
ItemCategory itemCategoryUpdated = db.ItemCategories
.Where(a =>
a.ItemCategoryID == itemCategory.ItemCategoryID
)
.FirstOrDefault();
itemCategoryUpdated.ItemCategoryName = itemCategory.ItemCategoryName;
db.SaveChanges();
return(true);
}
public ActionResult EditItemCategory(int id)
{
if (Request.IsAuthenticated)
{
ItemRepo itemRepo = new ItemRepo();
ItemCategoryVM itemCategory = itemRepo.GetCategoryDetails(id);
return(View(itemCategory));
}
else
{
return(RedirectToAction("Login", "Home"));
}
}
public ActionResult CreateItemCategory(ItemCategoryVM itemCategory)
{
string userID = FindUserID();
if (ModelState.IsValid)
{
ItemRepo itemRepo = new ItemRepo();
itemRepo.CreateItemCategory(itemCategory, userID);
return(RedirectToAction("ItemCategoryManagement"));
}
else
{
return(View());
}
}
public ActionResult Create(ItemCategoryVM itemCategory, HttpPostedFileBase file)
{
itemCategory.Date = DateTime.Now;
itemCategory.Image = imageData.ImageConvertToByte(file);
if (ModelState.IsValid)
{
if (itemCategoryDa.IsItemCategorySaved(itemCategory))
{
return(RedirectToAction("Index"));
}
}
ModelVm.SelectList = itemCategoryDa.GetItemCategorySelectList();
ModelVm.Code = itemCategoryDa.GetItemCategoryCode();
return(View(ModelVm));
}
public ActionResult Edit(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ModelVm = itemCategoryDa.FindItemCategory(id);
if (ModelVm == null)
{
return(HttpNotFound());
}
return(View(ModelVm));
}
public bool IsItemCategorySaved(ItemCategoryVM itemVm)
{
ItemCategory item = new ItemCategory()
{
Name = itemVm.Name,
Code = itemVm.Code,
Description = itemVm.Description,
Image = itemVm.Image,
Date = itemVm.Date,
ParentId = itemVm.ParentId
};
dbContext.ItemCategories.Add(item);
var isAdded = dbContext.SaveChanges() > 0;
return(isAdded);
}
public bool IsItemCategoryUpdated(ItemCategoryVM itemVm)
{
ItemCategory item = new ItemCategory()
{
Id = itemVm.Id,
Name = itemVm.Name,
Code = itemVm.Code,
Description = itemVm.Description,
Image = itemVm.Image,
Date = itemVm.Date,
ParentId = itemVm.ParentId
};
dbContext.Entry(item).State = EntityState.Modified;
var isUpdated = dbContext.SaveChanges() > 0;
return(isUpdated);
}
public ActionResult EditItemCategory(ItemCategoryVM itemCategory)
{
bool CategoryUpdated;
if (ModelState.IsValid)
{
ItemRepo itemRepo = new ItemRepo();
CategoryUpdated = itemRepo.UpdateItemCategory(itemCategory);
if (CategoryUpdated)
{
return(RedirectToAction("ItemCategoryDetail", new { id = itemCategory.ItemCategoryID }));
}
else
{
ViewBag.ErrorMsg = "Updated item category failed";
}
}
return(View());
}
public ItemCategoryVM GetCategoryDetails(int itemCategoryID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
ItemCategory category = db.ItemCategories
.Where(ic => ic.ItemCategoryID == itemCategoryID)
.FirstOrDefault();
IEnumerable <ItemVM> allItems = db.Items
.Where(i => i.ItemCategory == itemCategoryID)
.Select(item => new ItemVM
{
ItemName = item.ItemName,
ItemDescription = item.ItemDescription
});
ItemCategoryVM categoryVM = new ItemCategoryVM();
categoryVM.ItemCategoryName = category.ItemCategoryName;
categoryVM.UserID = category.UserID;
categoryVM.ItemCategoryID = itemCategoryID;
categoryVM.allItemsInCategory = allItems;
return(categoryVM);
}
public ItemCategoryVM FindItemCategory(long?id)
{
var item = dbContext.ItemCategories.Find(id);
var itemParent = dbContext.ItemCategories.Find(item.ParentId);
ItemCategoryVM itemVm = null;
if (item != null)
{
itemVm = new ItemCategoryVM()
{
Name = item.Name,
Code = item.Code,
Description = item.Description,
Image = item.Image,
Date = item.Date,
ParentId = item.ParentId,
Parent = itemParent
};
}
return(itemVm);
}
public async Task <WrapperItemCategoryListVM> Update(string id, ItemCategoryVM vm)
{
IEnumerable <ItemCategory> ItemDB = await _repositoryWrapper.ItemCategory.FindByConditionAsync(x => x.Id == id && x.FactoryId == vm.FactoryId);
var ItemUpdated = _utilService.GetMapper().Map <ItemCategoryVM, ItemCategory>(vm, ItemDB.ToList().FirstOrDefault());
_repositoryWrapper.ItemCategory.Update(ItemUpdated);
await _repositoryWrapper.ItemCategory.SaveChangesAsync();
this._utilService.LogInfo("Successful In Updating Item Cateory");
var dataParam = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperItemCategoryListVM data = await GetListPaged(dataParam);
return(data);
}
public async Task <WrapperItemCategoryListVM> Add(ItemCategoryVM vm)
{
var entityToAdd = _utilService.GetMapper().Map <ItemCategoryVM, ItemCategory>(vm);
//string uniqueIdTask =await _repositoryWrapper.ItemCategory.GetUniqueId();
//// Todo need to aandle unique id from db
//entityToAdd.UniqueId = uniqueIdTask;
entityToAdd = _repositoryWrapper.ItemCategory.Create(entityToAdd);
await _repositoryWrapper.ItemCategory.SaveChangesAsync();
this._utilService.LogInfo("Successful In saving Item Category");
var dataParam = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperItemCategoryListVM data = await GetListPaged(dataParam);
return(data);
}
public bool IsItemCategorySaved(ItemCategoryVM itemVm)
{
ItemCategory item = new ItemCategory()
{
Name = itemVm.Name,
Code = itemVm.Code,
Description = itemVm.Description,
Image = itemVm.Image,
Date = itemVm.Date,
ItemParentsID = itemVm.ItemParentsID
};
dbContext.ItemCategories.Add(item);
var isAdded = dbContext.SaveChanges() > 0;
if (isAdded)
{
return(true);
}
else
{
return(false);
}
}
private void UpdateSelectedCategory(ItemCategoryVM oldSelectedCategory)
{
if (oldSelectedCategory == null) return;
SelectedCategory = Categories.SingleOrDefault(category => category.ID.Equals(oldSelectedCategory.ID));
}
public async Task <ActionResult <WrapperItemCategoryListVM> > DeleteItemCategory([FromBody] ItemCategoryVM itemVM)
{
return(await _serviceWrapper.ItemCategoryService.Delete(itemVM));
}
public async Task <ActionResult <WrapperItemCategoryListVM> > AddItemCategory([FromBody] ItemCategoryVM itemCategory)
{
return(await _serviceWrapper.ItemCategoryService.Add(itemCategory));
}
public async Task <ActionResult <WrapperItemCategoryListVM> > UpdateItemCategory(string id, [FromBody] ItemCategoryVM itemCategory)
{
return(await _serviceWrapper.ItemCategoryService.Update(id, itemCategory));
}
public ActionResult Details(long id)
{
ItemCategoryVM itemVm = itemCategoryDa.FindItemCategory(id);
return(PartialView("_Details", itemVm));
}
