/// <summary>
/// Gets a credit card type
/// </summary>
/// <param name="creditCardTypeId">Credit card type identifier</param>
/// <returns>Credit card type</returns>
public static CreditCardType GetCreditCardTypeById(int creditCardTypeId)
{
if (creditCardTypeId == 0)
{
return(null);
}
string key = string.Format(CREDITCARDS_BY_ID_KEY, creditCardTypeId);
object obj2 = NopRequestCache.Get(key);
if (CreditCardTypeManager.CacheEnabled && (obj2 != null))
{
return((CreditCardType)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from cct in context.CreditCardTypes
where cct.CreditCardTypeId == creditCardTypeId
select cct;
var creditCardType = query.SingleOrDefault();
if (CreditCardTypeManager.CacheEnabled)
{
NopRequestCache.Add(key, creditCardType);
}
return(creditCardType);
}
/// <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 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>
/// 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>
/// 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 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 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>
/// Gets a customer action by identifier
/// </summary>
/// <param name="customerActionId">Customer action identifier</param>
/// <returns>Customer action</returns>
public static CustomerAction GetCustomerActionById(int customerActionId)
{
if (customerActionId == 0)
{
return(null);
}
string key = string.Format(CUSTOMERACTIONS_BY_ID_KEY, customerActionId);
object obj2 = NopRequestCache.Get(key);
if (ACLManager.CacheEnabled && (obj2 != null))
{
return((CustomerAction)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from ca in context.CustomerActions
where ca.CustomerActionId == customerActionId
select ca;
var customerAction = query.SingleOrDefault();
if (ACLManager.CacheEnabled)
{
NopRequestCache.Add(key, customerAction);
}
return(customerAction);
}
/// <summary>
/// Gets a tax provider
/// </summary>
/// <param name="taxProviderId">Tax provider identifier</param>
/// <returns>Tax provider</returns>
public static TaxProvider GetTaxProviderById(int taxProviderId)
{
if (taxProviderId == 0)
{
return(null);
}
string key = string.Format(TAXPROVIDERS_BY_ID_KEY, taxProviderId);
object obj2 = NopRequestCache.Get(key);
if (TaxProviderManager.CacheEnabled && (obj2 != null))
{
return((TaxProvider)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from tp in context.TaxProviders
where tp.TaxProviderId == taxProviderId
select tp;
var taxProvider = query.SingleOrDefault();
if (TaxProviderManager.CacheEnabled)
{
NopRequestCache.Add(key, taxProvider);
}
return(taxProvider);
}
/// <summary>
/// Gets a shipping status by identifier
/// </summary>
/// <param name="shippingStatusId">Shipping status identifier</param>
/// <returns>Shipping status</returns>
public static ShippingStatus GetShippingStatusById(int shippingStatusId)
{
if (shippingStatusId == 0)
{
return(null);
}
string key = string.Format(SHIPPINGTATUSES_BY_ID_KEY, shippingStatusId);
object obj2 = NopRequestCache.Get(key);
if (ShippingStatusManager.CacheEnabled && (obj2 != null))
{
return((ShippingStatus)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from ss in context.ShippingStatuses
where ss.ShippingStatusId == shippingStatusId
select ss;
var shippingStatus = query.SingleOrDefault();
if (ShippingStatusManager.CacheEnabled)
{
NopRequestCache.Add(key, shippingStatus);
}
return(shippingStatus);
}
/// <summary>
/// Gets a state/province
/// </summary>
/// <param name="stateProvinceId">The state/province identifier</param>
/// <returns>State/province</returns>
public static StateProvince GetStateProvinceById(int stateProvinceId)
{
if (stateProvinceId == 0)
{
return(null);
}
string key = string.Format(STATEPROVINCES_BY_ID_KEY, stateProvinceId);
object obj2 = NopRequestCache.Get(key);
if (StateProvinceManager.CacheEnabled && (obj2 != null))
{
return((StateProvince)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from sp in context.StateProvinces
where sp.StateProvinceId == stateProvinceId
select sp;
var stateProvince = query.SingleOrDefault();
if (StateProvinceManager.CacheEnabled)
{
NopRequestCache.Add(key, stateProvince);
}
return(stateProvince);
}
/// <summary>
/// Gets a payment status by identifier
/// </summary>
/// <param name="paymentStatusId">payment status identifier</param>
/// <returns>Payment status</returns>
public static PaymentStatus GetPaymentStatusById(int paymentStatusId)
{
if (paymentStatusId == 0)
{
return(null);
}
string key = string.Format(PAYMENTSTATUSES_BY_ID_KEY, paymentStatusId);
object obj2 = NopRequestCache.Get(key);
if (PaymentStatusManager.CacheEnabled && (obj2 != null))
{
return((PaymentStatus)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from ps in context.PaymentStatuses
where ps.PaymentStatusId == paymentStatusId
select ps;
var paymentStatus = query.SingleOrDefault();
if (PaymentStatusManager.CacheEnabled)
{
NopRequestCache.Add(key, paymentStatus);
}
return(paymentStatus);
}
/// <summary>
/// Gets a payment method
/// </summary>
/// <param name="paymentMethodId">Payment method identifier</param>
/// <returns>Payment method</returns>
public static PaymentMethod GetPaymentMethodById(int paymentMethodId)
{
if (paymentMethodId == 0)
{
return(null);
}
string key = string.Format(PAYMENTMETHODS_BY_ID_KEY, paymentMethodId);
object obj2 = NopRequestCache.Get(key);
if (PaymentMethodManager.CacheEnabled && (obj2 != null))
{
return((PaymentMethod)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pm in context.PaymentMethods
where pm.PaymentMethodId == paymentMethodId
select pm;
var paymentMethod = query.SingleOrDefault();
if (PaymentMethodManager.CacheEnabled)
{
NopRequestCache.Add(key, paymentMethod);
}
return(paymentMethod);
}
/// <summary>
/// Gets a tax rate
/// </summary>
/// <param name="taxRateId">Tax rate identifier</param>
/// <returns>Tax rate</returns>
public static TaxRate GetTaxRateById(int taxRateId)
{
if (taxRateId == 0)
{
return(null);
}
string key = string.Format(TAXRATE_BY_ID_KEY, taxRateId);
object obj2 = NopRequestCache.Get(key);
if (TaxRateManager.CacheEnabled && (obj2 != null))
{
return((TaxRate)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from tr in context.TaxRates
where tr.TaxRateId == taxRateId
select tr;
var taxRate = query.SingleOrDefault();
if (TaxRateManager.CacheEnabled)
{
NopRequestCache.Add(key, taxRate);
}
return(taxRate);
}
/// <summary>
/// Gets a product category mapping
/// </summary>
/// <param name="productCategoryId">Product category mapping identifier</param>
/// <returns>Product category mapping</returns>
public static ProductCategory GetProductCategoryById(int productCategoryId)
{
if (productCategoryId == 0)
{
return(null);
}
string key = string.Format(PRODUCTCATEGORIES_BY_ID_KEY, productCategoryId);
object obj2 = NopRequestCache.Get(key);
if (CategoryManager.MappingsCacheEnabled && (obj2 != null))
{
return((ProductCategory)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pc in context.ProductCategories
where pc.ProductCategoryId == productCategoryId
select pc;
var productCategory = query.SingleOrDefault();
if (CategoryManager.MappingsCacheEnabled)
{
NopRequestCache.Add(key, productCategory);
}
return(productCategory);
}
/// <summary>
/// Gets a SMS provider
/// </summary>
/// <param name="smsProviderId">SMS provider identifier</param>
/// <returns>SMS provider</returns>
public static SMSProvider GetSMSProviderById(int smsProviderId)
{
if (smsProviderId == 0)
{
return(null);
}
string key = string.Format(SMSPROVIDERS_BY_ID_KEY, smsProviderId);
object obj2 = NopRequestCache.Get(key);
if (CacheEnabled && (obj2 != null))
{
return((SMSProvider)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from p in context.SMSProviders
where p.SMSProviderId == smsProviderId
select p;
var smsProvider = query.SingleOrDefault();
if (CacheEnabled)
{
NopRequestCache.Add(key, smsProvider);
}
return(smsProvider);
}
/// <summary>
/// Gets an activity log type item
/// </summary>
/// <param name="activityLogTypeId">Activity log type identifier</param>
/// <returns>Activity log type item</returns>
public static ActivityLogType GetActivityTypeById(int activityLogTypeId)
{
if (activityLogTypeId == 0)
{
return(null);
}
string key = string.Format(ACTIVITYTYPE_BY_ID_KEY, activityLogTypeId);
if (NopRequestCache.IsEnabled)
{
object cache = NopRequestCache.Get(key);
if (cache != null)
{
return((ActivityLogType)cache);
}
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from at in context.ActivityLogTypes
where at.ActivityLogTypeId == activityLogTypeId
select at;
var activityLogType = query.SingleOrDefault();
if (NopRequestCache.IsEnabled)
{
NopRequestCache.Add(key, activityLogType);
}
return(activityLogType);
}
/// <summary>
/// Gets a manufacturer
/// </summary>
/// <param name="manufacturerId">Manufacturer identifier</param>
/// <returns>Manufacturer</returns>
public static Manufacturer GetManufacturerById(int manufacturerId)
{
if (manufacturerId == 0)
{
return(null);
}
string key = string.Format(MANUFACTURERS_BY_ID_KEY, manufacturerId);
object obj2 = NopRequestCache.Get(key);
if (ManufacturerManager.ManufacturersCacheEnabled && (obj2 != null))
{
return((Manufacturer)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from m in context.Manufacturers
where m.ManufacturerId == manufacturerId
select m;
var manufacturer = query.SingleOrDefault();
if (ManufacturerManager.ManufacturersCacheEnabled)
{
NopRequestCache.Add(key, manufacturer);
}
return(manufacturer);
}
/// <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>
/// Gets a product manufacturer mapping collection
/// </summary>
/// <param name="productId">Product identifier</param>
/// <returns>Product manufacturer mapping collection</returns>
public static List <ProductManufacturer> GetProductManufacturersByProductId(int productId)
{
if (productId == 0)
{
return(new List <ProductManufacturer>());
}
bool showHidden = NopContext.Current.IsAdmin;
string key = string.Format(PRODUCTMANUFACTURERS_ALLBYPRODUCTID_KEY, showHidden, productId);
object obj2 = NopRequestCache.Get(key);
if (ManufacturerManager.MappingsCacheEnabled && (obj2 != null))
{
return((List <ProductManufacturer>)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pm in context.ProductManufacturers
join m in context.Manufacturers on pm.ManufacturerId equals m.ManufacturerId
where pm.ProductId == productId &&
!m.Deleted &&
(showHidden || m.Published)
orderby pm.DisplayOrder
select pm;
var productManufacturers = query.ToList();
if (ManufacturerManager.MappingsCacheEnabled)
{
NopRequestCache.Add(key, productManufacturers);
}
return(productManufacturers);
}
/// <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>
/// Gets a product manufacturer mapping
/// </summary>
/// <param name="productManufacturerId">Product manufacturer mapping identifier</param>
/// <returns>Product manufacturer mapping</returns>
public static ProductManufacturer GetProductManufacturerById(int productManufacturerId)
{
if (productManufacturerId == 0)
{
return(null);
}
string key = string.Format(PRODUCTMANUFACTURERS_BY_ID_KEY, productManufacturerId);
object obj2 = NopRequestCache.Get(key);
if (ManufacturerManager.MappingsCacheEnabled && (obj2 != null))
{
return((ProductManufacturer)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pm in context.ProductManufacturers
where pm.ProductManufacturerId == productManufacturerId
select pm;
var productManufacturer = query.SingleOrDefault();
if (ManufacturerManager.MappingsCacheEnabled)
{
NopRequestCache.Add(key, productManufacturer);
}
return(productManufacturer);
}
/// <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>
/// Gets an blog post
/// </summary>
/// <param name="blogPostId">Blog post identifier</param>
/// <returns>Blog post</returns>
public static BlogPost GetBlogPostById(int blogPostId)
{
if (blogPostId == 0)
{
return(null);
}
string key = string.Format(BLOGPOST_BY_ID_KEY, blogPostId);
object obj2 = NopRequestCache.Get(key);
if (BlogManager.CacheEnabled && (obj2 != null))
{
return((BlogPost)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from bp in context.BlogPosts
where bp.BlogPostId == blogPostId
select bp;
var blogPost = query.SingleOrDefault();
if (BlogManager.CacheEnabled)
{
NopRequestCache.Add(key, blogPost);
}
return(blogPost);
}
/// <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 specification attribute
/// </summary>
/// <param name="specificationAttributeId">The specification attribute identifier</param>
/// <returns>Specification attribute</returns>
public static SpecificationAttribute GetSpecificationAttributeById(int specificationAttributeId)
{
if (specificationAttributeId == 0)
{
return(null);
}
string key = string.Format(SPECIFICATIONATTRIBUTE_BY_ID_KEY, specificationAttributeId);
object obj2 = NopRequestCache.Get(key);
if (SpecificationAttributeManager.CacheEnabled && (obj2 != null))
{
return((SpecificationAttribute)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from sa in context.SpecificationAttributes
where sa.SpecificationAttributeId == specificationAttributeId
select sa;
var specificationAttribute = query.SingleOrDefault();
if (SpecificationAttributeManager.CacheEnabled)
{
NopRequestCache.Add(key, specificationAttribute);
}
return(specificationAttribute);
}
/// <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>
/// Gets a product category mapping collection
/// </summary>
/// <param name="productId">Product identifier</param>
/// <returns>Product category mapping collection</returns>
public static List <ProductCategory> GetProductCategoriesByProductId(int productId)
{
if (productId == 0)
{
return(new List <ProductCategory>());
}
bool showHidden = NopContext.Current.IsAdmin;
string key = string.Format(PRODUCTCATEGORIES_ALLBYPRODUCTID_KEY, showHidden, productId);
object obj2 = NopRequestCache.Get(key);
if (CategoryManager.MappingsCacheEnabled && (obj2 != null))
{
return((List <ProductCategory>)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from pc in context.ProductCategories
join c in context.Categories on pc.CategoryId equals c.CategoryId
where pc.ProductId == productId &&
!c.Deleted &&
(showHidden || c.Published)
orderby pc.DisplayOrder
select pc;
var productCategories = query.ToList();
if (CategoryManager.MappingsCacheEnabled)
{
NopRequestCache.Add(key, productCategories);
}
return(productCategories);
}
/// <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>
/// Gets a tax category
/// </summary>
/// <param name="taxCategoryId">Tax category identifier</param>
/// <returns>Tax category</returns>
public static TaxCategory GetTaxCategoryById(int taxCategoryId)
{
if (taxCategoryId == 0)
{
return(null);
}
string key = string.Format(TAXCATEGORIES_BY_ID_KEY, taxCategoryId);
object obj2 = NopRequestCache.Get(key);
if (TaxCategoryManager.CacheEnabled && (obj2 != null))
{
return((TaxCategory)obj2);
}
var context = ObjectContextHelper.CurrentObjectContext;
var query = from tc in context.TaxCategories
where tc.TaxCategoryId == taxCategoryId
select tc;
var taxCategory = query.SingleOrDefault();
if (TaxCategoryManager.CacheEnabled)
{
NopRequestCache.Add(key, taxCategory);
}
return(taxCategory);
}