public ConsentGroup GetWithConsents(int consentGroupId)
{
Expression <Func <Consent, object> > orderBy = consent => consent.DisplayOrder;
var consentGroup = Repository.Join <Consent>("Id", "ConsentGroupId")
.Relate(RelationTypes.OneToMany <ConsentGroup, Consent>())
.Where(x => x.Id == consentGroupId)
.OrderBy(orderBy, RowOrder.Ascending)
.SelectNested()
.FirstOrDefault();
return(consentGroup);
}
public ClanRelations(Game.Clans clan, RelationTypes type)
{
switch (type)
{
case RelationTypes.None:
{
mData = new Byte[28 + 8];
WriteUInt16((UInt16)mData.Length, 0, mData);
WriteUInt16(1312, 2, mData);
WriteByte((Byte)type, 4, mData);
WriteByte((Byte)0, 16, mData);
break;
}
case RelationTypes.Allies:
{
mData = new Byte[28 + (clan.Allies.Count * 56) + 8];
WriteUInt16((UInt16)(mData.Length - 8), 0, mData);
WriteUInt16(1312, 2, mData);
WriteByte((Byte)type, 4, mData);
WriteByte((Byte)clan.Allies.Count, 16, mData);
foreach (Game.Clans clans in clan.Allies.Values)
{
WriteUInt16((UInt16)clans.ClanId, Offset, mData); Offset += 4;
WriteString(clans.ClanName, Offset, mData); Offset += 36;
WriteString(clans.ClanLider, Offset, mData); Offset += 16;
}
Offset = 20;
break;
}
case RelationTypes.Enemies:
{
mData = new Byte[28 + (clan.Enemies.Count * 56) + 8];
WriteUInt16((UInt16)(mData.Length - 8), 0, mData);
WriteUInt16(1312, 2, mData);
WriteByte((Byte)type, 4, mData);
WriteByte((Byte)clan.Enemies.Count, 16, mData);
foreach (Game.Clans clans in clan.Enemies.Values)
{
WriteUInt16((UInt16)clans.ClanId, Offset, mData); Offset += 4;
WriteString(clans.ClanName, Offset, mData); Offset += 36;
WriteString(clans.ClanLider, Offset, mData); Offset += 16;
}
Offset = 20;
break;
}
}
}
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 IList <ProductAttribute> GetByProductId(int productId, bool onlyVariantSpecific = false)
{
var q = Repository.Where(x => x.ProductId == productId)
.Join <AvailableAttribute>("AvailableAttributeId", "Id", joinType: JoinType.LeftOuter)
//.Join<Product>("ProductId", "Id")
.Join <ProductAttributeValue>("Id", "ProductAttributeId", SourceColumn.Parent,
joinType: JoinType.LeftOuter)
.Join <AvailableAttributeValue>("AvailableAttributeValueId", "Id", joinType: JoinType.LeftOuter);
//should we restrict to only variant specific attributes
if (onlyVariantSpecific)
{
var allowedInputTypes = VariantHelper.GetVariantSpecificFieldTypes();
Expression <Func <ProductAttribute, bool> > variantWhere =
attribute => allowedInputTypes.Contains(attribute.InputFieldType);
q.Where(variantWhere);
}
return(q
.Relate(RelationTypes.OneToMany <ProductAttribute, ProductAttributeValue>())
.Relate <AvailableAttributeValue>((productAttribute, availableAttributeValue) =>
{
if (productAttribute.Tag == null)
{
productAttribute.Tag = new List <AvailableAttributeValue>();
}
var attributeList = (List <AvailableAttributeValue>)productAttribute.Tag;
if (!attributeList.Contains(availableAttributeValue))
{
attributeList.Add(availableAttributeValue);
}
var pav = productAttribute.ProductAttributeValues.FirstOrDefault(
x => x.AvailableAttributeValueId == availableAttributeValue.Id);
if (pav != null)
{
pav.AvailableAttributeValue = availableAttributeValue;
}
})
.Relate <AvailableAttribute>((productAttribute, availableAttribute) =>
{
availableAttribute.AvailableAttributeValues = (List <AvailableAttributeValue>)productAttribute.Tag;
productAttribute.AvailableAttribute = availableAttribute;
})
.OrderBy(x => x.DisplayOrder)
.SelectNested()
.ToList());
}
public IEnumerable <AvailableAttribute> GetAvailableAttributes(out int totalResults, string searchText = null, int page = 1, int count = Int32.MaxValue)
{
var query = Repository;
if (!searchText.IsNullEmptyOrWhiteSpace())
{
query = query.Where(x => x.Name.Contains(searchText));
}
return(query.Join <AvailableAttributeValue>("Id", "AvailableAttributeId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <AvailableAttribute, AvailableAttributeValue>())
.OrderBy(x => x.Name)
.SelectNestedWithTotalMatches(out totalResults, page, count));
}
public ProductVariant GetByAttributeValueIds(IList <int> productAttributeValueIds)
{
//let's create a custom query here
var providerSpecificSelector = DatabaseManager.IsSqlServerProvider() ? "top 1" : "";
var variantIdFetcher =
$"select {providerSpecificSelector} productvariantid from productvariantattribute where productattributevalueid in ({string.Join(",", productAttributeValueIds)}) group by productvariantid HAVING COUNT(*) = {productAttributeValueIds.Count} order by count(*) desc";
string sql = "";
if (DatabaseManager.IsSqlServerProvider())
{
sql =
$"SELECT t2.[ProductVariantId] AS ProductVariantAttribute_ProductVariantId,t2.[ProductAttributeId] AS ProductVariantAttribute_ProductAttributeId,t2.[ProductAttributeValueId] AS ProductVariantAttribute_ProductAttributeValueId,t2.[Id] AS ProductVariantAttribute_Id,t3.[ProductId] AS ProductAttribute_ProductId,t3.[AvailableAttributeId] AS ProductAttribute_AvailableAttributeId,t3.[InputFieldType] AS ProductAttribute_InputFieldType,t3.[Label] AS ProductAttribute_Label,t3.[DisplayOrder] AS ProductAttribute_DisplayOrder,t3.[IsRequired] AS ProductAttribute_IsRequired,t3.[Id] AS ProductAttribute_Id,t4.[ProductAttributeId] AS ProductAttributeValue_ProductAttributeId,t4.[AvailableAttributeValueId] AS ProductAttributeValue_AvailableAttributeValueId,t4.[Label] AS ProductAttributeValue_Label,t4.[Id] AS ProductAttributeValue_Id,t5.[ProductId] AS WarehouseInventory_ProductId,t5.[ProductVariantId] AS WarehouseInventory_ProductVariantId,t5.[WarehouseId] AS WarehouseInventory_WarehouseId,t5.[TotalQuantity] AS WarehouseInventory_TotalQuantity,t5.[ReservedQuantity] AS WarehouseInventory_ReservedQuantity,t5.[Id] AS WarehouseInventory_Id,t1.[ProductId] AS ProductVariant_ProductId,t1.[Sku] AS ProductVariant_Sku,t1.[Gtin] AS ProductVariant_Gtin,t1.[Mpn] AS ProductVariant_Mpn,t1.[Price] AS ProductVariant_Price,t1.[ComparePrice] AS ProductVariant_ComparePrice,t1.[TrackInventory] AS ProductVariant_TrackInventory,t1.[CanOrderWhenOutOfStock] AS ProductVariant_CanOrderWhenOutOfStock,t1.[MediaId] AS ProductVariant_MediaId,t1.[Id] AS ProductVariant_Id FROM (SELECT [ProductId],[Sku],[Gtin],[Mpn],[Price],[ComparePrice],[TrackInventory],[CanOrderWhenOutOfStock],[MediaId],[Id] FROM [ProductVariant] t1) AS t1 LEFT OUTER JOIN [ProductVariantAttribute] t2 ON t1.[Id] = t2.[ProductVariantId] LEFT OUTER JOIN [ProductAttribute] t3 ON t2.[ProductAttributeId] = t3.[Id] LEFT OUTER JOIN [ProductAttributeValue] t4 ON t3.[Id] = t4.[ProductAttributeId] LEFT OUTER JOIN [WarehouseInventory] t5 ON t1.[Id] = t5.[ProductVariantId] WHERE t1.[Id] IN ({variantIdFetcher})";
}
else
{
sql =
$"SELECT t2.`ProductVariantId` AS ProductVariantAttribute_ProductVariantId,t2.`ProductAttributeId` AS ProductVariantAttribute_ProductAttributeId,t2.`ProductAttributeValueId` AS ProductVariantAttribute_ProductAttributeValueId,t2.`Id` AS ProductVariantAttribute_Id,t3.`ProductId` AS ProductAttribute_ProductId,t3.`AvailableAttributeId` AS ProductAttribute_AvailableAttributeId,t3.`InputFieldType` AS ProductAttribute_InputFieldType,t3.`Label` AS ProductAttribute_Label,t3.`DisplayOrder` AS ProductAttribute_DisplayOrder,t3.`IsRequired` AS ProductAttribute_IsRequired,t3.`Id` AS ProductAttribute_Id,t4.`ProductAttributeId` AS ProductAttributeValue_ProductAttributeId,t4.`AvailableAttributeValueId` AS ProductAttributeValue_AvailableAttributeValueId,t4.`Label` AS ProductAttributeValue_Label,t4.`Id` AS ProductAttributeValue_Id,t5.`ProductId` AS WarehouseInventory_ProductId,t5.`ProductVariantId` AS WarehouseInventory_ProductVariantId,t5.`WarehouseId` AS WarehouseInventory_WarehouseId,t5.`TotalQuantity` AS WarehouseInventory_TotalQuantity,t5.`ReservedQuantity` AS WarehouseInventory_ReservedQuantity,t5.`Id` AS WarehouseInventory_Id,t1.`ProductId` AS ProductVariant_ProductId,t1.`Sku` AS ProductVariant_Sku,t1.`Gtin` AS ProductVariant_Gtin,t1.`Mpn` AS ProductVariant_Mpn,t1.`Price` AS ProductVariant_Price,t1.`ComparePrice` AS ProductVariant_ComparePrice,t1.`TrackInventory` AS ProductVariant_TrackInventory,t1.`CanOrderWhenOutOfStock` AS ProductVariant_CanOrderWhenOutOfStock,t1.`MediaId` AS ProductVariant_MediaId,t1.`Id` AS ProductVariant_Id FROM (SELECT `ProductId`,`Sku`,`Gtin`,`Mpn`,`Price`,`ComparePrice`,`TrackInventory`,`CanOrderWhenOutOfStock`,`MediaId`,`Id` FROM `ProductVariant` t1) AS t1 LEFT OUTER JOIN `ProductVariantAttribute` t2 ON t1.`Id` = t2.`ProductVariantId` LEFT OUTER JOIN `ProductAttribute` t3 ON t2.`ProductAttributeId` = t3.`Id` LEFT OUTER JOIN `ProductAttributeValue` t4 ON t3.`Id` = t4.`ProductAttributeId` LEFT OUTER JOIN `WarehouseInventory` t5 ON t1.`Id` = t5.`ProductVariantId` WHERE t1.`Id` IN ({variantIdFetcher})";
}
var variant = Repository
.Join <ProductVariantAttribute>("Id", "ProductVariantId", joinType: JoinType.LeftOuter)
.Join <ProductAttribute>("ProductAttributeId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductAttributeValue>("Id", "ProductAttributeId", joinType: JoinType.LeftOuter)
.Join <WarehouseInventory>("Id", "ProductVariantId", SourceColumn.Parent, joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <ProductVariant, ProductVariantAttribute>())
.Relate <ProductAttribute>((productVariant, attribute) =>
{
var pva = productVariant.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttributeId == attribute.Id);
if (pva != null)
{
pva.ProductAttribute = attribute;
}
})
.Relate <ProductAttributeValue>((productVariant, value) =>
{
var pva = productVariant.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttributeValueId == value.Id);
if (pva != null)
{
pva.ProductAttributeValue = value;
}
})
.Relate(RelationTypes.OneToMany <ProductVariant, WarehouseInventory>())
.QueryNested(sql)
.FirstOrDefault();
return(variant);
}
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 async Task <Result> MakeRelation(int personID, int targetID, RelationTypes type)
{
try
{
var person = await _peopleDomainService.GetPerson(personID);
var relativePerson = await _peopleDomainService.GetPerson(targetID);
person.AddRelatedPerson(relativePerson, type);
return(await _peopleDomainService.UpdatePerson(personID, person));
}
catch (Exception ex)
{
return(new Result(-1, false, ex.Message));
}
}
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 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 virtual List <Member> GetSelfMemberships(Center center, RelationTypes relationType, bool?isArchive = null)
{
//var = new IField[0];
var centerTypeId = _centerService
.GetDefaultQuery()
.Where(p => p.Id == center.Id)
.Select(p => p.CenterTypeId)
.FirstOrDefault();
var relationRule = _relationRuleService
.GetDefaultQuery()
.Where(p => p.RelationTypeId == (int)relationType)
.FirstOrDefault();
var memberService = _memberService;
if (relationRule.CenterTypeId1 == centerTypeId && relationRule.CenterTypeId2 == centerTypeId)
{
return(memberService
.GetDefaultQuery()
.Where(p => p.RelatedTypeId == (int)relationType && (p.CenterId1 == center.Id || p.CenterId2 == center.Id))
.Where(p => isArchive.HasValue && p.IsArchive == isArchive.Value)
.ToList());
}
else if (relationRule.CenterTypeId1 == centerTypeId)
{
return(memberService
.GetDefaultQuery()
.Where(p => p.RelatedTypeId == (int)relationType && p.CenterId1 == center.Id)
.Where(p => isArchive.HasValue && p.IsArchive == isArchive.Value)
.ToList());
}
else if (relationRule.CenterTypeId2 == centerTypeId)
{
return(memberService
.GetDefaultQuery()
.Where(p => p.RelatedTypeId == (int)relationType && (p.CenterId1 == center.Id || p.CenterId2 == center.Id))
.Where(p => isArchive.HasValue && p.IsArchive == isArchive.Value)
.ToList());
}
else
{
return(new List <Member>());
}
}
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 <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 <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 <Menu> GetByWhere(Expression <Func <Menu, bool> > @where)
{
Expression <Func <MenuItem, object> > orderBy = x => x.DisplayOrder;
return(_eventPublisherService.Filter(Repository
.Join <MenuItem>("Id", "MenuId", joinType: JoinType.LeftOuter)
.Join <SeoMeta>("SeoMetaId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <Menu, MenuItem>())
.Relate <SeoMeta>((menu, meta) =>
{
var menuItems = menu.MenuItems.Where(x => x.SeoMetaId == meta.Id);
foreach (var menuItem in menuItems)
{
menuItem.SeoMeta = meta;
}
})
.Where(where)
.OrderBy(orderBy, RowOrder.Ascending)));
}
public IList <User> GetUsers(string searchText, int[] restrictToRoles, Expression <Func <User, object> > orderBy, SortOrder sortOrder, int page, int count, out int totalMatches, bool negateRoleRestriction = false, Expression <Func <User, bool> > where = null)
{
var query = Repository
.Where(x => !x.Deleted)
.Join <UserRole>("Id", "UserId", joinType: JoinType.LeftOuter)
.Join <Role>("RoleId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <User, Role>());
if (!searchText.IsNullEmptyOrWhiteSpace())
{
searchText = searchText.Trim();
query = query.Where(x => x.FirstName.Contains(searchText) ||
x.LastName.Contains(searchText) ||
x.LastLoginIpAddress.Contains(searchText) ||
x.Email.Contains(searchText));
}
if (restrictToRoles != null && restrictToRoles.Any())
{
var roleIds = restrictToRoles.ToList();
Expression <Func <Role, bool> > roleWhere;
if (negateRoleRestriction)
{
roleWhere = role => !roleIds.Contains(role.Id);
}
else
{
roleWhere = role => roleIds.Contains(role.Id);
}
query = query.Where(roleWhere);
}
if (orderBy == null)
{
orderBy = x => x.Name;
}
if (where != null)
{
query = query.Where(where);
}
query = query.OrderBy(orderBy, sortOrder == SortOrder.Ascending ? RowOrder.Ascending : RowOrder.Descending);
return(query.SelectNestedWithTotalMatches(out totalMatches, page, count).ToList());
}
public void AddRelatedPerson(Person rp, RelationTypes type)
{
var relPerson = new RelatedPerson
{
BirthDate = rp.BirthDate,
City = rp.City,
CityID = rp.CityID,
FirstName = rp.FirstName,
Gender = rp.Gender,
ImageUrl = rp.ImageUrl,
ID = rp.ID,
LastName = rp.LastName,
PersonalNumber = rp.PersonalNumber,
PhoneNumber = rp.PhoneNumber.Number.Value,
PhoneNumberType = rp.PhoneNumber.PhoneNumberType,
RelationType = type
};
_relatedPeople.Add(relPerson);
//TODO: VALIDATIOn
}
/// <summary>
/// Sammelt die Namen der in <paramref name="relationType"/> gesetzten Flags in
/// <paramref name="list"/>. <paramref name="list"/> wird von der Methode nicht
/// geleert.
/// </summary>
/// <param name="relationType"><see cref="RelationTypes"/>-Objekt oder <c>null</c>.</param>
/// <param name="list">Eine Liste zum sammeln.</param>
internal static void CollectValueStrings(RelationTypes?relationType, List <string> list)
{
Debug.Assert(list != null);
if (!relationType.HasValue)
{
return;
}
RelationTypes value = relationType.Value & RelationTypesConverter.DEFINED_RELATION_TYPES_VALUES;
for (int i = RelationTypesConverter.RelationTypesMinBit; i <= RelationTypesConverter.RelationTypesMaxBit; i++)
{
RelationTypes flag = (RelationTypes)(1 << i);
if (value.HasFlag(flag))
{
list.Add(flag.ToVcfString());
}
}
}
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);
}
public virtual List <MembershipEntity> GetMemberships(int centerId, RelationTypes relationType, bool?isArchive, bool includeAdditionalInfo)
{
//var = new IField[0];
var memberService = _memberService;
var centerService = _centerService;
var relationTypeService = _relationTypeService;
var relationRuleService = _relationRuleService;
//centerService.MakeFriend(memberService);
//relationTypeService.MakeFriend(memberService);
//relationRuleService.MakeFriend(relationTypeService);
var result = from m in memberService.GetDefaultQuery()
join c1 in centerService.GetDefaultQuery() on m.CenterId1 equals c1.Id
join c2 in centerService.GetDefaultQuery() on m.CenterId2 equals c2.Id
join rt in relationTypeService.GetDefaultQuery() on m.RelatedTypeId equals rt.Id
join rr in relationRuleService.GetDefaultQuery() on rt.Id equals rr.RelationTypeId
where ((c1.Id == centerId && c1.CenterTypeId == rr.CenterTypeId1) ||
(c2.Id == centerId && c2.CenterTypeId == rr.CenterTypeId2)) &&
(rt.Id == (int)relationType || (int)relationType == (int)RelationTypes.None) &&
((isArchive.HasValue && m.IsArchive == isArchive.Value) || !isArchive.HasValue)
select new MembershipEntity
{
MemberId = m.Id,
SelfCenterId = c1.Id == centerId ? c1.Id : c2.Id,
SelfCenterTitle = c1.Id == centerId ? c1.Title : c2.Title,
SelfCenterIndex = c1.Id == centerId ? 1 : 2,
CenterId = c1.Id == centerId ? c2.Id : c1.Id,
CenterTitle = c1.Id == centerId ? c2.Title : c1.Title,
FromDate = m.FromDate,
ToDate = m.ToDate,
IsArchive = m.IsArchive,
RelationTypeId = (int)relationType,
RelationTypeTitle = rt.Title,
RelationTypeFarsiTitle = rt.FarsiTitle,
AdditionalInfo = includeAdditionalInfo ? m.AdditionalInfo : null,
OrderNo = m.OrderNo
};
return(result.ToList());
}
public IEntitySet <T> Filter(IEntitySet <T> entity)
{
var entityName = typeof(T).Name;
Expression <Func <EntityStore, bool> > storeWhere = x => true;
if (!_alwaysAllTypes.Contains(typeof(T)))
{
//restrict to current store
var storeId = ApplicationEngine.CurrentStore?.Id ?? 0;
var allowedStoreIds = new List <int> {
storeId, 0
};
storeWhere = store => store.StoreId == null || allowedStoreIds.Contains(store.StoreId);
}
entity.Join <EntityStore>("Id", "EntityId", SourceColumn.Parent, JoinType.LeftOuter, (storeEntity, store) =>
store.EntityName == entityName)
.Join <Store>("StoreId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <T, Store>())
.Where(storeWhere);
return(entity);
}
public virtual IQueryable <MembershipTwoEntity> GetQueryableMemberships(RelationTypes relationType, bool?isArchive, bool includeAdditionalInfo)
{
//var = new IField[0];
var memberService = _memberService;
var centerService = _centerService;
var relationTypeService = _relationTypeService;
var relationRuleService = _relationRuleService;
//centerService.MakeFriend(memberService);
//relationTypeService.MakeFriend(centerService);
//if (service != null)
// service.MakeFriend(memberService);
var result = from m in memberService.GetDefaultQuery()
join c1 in centerService.GetDefaultQuery() on m.CenterId1 equals c1.Id
join c2 in centerService.GetDefaultQuery() on m.CenterId2 equals c2.Id
join rt in relationTypeService.GetDefaultQuery() on m.RelatedTypeId equals rt.Id
where (m.RelatedTypeId == (int)relationType || (int)relationType == (int)RelationTypes.None) &&
((isArchive.HasValue && m.IsArchive == isArchive.Value) || !isArchive.HasValue)
select new MembershipTwoEntity
{
MemberId = m.Id,
CenterId1 = c1.Id,
CenterTitle1 = c1.Title,
CenterId2 = c2.Id,
CenterTitle2 = c2.Title,
FromDate = m.FromDate,
ToDate = m.ToDate,
IsArchive = m.IsArchive,
RelationTypeId = rt.Id,
RelationTypeTitle = rt.Title,
RelationTypeFarsiTitle = rt.FarsiTitle,
AdditionalInfo = includeAdditionalInfo ? m.AdditionalInfo : null,
OrderNo = m.OrderNo
};
return(result.AsQueryable());
}
private User GetByWhere(Expression <Func <User, bool> > where)
{
var query = Repository.Where(where)
.Join <UserRole>("Id", "UserId", joinType: JoinType.LeftOuter)
.Join <Role>("RoleId", "Id", joinType: JoinType.LeftOuter)
.Join <RoleCapability>("Id", "RoleId", joinType: JoinType.LeftOuter)
.Join <Capability>("CapabilityId", "Id", joinType: JoinType.LeftOuter)
.Join <UserCapability>("Id", "UserId", SourceColumn.Parent, JoinType.LeftOuter)
.Join <Capability>("CapabilityId", "Id", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <User, Role>())
.Relate <Capability>((user, capability) =>
{
user.Capabilities = user.Capabilities ?? new List <Capability>();
if (user.Capabilities.All(x => x.Id != capability.Id))
{
user.Capabilities.Add(capability);
}
});
var userObject = query.SelectNested().FirstOrDefault();
return(userObject);
}
public Conditional()
{
_innerType = RelationTypes.Conditional;
}
public static RelationTypes?Unset(this RelationTypes?value, RelationTypes flags)
{
value &= ~flags;
return(value == (RelationTypes)0 ? null : value);
}
public Categorical()
{
_innerType = RelationTypes.Categorical;
}
private IEntitySet <DiscountCoupon> GetByWhere(Expression <Func <DiscountCoupon, bool> > where)
{
return(Repository.Where(where)
.Join <RestrictionValue>("Id", "DiscountCouponId", joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <DiscountCoupon, RestrictionValue>()));
}
private IEntitySet <ProductVariant> GetQuery(Expression <Func <ProductVariant, bool> > where)
{
return(Repository.Where(where)
.Join <ProductVariantAttribute>("Id", "ProductVariantId", joinType: JoinType.LeftOuter)
.Join <ProductAttributeValue>("ProductAttributeValueId", "Id", joinType: JoinType.LeftOuter)
.Join <ProductAttribute>("ProductAttributeId", "Id", joinType: JoinType.LeftOuter)
.Join <AvailableAttribute>("AvailableAttributeId", "Id", joinType: JoinType.LeftOuter)
.Join <AvailableAttributeValue>("Id", "AvailableAttributeId", joinType: JoinType.LeftOuter)
.Join <WarehouseInventory>("Id", "ProductVariantId", SourceColumn.Parent, joinType: JoinType.LeftOuter)
.Relate(RelationTypes.OneToMany <ProductVariant, ProductVariantAttribute>())
.Relate <ProductAttributeValue>((variant, value) =>
{
var productVariantAttribute =
variant.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttributeValueId == value.Id);
if (productVariantAttribute != null)
{
productVariantAttribute.ProductAttributeValue = value;
}
})
.Relate <ProductAttribute>((variant, attribute) =>
{
var productVariantAttribute =
variant.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttributeId == attribute.Id);
if (productVariantAttribute != null && productVariantAttribute.ProductAttribute == null)
{
productVariantAttribute.ProductAttribute = attribute;
}
})
.Relate <AvailableAttribute>((variant, attribute) =>
{
var productVariantAttribute =
variant.ProductVariantAttributes.FirstOrDefault(
x => x.ProductAttribute.AvailableAttribute == null &&
x.ProductAttribute.AvailableAttributeId == attribute.Id);
if (productVariantAttribute != null)
{
productVariantAttribute.ProductAttribute.AvailableAttribute = attribute;
if (productVariantAttribute.ProductAttribute.Label.IsNullEmptyOrWhiteSpace())
{
productVariantAttribute.ProductAttribute.Label = attribute.Name;
}
}
})
.Relate <AvailableAttributeValue>((variant, attributeValue) =>
{
var pav = variant.ProductVariantAttributes.Select(x => x.ProductAttributeValue)
.FirstOrDefault(x => x.AvailableAttributeValueId == attributeValue.Id);
if (pav != null)
{
if (pav.AvailableAttributeValue == null)
{
pav.AvailableAttributeValue = attributeValue;
}
if (pav.Label.IsNullEmptyOrWhiteSpace())
{
pav.Label = attributeValue?.Value;
}
}
})
.Relate(RelationTypes.OneToMany <ProductVariant, WarehouseInventory>()));
}
public static bool IsSet(this RelationTypes?value, RelationTypes flags) => (value & flags) == flags;
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 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());
}
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 Separative()
{
_innerType = RelationTypes.Separative;
}
public Relationship(PartyMember member, RelationTypes type)
{
relationSubject=member;
relationType=type;
}
public static RelationTypes?Set(this RelationTypes?value, RelationTypes flags) => value.HasValue ? (value.Value | flags) : flags;
