/// <summary>
/// Gets a measure weight by identifier
/// </summary>
/// <param name="measureWeightId">Measure weight identifier</param>
/// <returns>Measure weight</returns>
public static MeasureWeight GetMeasureWeightById(int measureWeightId)
{
if (measureWeightId == 0)
{
return(null);
}
string key = string.Format(MEASUREWEIGHTS_BY_ID_KEY, measureWeightId);
object obj2 = NopRequestCache.Get(key);
if (MeasureManager.CacheEnabled && (obj2 != null))
{
return((MeasureWeight)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from mw in context.MeasureWeights
where mw.MeasureWeightId == measureWeightId
select mw;
var measureWeight = query.SingleOrDefault();
if (MeasureManager.CacheEnabled)
{
NopRequestCache.Add(key, measureWeight);
}
return(measureWeight);
}
/// <summary>
/// Gets a discount collection of a category
/// </summary>
/// <param name="categoryId">Category identifier</param>
/// <returns>Discount collection</returns>
public static List <Discount> GetDiscountsByCategoryId(int categoryId)
{
bool showHidden = NopContext.Current.IsAdmin;
string key = string.Format(DISCOUNTS_BY_CATEGORYID_KEY, categoryId, showHidden);
object obj2 = NopRequestCache.Get(key);
if (DiscountManager.CacheEnabled && (obj2 != null))
{
return((List <Discount>)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from d in context.Discounts
from c in d.NpCategories
where (showHidden || (d.StartDate <= DateTime.UtcNow && d.EndDate >= DateTime.UtcNow)) &&
!d.Deleted &&
c.CategoryId == categoryId
orderby d.StartDate descending
select d;
var discounts = query.ToList();
if (DiscountManager.CacheEnabled)
{
NopRequestCache.Add(key, discounts);
}
return(discounts);
}
/// <summary>
/// Updates the shipping method
/// </summary>
/// <param name="shippingMethodId">The shipping method identifier</param>
/// <param name="name">The name</param>
/// <param name="description">The description</param>
/// <param name="displayOrder">The display order</param>
/// <returns>Shipping method</returns>
public static ShippingMethod UpdateShippingMethod(int shippingMethodId,
string name, string description, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
description = CommonHelper.EnsureMaximumLength(description, 2000);
var shippingMethod = GetShippingMethodById(shippingMethodId);
if (shippingMethod == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(shippingMethod))
{
context.ShippingMethods.Attach(shippingMethod);
}
shippingMethod.Name = name;
shippingMethod.Description = description;
shippingMethod.DisplayOrder = displayOrder;
context.SaveChanges();
if (ShippingMethodManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(SHIPPINGMETHODS_PATTERN_KEY);
}
return(shippingMethod);
}
/// <summary>
/// Updates the product template
/// </summary>
/// <param name="productTemplateId">The product template identifier</param>
/// <param name="name">The name</param>
/// <param name="templatePath">The template path</param>
/// <param name="displayOrder">The display order</param>
/// <param name="createdOn">The date and time of instance creation</param>
/// <param name="updatedOn">The date and time of instance update</param>
/// <returns>Product template</returns>
public static ProductTemplate UpdateProductTemplate(int productTemplateId,
string name, string templatePath, int displayOrder,
DateTime createdOn, DateTime updatedOn)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
templatePath = CommonHelper.EnsureMaximumLength(templatePath, 200);
var productTemplate = GetProductTemplateById(productTemplateId);
if (productTemplate == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(productTemplate))
{
context.ProductTemplates.Attach(productTemplate);
}
productTemplate.Name = name;
productTemplate.TemplatePath = templatePath;
productTemplate.DisplayOrder = displayOrder;
productTemplate.CreatedOn = createdOn;
productTemplate.UpdatedOn = updatedOn;
context.SaveChanges();
if (TemplateManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTTEMPLATES_PATTERN_KEY);
}
return(productTemplate);
}
/// <summary>
/// Removes a discount from a product variant
/// </summary>
/// <param name="productVariantId">Product variant identifier</param>
/// <param name="discountId">Discount identifier</param>
public static void RemoveDiscountFromProductVariant(int productVariantId, int discountId)
{
var productVariant = ProductManager.GetProductVariantById(productVariantId);
if (productVariant == null)
{
return;
}
var discount = GetDiscountById(discountId);
if (discount == null)
{
return;
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(productVariant))
{
context.ProductVariants.Attach(productVariant);
}
if (!context.IsAttached(discount))
{
context.Discounts.Attach(discount);
}
productVariant.NpDiscounts.Remove(discount);
context.SaveChanges();
if (DiscountManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(DISCOUNTS_PATTERN_KEY);
}
}
/// <summary>
/// Gets a category template
/// </summary>
/// <param name="categoryTemplateId">Category template identifier</param>
/// <returns>A category template</returns>
public static CategoryTemplate GetCategoryTemplateById(int categoryTemplateId)
{
if (categoryTemplateId == 0)
{
return(null);
}
string key = string.Format(CATEGORYTEMPLATES_BY_ID_KEY, categoryTemplateId);
object obj2 = NopRequestCache.Get(key);
if (TemplateManager.CacheEnabled && (obj2 != null))
{
return((CategoryTemplate)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from ct in context.CategoryTemplates
where ct.CategoryTemplateId == categoryTemplateId
select ct;
var categoryTemplate = query.SingleOrDefault();
if (TemplateManager.CacheEnabled)
{
NopRequestCache.Add(key, categoryTemplate);
}
return(categoryTemplate);
}
/// <summary>
/// Gets a product template
/// </summary>
/// <param name="productTemplateId">Product template identifier</param>
/// <returns>Product template</returns>
public static ProductTemplate GetProductTemplateById(int productTemplateId)
{
if (productTemplateId == 0)
{
return(null);
}
string key = string.Format(PRODUCTTEMPLATES_BY_ID_KEY, productTemplateId);
object obj2 = NopRequestCache.Get(key);
if (TemplateManager.CacheEnabled && (obj2 != null))
{
return((ProductTemplate)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pt in context.ProductTemplates
where pt.ProductTemplateId == productTemplateId
select pt;
var productTemplate = query.SingleOrDefault();
if (TemplateManager.CacheEnabled)
{
NopRequestCache.Add(key, productTemplate);
}
return(productTemplate);
}
/// <summary>
/// Gets a product variant attribute value
/// </summary>
/// <param name="productVariantAttributeValueId">Product variant attribute value identifier</param>
/// <returns>Product variant attribute value</returns>
public static ProductVariantAttributeValue GetProductVariantAttributeValueById(int productVariantAttributeValueId)
{
if (productVariantAttributeValueId == 0)
{
return(null);
}
string key = string.Format(PRODUCTVARIANTATTRIBUTEVALUES_BY_ID_KEY, productVariantAttributeValueId);
object obj2 = NopRequestCache.Get(key);
if (ProductAttributeManager.CacheEnabled && (obj2 != null))
{
return((ProductVariantAttributeValue)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pvav in context.ProductVariantAttributeValues
where pvav.ProductVariantAttributeValueId == productVariantAttributeValueId
select pvav;
var productVariantAttributeValue = query.SingleOrDefault();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.Add(key, productVariantAttributeValue);
}
return(productVariantAttributeValue);
}
/// <summary>
/// Inserts a product variant attribute value
/// </summary>
/// <param name="productVariantAttributeId">The product variant attribute mapping identifier</param>
/// <param name="name">The product variant attribute name</param>
/// <param name="priceAdjustment">The price adjustment</param>
/// <param name="weightAdjustment">The weight adjustment</param>
/// <param name="isPreSelected">The value indicating whether the value is pre-selected</param>
/// <param name="displayOrder">The display order</param>
/// <returns>Product variant attribute value</returns>
public static ProductVariantAttributeValue InsertProductVariantAttributeValue(int productVariantAttributeId,
string name, decimal priceAdjustment, decimal weightAdjustment,
bool isPreSelected, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
var context = ObjectContextHelper.CurrentObjectContext;
var productVariantAttributeValue = context.ProductVariantAttributeValues.CreateObject();
productVariantAttributeValue.ProductVariantAttributeId = productVariantAttributeId;
productVariantAttributeValue.Name = name;
productVariantAttributeValue.PriceAdjustment = priceAdjustment;
productVariantAttributeValue.WeightAdjustment = weightAdjustment;
productVariantAttributeValue.IsPreSelected = isPreSelected;
productVariantAttributeValue.DisplayOrder = displayOrder;
context.ProductVariantAttributeValues.AddObject(productVariantAttributeValue);
context.SaveChanges();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
}
return(productVariantAttributeValue);
}
/// <summary>
/// Inserts a product variant attribute mapping
/// </summary>
/// <param name="productVariantId">The product variant identifier</param>
/// <param name="productAttributeId">The product attribute identifier</param>
/// <param name="textPrompt">The text prompt</param>
/// <param name="isRequired">The value indicating whether the entity is required</param>
/// <param name="attributeControlType">The attribute control type</param>
/// <param name="displayOrder">The display order</param>
/// <returns>Product variant attribute mapping</returns>
public static ProductVariantAttribute InsertProductVariantAttribute(int productVariantId,
int productAttributeId, string textPrompt, bool isRequired, AttributeControlTypeEnum attributeControlType, int displayOrder)
{
textPrompt = CommonHelper.EnsureMaximumLength(textPrompt, 200);
var context = ObjectContextHelper.CurrentObjectContext;
var productVariantAttribute = context.ProductVariantAttributes.CreateObject();
productVariantAttribute.ProductVariantId = productVariantId;
productVariantAttribute.ProductAttributeId = productAttributeId;
productVariantAttribute.TextPrompt = textPrompt;
productVariantAttribute.IsRequired = isRequired;
productVariantAttribute.AttributeControlTypeId = (int)attributeControlType;
productVariantAttribute.DisplayOrder = displayOrder;
context.ProductVariantAttributes.AddObject(productVariantAttribute);
context.SaveChanges();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
}
return(productVariantAttribute);
}
/// <summary>
/// Deletes a product variant attribute value
/// </summary>
/// <param name="productVariantAttributeValueId">Product variant attribute value identifier</param>
public static void DeleteProductVariantAttributeValue(int productVariantAttributeValueId)
{
var productVariantAttributeValue = GetProductVariantAttributeValueById(productVariantAttributeValueId);
if (productVariantAttributeValue == null)
{
return;
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(productVariantAttributeValue))
{
context.ProductVariantAttributeValues.Attach(productVariantAttributeValue);
}
context.DeleteObject(productVariantAttributeValue);
context.SaveChanges();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
}
}
/// <summary>
/// Updates the product attribute
/// </summary>
/// <param name="productAttributeId">Product attribute identifier</param>
/// <param name="name">The name</param>
/// <param name="description">The description</param>
/// <returns>Product attribute </returns>
public static ProductAttribute UpdateProductAttribute(int productAttributeId,
string name, string description)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
description = CommonHelper.EnsureMaximumLength(description, 400);
var productAttribute = GetProductAttributeById(productAttributeId);
if (productAttribute == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(productAttribute))
{
context.ProductAttributes.Attach(productAttribute);
}
productAttribute.Name = name;
productAttribute.Description = description;
context.SaveChanges();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
}
return(productAttribute);
}
/// <summary>
/// Gets a measure dimension by identifier
/// </summary>
/// <param name="measureDimensionId">Measure dimension identifier</param>
/// <returns>Measure dimension</returns>
public static MeasureDimension GetMeasureDimensionById(int measureDimensionId)
{
if (measureDimensionId == 0)
{
return(null);
}
string key = string.Format(MEASUREDIMENSIONS_BY_ID_KEY, measureDimensionId);
object obj2 = NopRequestCache.Get(key);
if (MeasureManager.CacheEnabled && (obj2 != null))
{
return((MeasureDimension)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from md in context.MeasureDimensions
where md.MeasureDimensionId == measureDimensionId
select md;
var measureDimension = query.SingleOrDefault();
if (MeasureManager.CacheEnabled)
{
NopRequestCache.Add(key, measureDimension);
}
return(measureDimension);
}
/// <summary>
/// Updates the measure weight
/// </summary>
/// <param name="measureWeightId">Measure weight identifier</param>
/// <param name="name">The name</param>
/// <param name="systemKeyword">The system keyword</param>
/// <param name="ratio">The ratio</param>
/// <param name="displayOrder">The display order</param>
/// <returns>A measure weight</returns>
public static MeasureWeight UpdateMeasureWeight(int measureWeightId, string name,
string systemKeyword, decimal ratio, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
systemKeyword = CommonHelper.EnsureMaximumLength(systemKeyword, 100);
var weight = GetMeasureWeightById(measureWeightId);
if (weight == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(weight))
{
context.MeasureWeights.Attach(weight);
}
weight.Name = name;
weight.SystemKeyword = systemKeyword;
weight.Ratio = ratio;
weight.DisplayOrder = displayOrder;
context.SaveChanges();
if (MeasureManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(MEASUREWEIGHTS_PATTERN_KEY);
}
return(weight);
}
/// <summary>
/// Gets a checkout attribute value
/// </summary>
/// <param name="checkoutAttributeValueId">Checkout attribute value identifier</param>
/// <returns>Checkout attribute value</returns>
public static CheckoutAttributeValue GetCheckoutAttributeValueById(int checkoutAttributeValueId)
{
if (checkoutAttributeValueId == 0)
{
return(null);
}
string key = string.Format(CHECKOUTATTRIBUTEVALUES_BY_ID_KEY, checkoutAttributeValueId);
object obj2 = NopRequestCache.Get(key);
if (CheckoutAttributeManager.CacheEnabled && (obj2 != null))
{
return((CheckoutAttributeValue)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from cav in context.CheckoutAttributeValues
where cav.CheckoutAttributeValueId == checkoutAttributeValueId
select cav;
var checkoutAttributeValue = query.SingleOrDefault();
if (CheckoutAttributeManager.CacheEnabled)
{
NopRequestCache.Add(key, checkoutAttributeValue);
}
return(checkoutAttributeValue);
}
/// <summary>
/// Inserts a localized product variant attribute value
/// </summary>
/// <param name="productVariantAttributeValueId">Product variant attribute value identifier</param>
/// <param name="languageId">Language identifier</param>
/// <param name="name">Name text</param>
/// <returns>Localized product variant attribute value</returns>
public static ProductVariantAttributeValueLocalized InsertProductVariantAttributeValueLocalized(int productVariantAttributeValueId,
int languageId, string name)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
var context = ObjectContextHelper.CurrentObjectContext;
var productVariantAttributeValueLocalized = context.ProductVariantAttributeValueLocalized.CreateObject();
productVariantAttributeValueLocalized.ProductVariantAttributeValueId = productVariantAttributeValueId;
productVariantAttributeValueLocalized.LanguageId = languageId;
productVariantAttributeValueLocalized.Name = name;
context.ProductVariantAttributeValueLocalized.AddObject(productVariantAttributeValueLocalized);
context.SaveChanges();
if (ProductAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
}
return(productVariantAttributeValueLocalized);
}
/// <summary>
/// Inserts a checkout attribute value
/// </summary>
/// <param name="checkoutAttributeId">The checkout attribute identifier</param>
/// <param name="name">The checkout attribute name</param>
/// <param name="priceAdjustment">The price adjustment</param>
/// <param name="weightAdjustment">The weight adjustment</param>
/// <param name="isPreSelected">The value indicating whether the value is pre-selected</param>
/// <param name="displayOrder">The display order</param>
/// <returns>Checkout attribute value</returns>
public static CheckoutAttributeValue InsertCheckoutAttributeValue(int checkoutAttributeId,
string name, decimal priceAdjustment, decimal weightAdjustment,
bool isPreSelected, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
var context = ObjectContextHelper.CurrentObjectContext;
var checkoutAttributeValue = context.CheckoutAttributeValues.CreateObject();
checkoutAttributeValue.CheckoutAttributeId = checkoutAttributeId;
checkoutAttributeValue.Name = name;
checkoutAttributeValue.PriceAdjustment = priceAdjustment;
checkoutAttributeValue.WeightAdjustment = weightAdjustment;
checkoutAttributeValue.IsPreSelected = isPreSelected;
checkoutAttributeValue.DisplayOrder = displayOrder;
context.CheckoutAttributeValues.AddObject(checkoutAttributeValue);
context.SaveChanges();
if (CheckoutAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTEVALUES_PATTERN_KEY);
}
return(checkoutAttributeValue);
}
/// <summary>
/// Inserts a news item
/// </summary>
/// <param name="languageId">The language identifier</param>
/// <param name="title">The news title</param>
/// <param name="shortText">The short text</param>
/// <param name="fullText">The full text</param>
/// <param name="published">A value indicating whether the entity is published</param>
/// <param name="allowComments">A value indicating whether the entity allows comments</param>
/// <param name="createdOn">The date and time of instance creation</param>
/// <returns>News item</returns>
public static News InsertNews(int languageId, string title, string shortText,
string fullText, bool published, bool allowComments, DateTime createdOn)
{
title = CommonHelper.EnsureMaximumLength(title, 1000);
shortText = CommonHelper.EnsureMaximumLength(shortText, 4000);
var context = ObjectContextHelper.CurrentObjectContext;
var news = context.News.CreateObject();
news.LanguageId = languageId;
news.Title = title;
news.Short = shortText;
news.Full = fullText;
news.Published = published;
news.AllowComments = allowComments;
news.CreatedOn = createdOn;
context.News.AddObject(news);
context.SaveChanges();
if (NewsManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(NEWS_PATTERN_KEY);
}
return(news);
}
/// <summary>
/// Gets a manufacturer template
/// </summary>
/// <param name="manufacturerTemplateId">Manufacturer template identifier</param>
/// <returns>Manufacturer template</returns>
public static ManufacturerTemplate GetManufacturerTemplateById(int manufacturerTemplateId)
{
if (manufacturerTemplateId == 0)
{
return(null);
}
string key = string.Format(MANUFACTURERTEMPLATES_BY_ID_KEY, manufacturerTemplateId);
object obj2 = NopRequestCache.Get(key);
if (TemplateManager.CacheEnabled && (obj2 != null))
{
return((ManufacturerTemplate)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from mt in context.ManufacturerTemplates
where mt.ManufacturerTemplateId == manufacturerTemplateId
select mt;
var manufacturerTemplate = query.SingleOrDefault();
if (TemplateManager.CacheEnabled)
{
NopRequestCache.Add(key, manufacturerTemplate);
}
return(manufacturerTemplate);
}
/// <summary>
/// Gets a news
/// </summary>
/// <param name="newsId">The news identifier</param>
/// <returns>News</returns>
public static News GetNewsById(int newsId)
{
if (newsId == 0)
{
return(null);
}
string key = string.Format(NEWS_BY_ID_KEY, newsId);
object obj2 = NopRequestCache.Get(key);
if (NewsManager.CacheEnabled && (obj2 != null))
{
return((News)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from n in context.News
where n.NewsId == newsId
select n;
var news = query.SingleOrDefault();
if (NewsManager.CacheEnabled)
{
NopRequestCache.Add(key, news);
}
return(news);
}
/// <summary>
/// Inserts a product template
/// </summary>
/// <param name="name">The name</param>
/// <param name="templatePath">The template path</param>
/// <param name="displayOrder">The display order</param>
/// <param name="createdOn">The date and time of instance creation</param>
/// <param name="updatedOn">The date and time of instance update</param>
/// <returns>Product template</returns>
public static ProductTemplate InsertProductTemplate(string name, string templatePath,
int displayOrder, DateTime createdOn, DateTime updatedOn)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
templatePath = CommonHelper.EnsureMaximumLength(templatePath, 200);
var context = ObjectContextHelper.CurrentObjectContext;
var productTemplate = context.ProductTemplates.CreateObject();
productTemplate.Name = name;
productTemplate.TemplatePath = templatePath;
productTemplate.DisplayOrder = displayOrder;
productTemplate.CreatedOn = createdOn;
productTemplate.UpdatedOn = updatedOn;
context.ProductTemplates.AddObject(productTemplate);
context.SaveChanges();
if (TemplateManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(PRODUCTTEMPLATES_PATTERN_KEY);
}
return(productTemplate);
}
/// <summary>
/// Gets a country
/// </summary>
/// <param name="countryId">Country identifier</param>
/// <returns>Country</returns>
public static Country GetCountryById(int countryId)
{
if (countryId == 0)
{
return(null);
}
string key = string.Format(COUNTRIES_BY_ID_KEY, countryId);
object obj2 = NopRequestCache.Get(key);
if (CountryManager.CacheEnabled && (obj2 != null))
{
return((Country)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from c in context.Countries
where c.CountryId == countryId
select c;
var country = query.SingleOrDefault();
if (CountryManager.CacheEnabled)
{
NopRequestCache.Add(key, country);
}
return(country);
}
/// <summary>
/// Updates the discount
/// </summary>
/// <param name="discountId">Discount identifier</param>
/// <param name="discountType">The discount type</param>
/// <param name="discountRequirement">The discount requirement</param>
/// <param name="requirementSpentAmount">The discount requirement - applies if customer has spent/purchased x.xx amount</param>
/// <param name="requirementBillingCountryIs">The discount requirement - customer's billing country is... (used when requirement is set to "Billing country is")</param>
/// <param name="requirementShippingCountryIs">The discount requirement - customer's shipping country is... (used when requirement is set to "Shipping country is")</param>
/// <param name="discountLimitation">The discount limitation</param>
/// <param name="limitationTimes">The discount limitation times (used when Limitation is set to "N Times Only" or "N Times Per Customer")</param>
/// <param name="name">The name</param>
/// <param name="usePercentage">A value indicating whether to use percentage</param>
/// <param name="discountPercentage">The discount percentage</param>
/// <param name="discountAmount">The discount amount</param>
/// <param name="startDate">The discount start date and time</param>
/// <param name="endDate">The discount end date and time</param>
/// <param name="requiresCouponCode">The value indicating whether discount requires coupon code</param>
/// <param name="couponCode">The coupon code</param>
/// <param name="deleted">A value indicating whether the entity has been deleted</param>
/// <returns>Discount</returns>
public static Discount UpdateDiscount(int discountId, DiscountTypeEnum discountType,
DiscountRequirementEnum discountRequirement, decimal requirementSpentAmount,
int requirementBillingCountryIs, int requirementShippingCountryIs,
DiscountLimitationEnum discountLimitation, int limitationTimes,
string name, bool usePercentage,
decimal discountPercentage, decimal discountAmount,
DateTime startDate, DateTime endDate, bool requiresCouponCode,
string couponCode, bool deleted)
{
if (startDate.CompareTo(endDate) >= 0)
{
throw new NopException("Start date should be less then expiration date");
}
if (requiresCouponCode && String.IsNullOrEmpty(couponCode))
{
throw new NopException("Discount requires coupon code. Coupon code could not be empty.");
}
name = CommonHelper.EnsureMaximumLength(name, 100);
couponCode = CommonHelper.EnsureMaximumLength(couponCode, 100);
var discount = GetDiscountById(discountId);
if (discount == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(discount))
{
context.Discounts.Attach(discount);
}
discount.DiscountTypeId = (int)discountType;
discount.DiscountRequirementId = (int)discountRequirement;
discount.RequirementSpentAmount = requirementSpentAmount;
discount.RequirementBillingCountryIs = requirementBillingCountryIs;
discount.RequirementShippingCountryIs = requirementShippingCountryIs;
discount.DiscountLimitationId = (int)discountLimitation;
discount.LimitationTimes = limitationTimes;
discount.Name = name;
discount.UsePercentage = usePercentage;
discount.DiscountPercentage = discountPercentage;
discount.DiscountAmount = discountAmount;
discount.StartDate = startDate;
discount.EndDate = endDate;
discount.RequiresCouponCode = requiresCouponCode;
discount.CouponCode = couponCode;
discount.Deleted = deleted;
context.SaveChanges();
if (DiscountManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(DISCOUNTS_PATTERN_KEY);
}
return(discount);
}
/// <summary>
/// Inserts a country
/// </summary>
/// <param name="name">The name</param>
/// <param name="allowsRegistration">A value indicating whether registration is allowed to this country</param>
/// <param name="allowsBilling">A value indicating whether billing is allowed to this country</param>
/// <param name="allowsShipping">A value indicating whether shipping is allowed to this country</param>
/// <param name="twoLetterIsoCode">The two letter ISO code</param>
/// <param name="threeLetterIsoCode">The three letter ISO code</param>
/// <param name="numericIsoCode">The numeric ISO code</param>
/// <param name="subjectToVAT">A value indicating whether customers in this country must be charged EU VAT</param>
/// <param name="published">A value indicating whether the entity is published</param>
/// <param name="displayOrder">The display order</param>
/// <returns>Country</returns>
public static Country InsertCountry(string name,
bool allowsRegistration, bool allowsBilling, bool allowsShipping,
string twoLetterIsoCode, string threeLetterIsoCode, int numericIsoCode,
bool subjectToVAT, bool published, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
twoLetterIsoCode = CommonHelper.EnsureMaximumLength(twoLetterIsoCode, 2);
threeLetterIsoCode = CommonHelper.EnsureMaximumLength(threeLetterIsoCode, 3);
var context = ObjectContextHelper.CurrentObjectContext;
var country = context.Countries.CreateObject();
country.Name = name;
country.AllowsRegistration = allowsRegistration;
country.AllowsBilling = allowsBilling;
country.AllowsShipping = allowsShipping;
country.TwoLetterIsoCode = twoLetterIsoCode;
country.ThreeLetterIsoCode = threeLetterIsoCode;
country.NumericIsoCode = numericIsoCode;
country.SubjectToVAT = subjectToVAT;
country.Published = published;
country.DisplayOrder = displayOrder;
context.Countries.AddObject(country);
context.SaveChanges();
if (CountryManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(COUNTRIES_PATTERN_KEY);
}
return(country);
}
/// <summary>
/// Removes a discount from a category
/// </summary>
/// <param name="categoryId">Category identifier</param>
/// <param name="discountId">Discount identifier</param>
public static void RemoveDiscountFromCategory(int categoryId, int discountId)
{
var category = CategoryManager.GetCategoryById(categoryId);
if (category == null)
{
return;
}
var discount = GetDiscountById(discountId);
if (discount == null)
{
return;
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(category))
{
context.Categories.Attach(category);
}
if (!context.IsAttached(discount))
{
context.Discounts.Attach(discount);
}
category.NpDiscounts.Remove(discount);
context.SaveChanges();
if (DiscountManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(DISCOUNTS_PATTERN_KEY);
}
}
/// <summary>
/// Inserts a checkout attribute
/// </summary>
/// <param name="name">Name</param>
/// <param name="textPrompt">Text prompt</param>
/// <param name="isRequired">Value indicating whether the entity is required</param>
/// <param name="shippableProductRequired">Value indicating whether shippable products are required in order to display this attribute</param>
/// <param name="isTaxExempt">Value indicating whether the attribute is marked as tax exempt</param>
/// <param name="taxCategoryId">Tax category identifier</param>
/// <param name="attributeControlTypeId">Attribute control type identifier</param>
/// <param name="displayOrder">Display order</param>
/// <returns>Checkout attribute</returns>
public static CheckoutAttribute InsertCheckoutAttribute(string name,
string textPrompt, bool isRequired, bool shippableProductRequired,
bool isTaxExempt, int taxCategoryId, int attributeControlTypeId,
int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
textPrompt = CommonHelper.EnsureMaximumLength(textPrompt, 300);
var context = ObjectContextHelper.CurrentObjectContext;
var checkoutAttribute = context.CheckoutAttributes.CreateObject();
checkoutAttribute.Name = name;
checkoutAttribute.TextPrompt = textPrompt;
checkoutAttribute.IsRequired = isRequired;
checkoutAttribute.ShippableProductRequired = shippableProductRequired;
checkoutAttribute.IsTaxExempt = isTaxExempt;
checkoutAttribute.TaxCategoryId = taxCategoryId;
checkoutAttribute.AttributeControlTypeId = attributeControlTypeId;
checkoutAttribute.DisplayOrder = displayOrder;
context.CheckoutAttributes.AddObject(checkoutAttribute);
context.SaveChanges();
if (CheckoutAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTEVALUES_PATTERN_KEY);
}
return(checkoutAttribute);
}
/// <summary>
/// Gets a discount
/// </summary>
/// <param name="discountId">Discount identifier</param>
/// <returns>Discount</returns>
public static Discount GetDiscountById(int discountId)
{
if (discountId == 0)
{
return(null);
}
string key = string.Format(DISCOUNTS_BY_ID_KEY, discountId);
object obj2 = NopRequestCache.Get(key);
if (DiscountManager.CacheEnabled && (obj2 != null))
{
return((Discount)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from d in context.Discounts
where d.DiscountId == discountId
select d;
var discount = query.SingleOrDefault();
if (DiscountManager.CacheEnabled)
{
NopRequestCache.Add(key, discount);
}
return(discount);
}
/// <summary>
/// Inserts a localized checkout attribute
/// </summary>
/// <param name="checkoutAttributeId">Checkout attribute identifier</param>
/// <param name="languageId">Language identifier</param>
/// <param name="name">Name text</param>
/// <param name="textPrompt">Text prompt</param>
/// <returns>Checkout attribute content</returns>
public static CheckoutAttributeLocalized InsertCheckoutAttributeLocalized(int checkoutAttributeId,
int languageId, string name, string textPrompt)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
textPrompt = CommonHelper.EnsureMaximumLength(textPrompt, 300);
var context = ObjectContextHelper.CurrentObjectContext;
var checkoutAttributeLocalized = context.CheckoutAttributeLocalized.CreateObject();
checkoutAttributeLocalized.CheckoutAttributeId = checkoutAttributeId;
checkoutAttributeLocalized.LanguageId = languageId;
checkoutAttributeLocalized.Name = name;
checkoutAttributeLocalized.TextPrompt = textPrompt;
context.CheckoutAttributeLocalized.AddObject(checkoutAttributeLocalized);
context.SaveChanges();
if (CheckoutAttributeManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTES_PATTERN_KEY);
NopRequestCache.RemoveByPattern(CHECKOUTATTRIBUTEVALUES_PATTERN_KEY);
}
return(checkoutAttributeLocalized);
}
/// <summary>
/// Gets a shipping method
/// </summary>
/// <param name="shippingMethodId">The shipping method identifier</param>
/// <returns>Shipping method</returns>
public static ShippingMethod GetShippingMethodById(int shippingMethodId)
{
if (shippingMethodId == 0)
{
return(null);
}
string key = string.Format(SHIPPINGMETHODS_BY_ID_KEY, shippingMethodId);
object obj2 = NopRequestCache.Get(key);
if (ShippingMethodManager.CacheEnabled && (obj2 != null))
{
return((ShippingMethod)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from sm in context.ShippingMethods
where sm.ShippingMethodId == shippingMethodId
select sm;
var shippingMethod = query.SingleOrDefault();
if (ShippingMethodManager.CacheEnabled)
{
NopRequestCache.Add(key, shippingMethod);
}
return(shippingMethod);
}
/// <summary>
/// Updates the measure dimension
/// </summary>
/// <param name="measureDimensionId">Measure dimension identifier</param>
/// <param name="name">The name</param>
/// <param name="systemKeyword">The system keyword</param>
/// <param name="ratio">The ratio</param>
/// <param name="displayOrder">The display order</param>
/// <returns>A measure dimension</returns>
public static MeasureDimension UpdateMeasureDimension(int measureDimensionId,
string name, string systemKeyword, decimal ratio, int displayOrder)
{
name = CommonHelper.EnsureMaximumLength(name, 100);
systemKeyword = CommonHelper.EnsureMaximumLength(systemKeyword, 100);
var measure = GetMeasureDimensionById(measureDimensionId);
if (measure == null)
{
return(null);
}
var context = ObjectContextHelper.CurrentObjectContext;
if (!context.IsAttached(measure))
{
context.MeasureDimensions.Attach(measure);
}
measure.Name = name;
measure.SystemKeyword = systemKeyword;
measure.Ratio = ratio;
measure.DisplayOrder = displayOrder;
context.SaveChanges();
if (MeasureManager.CacheEnabled)
{
NopRequestCache.RemoveByPattern(MEASUREDIMENSIONS_PATTERN_KEY);
}
return(measure);
}
