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 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 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 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 Delete(string[] ids, string[] memberTypes = null)
{
using (var repository = RepositoryFactory())
{
var members = GetByIds(ids, null, memberTypes);
if (!members.IsNullOrEmpty())
{
var changedEntries = members.Select(x => new GenericChangedEntry <Member>(x, EntryState.Deleted));
EventPublisher.Publish(new MemberChangingEvent(changedEntries));
repository.RemoveMembersByIds(members.Select(m => m.Id).ToArray());
CommitChanges(repository);
foreach (var member in members)
{
DynamicPropertyService.DeleteDynamicPropertyValues(member);
var seoObject = member as ISeoSupport;
if (seoObject != null)
{
CommerceService.DeleteSeoForObject(seoObject);
}
}
EventPublisher.Publish(new MemberChangedEvent(changedEntries));
}
}
}
public virtual async Task <IEnumerable <ShoppingCart> > GetByIdsAsync(string[] cartIds, string responseGroup = null)
{
var retVal = new List <ShoppingCart>();
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", cartIds), responseGroup);
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
using (var repository = RepositoryFactory())
{
//Disable DBContext change tracking for better performance
repository.DisableChangesTracking();
var cartEntities = await repository.GetShoppingCartsByIdsAsync(cartIds, responseGroup);
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);
cacheEntry.AddExpirationToken(CartCacheRegion.CreateChangeToken(cart));
}
}
await DynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
return retVal;
}));
}
public virtual void Delete(string[] ids)
{
var orders = GetByIds(ids, CustomerOrderResponseGroup.Full.ToString());
using (var repository = RepositoryFactory())
{
foreach (var order in orders)
{
OrderChangingPublisher.Publish(new OrderChangeEvent(EntryState.Deleted, order, order));
}
repository.RemoveOrdersByIds(ids);
foreach (var order in orders)
{
DynamicPropertyService.DeleteDynamicPropertyValues(order);
}
repository.UnitOfWork.Commit();
foreach (var order in orders)
{
OrderChangedPublisher.Publish(new OrderChangedEvent(EntryState.Deleted, order, order));
}
}
}
/// <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 async Task <Store[]> GetByIdsAsync(string[] ids)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", ids));
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var stores = new List <Store>();
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
var dbStores = await repository.GetStoresByIdsAsync(ids);
foreach (var dbStore in dbStores)
{
var store = AbstractTypeFactory <Store> .TryCreateInstance();
dbStore.ToModel(store);
PopulateStore(store, dbStore);
await SettingManager.DeepLoadSettingsAsync(store);
stores.Add(store);
cacheEntry.AddExpirationToken(StoreCacheRegion.CreateChangeToken(store));
}
}
var result = stores.ToArray();
var taskLoadDynamicPropertyValues = DynamicPropertyService.LoadDynamicPropertyValuesAsync(result);
var taskLoadSeoForObjects = SeoService.LoadSeoForObjectsAsync(result);
await Task.WhenAll(taskLoadDynamicPropertyValues, taskLoadSeoForObjects);
return result;
}));
}
/// <summary>
/// Create or update members in database
/// </summary>
/// <param name="members"></param>
public virtual void SaveChanges(Member[] members)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEvents = new List <MemberChangedEvent>();
using (var repository = RepositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var existingMemberEntities = repository.GetMembersByIds(members.Where(m => !m.IsTransient()).Select(m => m.Id).ToArray());
foreach (var member in members)
{
var memberEntityType = AbstractTypeFactory <Member> .AllTypeInfos.Where(t => t.MappedType != null && t.IsAssignableTo(member.MemberType)).Select(t => t.MappedType).FirstOrDefault();
if (memberEntityType != null)
{
var dataSourceMember = AbstractTypeFactory <MemberDataEntity> .TryCreateInstance(memberEntityType.Name);
if (dataSourceMember != null)
{
dataSourceMember.FromModel(member, pkMap);
var dataTargetMember = existingMemberEntities.FirstOrDefault(m => m.Id == member.Id);
if (dataTargetMember != null)
{
changeTracker.Attach(dataTargetMember);
dataSourceMember.Patch(dataTargetMember);
MemberChangingEventPublisher.Publish(new MemberChangingEvent(EntryState.Modified, member));
changedEvents.Add(new MemberChangedEvent(EntryState.Modified, member));
}
else
{
repository.Add(dataSourceMember);
MemberChangingEventPublisher.Publish(new MemberChangingEvent(EntryState.Added, member));
changedEvents.Add(new MemberChangedEvent(EntryState.Added, member));
}
}
}
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Save dynamic properties
foreach (var member in members)
{
DynamicPropertyService.SaveDynamicPropertyValues(member);
}
CommerceService.UpsertSeoForObjects(members.OfType <ISeoSupport>().ToArray());
foreach (var changedEvent in changedEvents)
{
MemberChangedEventPublisher.Publish(changedEvent);
}
}
public DynamicPropertyServiceUnitTests()
{
_platformRepositoryMock = new Mock <IPlatformRepository>();
_repositoryFactory = () => _platformRepositoryMock.Object;
_mockUnitOfWork = new Mock <IUnitOfWork>();
_platformRepositoryMock.Setup(ss => ss.UnitOfWork).Returns(_mockUnitOfWork.Object);
_memoryCasheMock = new Mock <IPlatformMemoryCache>();
_dynamicPropertyService = new DynamicPropertyService(_repositoryFactory, _memoryCasheMock.Object);
}
public virtual void SaveChanges(CustomerOrder[] orders)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEvents = new List <OrderChangedEvent>();
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);
var originalEntity = dataExistOrders.FirstOrDefault(x => x.Id == order.Id);
var originalOrder = originalEntity != null ? (CustomerOrder)originalEntity.ToModel(AbstractTypeFactory <CustomerOrder> .TryCreateInstance()) : order;
//Calculate order totals before event raising
TotalsCalculator.CalculateTotals(order);
var changingEvent = new OrderChangeEvent(originalEntity == null ? EntryState.Added : EntryState.Modified, originalOrder, order);
OrderChangingPublisher.Publish(changingEvent);
changedEvents.Add(new OrderChangedEvent(changingEvent.ChangeState, changingEvent.OrigOrder, changingEvent.ModifiedOrder));
//Calculate order totals after event raising but before save
TotalsCalculator.CalculateTotals(order);
var modifiedEntity = AbstractTypeFactory <CustomerOrderEntity> .TryCreateInstance()
.FromModel(order, pkMap) as CustomerOrderEntity;
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
modifiedEntity?.Patch(originalEntity);
}
else
{
repository.Add(modifiedEntity);
}
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Save dynamic properties
foreach (var order in orders)
{
DynamicPropertyService.SaveDynamicPropertyValues(order);
}
//Raise changed events
foreach (var changedEvent in changedEvents)
{
OrderChangedPublisher.Publish(changedEvent);
}
}
private static CustomerModuleController GetContactController()
{
Func <IPlatformRepository> platformRepositoryFactory = () => new PlatformRepository("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor(null));
Func <ICustomerRepository> customerRepositoryFactory = () => new CustomerRepositoryImpl("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor(null));
var dynamicPropertyService = new DynamicPropertyService(platformRepositoryFactory);
var memberService = new MemberServiceImpl(customerRepositoryFactory, dynamicPropertyService, null);
return(new CustomerModuleController(memberService, null));
}
private static CustomerModuleController GetContactController()
{
Func <IPlatformRepository> platformRepositoryFactory = () => new PlatformRepository("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor());
Func <ICustomerRepository> customerRepositoryFactory = () => new CustomerRepositoryImpl("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor());
var dynamicPropertyService = new DynamicPropertyService(platformRepositoryFactory);
var contactService = new ContactServiceImpl(customerRepositoryFactory, dynamicPropertyService);
var orgService = new OrganizationServiceImpl(customerRepositoryFactory, dynamicPropertyService);
var searchService = new CustomerSearchServiceImpl(customerRepositoryFactory);
return(new CustomerModuleController(contactService, orgService, searchService));
}
private StoreModuleController GetStoreController()
{
Func <IPlatformRepository> platformRepositoryFactory = () => new PlatformRepository("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor(null));
Func <IStoreRepository> repositoryFactory = () => new StoreRepositoryImpl("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor(null));
var dynamicPropertyService = new DynamicPropertyService(platformRepositoryFactory);
var storeService = new StoreServiceImpl(repositoryFactory, GetCommerceService(), null, dynamicPropertyService, null, null, null, null);
var controller = new StoreModuleController(storeService, null, null, null, null, null, null);
return(controller);
}
private static CustomerOrderServiceImpl GetCustomerOrderService()
{
Func <IPlatformRepository> platformRepositoryFactory = () => new PlatformRepository("VirtoCommerce", new EntityPrimaryKeyGeneratorInterceptor(), new AuditableInterceptor());
Func <ICartRepository> repositoryFactory = () => new CartRepositoryImpl("VirtoCommerce", new AuditableInterceptor());
var dynamicPropertyService = new DynamicPropertyService(platformRepositoryFactory);
var orderEventPublisher = new EventPublisher <OrderChangeEvent>(Enumerable.Empty <IObserver <OrderChangeEvent> >().ToArray());
var cartEventPublisher = new EventPublisher <CartChangeEvent>(Enumerable.Empty <IObserver <CartChangeEvent> >().ToArray());
var cartService = new ShoppingCartServiceImpl(repositoryFactory, cartEventPublisher, null);
var orderService = new CustomerOrderServiceImpl(GetOrderRepositoryFactory(), new TimeBasedNumberGeneratorImpl(), orderEventPublisher, cartService, null, dynamicPropertyService);
return(orderService);
}
private IStoreService GetStoreService()
{
_mockStoreRepository.Setup(ss => ss.UnitOfWork).Returns(_mockUnitOfWork.Object);
_mockPlatformRepository.Setup(ss => ss.UnitOfWork).Returns(_mockUnitOfWork.Object);
IPlatformRepository platformRepositoryFactory() => _mockPlatformRepository.Object;
IStoreRepository repositoryFactory() => _mockStoreRepository.Object;
var dynamicPropertyService = new DynamicPropertyService(platformRepositoryFactory);
var storeService = new StoreServiceImpl(repositoryFactory, _mockCommerceService.Object, _mockSettingsManager.Object, dynamicPropertyService, null, null, null);
return(storeService);
}
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 void Delete(string[] ids)
{
var orders = GetByIds(ids, CustomerOrderResponseGroup.Full.ToString());
using (var repository = RepositoryFactory()) {
var dbOrders = repository.GetCustomerOrdersByIds(ids, CustomerOrderResponseGroup.Full);
foreach (var order in orders)
{
CustomerOrderEventventPublisher.Publish(new OrderChangeEvent(Platform.Core.Common.EntryState.Deleted, order, order));
}
repository.RemoveOrdersByIds(ids);
foreach (var order in orders)
{
DynamicPropertyService.DeleteDynamicPropertyValues(order);
}
repository.UnitOfWork.Commit();
}
}
public virtual void Delete(string[] cartIds)
{
var carts = GetByIds(cartIds);
using (var repository = RepositoryFactory())
{
//Raise domain events before deletion
var changedEntries = carts.Select(x => new GenericChangedEntry <ShoppingCart>(x, EntryState.Deleted));
EventPublisher.Publish(new CartChangeEvent(changedEntries));
repository.RemoveCarts(cartIds);
foreach (var cart in carts)
{
DynamicPropertyService.DeleteDynamicPropertyValues(cart);
}
repository.UnitOfWork.Commit();
//Raise domain events after deletion
EventPublisher.Publish(new CartChangedEvent(changedEntries));
}
}
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());
}
public override void SaveChanges(CustomerOrder[] orders)
{
var pkMap = new PrimaryKeyResolvingMap();
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);
var originalEntity = dataExistOrders.FirstOrDefault(x => x.Id == order.Id);
var originalOrder = originalEntity != null ? (CustomerOrder)originalEntity.ToModel(AbstractTypeFactory <CustomerOrder> .TryCreateInstance()) : order;
var changeEvent = new OrderChangeEvent(originalEntity == null ? EntryState.Added : EntryState.Modified, originalOrder, order);
CustomerOrderEventventPublisher.Publish(changeEvent);
var modifiedEntity = AbstractTypeFactory <CustomerOrderEntity> .TryCreateInstance()
.FromModel(order, pkMap) as CustomerOrderEntity;
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
modifiedEntity.Patch(originalEntity);
}
else
{
repository.Add(modifiedEntity);
}
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Save dynamic properties
foreach (var order in orders)
{
DynamicPropertyService.SaveDynamicPropertyValues(order);
}
}
/// <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 async Task <Member[]> GetByIdsAsync(string[] memberIds, string responseGroup = null, string[] memberTypes = null)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", memberIds), responseGroup, memberTypes == null ? null : string.Join("-", memberTypes));
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var retVal = new List <Member>();
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
//There is loading for all corresponding members conceptual 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 = await repository.GetMembersByIdsAsync(memberIds, responseGroup, memberTypes);
foreach (var dataMember in dataMembers)
{
var member = AbstractTypeFactory <Member> .TryCreateInstance(dataMember.MemberType);
if (member != null)
{
dataMember.ToModel(member);
retVal.Add(member);
cacheEntry.AddExpirationToken(CustomerCacheRegion.CreateChangeToken(member));
}
}
}
var taskDynamicProperty = DynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
var taskSeo = SeoService.LoadSeoForObjectsAsync(retVal.OfType <ISeoSupport>().ToArray());
await Task.WhenAll(taskDynamicProperty, taskSeo);
return retVal.ToArray();
}));
}
public virtual void Delete(string[] ids)
{
var orders = GetByIds(ids, CustomerOrderResponseGroup.Full.ToString());
using (var repository = RepositoryFactory())
{
//Raise domain events before deletion
var changedEntries = orders.Select(x => new GenericChangedEntry <CustomerOrder>(x, EntryState.Deleted));
EventPublisher.Publish(new OrderChangeEvent(changedEntries));
repository.RemoveOrdersByIds(ids);
foreach (var order in orders)
{
DynamicPropertyService.DeleteDynamicPropertyValues(order);
}
repository.UnitOfWork.Commit();
//Raise domain events after deletion
EventPublisher.Publish(new OrderChangedEvent(changedEntries));
}
}
/// <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());
}
private IDynamicPropertyService GetDynamicPropertyService()
{
var service = new DynamicPropertyService(() => GetPlatformRepository());
return(service);
}
private static IDynamicPropertyService GetDynamicPropertyService()
{
var service = new DynamicPropertyService(GetPlatformRepository);
return(service);
}
