public IActionResult AddProductCategory(AddNewProductCategoryModel addproductCategorymodel)
{
try
{
if (ModelState.IsValid)
{
ProductCategory productCategoryModel = ProductCategoryHelper.BindProductCategoryModel(addproductCategorymodel);
long productCategoryId = iProductCategory.AddProductCategory(productCategoryModel);
if (productCategoryId > 0)
{
return(Ok(ResponseHelper.Success(MessageConstants.ProductCategoryAdded)));
}
else if (productCategoryId == ReturnCode.AlreadyExist.GetHashCode())
{
return(Ok(ResponseHelper.Error(MessageConstants.TryDifferentName)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.ProductCategoryNotAdded)));
}
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.CompulsoryData)));
}
}
catch (Exception ex)
{
LogHelper.ExceptionLog(ex.Message + " ::::: " + ex.StackTrace);
return(Ok(ResponseHelper.Error(ex.Message)));
}
}
private async Task <String> GetProductCategoriesHtml(string designName, int imageWidth, int imageHeight)
{
string returnHtml;
var categoriesTask = ProductCategoryService.GetProductCategoriesByStoreIdAsync(StoreId, StoreConstants.ProductType,
true);
var pageDesignTask = PageDesignService.GetPageDesignByName(StoreId, designName);
ProductCategoryHelper.StoreSettings = GetStoreSettings();
ProductCategoryHelper.ImageWidth = imageWidth == 0
? GetSettingValueInt("ProductCategoriesPartial_ImageWidth", 50)
: imageWidth;
ProductCategoryHelper.ImageHeight = imageHeight == 0
? GetSettingValueInt("ProductCategoriesPartial_ImageHeight", 50)
: imageHeight;
await Task.WhenAll(categoriesTask, pageDesignTask);
var categories = categoriesTask.Result;
var pageDesign = pageDesignTask.Result;
var pageOuput = ProductCategoryHelper.GetProductCategoriesPartial(categories, pageDesign);
returnHtml = pageOuput.PageOutputText;
return(returnHtml);
}
// GET: Product
public ActionResult Index(string searchString, string metaTitle = "Lasted", int page = 1, int sizePage = 8)
{
ViewBag.CategoryActive = "#" + metaTitle + "";
ViewBag.SearchString = searchString;
ViewBag.MetaTitle = metaTitle;
ViewBag.Page = page;
IPagedList <ProductOnPage> products;
IEnumerable <ProductCategory> categories = ProductCategoryHelper.GetProductCategories();
if (metaTitle == "Lasted")
{
products = ProductHelper.GetNewProducts(searchString).ToPagedList(page, sizePage);
}
else if (metaTitle == "Best-Saler")
{
products = ProductHelper.GetBestSalerProducts(searchString).ToPagedList(page, sizePage);
}
else if (metaTitle == "Hot")
{
products = ProductHelper.GetHotProducts(searchString).ToPagedList(page, sizePage);
}
else
{
products = ProductHelper.GetProductsByCategoryMetaTitle(metaTitle, searchString).OrderByDescending(x => x.ProductID).ToPagedList(page, sizePage);
}
ProductViewModel model = new ProductViewModel()
{
Products = products, Categories = categories
};
return(View(model));
}
public IActionResult ProductCategoryDetail(ProductCategoryDetailModel model)
{
try
{
if (ModelState.IsValid)
{
var productCategoryDetail = iProductCategory.GetProductCategoryDetail(DBHelper.ParseInt64(model.productCategoryId));
if (productCategoryDetail != null)
{
ProductCategoryListModel productCategoryListModel = ProductCategoryHelper.BindProductCategoryListModel(productCategoryDetail);
return(Ok(ResponseHelper.Success(productCategoryListModel)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.DataNotFound)));
}
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.CompulsoryData)));
}
}
catch (Exception ex)
{
LogHelper.ExceptionLog(ex.Message + " ::::: " + ex.StackTrace);
return(Ok(ResponseHelper.Error(ex.Message)));
}
}
public IActionResult ProductCategoryList(SearchPaginationListModel model)
{
try
{
if (model.pageNo <= 0)
{
model.pageNo = 1;
}
var productCategoryList = iProductCategory.GetProductCategory(model.searchString);
if (productCategoryList != null)
{
var productCategoryPagedresult = productCategoryList.OrderByDescending(x => x.ProductCategoryId).ToPagedList(model.pageNo, model.limit).ToList();
List <ProductCategoryListModel> productCategoryListModel = ProductCategoryHelper.BindProductCategoryListModel(productCategoryPagedresult);
return(Ok(ResponseHelper.Success(productCategoryListModel)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.DataNotFound)));
}
}
catch (Exception ex)
{
LogHelper.ExceptionLog(ex.Message + " ::::: " + ex.StackTrace);
return(Ok(ResponseHelper.Error(ex.Message)));
}
}
public ActionResult Update(ProductCategory model)
{
if (ProductCategoryHelper.UpdateProductCategory(model as ProductCategory))
{
return(Content("success"));
}
return(Content("failure"));
}
public ActionResult Delete(DeleteViewModel model)
{
if (ProductCategoryHelper.DeleteProductCategory(model.ID))
{
return(Content("success"));
}
return(Content("failure"));
}
public async Task <ActionResult> Index(int page = 1)
{
try
{
if (!IsModulActive(StoreConstants.ProductType))
{
Logger.Trace("Navigation Modul is not active:" + StoreConstants.ProductType);
return(HttpNotFound("Not Found"));
}
var pageDesignTask = PageDesignService.GetPageDesignByName(StoreId, IndexPageDesingName);
var pageSize = GetSettingValueInt("ProductCategories_PageSize", StoreConstants.DefaultPageSize);
var categoriesTask = ProductCategoryService.GetProductCategoriesByStoreIdAsync(StoreId, StoreConstants.ProductType, true, page, pageSize);
var settings = GetStoreSettings();
ProductCategoryHelper.StoreSettings = settings;
await Task.WhenAll(pageDesignTask, categoriesTask);
var pageDesign = pageDesignTask.Result;
var categories = categoriesTask.Result;
if (pageDesign == null)
{
throw new Exception("PageDesing is null:" + IndexPageDesingName);
}
var pageOutput = ProductCategoryHelper.GetCategoriesIndexPage(pageDesign, categories);
var pagingPageDesignTask = PageDesignService.GetPageDesignByName(StoreId, "Paging");
PagingHelper.StoreSettings = GetStoreSettings();
PagingHelper.StoreId = StoreId;
PagingHelper.PageOutput = pageOutput;
PagingHelper.HttpRequestBase = this.Request;
PagingHelper.RouteData = this.RouteData;
PagingHelper.ActionName = this.ControllerContext.RouteData.Values["action"].ToString();
PagingHelper.ControllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
await Task.WhenAll(pagingPageDesignTask);
var pagingDic = PagingHelper.GetPaging(pagingPageDesignTask.Result);
pagingDic.StoreSettings = settings;
pagingDic.MyStore = this.MyStore;
pageOutput.PageTitle = "Product Categories";
return(View(pagingDic));
}
catch (Exception ex)
{
Logger.Error(ex, "ProductCategories:Index:" + ex.StackTrace, page);
throw ex;
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
ProductCategoryHelper pch = new ProductCategoryHelper();
DataTable dtListStore = pch.GetListCateParentPagging(1, 6, 224);
if (dtListStore != null && dtListStore.Rows.Count > 0)
{
rptListStore.DataSource = dtListStore;
rptListStore.DataBind();
}
}
}
// GET: Admin/ProductCategory
public ActionResult Index(string searchString, int page = 1, int sizePage = 10)
{
ViewBag.Active = "#ProductCategory";
IEnumerable <ProductCategory> models;
if (String.IsNullOrEmpty(searchString))
{
models = ProductCategoryHelper.GetProductCategories();
}
else
{
models = ProductCategoryHelper.GetProductCategories(searchString);
}
ViewBag.SearchString = searchString;
return(View(models.OrderByDescending(x => x.ID).ToPagedList(page, sizePage)));
}
public ActionResult Add(ProductCategory model)
{
if (ModelState.IsValid)
{
if (ProductCategoryHelper.AddProductCategory(model as ProductCategory))
{
return(Content("success"));
}
else
{
ModelState.AddModelError("", "Existing User ID!");
return(PartialView("Add"));
}
}
else
{
return(PartialView("Add"));
}
}
public async Task <ActionResult> Category(String id = "", int page = 1)
{
try
{
if (!IsModulActive(StoreConstants.ProductType))
{
Logger.Trace("Navigation Modul is not active:" + StoreConstants.ProductType);
return(HttpNotFound("Not Found"));
}
int categoryId = id.Split("-".ToCharArray()).Last().ToInt();
var pageDesignTask = PageDesignService.GetPageDesignByName(StoreId, CategoryPageDesingName);
var categoryTask = ProductCategoryService.GetProductCategoryAsync(categoryId);
var settings = GetStoreSettings();
ProductCategoryHelper.StoreSettings = settings;
ProductCategoryHelper.ImageWidth = GetSettingValueInt("ProductCategoryPage_ImageWidth", 50);
ProductCategoryHelper.ImageHeight = GetSettingValueInt("ProductCategoryPage_ImageHeight", 50);
await Task.WhenAll(pageDesignTask, categoryTask);
var pageDesign = pageDesignTask.Result;
var category = categoryTask.Result;
if (pageDesign == null)
{
throw new Exception("PageDesing is null" + CategoryPageDesingName);
}
var pageOutput = ProductCategoryHelper.GetCategoryPage(pageDesign, category);
pageOutput.StoreSettings = settings;
pageOutput.MyStore = this.MyStore;
pageOutput.PageTitle = category.Name;
return(View(pageOutput));
}
catch (Exception ex)
{
Logger.Error(ex, "Category:Index:" + ex.StackTrace, id);
throw ex;
}
}
public IActionResult UpdateProductCategory(UpdateProductCategoryModel updateProdutCategorymodel)
{
if (ModelState.IsValid)
{
ProductCategory produtCategoryModel = ProductCategoryHelper.BindProductCategoryModel(updateProdutCategorymodel);
long productCategoryId = iProductCategory.UpdateProductCategory(produtCategoryModel, DBHelper.ParseInt64(produtCategoryModel.UpdatedBy));
if (productCategoryId > 0)
{
return(Ok(ResponseHelper.Success(MessageConstants.ProductCategoryUpdated)));
}
else if (productCategoryId == ReturnCode.AlreadyExist.GetHashCode())
{
return(Ok(ResponseHelper.Error(MessageConstants.TryDifferentName)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.ProductCategoryNotUpdated)));
}
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.CompulsoryData)));
}
}
public ActionResult UpdateTransfer(int?id)
{
ProductCategory model = ProductCategoryHelper.GetProductCategoryByID((int)id);
return(PartialView("Update", model));
}
