public ActionResult PostTblProducts(TblProducts tblProducts)
{
tblProducts.AddedDate = DateTime.Now;
tblProducts.Modified = DateTime.Now;
_repository.AddProduct(tblProducts);
return(CreatedAtAction("GetTblProducts", new { id = tblProducts.ProductId }, tblProducts));
}
public async Task <int> Create(TblProducts product)
{
await _dbContext.Tbl_Products.AddAsync(product);
await _dbContext.SaveChangesAsync();
return(product.ProductId);
}
public ActionResult AddProduct(TblProducts tblProducts)
{
var ctg = db.TblCategories.Where(m => m.CategoryID == tblProducts.TblCategories.CategoryID).FirstOrDefault();
tblProducts.TblCategories = ctg;
db.TblProducts.Add(tblProducts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult PutTblProducts(int id, TblProducts tblProducts)
{
if (id != tblProducts.ProductId)
{
return(BadRequest());
}
tblProducts.Modified = DateTime.Now;
_repository.UpdatProduct(tblProducts);
return(NoContent());
}
//Metodos
public int Add(TblProducts entity)
{
parameters = new List <SqlParameter>
{
new SqlParameter("@prod_Cod", entity.ProdCod),
new SqlParameter("@prod_Name", entity.ProdName),
new SqlParameter("@prod_Pr_may", entity.ProdPrMay),
new SqlParameter("@prod_Pr_men", entity.ProdPrMen),
new SqlParameter("@prod_Stock", entity.ProdStock)
};
return(ExecuteNonQuery(insert_update));
}
public async Task <IActionResult> Create(TblProducts products)
{
if (ModelState.IsValid)
{
await _product.Create(products);
return(Ok());
}
else
{
return(BadRequest());
}
}
// creates query parameters list from TblProducts object
object[] TakeProduct(TblProducts pro)
{
return(new object[]
{
"@ProductName", pro.ProductName,
"@Brand", pro.Brand,
"@Description", pro.Description,
"@LaunchDate", pro.LaunchDate,
"@Price", pro.Price,
"@Image", pro.Image,
"@Quantity", pro.Quantity
});
}
public void UpdatProduct(TblProducts product)
{
using (var context = new DRYFRUITSSERVICESMDFContext())
{
var updateproduct = context.TblProducts.Find(product.ProductId);
updateproduct.Quantity = product.Quantity;
updateproduct.Description = product.Description;
updateproduct.Price = product.Price;
updateproduct.Modified = DateTime.Now;
context.Update(updateproduct);
context.SaveChanges();
}
}
public async Task <int> PutEditProduct(TblProducts product)
{
var getProduct = await _dbContext.Tbl_Products.FirstOrDefaultAsync(p => p.ProductId == product.ProductId);
if (product.ProductImage == null)
{
product.ProductImage = getProduct.ProductImage;
}
_dbContext.Entry(getProduct).CurrentValues.SetValues(product);
await _dbContext.SaveChangesAsync();
return(product.ProductId);
}
public void AddProduct(TblProducts product)
{
try
{
using (var context = new DRYFRUITSSERVICESMDFContext())
{
context.TblProducts.Add(product);
context.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public bool UpdateProduct(TblProducts Product)
{
string StoreProc = "spUpdateProduct";
object[] parms =
{
"@ProductID", Product.ProductID,
"@ProductName", Product.ProductName,
"@Brand", Product.Brand,
"@Description", Product.Description,
"@LaunchDate", Product.LaunchDate,
"@Price", Product.Price,
"@Image", Product.Image,
"@Quantity", Product.Quantity
};
return(db.Update(StoreProc, parms) > 0);
}
public int Edit(TblProducts tbl_pro_obj, List <IFormFile> pImage)
{
string wwwPath = this.Environment.WebRootPath;
string contentPath = this.Environment.ContentRootPath;
string path = Path.Combine(this.Environment.WebRootPath, "Uploads");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
List <string> uploadedFiles = new List <string>();
foreach (IFormFile postedFile in pImage)
{
string fileName = Path.GetFileName(postedFile.FileName);
if ((postedFile != null) && (Path.GetExtension(postedFile.FileName) == ".jpg") || (Path.GetExtension(postedFile.FileName) == ".png") || (Path.GetExtension(postedFile.FileName) == ".jpeg"))
{
string tme = DateTime.Now.ToString();
string qq = tme.Replace(":", "-");
string qq1 = qq.Replace("/", "-");
string wq = qq1 + Guid.NewGuid() + fileName;
tbl_pro_obj.PImage = wq;
using (FileStream stream = new FileStream(Path.Combine(path, wq), FileMode.Create))
{
postedFile.CopyTo(stream);
uploadedFiles.Add(fileName);
ViewBag.Message += string.Format("<b>{0}</b> uploaded.<br />", fileName);
}
return(obj_Product.Product_Update(tbl_pro_obj));
}
else
{
// tbl_pro_obj.PImage = Path.GetExtension(postedFile.FileName);
return(0);
}
}
return(0);
}
public virtual async Task <ProductModel> PrepareProductModelAsync(TblProducts product)
{
ProductModel result;
if (product == null)
{
result = new ProductModel();
}
else
{
result = product.Adapt <ProductModel>();
await product.LoadAllLocalizedStringsToModelAsync(result);
var tags = await product.Tags.Select(p => p.Tag).OrderBy(p => p).ToListAsync();
result.ProductTags = tags?.ToArray() ?? new string[] { };
var categories = await product.Categories.OrderBy(p => p.CategoryName).Select(p => p.Id).ToListAsync();
result.ProductCategories = categories.ToArray();
}
return(result);
}
public bool UpdateProduct(TblProducts Product)
{
return(tblProductsDAO.UpdateProduct(Product));
}
public bool AddProduct(TblProducts Product)
{
return(tblProductsDAO.AddProduct(Product));
}
public virtual async Task <string> GenerateLicenseForProductAsync(TblInvoices invoice, TblUsers user,
TblProducts product, int quantity)
{
return("Test product license for : " + product.GetLocalized(p => p.Title));
}
public async Task <IActionResult> Edit(TblProducts inputProduct)
{
var product = await _product.PutEditProduct(inputProduct);
return(Ok());
}
protected virtual string GenerateUserGroupDiscountsDescription(TblProducts product, TblUsers user)
{
string result = "";
var fromGroup = user?.UserGroupId != null ? user.UserGroup.GroupPriority : int.MinValue;
var discounts = _productDiscountsForUserGroupsService.FindProductDiscounts(product.Id);
foreach (var discount in discounts.Where(p => p.UserGroup.GroupPriority >= fromGroup))
{
var price = product.Price - (discount.DiscountPercent * product.Price) / 100;
var groupName = discount.UserGroup.GetLocalized(p => p.GroupName);
if (price <= 0)
{
//Free
if (discount.ApplyDiscountToHigherUserGroups)
{
result += string.Format(
_localizationService.GetResource("FreeForUserGroupsOrHigher"),
groupName,
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug) + "<br/>";
}
else
{
result += string.Format(
_localizationService.GetResource("FreeForUserGroups"),
groupName,
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug) + "<br/>";
}
}
else
{
if (discount.ApplyDiscountToHigherUserGroups)
{
result += string.Format(
_localizationService.GetResource("DiscountForUserGroupsOrHigher"),
discount.DiscountPercent,
groupName,
price.ExchangeCurrencyStr(),
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug) + "<br/>";
}
else
{
result += string.Format(
_localizationService.GetResource("DiscountForUserGroups"),
discount.DiscountPercent,
groupName,
price.ExchangeCurrencyStr(),
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug) + "<br/>";
}
}
}
return(result);
}
public virtual ProductModel PrepareProductModel(TblProducts product, TblUsers currentUser, UrlHelper url)
{
var result = product.Adapt <TblProducts, ProductModel>();
result.Title = product.GetLocalized(p => p.Title);
result.PageTitle = product.GetLocalized(p => p.PageTitle);
result.MetaDescription = product.GetLocalized(p => p.MetaDescription);
result.MetaKeyWords = product.GetLocalized(p => p.MetaKeyWords);
var downloadsCount = _productService.GetNumberOfDownloads(product.Id);
var likesCount = _userLikesService.GetNumberOfLikes(product.Id);
result.NumberOfDownloads = downloadsCount;
result.NumberOfLikes = likesCount;
result.LastUpdate = product.LastUpDate ?? product.PublishDate;
result.Categories = product.Categories
.Select(p => new PostCategoriesModel()
{
Id = p.Id,
CategoryName = p.GetLocalized(x => x.CategoryName),
Slug = p.Slug,
CategoryUrl = url.Action("FilterByCategory", "Product", new { slug = p.Slug })
})
.ToList();
result.TagsList = product.Tags
.Select(p => new Tuple <int, string>(p.Id, p.GetLocalized(x => x.Tag)))
.ToList();
//user purchased current product ?
var purchasedProducts = _usersService.GetUserPurchasedProducts(currentUser?.Id, product.Id);
if (purchasedProducts.Any(p => p.PurchaseExpiration > DateTime.Now))
{
result.CurrentUserHasAlreadyPurchasedThisProduct = true;
}
result.PriceForCurrentUser = _productService.CalculateProductPriceForUser(product, currentUser);
result.CurrentUserGroup = currentUser?.UserGroup;
result.LikeWishlistButtonsModel = new LikeWishlistButtonsModel()
{
PostId = product.Id,
AlreadyAddedToWishlist = _userWishlistService.UserAddedThisPostToWishlist(product.Id, currentUser?.Id),
AlreadyLiked = _userLikesService.UserLikedThisPost(product.Id, currentUser?.Id)
};
result.DownloadModel = PrepareProductDownloadPurchaseButtonModel(product, currentUser);
result.Images.Clear();
foreach (var img in product.Images.OrderBy(p => p.DisplayOrder))
{
result.Images.Add(new PostImagesModel()
{
Title = img.GetLocalized(p => p.Title) ?? result.PageTitle,
Alt = img.GetLocalized(p => p.Alt) ?? result.Title,
ImageUrl = img.GetLocalized(p => p.ImageUrl),
DisplayOrder = img.DisplayOrder
});
}
result.Descriptions.Clear();
foreach (var desc in product.Descriptions.OrderBy(p => p.DisplayOrder))
{
var description = desc.GetLocalized(x => x.HtmlDescription);
result.Descriptions.Add(new PostDescriptionsModel()
{
Description = description,
Title = desc.GetLocalized(x => x.Title),
IsRtl = description.StripHtml().IsRtlLanguage()
});
}
result.Attributes.Clear();
foreach (var attr in product.Attributes)
{
result.Attributes.Add(new PostAttributesModel()
{
Type = attr.PostAttribute.AttributeType,
Name = attr.PostAttribute.GetLocalized(p => p.Name),
Value = attr.PostAttribute.AttributeType == PostAttributeType.Option
? attr.AttributeOption.GetLocalized(p => p.Name)
: attr.GetLocalized(p => p.Value),
DisplayOrder = attr.DisplayOrder
});
}
result.CheckoutAttributes.Clear();
foreach (var attr in product.CheckoutAttributes)
{
result.CheckoutAttributes.Add(new TblProductCheckoutAttributes()
{
Id = attr.Id,
Name = attr.GetLocalized(p => p.Name),
Description = attr.GetLocalized(p => p.Description),
AttributeType = attr.AttributeType,
DisplayOrder = attr.DisplayOrder,
ProductId = attr.ProductId,
Required = attr.Required,
MaxRange = attr.MaxRange,
MinRange = attr.MinRange,
LicenseGeneratorServiceId = attr.LicenseGeneratorServiceId,
UnitPrice = attr.UnitPrice,
Options = attr.Options.Select(p => p.Adapt <TblProductCheckoutAttributeOptions>()).ToList()
});
}
var protocol = _httpContext?.Request.Url?.Scheme ?? "http";
result.PostUrl = new Uri(url.Action("Index", "Product", new { slug = product.Slug }, protocol: protocol) ?? "").ToString();
return(result);
}
public virtual ProductDownloadModel PrepareProductDownloadPurchaseButtonModel(TblProducts product, TblUsers currentUser)
{
var productCheckoutAttributes = AsyncHelper
.RunSync(() => _checkoutAttributesService.FindProductAttributesAsync(product.Id)).ToList();
TblUserGroups downloadLimitedToUserGroupRecord = null;
if (product.DownloadLimitedToUserGroupId != null)
{
downloadLimitedToUserGroupRecord = AsyncHelper
.RunSync(() => _userGroupsService.FindByIdAsync(product.DownloadLimitedToUserGroupId.Value));
}
var result = new ProductDownloadModel
{
ProductId = product.Id,
AlwaysShowDownloadButton = product.AlwaysShowDownloadButton,
DownloadLimitedToUserGroup = downloadLimitedToUserGroupRecord,
HigherUserGroupsCanDownload = product.HigherUserGroupsCanDownload,
HasDownloadableFile = !string.IsNullOrWhiteSpace(product.FilesPath) ||
productCheckoutAttributes.Any(p =>
p.Options.Any(x => !string.IsNullOrWhiteSpace(x.FilesPath))),
PriceForCurrentUser = _productService.CalculateProductPriceForUser(product, currentUser),
DiscountForUserGroupsDescription = GenerateUserGroupDiscountsDescription(product, currentUser),
DownloadBlockingReason = _productService.UserCanDownloadProduct(product, currentUser, false)
};
result.CanDownloadByCurrentUser = result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserCanDownloadProduct);
result.CurrentUserGroup = currentUser?.UserGroup;
result.HasDemoVersion = !string.IsNullOrWhiteSpace(product.DemoFilesPath);
//user purchased current product ?
var purchasedProducts = _usersService.GetUserPurchasedProducts(currentUser?.Id, product.Id);
if (purchasedProducts.Any(p => p.PurchaseExpiration > DateTime.Now))
{
result.CurrentUserHasAlreadyPurchasedThisProduct = true;
}
//ShowUpgradeUserAccountBtn
if (result.DownloadLimitedToUserGroup != null &&
(result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlan) ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlanOrHigher)))
{
if (result.CurrentUserGroup == null)
{
//Current user don't subscribed to any plan
result.ShowUpgradeUserAccountBtn = true;
}
else
{
if (result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlan) &&
result.CurrentUserGroup.Id != result.DownloadLimitedToUserGroup.Id)
{
result.ShowUpgradeUserAccountBtn = true;
}
if (result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlanOrHigher) &&
result.CurrentUserGroup.GroupPriority < result.DownloadLimitedToUserGroup.GroupPriority)
{
result.ShowUpgradeUserAccountBtn = true;
}
}
}
//ShowDownloadFullVersionBtn
if (result.HasDownloadableFile)
{
if (result.AlwaysShowDownloadButton ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserCanDownloadProduct))
{
result.ShowDownloadFullVersionBtn = true;
}
if (result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustLoggedIn) ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserDownloadLimitReached) ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserGroupDownloadLimitReached))
{
if (!(result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlan) ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustSubscribeToAPlanOrHigher) ||
result.DownloadBlockingReason.HasFlagFast(ProductService.UserCanDownloadProductResult.UserMustPurchaseTheProduct)))
{
result.ShowDownloadFullVersionBtn = true;
}
}
}
//ShowPurchaseBtn
result.ShowPurchaseBtn =
result.PriceForCurrentUser > 0 || !string.IsNullOrWhiteSpace(product.LicenseGeneratorServiceId) ||
productCheckoutAttributes.Any(p =>
(p.UnitPrice > 0 && p.AttributeType == ProductCheckoutAttributeType.NumberBox) ||
!string.IsNullOrWhiteSpace(p.LicenseGeneratorServiceId)) ||
productCheckoutAttributes.SelectMany(p => p.Options).Any(p =>
p.Price > 0 ||
!string.IsNullOrWhiteSpace(p.LicenseGeneratorServiceId));
//ShowDownloadDemoVersionBtn
result.ShowDownloadDemoVersionBtn = result.HasDemoVersion;
return(result);
}
public bool AddProduct(TblProducts Product)
{
string StoreProc = "spAddProduct";
return(db.Update(StoreProc, TakeProduct(Product)) > 0);
}
protected virtual List <Tuple <TblUserGroups, string> > GenerateUserGroupDiscountsDescription(TblProducts product, TblUsers user)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
var result = new List <Tuple <TblUserGroups, string> >();
var fromGroup = user?.UserGroupId != null ? user.UserGroup.GroupPriority : int.MinValue;
var discounts = _productDiscountsForUserGroupsService.FindProductDiscounts(product.Id);
foreach (var discount in discounts.Where(p => p.UserGroup.GroupPriority >= fromGroup))
{
var price = product.Price - (discount.DiscountPercent * product.Price) / 100;
var groupName = discount.UserGroup.GetLocalized(p => p.GroupName);
if (price <= 0)
{
//Free
if (discount.ApplyDiscountToHigherUserGroups)
{
result.Add(new Tuple <TblUserGroups, string>(discount.UserGroup, string.Format(
_localizationService.GetResource("FreeForUserGroupsOrHigher"),
groupName,
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug)));
}
else
{
result.Add(new Tuple <TblUserGroups, string>(discount.UserGroup, string.Format(
_localizationService.GetResource("FreeForUserGroups"),
groupName,
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug)));
}
}
else
{
if (discount.ApplyDiscountToHigherUserGroups)
{
result.Add(new Tuple <TblUserGroups, string>(discount.UserGroup, string.Format(
_localizationService.GetResource("DiscountForUserGroupsOrHigher"),
discount.DiscountPercent,
groupName,
price.ExchangeCurrencyStr(),
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug)));
}
else
{
result.Add(new Tuple <TblUserGroups, string>(discount.UserGroup, string.Format(
_localizationService.GetResource("DiscountForUserGroups"),
discount.DiscountPercent,
groupName,
price.ExchangeCurrencyStr(),
discount.UserGroup.Id,
discount.UserGroup.GroupPriority,
product.Id,
product.Slug)));
}
}
}
return(result);
}
