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