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)); }