public static List <BounceItem> GetBouncedListByHour(IRepoStrategy <hcc_Order> repo, long storeId,
DateTime rangeStart, DateTime rangeEnd, Guid?productGuid = null, Guid?categoryGuid = null)
{
var bouncedList = new List <BounceItem>();
var result = repo.ExecFunction <hcc_GetBouncedListByHour_Result>("GetBouncedListByHour",
new
{
storeId,
rangeStart,
rangeEnd,
productGuid,
categoryGuid
}
);
foreach (var item in result)
{
bouncedList.Add(new BounceItem
{
Day = item.Day.Value,
Hour = item.Hour.Value,
Amount = item.Count.Value
});
}
return(bouncedList);
}
protected IQueryable <JoinedItem <hcc_Category, hcc_CategoryTranslation> > GetSecureQueryForCurrentStore(
IRepoStrategy <hcc_Category> strategy, string parentId)
{
var parentGuid = DataTypeHelper.BvinToNullableGuid(parentId);
return
(GetSecureQueryForCurrentStore(strategy)
.Where(i => i.Item.ParentID == parentGuid || (!i.Item.ParentID.HasValue && !parentGuid.HasValue)));
}
public static IList <hcc_GetPromotionsActivityList_Result> GetPromotionsActivityList(
IRepoStrategy <hcc_Order> repo, long storeId, DateTime startDateUtc, DateTime endDateUtc)
{
return(repo.ExecFunction <hcc_GetPromotionsActivityList_Result>("GetPromotionsActivityList",
new
{
StoreId = storeId,
StartDateUtc = startDateUtc,
EndDateUtc = endDateUtc
}));
}
internal AffiliateReportHelper(DnnAffiliateRepository rep, IRepoStrategy <hcc_Affiliate> strategy,
AffiliateReportCriteria criteria, int pageNumber, int pageSize)
{
_rep = rep;
_strategy = strategy;
_criteria = criteria;
_pageNumber = pageNumber;
_pageSize = pageSize;
_storeId = _rep.Context.CurrentStore.Id;
_applyVATRules = _rep.Context.CurrentStore.Settings.ApplyVATRules;
}
protected override IQueryable <JoinedItem <hcc_Product, hcc_ProductTranslation> > GetSecureQuery(
IRepoStrategy <hcc_Product> strategy)
{
// -------------------------
// Keep synced logic in following functions:
// - DnnProductSearcher.SecurityFilterImpl
// - DnnProductRepository.GetSecureQuery
// -------------------------
var items = base.GetSecureQuery(strategy);
var pSett = DnnGlobal.Instance.GetCurrentPortalSettings();
var user = DnnUserController.Instance.GetCurrentUserInfo();
if (user == null)
{
return(items = items.Where(i =>
!i.Item.hcc_CatalogRoles.Any() &&
!i.Item.hcc_ProductXCategory.Any(pc => pc.hcc_Category.hcc_CatalogRoles.Any()) &&
!i.Item.hcc_ProductType.hcc_CatalogRoles.Any()));
}
if (user.IsSuperUser || user.IsInRole(pSett.AdministratorRoleName))
{
return(items);
}
return(items.Where(i =>
(!i.Item.hcc_CatalogRoles.Any() &&
!i.Item.hcc_ProductXCategory.Any(pc => pc.hcc_Category.hcc_CatalogRoles.Any()) &&
!i.Item.hcc_ProductType.hcc_CatalogRoles.Any()
) ||
(!i.Item.hcc_CatalogRoles.Any() &&
!i.Item.hcc_ProductXCategory.Any(pc => pc.hcc_Category.hcc_CatalogRoles.Any()) &&
i.Item.hcc_ProductType.hcc_CatalogRoles.Any(r => user.Roles.Contains(r.RoleName))
) ||
(!i.Item.hcc_CatalogRoles.Any() &&
i.Item.hcc_ProductXCategory.Any(
pc => pc.hcc_Category.hcc_CatalogRoles.Any(r => user.Roles.Contains(r.RoleName)))
) ||
i.Item.hcc_CatalogRoles.Any(r => user.Roles.Contains(r.RoleName))));
}
protected IQueryable <JoinedItem <T, TT> > GetJoinedQuery(IRepoStrategy <T> strategy,
Expression <Func <T, bool> > predicate = null, bool singleCulture = false)
{
var mainCulture = Context.MainContentCulture;
var fallbackCulture = Context.FallbackContentCulture;
var objSet = predicate == null?strategy.GetQuery() : strategy.GetQuery(predicate);
var translationSet =
strategy.GetQuery <TT>(
it => it.Culture == mainCulture || (!singleCulture && it.Culture == fallbackCulture));
return(objSet.GroupJoin(translationSet, ItemKeyExp, ItemTranslationKeyExp,
(i, it) =>
new JoinedItem <T, TT>
{
Item = i,
ItemTranslation = it.OrderBy(iit => iit.Culture == mainCulture ? 1 : 2).FirstOrDefault()
}));
}
protected override IQueryable <JoinedItem <hcc_Category, hcc_CategoryTranslation> > GetSecureQuery(
IRepoStrategy <hcc_Category> strategy)
{
var query = GetJoinedQuery(strategy);
var user = DnnUserController.Instance.GetCurrentUserInfo();
if (user == null)
{
return(query = query.Where(i => !i.Item.hcc_CatalogRoles.Any()));
}
if (DnnUserController.Instance.IsPortalAdmin(user))
{
return(query);
}
return(query.Where(i =>
!i.Item.hcc_CatalogRoles.Any() ||
i.Item.hcc_CatalogRoles.Any(r => user.Roles.Contains(r.RoleName))));
}
protected virtual IQueryable <JoinedItem <hcc_Category, hcc_CategoryTranslation> > GetSecureQueryForCurrentStore(
IRepoStrategy <hcc_Category> strategy)
{
return(GetSecureQuery(strategy).Where(i => i.Item.StoreId == Context.CurrentStore.Id));
}
protected virtual IQueryable <JoinedItem <hcc_Category, hcc_CategoryTranslation> > GetSecureQuery(
IRepoStrategy <hcc_Category> strategy)
{
return(GetJoinedQuery(strategy));
}
protected IQueryable <JoinedItem <hcc_Product, hcc_ProductTranslation> > GetSecureQueryForCurrentStore(
IRepoStrategy <hcc_Product> strategy)
{
return(GetSecureQuery(strategy).Where(i => i.Item.StoreId == Context.CurrentStore.Id));
}
protected IQueryable <JoinedItem <hcc_Product, hcc_ProductTranslation> > GetSecureQueryForStore(
IRepoStrategy <hcc_Product> strategy, long storeId)
{
return(GetSecureQuery(strategy).Where(i => i.Item.StoreId == storeId));
}
private IQueryable <JoinedItem <hcc_Product, hcc_ProductTranslation> > BuildCriteriaQuery(
ProductSearchCriteria criteria, IRepoStrategy <hcc_Product> s)
{
var items = GetSecureQueryForCurrentStore(s);
var categoryGuid = DataTypeHelper.BvinToNullableGuid(criteria.CategoryId);
var productTypeGuid = DataTypeHelper.BvinToNullableGuid(criteria.ProductTypeId);
var manufacturerGuid = DataTypeHelper.BvinToNullableGuid(criteria.ManufacturerId);
var vendorGuid = DataTypeHelper.BvinToNullableGuid(criteria.VendorId);
if (criteria.NotCategorized)
{
items = items.Where(y => !y.Item.hcc_ProductXCategory.Any());
}
else if (categoryGuid.HasValue)
{
items =
items.Where(
y =>
y.Item.hcc_ProductXCategory.Where(z => z.CategoryId == categoryGuid).FirstOrDefault() !=
null);
}
// Display Inactive
if (!criteria.DisplayInactiveProducts)
{
items = items.Where(y => y.Item.Status == 1);
}
// Display Bundles
if (!criteria.DisplayBundles)
{
items = items.Where(y => !y.Item.IsBundle);
}
// Display Recurring
if (!criteria.DisplayRecurring)
{
items = items.Where(y => !y.Item.IsRecurring);
}
// Display Gift Cards
if (!criteria.DisplayGiftCards)
{
items = items.Where(y => !y.Item.IsGiftCard);
}
// Status
if (criteria.Status != ProductStatus.NotSet)
{
items = items.Where(y => y.Item.Status == (int)criteria.Status);
}
// Inventory Status
if (criteria.InventoryStatus != ProductInventoryStatus.NotSet)
{
if (criteria.InventoryStatus == ProductInventoryStatus.Available)
{
// show products, excluding those that are not available due to inventory settings
items =
items.Where(
y =>
y.Item.IsAvailableForSale ||
y.Item.OutOfStockMode != (int)ProductInventoryMode.WhenOutOfStockHide);
}
else if (criteria.InventoryStatus == ProductInventoryStatus.NotAvailable)
{
// show only products that are not currently availabe in the store due to inventory settings
items =
items.Where(
y =>
!y.Item.IsAvailableForSale &&
y.Item.OutOfStockMode == (int)ProductInventoryMode.WhenOutOfStockHide);
}
else
{
// filter by products with inventory levels that are set (ignore zeroes)
items =
items.Where(
y =>
y.Item.hcc_ProductInventory.Where(
z =>
z.QuantityOnHand <= z.LowStockPoint &&
z.QuantityOnHand != 0 & z.LowStockPoint != 0).Any());
}
}
// Product Type
if (productTypeGuid.HasValue)
{
items = items.Where(y => y.Item.ProductTypeId == productTypeGuid);
}
// Manufacturer
if (manufacturerGuid.HasValue)
{
items = items.Where(y => y.Item.ManufacturerID == manufacturerGuid);
}
// Vendor
if (vendorGuid.HasValue)
{
items = items.Where(y => y.Item.VendorID == vendorGuid);
}
// Keywords
if (!string.IsNullOrEmpty(criteria.Keyword))
{
items = items.Where(y => y.Item.SKU.Contains(criteria.Keyword) ||
y.ItemTranslation.ProductName.Contains(criteria.Keyword) ||
y.ItemTranslation.MetaDescription.Contains(criteria.Keyword) ||
y.ItemTranslation.MetaKeywords.Contains(criteria.Keyword) ||
y.ItemTranslation.ShortDescription.Contains(criteria.Keyword) ||
y.ItemTranslation.LongDescription.Contains(criteria.Keyword) ||
y.ItemTranslation.Keywords.Contains(criteria.Keyword) ||
y.ItemTranslation.HiddenSearchKeywords.Contains(criteria.Keyword)
);
}
if (!criteria.DisplayProductWithChoice)
{
var optionQry = s.GetQuery <hcc_ProductXOption>();
items = items.Where(y => optionQry.Where(x => x.ProductBvin == y.Item.bvin).Count() <= 0)
.Where(
y =>
y.Item.hcc_BundledProducts.Where(
x => optionQry.Any(xx => xx.ProductBvin == x.BundledProductId)).Count() <= 0);
}
switch (criteria.CategorySort)
{
case CategorySortOrder.ProductName:
items = items.OrderBy(y => y.ItemTranslation.ProductName);
break;
case CategorySortOrder.ProductNameDescending:
items = items.OrderByDescending(y => y.ItemTranslation.ProductName);
break;
case CategorySortOrder.ProductPriceAscending:
items = items.OrderBy(y => y.Item.SitePrice);
break;
case CategorySortOrder.ProductPriceDescending:
items = items.OrderByDescending(y => y.Item.SitePrice);
break;
case CategorySortOrder.ProductSKUAscending:
items = items.OrderBy(y => y.Item.SKU);
break;
case CategorySortOrder.ProductSKUDescending:
items = items.OrderByDescending(y => y.Item.SKU);
break;
default:
if (categoryGuid.HasValue)
{
items =
items.OrderBy(
y =>
y.Item.hcc_ProductXCategory.Where(z => z.CategoryId == categoryGuid)
.Select(z => z.SortOrder)
.FirstOrDefault());
}
else
{
items = items.OrderBy(y => y.ItemTranslation.ProductName);
}
break;
}
return(items);
}
