/// <summary>
/// Return members by requested ids can be override for load extra data for resulting members
/// </summary>
/// <param name="memberIds"></param>
/// <param name="responseGroup"></param>
/// <param name="memberTypes"></param>
/// <returns></returns>
public virtual Member[] GetByIds(string[] memberIds, string responseGroup = null, string[] memberTypes = null)
{
var retVal = new List <Member>();
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
var dataMembers = repository.GetMembersByIds(memberIds, responseGroup, memberTypes);
foreach (var dataMember in dataMembers)
{
var member = AbstractTypeFactory <Member> .TryCreateInstance(dataMember.MemberType);
if (member != null)
{
dataMember.ToModel(member);
retVal.Add(member);
}
}
}
var memberRespGroup = Common.EnumUtility.SafeParseFlags(responseGroup, MemberResponseGroup.Full);
if (memberRespGroup.HasFlag(MemberResponseGroup.WithDynamicProperties))
{
//Load dynamic properties for member
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray <IHasDynamicProperties>());
}
if (memberRespGroup.HasFlag(MemberResponseGroup.WithSeo))
{
CommerceService.LoadSeoForObjects(retVal.OfType <ISeoSupport>().ToArray());
}
return(retVal.ToArray());
}
public virtual CustomerOrder[] GetByIds(string[] orderIds, string responseGroup = null)
{
var retVal = new List <CustomerOrder>();
var orderResponseGroup = EnumUtility.SafeParse(responseGroup, CustomerOrderResponseGroup.Full);
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
var orderEntities = repository.GetCustomerOrdersByIds(orderIds, orderResponseGroup);
foreach (var orderEntity in orderEntities)
{
var customerOrder = AbstractTypeFactory <CustomerOrder> .TryCreateInstance();
if (customerOrder != null)
{
customerOrder = orderEntity.ToModel(customerOrder) as CustomerOrder;
//Calculate totals only for full responseGroup
if (orderResponseGroup == CustomerOrderResponseGroup.Full)
{
TotalsCalculator.CalculateTotals(customerOrder);
}
LoadOrderDependencies(customerOrder);
retVal.Add(customerOrder);
}
}
}
if (DynamicPropertyService != null)
{
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray <IHasDynamicProperties>());
}
return(retVal.ToArray());
}
public virtual ShoppingCart[] GetByIds(string[] cartIds, string responseGroup = null)
{
var retVal = new List <ShoppingCart>();
using (var repository = RepositoryFactory())
{
//Disable DBContext change tracking for better performance
repository.DisableChangesTracking();
var cartEntities = repository.GetShoppingCartsByIds(cartIds);
foreach (var cartEntity in cartEntities)
{
var cart = cartEntity.ToModel(AbstractTypeFactory <ShoppingCart> .TryCreateInstance());
//Calculate totals only for full responseGroup
if (responseGroup == null)
{
TotalsCalculator.CalculateTotals(cart);
}
retVal.Add(cart);
}
}
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray <IHasDynamicProperties>());
return(retVal.ToArray());
}
public virtual void SaveChanges(CustomerOrder[] orders)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <CustomerOrder> >();
using (var repository = RepositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var dataExistOrders = repository.GetCustomerOrdersByIds(orders.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray(), CustomerOrderResponseGroup.Full);
foreach (var modifiedOrder in orders)
{
EnsureThatAllOperationsHaveNumber(modifiedOrder);
LoadOrderDependencies(modifiedOrder);
var originalEntity = dataExistOrders.FirstOrDefault(x => x.Id == modifiedOrder.Id);
var modifiedEntity = AbstractTypeFactory <CustomerOrderEntity> .TryCreateInstance().FromModel(modifiedOrder, pkMap) as CustomerOrderEntity;
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
var originalOlder = (CustomerOrder)originalEntity.ToModel(AbstractTypeFactory <CustomerOrder> .TryCreateInstance());
DynamicPropertyService.LoadDynamicPropertyValues(originalOlder);
changedEntries.Add(new GenericChangedEntry <CustomerOrder>(modifiedOrder, originalOlder, EntryState.Modified));
modifiedEntity?.Patch(originalEntity);
//originalEntity is fully loaded and contains changes from order
var newModel = (CustomerOrder)originalEntity.ToModel(AbstractTypeFactory <CustomerOrder> .TryCreateInstance());
//newmodel is fully loaded, so we can call CalculateTotals for order
TotalsCalculator.CalculateTotals(newModel);
//Double convert and patch are required, because of partial order update when some properties are used in totals calculation are missed
var newModifiedEntity = AbstractTypeFactory <CustomerOrderEntity> .TryCreateInstance().FromModel(newModel, pkMap) as CustomerOrderEntity;
newModifiedEntity?.Patch(originalEntity);
}
else
{
TotalsCalculator.CalculateTotals(modifiedOrder);
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <CustomerOrder>(modifiedOrder, EntryState.Added));
}
}
//Raise domain events
EventPublisher.Publish(new OrderChangeEvent(changedEntries));
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Save dynamic properties
foreach (var order in orders)
{
DynamicPropertyService.SaveDynamicPropertyValues(order);
}
//Raise domain events
EventPublisher.Publish(new OrderChangedEvent(changedEntries));
}
public virtual CustomerOrder[] GetByIds(string[] orderIds, string responseGroup = null)
{
var retVal = new List <CustomerOrder>();
var orderResponseGroup = EnumUtility.SafeParse(responseGroup, CustomerOrderResponseGroup.Full);
using (var repository = RepositoryFactory())
{
var orderEntities = repository.GetCustomerOrdersByIds(orderIds, orderResponseGroup);
foreach (var orderEntity in orderEntities)
{
var customerOrder = AbstractTypeFactory <CustomerOrder> .TryCreateInstance();
if (customerOrder != null)
{
customerOrder = orderEntity.ToModel(customerOrder) as CustomerOrder;
if (customerOrder != null)
{
var shippingMethods = ShippingMethodsService.GetAllShippingMethods();
if (!shippingMethods.IsNullOrEmpty())
{
foreach (var shipment in customerOrder.Shipments)
{
shipment.ShippingMethod = shippingMethods.FirstOrDefault(x => x.Code.EqualsInvariant(shipment.ShipmentMethodCode));
}
}
var paymentMethods = PaymentMethodsService.GetAllPaymentMethods();
if (!paymentMethods.IsNullOrEmpty())
{
foreach (var payment in customerOrder.InPayments)
{
payment.PaymentMethod = paymentMethods.FirstOrDefault(x => x.Code.EqualsInvariant(payment.GatewayCode));
}
}
}
//Calculate totals only for full responseGroup
if (orderResponseGroup == CustomerOrderResponseGroup.Full)
{
TotalsCalculator.CalculateTotals(customerOrder);
}
retVal.Add(customerOrder);
}
}
}
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray <IHasDynamicProperties>());
foreach (var order in retVal)
{
ChangeLogService.LoadChangeLogs(order);
//Make general change log for order
order.OperationsLog = order.GetFlatObjectsListWithInterface <IHasChangesHistory>()
.Distinct()
.SelectMany(x => x.OperationsLog)
.OrderBy(x => x.CreatedDate)
.Distinct().ToList();
}
return(retVal.ToArray());
}
public virtual void SaveChanges(CustomerOrder[] orders)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <CustomerOrder> >();
using (var repository = RepositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var dataExistOrders = repository.GetCustomerOrdersByIds(orders.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray(), CustomerOrderResponseGroup.Full);
foreach (var order in orders)
{
EnsureThatAllOperationsHaveNumber(order);
LoadOrderDependencies(order);
var originalEntity = dataExistOrders.FirstOrDefault(x => x.Id == order.Id);
//Calculate order totals
TotalsCalculator.CalculateTotals(order);
var modifiedEntity = AbstractTypeFactory <CustomerOrderEntity> .TryCreateInstance()
.FromModel(order, pkMap) as CustomerOrderEntity;
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
var oldEntry = (CustomerOrder)originalEntity.ToModel(AbstractTypeFactory <CustomerOrder> .TryCreateInstance());
DynamicPropertyService.LoadDynamicPropertyValues(oldEntry);
changedEntries.Add(new GenericChangedEntry <CustomerOrder>(order, oldEntry, EntryState.Modified));
modifiedEntity?.Patch(originalEntity);
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <CustomerOrder>(order, EntryState.Added));
}
}
//Raise domain events
EventPublisher.Publish(new OrderChangeEvent(changedEntries));
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Save dynamic properties
foreach (var order in orders)
{
DynamicPropertyService.SaveDynamicPropertyValues(order);
}
//Raise domain events
EventPublisher.Publish(new OrderChangedEvent(changedEntries));
}
public virtual void SaveChanges(ShoppingCart[] carts)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <ShoppingCart> >();
using (var repository = RepositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var dataExistCarts = repository.GetShoppingCartsByIds(carts.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray());
foreach (var cart in carts)
{
//Calculate cart totals before save
TotalsCalculator.CalculateTotals(cart);
var originalEntity = dataExistCarts.FirstOrDefault(x => x.Id == cart.Id);
var modifiedEntity = AbstractTypeFactory <ShoppingCartEntity> .TryCreateInstance()
.FromModel(cart, pkMap);
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
var oldEntry = originalEntity.ToModel(AbstractTypeFactory <ShoppingCart> .TryCreateInstance());
DynamicPropertyService.LoadDynamicPropertyValues(oldEntry);
changedEntries.Add(new GenericChangedEntry <ShoppingCart>(cart, oldEntry, EntryState.Modified));
modifiedEntity.Patch(originalEntity);
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <ShoppingCart>(cart, EntryState.Added));
}
}
//Raise domain events
EventPublisher.Publish(new CartChangeEvent(changedEntries));
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
EventPublisher.Publish(new CartChangedEvent(changedEntries));
}
//Save dynamic properties
foreach (var cart in carts)
{
DynamicPropertyService.SaveDynamicPropertyValues(cart);
}
}
public override CustomerOrder[] GetByIds(string[] orderIds, string responseGroup = null)
{
var retVal = new List <CustomerOrder>();
var orderResponseGroup = EnumUtility.SafeParse(responseGroup, CustomerOrderResponseGroup.Full);
using (var repository = RepositoryFactory())
{
var orderEntities = repository.GetCustomerOrdersByIds(orderIds, orderResponseGroup);
foreach (var orderEntity in orderEntities)
{
var customerOrder = AbstractTypeFactory <CustomerOrder> .TryCreateInstance();
if (customerOrder != null)
{
var shippingMethods = ShippingMethodsService.GetAllShippingMethods();
var paymentMethods = PaymentMethodsService.GetAllPaymentMethods();
customerOrder = orderEntity.ToModel(customerOrder) as CustomerOrder;
if (!shippingMethods.IsNullOrEmpty())
{
foreach (var shipment in customerOrder.Shipments)
{
shipment.ShippingMethod = shippingMethods.FirstOrDefault(x => x.Code.EqualsInvariant(shipment.ShipmentMethodCode));
}
}
if (!paymentMethods.IsNullOrEmpty())
{
foreach (var payment in customerOrder.InPayments)
{
payment.PaymentMethod = paymentMethods.FirstOrDefault(x => x.Code.EqualsInvariant(payment.GatewayCode));
}
}
retVal.Add(customerOrder);
}
}
}
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray());
return(retVal.ToArray());
}
/// <summary>
/// Return members by requested ids can be override for load extra data for resulting members
/// </summary>
/// <param name="memberIds"></param>
/// <param name="responseGroup"></param>
/// <param name="memberTypes"></param>
/// <returns></returns>
public virtual Member[] GetByIds(string[] memberIds, string responseGroup = null, string[] memberTypes = null)
{
var retVal = new List <Member>();
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
//There is loading for all coresponding members conseptual model entities types
//query performance when TPT inheritance used it is too slow, for improve performance we are passing concrete member types in to the repository
var memberTypeInfos = AbstractTypeFactory <Member> .AllTypeInfos.Where(t => t.MappedType != null);
if (memberTypes != null)
{
memberTypeInfos = memberTypeInfos.Where(x => memberTypes.Any(mt => x.IsAssignableTo(mt)));
}
memberTypes = memberTypeInfos.Select(t => t.MappedType.AssemblyQualifiedName).Distinct().ToArray();
var dataMembers = repository.GetMembersByIds(memberIds, responseGroup, memberTypes);
foreach (var dataMember in dataMembers)
{
var member = AbstractTypeFactory <Member> .TryCreateInstance(dataMember.MemberType);
if (member != null)
{
dataMember.ToModel(member);
retVal.Add(member);
}
}
}
//Load dynamic properties for member
DynamicPropertyService.LoadDynamicPropertyValues(retVal.ToArray <IHasDynamicProperties>());
CommerceService.LoadSeoForObjects(retVal.OfType <ISeoSupport>().ToArray());
return(retVal.ToArray());
}
