private IEntitySet <Warehouse> GetWithJoin()
{
return(Repository.Join <Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Join <Country>("CountryId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <Warehouse, Address>())
.Relate <Country>((warehouse, country) => { warehouse.Address.Country = country; }));
}
private IEntitySet <Review> GetByWhere(Expression <Func <Review, bool> > where, Expression <Func <Review, object> > orderBy, RowOrder rowOrder)
{
Expression <Func <Product, bool> > productWhere = product => !product.ReviewsDisabled;
Expression <Func <SeoMeta, bool> > seoMetaWhere = meta => meta.EntityName == nameof(Product);
return(Repository.Join <User>("UserId", "Id", joinType: JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <SeoMeta>("Id", "EntityId", typeof(Product), JoinType.LeftOuter)
.Join <ProductMedia>("Id", "ProductId", typeof(Product), JoinType.LeftOuter)
.Join <Media>("MediaId", "Id", SourceColumn.Chained, JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <Review, User>())
.Relate(RelationTypes.OneToOne <Review, Product>())
.Relate <SeoMeta>((review, meta) => { review.Product.SeoMeta = meta; })
.Relate <Media>((review, media) =>
{
review.Product.MediaItems = review.Product.MediaItems ?? new List <Media>();
if (!review.Product.MediaItems.Contains(media))
{
review.Product.MediaItems.Add(media);
}
})
.OrderBy(orderBy, rowOrder)
.Where(where)
.Where(seoMetaWhere)
.Where(productWhere));
}
public override IEnumerable <OrderFulfillment> Get(Expression <Func <OrderFulfillment, bool> > @where, int page = 1, int count = Int32.MaxValue)
{
return(Repository.Join <OrderItem>("OrderItemId", "Id", joinType: JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductMedia>("Id", "ProductId", joinType: JoinType.LeftOuter)
.Join <Media>("MediaId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductVariant>("ProductVariantId", "Id", typeof(OrderItem), joinType: JoinType.LeftOuter)
.Join <WarehouseInventory>("WarehouseId", "WarehouseId", SourceColumn.Parent, joinType: JoinType.LeftOuter)
.Join <Warehouse>("WarehouseId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <OrderFulfillment, OrderItem>())
.Relate(RelationTypes.OneToOne <OrderFulfillment, Warehouse>())
.Relate <Address>((fulfillment, address) => { fulfillment.Warehouse.Address = address; })
.Relate <Product>((fulfillment, product) => { fulfillment.OrderItem.Product = product; })
.Relate <ProductVariant>((fulfillment, variant) =>
{
if (fulfillment.OrderItem.ProductVariantId > 0)
{
fulfillment.OrderItem.ProductVariant = variant;
}
})
.Relate(RelationTypes.OneToOne <OrderFulfillment, WarehouseInventory>((fulfillment, inventory) =>
{
IList <WarehouseInventory> inventories;
if (inventory.ProductVariantId > 0)
{
if (inventory.ProductVariant == null)
{
return;
}
fulfillment.OrderItem.ProductVariant.Inventories =
fulfillment.OrderItem.ProductVariant.Inventories ?? new List <WarehouseInventory>();
inventories = fulfillment.OrderItem.ProductVariant.Inventories;
}
else
{
fulfillment.OrderItem.Product.Inventories =
fulfillment.OrderItem.Product.Inventories ?? new List <WarehouseInventory>();
inventories = fulfillment.OrderItem.Product.Inventories;
}
if (!inventories.Contains(inventory))
{
inventories.Add(inventory);
}
}))
.Relate <Media>((fulfillment, media) =>
{
var product = fulfillment.OrderItem.Product;
product.MediaItems =
product.MediaItems ?? new List <Media>();
if (!product.MediaItems.Contains(media))
{
product.MediaItems.Add(media);
}
})
.Where(where)
.SelectNested(page, count));
}
public override IEnumerable <UiSlider> Get(Expression <Func <UiSlider, bool> > where, int page = 1, int count = Int32.MaxValue)
{
return(Repository.Join <Media>("MediaId", "Id")
.Relate(RelationTypes.OneToOne <UiSlider, Media>())
.OrderBy(x => x.DisplayOrder)
.Where(where)
.SelectNested(page, count));
}
public override OrderItem Get(int id)
{
return(Repository.Where(x => x.Id == id)
.Join <Order>("OrderId", "Id")
.Relate(RelationTypes.OneToOne <OrderItem, Order>())
.SelectNested()
.FirstOrDefault());
}
public UserCode GetUserCode(string code, UserCodeType userCodeType)
{
return(Repository.Where(x => x.Code == code && x.CodeType == userCodeType)
.Join <User>("UserId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <UserCode, User>())
.SelectNested()
.FirstOrDefault());
}
public override UiSlider Get(int id)
{
return(Repository.Join <Media>("MediaId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <UiSlider, Media>())
.Where(x => x.Id == id)
.SelectNested()
.FirstOrDefault());
}
IEntitySet <ContentPage> WithRelations(IEntitySet <ContentPage> query)
{
return(_eventPublisherService.Filter(query.Join <SeoMeta>("Id", "EntityId",
additionalExpression: (page, meta) => meta.EntityName == "ContentPage")
.Join <User>("UserId", "Id", SourceColumn.Parent)
.Relate(RelationTypes.OneToOne <ContentPage, SeoMeta>())
.Relate(RelationTypes.OneToOne <ContentPage, User>())));
}
public override IEnumerable <UserPoint> Get(out int totalResults, Expression <Func <UserPoint, bool> > @where, Expression <Func <UserPoint, object> > orderBy = null,
RowOrder rowOrder = RowOrder.Ascending, int page = 1, int count = Int32.MaxValue)
{
return(Repository.Join <User>("ActivatorUserId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <UserPoint, User>())
.Where(where)
.OrderBy(orderBy, rowOrder)
.SelectNestedWithTotalMatches(out totalResults, page, count));
}
public IEnumerable<Consent> GetConsents(out int totalResults, int consentGroupId, string searchText = null, int page = 1, int count = Int32.MaxValue)
{
var query = Repository.Where(x => x.ConsentGroupId == consentGroupId).Join<ConsentGroup>("ConsentGroupId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne<Consent, ConsentGroup>());
if (searchText.IsNullEmptyOrWhiteSpace())
query = query.Where(x => x.Title.Contains(searchText));
query = query.OrderBy(x => x.DisplayOrder);
return query.SelectWithTotalMatches(out totalResults, page, count);
}
public override IEnumerable <EmailMessage> Get(Expression <Func <EmailMessage, bool> > @where, int page = 1, int count = Int32.MaxValue)
{
return(Repository.Join <EmailAccount>("EmailAccountId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <EmailMessage, EmailAccount>())
.Where(where)
.OrderBy(x => x.Id)
.SelectNested(page, count));
}
public override Consent Get(int id)
{
return Repository.Join<ConsentGroup>("ConsentGroupId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne<Consent, ConsentGroup>())
.Where(x => x.Id == id)
.SelectNested()
.FirstOrDefault();
}
IEntitySet <ContentPage> WithRelations(IEntitySet <ContentPage> query)
{
Expression <Func <SeoMeta, bool> > seoMetaWhere = meta => meta.EntityName == "ContentPage";
return(query.Join <SeoMeta>("Id", "EntityId")
.Join <User>("UserId", "Id", SourceColumn.Parent)
.Relate(RelationTypes.OneToOne <ContentPage, SeoMeta>())
.Relate(RelationTypes.OneToOne <ContentPage, User>())
.Where(seoMetaWhere));
}
public override IEnumerable <Address> Get(Expression <Func <Address, bool> > @where, int page = 1, int count = int.MaxValue)
{
return(Repository.Where(where)
.Join <Country>("CountryId", "Id", joinType: JoinType.LeftOuter)
.Join <StateOrProvince>("StateProvinceId", "Id", SourceColumn.Parent, joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <Address, Country>())
.Relate(RelationTypes.OneToOne <Address, StateOrProvince>())
.OrderBy(x => x.Id)
.SelectNested(page, count));
}
public override Category Get(int id)
{
Expression <Func <SeoMeta, bool> > nameWhere = (meta) => meta.EntityName == "Category" && meta.EntityId == id;
return(Repository.Join <SeoMeta>("Id", "EntityId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <Category, SeoMeta>())
.Where(x => x.Id == id)
.Where(nameWhere)
.SelectNested()
.FirstOrDefault());
}
public override IEnumerable<Consent> Get(Expression<Func<Consent, bool>> @where, int page = 1, int count = Int32.MaxValue)
{
Expression<Func<ConsentGroup, object>> orderByConsentGroup = x => x.DisplayOrder;
return Repository.Join<ConsentGroup>("ConsentGroupId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne<Consent, ConsentGroup>((consent, group) =>
{
group.Consents = group.Consents ?? new List<Consent>();
group.Consents.Add(consent);
}))
.Where(where)
.OrderBy(x => x.DisplayOrder)
.OrderBy(orderByConsentGroup)
.SelectNested(page, count);}
public UserCode GetUserCode(int userId, UserCodeType userCodeType)
{
var userCode = Repository.Where(x => x.UserId == userId && x.CodeType == userCodeType)
.Join <User>("UserId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <UserCode, User>())
.SelectNested()
.FirstOrDefault() ?? new UserCode();
userCode.UserId = userId;
userCode.Code = userCodeType == UserCodeType.EmailOtp ? _cryptographyService.GetNumericCode(6) : Guid.NewGuid().ToString("D");
userCode.CodeType = userCodeType;
userCode.CreatedOn = DateTime.UtcNow;
InsertOrUpdate(userCode);
return(userCode);
}
public override EmailTemplate FirstOrDefault(Expression <Func <EmailTemplate, bool> > @where)
{
return(Repository.Join <EmailAccount>("EmailAccountId", "Id")
.Join <EmailTemplate>("ParentEmailTemplateId", "Id", typeof(EmailTemplate), JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <EmailTemplate, EmailAccount>())
.Relate <EmailTemplate>((template, emailTemplate) =>
{
if (template.ParentEmailTemplateId == emailTemplate.Id)
{
template.ParentEmailTemplate = emailTemplate;
}
})
.OrderBy(x => x.TemplateName)
.Where(where)
.SelectNested()
.FirstOrDefault());
}
public IEnumerable <WarehouseInventory> GetByProductVariants(IList <int> productVariantIds, int?warehouseId = null)
{
Expression <Func <WarehouseInventory, bool> > warehouseWhere = x => true;
if (warehouseId.HasValue)
{
warehouseWhere = x => x.WarehouseId == warehouseId;
}
return(Repository
.Join <Warehouse>("WarehouseId", "Id", joinType: JoinType.LeftOuter)
.Join <Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <WarehouseInventory, Warehouse>())
.Relate <Address>((inventory, address) => { inventory.Warehouse.Address = address; })
.Where(x => x.ProductVariantId != null && productVariantIds.Contains((int)x.ProductVariantId))
.Where(warehouseWhere)
.SelectNested());
}
public IList <Shipment> GetShipmentsByOrderId(int orderId)
{
Expression <Func <OrderItem, bool> > whereOrderIdMatches = item => item.OrderId == orderId;
return(Repository.Join <ShipmentItem>("Id", "ShipmentId", joinType: JoinType.LeftOuter)
.Join <OrderItem>("OrderItemId", "Id", joinType: JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", joinType: JoinType.LeftOuter)
.Join <ShipmentHistory>("Id", "ShipmentId", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Warehouse>("WarehouseId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <Shipment, ShipmentItem>())
.Relate(RelationTypes.OneToMany <Shipment, ShipmentHistory>())
.Relate <OrderItem>((shipment, item) =>
{
if (shipment.ShipmentItems == null)
{
return;
}
var shipmentItem = shipment.ShipmentItems.FirstOrDefault(x => x.OrderItemId == item.Id);
if (shipmentItem != null)
{
shipmentItem.OrderItem = item;
}
})
.Relate <Product>((shipment, product) =>
{
if (shipment.ShipmentItems == null)
{
return;
}
var shipmentItem =
shipment.ShipmentItems.FirstOrDefault(
x => x.OrderItem != null && x.OrderItem.ProductId == product.Id);
if (shipmentItem != null)
{
shipmentItem.OrderItem.Product = product;
}
})
.Relate(RelationTypes.OneToOne <Shipment, Warehouse>())
.Relate <Address>((shipment, address) => { shipment.Warehouse.Address = address; })
.Where(whereOrderIdMatches)
.SelectNested()
.ToList());
}
public IList <ProductSpecification> GetByProductId(int productId, int?groupId = null)
{
var query = Repository
.Join <ProductSpecificationGroup>("ProductSpecificationGroupId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductSpecificationValue>("Id", "ProductSpecificationId", SourceColumn.Parent,
JoinType.LeftOuter)
.Join <AvailableAttributeValue>("AvailableAttributeValueId", "Id", joinType: JoinType.LeftOuter)
.Join <AvailableAttribute>("AvailableAttributeId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <ProductSpecification, ProductSpecificationGroup>())
.Relate(RelationTypes.OneToMany <ProductSpecification, ProductSpecificationValue>())
.Relate <AvailableAttributeValue>((specification, value) =>
{
if (specification.Tag == null)
{
specification.Tag = new List <AvailableAttributeValue>();
}
var attributeList = (List <AvailableAttributeValue>)specification.Tag;
if (!attributeList.Contains(value))
{
attributeList.Add(value);
}
var pav = specification.ProductSpecificationValues.FirstOrDefault(
x => x.AvailableAttributeValueId == value.Id);
if (pav != null)
{
pav.AvailableAttributeValue = value;
}
})
.Relate <AvailableAttribute>((specification, availableAttribute) =>
{
availableAttribute.AvailableAttributeValues = (List <AvailableAttributeValue>)specification.Tag;
specification.AvailableAttribute = availableAttribute;
})
.Where(x => x.ProductId == productId)
.OrderBy(x => x.DisplayOrder);
if (groupId.HasValue)
{
query = query.Where(x => x.ProductSpecificationGroupId == groupId);
}
return(query.SelectNested().ToList());
}
public IList <Category> GetFullCategoryTree()
{
return(_cacheProvider.Get <IList <Category> >(CategoryTreeCacheKey, () =>
{
Expression <Func <SeoMeta, bool> > nameWhere = (meta) => meta.EntityName == "Category";
var allCategories = Repository.Join <SeoMeta>("Id", "EntityId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <Category, SeoMeta>())
.Where(nameWhere)
.SelectNested()
.ToList();
foreach (var category in allCategories)
{
MakeTree(category, allCategories);
}
return allCategories.ToList();
}));
}
private IEntitySet <ReturnRequest> GetWithJoin(bool withReturnOrder = false)
{
var query = Repository.Join <Order>("OrderId", "Id", joinType: JoinType.LeftOuter)
.Join <OrderItem>("OrderItemId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", typeof(OrderItem))
.Join <ProductMedia>("Id", "ProductId", joinType: JoinType.LeftOuter)
.Join <Media>("MediaId", "Id", joinType: JoinType.LeftOuter)
.Join <User>("UserId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Relate <Order>((request, order) =>
{
if (request.OrderId == order.Id)
{
request.Order = order;
}
if (request.ReturnOrderId == order.Id)
{
request.ReturnOrder = order;
}
})
.Relate(RelationTypes.OneToOne <ReturnRequest, OrderItem>((request, item) =>
{
request.Order.OrderItems = request.Order.OrderItems ?? new List <OrderItem>();
request.Order.OrderItems.Add(item);
}))
.Relate <Product>((request, product) => { request.OrderItem.Product = product; })
.Relate <Media>((request, media) =>
{
request.OrderItem.Product.MediaItems =
request.OrderItem.Product.MediaItems ?? new List <Media>();
request.OrderItem.Product.MediaItems.Add(media);
})
.Relate(RelationTypes.OneToOne <ReturnRequest, User>());
if (withReturnOrder)
{
query = query.Join <Order>("ReturnOrderId", "Id", SourceColumn.Parent, JoinType.LeftOuter);
}
return(query);
}
private Cart GetCart(int userId, bool isWishlist)
{
Expression <Func <SeoMeta, bool> > seoMetaWhere = meta => meta.EntityName == "Product";
Expression <Func <Product, bool> > productWhere = product => product.Published;
Expression <Func <Address, bool> > addressWhere = address => address.EntityName == null || address.EntityName == nameof(User);
var userCart = Repository.Where(x => x.UserId == userId && x.IsWishlist == isWishlist)
.Join <CartItem>("Id", "CartId", joinType: JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", joinType: JoinType.LeftOuter)
.Join <SeoMeta>("Id", "EntityId", joinType: JoinType.LeftOuter)
.Join <ProductMedia>("EntityId", "ProductId", joinType: JoinType.LeftOuter)
.Join <Media>("MediaId", "Id", joinType: JoinType.LeftOuter)
.Join <DiscountCoupon>("DiscountCouponId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <RestrictionValue>("Id", "DiscountCouponId", joinType: JoinType.LeftOuter)
.Join <User>("UserId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <UserRole>("Id", "UserId", joinType: JoinType.LeftOuter)
.Join <Role>("RoleId", "Id", joinType: JoinType.LeftOuter)
.Join <Address>("BillingAddressId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Country>("CountryId", "Id", joinType: JoinType.LeftOuter)
.Join <Address>("ShippingAddressId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Country>("CountryId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <Cart, CartItem>())
.Relate <Product>((cart, product) =>
{
var cartItem = cart.CartItems.FirstOrDefault(x => x.ProductId == product.Id && x.Product == null);
if (cartItem != null)
{
cartItem.Product = product;
}
})
.Relate <SeoMeta>((cart, meta) =>
{
var cartItem = cart.CartItems.FirstOrDefault(x => x.ProductId == meta.EntityId);
if (cartItem != null)
{
cartItem.Product.SeoMeta = meta;
}
})
.Relate <ProductMedia>((cart, media) =>
{
var cartItem = cart.CartItems.FirstOrDefault(x => x.ProductId == media.ProductId);
if (cartItem?.Product != null)
{
//temporary storage for media ids
cartItem.Tag = cartItem.Tag ?? new List <int>();
cartItem.Product.MediaItems = cartItem.Product.MediaItems ?? new List <Media>();
(cartItem.Tag as List <int>).Add(media.MediaId);
}
})
.Relate <Media>((cart, media) =>
{
var cartItem =
cart.CartItems.FirstOrDefault(
x => x.Tag != null && (x.Tag as List <int>).Contains(media.Id));
if (cartItem != null)
{
if (cartItem.Product.MediaItems.All(x => x.Id != media.Id))
{
cartItem.Product.MediaItems.Add(media);
}
}
})
.Relate(RelationTypes.OneToOne <Cart, DiscountCoupon>())
.Relate <RestrictionValue>((cart, value) =>
{
cart.DiscountCoupon.RestrictionValues =
cart.DiscountCoupon.RestrictionValues ?? new List <RestrictionValue>();
cart.DiscountCoupon.RestrictionValues.Add(value);
})
.Relate(RelationTypes.OneToOne <Cart, User>())
.Relate <Role>((cart, role) =>
{
cart.User.Roles = cart.User.Roles ?? new List <Role>();
cart.User.Roles.Add(role);
})
.Relate <Address>((cart, address) =>
{
if (cart.BillingAddressId == address.Id)
{
cart.BillingAddress = address;
}
if (cart.ShippingAddressId == address.Id)
{
cart.ShippingAddress = address;
}
})
.Relate <Country>((cart, country) =>
{
if (cart.BillingAddress?.CountryId == country.Id)
{
cart.BillingAddress.Country = country;
}
if (cart.ShippingAddress != null && cart.ShippingAddress?.CountryId == country.Id)
{
cart.ShippingAddress.Country = country;
}
})
.Where(seoMetaWhere)
.Where(productWhere)
.Where(addressWhere)
.SelectNested()
.FirstOrDefault();
//do we have an empty cart
userCart = userCart ?? Repository.Where(x => x.UserId == userId && x.IsWishlist == isWishlist).SelectSingle() ?? new Cart();
if (userCart.Id == 0)
{
//save a new cart for user
userCart.UserId = userId;
userCart.IsWishlist = isWishlist;
Insert(userCart);
}
return(userCart);
}
public override Shipment Get(int id)
{
Expression <Func <SeoMeta, bool> > where = meta => meta.EntityName == nameof(Product);
return(Repository.Where(x => x.Id == id)
.Join <ShipmentItem>("Id", "ShipmentId", joinType: JoinType.LeftOuter)
.Join <OrderItem>("OrderItemId", "Id", joinType: JoinType.LeftOuter)
.Join <Order>("OrderId", "Id", joinType: JoinType.LeftOuter)
.Join <ShipmentHistory>("Id", "ShipmentId", SourceColumn.Parent, JoinType.LeftOuter)
.Join <User>("UserId", "Id", typeof(Order), JoinType.LeftOuter)
.Join <Warehouse>("WarehouseId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", typeof(OrderItem), JoinType.LeftOuter)
.Join <SeoMeta>("Id", "EntityId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <Shipment, ShipmentItem>())
.Relate(RelationTypes.OneToMany <Shipment, ShipmentHistory>())
.Relate <OrderItem>((shipment, item) =>
{
var shipmentItem = shipment.ShipmentItems.FirstOrDefault(x => x.OrderItemId == item.Id);
if (shipmentItem != null)
{
shipmentItem.OrderItem = item;
}
})
.Relate <Order>((shipment, order) =>
{
var shipmentItem = shipment.ShipmentItems.FirstOrDefault(x => x.OrderItem.OrderId == order.Id);
if (shipmentItem == null)
{
return;
}
shipmentItem.OrderItem.Order = order;
order.OrderItems = order.OrderItems ?? new List <OrderItem>();
if (!order.OrderItems.Contains(shipmentItem.OrderItem))
{
order.OrderItems.Add(shipmentItem.OrderItem);
}
order.Shipments = order.Shipments ?? new List <Shipment>();
if (!order.Shipments.Contains(shipment))
{
order.Shipments.Add(shipment);
}
})
.Relate <User>((shipment, user) =>
{
shipment.User = user;
})
.Relate(RelationTypes.OneToOne <Shipment, Warehouse>())
.Relate <Address>((shipment, address) => { shipment.Warehouse.Address = address; })
.Relate <Product>((shipment, product) =>
{
foreach (var shipmentItem in shipment.ShipmentItems)
{
if (shipmentItem.OrderItem.ProductId == product.Id)
{
shipmentItem.OrderItem.Product = product;
}
}
})
.Relate <SeoMeta>((shipment, meta) =>
{
foreach (var shipmentItem in shipment.ShipmentItems)
{
if (shipmentItem.OrderItem.ProductId == meta.EntityId)
{
shipmentItem.OrderItem.Product.SeoMeta = meta;
}
}
})
.SelectNested()
.FirstOrDefault());
}
public IEnumerable <Order> GetOrders(out int totalResults, string productName = null, int?userId = null, int?storeId = null, IList <int> orderIds = null, IList <int> productIds = null, IList <OrderStatus> orderStatus = null, IList <PaymentStatus> paymentStatus = null, IList <int> vendorIds = null, DateTime?startDate = null, DateTime?endDate = null, int page = 1, int count = int.MaxValue)
{
var query = Repository;
//check one by one for each filter
if (userId.HasValue)
{
query = query.Where(x => x.UserId == userId);
}
if (storeId.HasValue)
{
query = query.Where(x => x.StoreId == storeId);
}
if (orderIds != null && orderIds.Any())
{
query = query.Where(x => orderIds.Contains(x.Id));
}
//date filters
if (startDate.HasValue)
{
query = query.Where(x => x.CreatedOn >= startDate);
}
if (endDate.HasValue)
{
query = query.Where(x => x.CreatedOn <= endDate);
}
query = query.Join <OrderItem>("Id", "OrderId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <Order, OrderItem>());
query = query.Join <Product>("ProductId", "Id", joinType: JoinType.LeftOuter)
.Relate <Product>((order, product) =>
{
foreach (var orderItem in order.OrderItems)
{
if (orderItem.ProductId == product.Id)
{
orderItem.Product = product;
}
}
});
if (productIds?.Any() ?? false)
{
Expression <Func <OrderItem, bool> > whereProductIdMatches = (orderItem) => productIds.Contains(orderItem.ProductId);
query = query.Where(whereProductIdMatches);
}
if (!productName.IsNullEmptyOrWhiteSpace() || (vendorIds?.Any() ?? false))
{
if (vendorIds?.Any() ?? false)
{
Expression <Func <ProductVendor, bool> > whereVendorIdMatches = (vendorItem) => vendorIds.Contains(vendorItem.VendorId);
query = query.Join <ProductVendor>("Id", "ProductId", joinType: JoinType.LeftOuter)
.Where(whereVendorIdMatches);
}
if (!productName.IsNullEmptyOrWhiteSpace())
{
Expression <Func <Product, bool> > whereProductName = product => product.Name.Contains(productName);
query = query.Where(whereProductName);
}
}
if (orderStatus != null && orderStatus.Any())
{
query = query.Where(x => orderStatus.Contains(x.OrderStatus));
}
if (paymentStatus != null && paymentStatus.Any())
{
query = query.Where(x => paymentStatus.Contains(x.PaymentStatus));
}
query = query.Join <User>("UserId", "Id", SourceColumn.Parent, JoinType.LeftOuter).Relate(RelationTypes.OneToOne <Order, User>());
; query = query.OrderBy(x => x.CreatedOn, RowOrder.Descending);
query.SkipColumns <Order>(nameof(Order.BillingAddressSerialized), nameof(Order.ShippingAddressSerialized), nameof(Order.Remarks));
query.SkipColumns <User>(nameof(User.Password), nameof(User.PasswordSalt), nameof(User.PasswordFormat));
var orders = query.SelectNestedWithTotalMatches(out totalResults, page, count);
return(orders);
}
public IEnumerable <OrderItem> GetWithProducts(IList <int> orderItemIds)
{
return(Repository.Where(x => orderItemIds.Contains(x.Id))
.Join <Product>("ProductId", "Id", joinType: JoinType.LeftOuter)
.Join <WarehouseInventory>("Id", "ProductId", joinType: JoinType.LeftOuter)
//.Join<Warehouse>("WarehouseId", "Id", joinType: JoinType.LeftOuter)
//.Join<Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductVariant>("ProductVariantId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <WarehouseInventory>("Id", "ProductVariantId", joinType: JoinType.LeftOuter)
.Join <Order>("OrderId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
//.Join<Warehouse>("WarehouseId", "Id", joinType: JoinType.LeftOuter)
//.Join<Address>("AddressId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <OrderItem, Product>())
.Relate(RelationTypes.OneToOne <OrderItem, ProductVariant>())
.Relate(RelationTypes.OneToOne <OrderItem, Order>((item, order) =>
{
order.OrderItems = order.OrderItems ?? new List <OrderItem>();
if (!order.OrderItems.Contains(item))
{
order.OrderItems.Add(item);
}
}))
.Relate <WarehouseInventory>((item, inventory) =>
{
if (item.ProductVariantId > 0)
{
item.ProductVariant.Inventories =
item.ProductVariant.Inventories ?? new List <WarehouseInventory>();
if (!item.ProductVariant.Inventories.Contains(inventory))
{
item.ProductVariant.Inventories.Add(inventory);
}
}
else
{
item.Product.Inventories =
item.Product.Inventories ?? new List <WarehouseInventory>();
if (!item.Product.Inventories.Contains(inventory))
{
item.Product.Inventories.Add(inventory);
}
}
})
/*.Relate<Warehouse>((item, warehouse) =>
* {
* var inventories = item.ProductVariantId > 0
* ? item.ProductVariant.Inventories
* : item.Product.Inventories;
* if (inventories != null)
* {
* foreach (var inventory in inventories.Where(x => x.WarehouseId == warehouse.Id))
* inventory.Warehouse = warehouse;
* }
* })
* .Relate<Address>((item, address) =>
* {
* var inventories = item.ProductVariantId > 0
* ? item.ProductVariant.Inventories
* : item.Product.Inventories;
* if (inventories != null)
* {
* foreach (var inventory in inventories.Where(x => x.Warehouse.AddressId == address.Id))
* inventory.Warehouse.Address = address;
* }
* })*/
.SelectNested());
}
private IEntitySet <ConsentLog> GetByWhere(Expression <Func <ConsentLog, bool> > where)
{
return(Repository.Where(where).Join <Consent>("ConsentId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToOne <ConsentLog, Consent>()));
}
private IEntitySet <Order> GetByWhere(Expression <Func <Order, bool> > where)
{
Expression <Func <SeoMeta, bool> > meteWhere = x => x.EntityName == "Product";
return(Repository.Where(where)
.Join <OrderItem>("Id", "OrderId", joinType: JoinType.LeftOuter)
.Join <ShipmentItem>("Id", "OrderItemId", joinType: JoinType.LeftOuter)
.Join <Shipment>("ShipmentId", "Id", joinType: JoinType.LeftOuter)
.Join <User>("UserId", "Id", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Product>("ProductId", "Id", typeof(OrderItem))
.Join <ProductMedia>("Id", "ProductId", joinType: JoinType.LeftOuter)
.Join <Media>("MediaId", "Id", joinType: JoinType.LeftOuter)
.Join <SeoMeta>("Id", "EntityId", typeof(Product))
.Relate(RelationTypes.OneToMany <Order, OrderItem>())
.Relate(RelationTypes.OneToMany <Order, Shipment>())
.Relate(RelationTypes.OneToOne <Order, User>())
.Relate <ShipmentItem>((order, shipmentItem) =>
{
var orderItem = order.OrderItems.First(x => x.Id == shipmentItem.OrderItemId);
orderItem.Shipment = order.Shipments.First(x => x.Id == shipmentItem.ShipmentId);
orderItem.Shipment.ShipmentItems = orderItem.Shipment.ShipmentItems ?? new List <ShipmentItem>();
if (!orderItem.Shipment.ShipmentItems.Contains(shipmentItem))
{
orderItem.Shipment.ShipmentItems.Add(shipmentItem);
shipmentItem.OrderItem = orderItem;
}
})
.Relate <Product>((order, product) =>
{
foreach (var orderItem in order.OrderItems)
{
if (orderItem.ProductId == product.Id)
{
orderItem.Product = product;
}
}
})
.Relate <ProductMedia>((order, media) =>
{
foreach (var orderItem in order.OrderItems)
{
if (orderItem.ProductId == media.ProductId)
{
orderItem.Product.Tag = media.MediaId;
}
}
})
.Relate <Media>((order, media) =>
{
foreach (var orderItem in order.OrderItems)
{
if ((int)orderItem.Product.Tag == media.Id)
{
orderItem.Product.MediaItems = orderItem.Product.MediaItems ?? new List <Media>();
if (!orderItem.Product.MediaItems.Contains(media))
{
orderItem.Product.MediaItems.Add(media);
}
}
}
})
.Relate <SeoMeta>((order, meta) =>
{
var orderItem = order.OrderItems.FirstOrDefault(x => x.ProductId == meta.EntityId);
if (orderItem != null)
{
orderItem.Product.SeoMeta = meta;
}
})
.Where(meteWhere));
}