public void UpsertSeoInfos(coreModel.SeoInfo[] seoinfos)
{
var pkMap = new PrimaryKeyResolvingMap();
using (var repository = _repositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var alreadyExistSeoInfos = repository.GetSeoByIds(seoinfos.Select(x => x.Id).ToArray());
var target = new { SeoInfos = new ObservableCollection <dataModel.SeoUrlKeyword>(alreadyExistSeoInfos) };
var source = new { SeoInfos = new ObservableCollection <dataModel.SeoUrlKeyword>(seoinfos.Select(x => AbstractTypeFactory <dataModel.SeoUrlKeyword> .TryCreateInstance().FromModel(x, pkMap))) };
changeTracker.Attach(target);
source.SeoInfos.Patch(target.SeoInfos, (sourceSeoUrlKeyword, targetSeoUrlKeyword) => sourceSeoUrlKeyword.Patch(targetSeoUrlKeyword));
repository.UnitOfWork.Commit();
pkMap.ResolvePrimaryKeys();
}
}
public static DiscountEntity ToDataModel(this coreModel.Discount discount, PrimaryKeyResolvingMap pkMap)
{
if (discount == null)
{
throw new ArgumentNullException("discount");
}
var retVal = new DiscountEntity();
pkMap.AddPair(discount, retVal);
retVal.InjectFrom(discount);
retVal.Currency = discount.Currency.ToString();
retVal.CouponCode = discount.Coupon;
return(retVal);
}
public virtual UserApiKeyEntity FromModel(UserApiKey apiKey, PrimaryKeyResolvingMap pkMap)
{
if (apiKey == null)
{
throw new ArgumentNullException(nameof(apiKey));
}
pkMap.AddPair(apiKey, this);
Id = apiKey.Id;
ApiKey = apiKey.ApiKey;
UserName = apiKey.UserName;
UserId = apiKey.UserId;
IsActive = apiKey.IsActive;
return(this);
}
public virtual VideoLinkEntity FromModel(VideoLink videolink, PrimaryKeyResolvingMap pkMap)
{
if (videolink == null)
{
throw new ArgumentNullException(nameof(videolink));
}
pkMap.AddPair(videolink, this);
Id = videolink.Id;
Url = videolink.Url;
ProductId = videolink.ProductId;
CreatedDate = videolink.CreatedDate;
ModifiedDate = videolink.ModifiedDate;
Status = videolink.Status;
return(this);
}
public virtual StoreTaxProviderEntity FromModel(TaxProvider taxProvider, PrimaryKeyResolvingMap pkMap)
{
if (taxProvider == null)
{
throw new ArgumentNullException(nameof(taxProvider));
}
pkMap.AddPair(taxProvider, this);
IsActive = taxProvider.IsActive;
Code = taxProvider.Code;
Description = taxProvider.Description;
LogoUrl = taxProvider.LogoUrl;
Name = taxProvider.Name;
Priority = taxProvider.Priority;
return(this);
}
public coreModel.DynamicContentItem CreateContent(coreModel.DynamicContentItem content)
{
var pkMap = new PrimaryKeyResolvingMap();
var entity = content.ToDataModel(pkMap);
using (var repository = _repositoryFactory())
{
repository.Add(entity);
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
_dynamicPropertyService.SaveDynamicPropertyValues(content);
var retVal = GetContentItemById(entity.Id);
return(retVal);
}
public coreModel.Organization Create(coreModel.Organization organization)
{
var pkMap = new PrimaryKeyResolvingMap();
var entity = organization.ToDataModel(pkMap);
using (var repository = _repositoryFactory())
{
repository.Add(entity);
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
_dynamicPropertyService.SaveDynamicPropertyValues(organization);
var retVal = GetById(entity.Id);
return(retVal);
}
public void SaveCustomerReviewVotes(CustomerReviewVote[] items)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
var pkMap = new PrimaryKeyResolvingMap();
int i = 0;
#pragma warning disable S3353 // Unchanged local variables should be "const"
#pragma warning disable S1481 // Unused local variables should be removed
int r = 0;
#pragma warning restore S1481 // Unused local variables should be removed
#pragma warning restore S3353 // Unchanged local variables should be "const"
using (var repository = _repositoryFactory())
{
using (var changeTracker = GetChangeTracker(repository))
{
var alreadyExistEntities = repository.GetVoteByIds(items.Where(m => !m.IsTransient()).Select(x => x.Id).ToArray());
foreach (var derivativeContract in items)
{
var sourceEntity = AbstractTypeFactory <CustomerReviewVoteEntity> .TryCreateInstance().FromModel(derivativeContract, pkMap);
var targetEntity = alreadyExistEntities.FirstOrDefault(x => x.Id == sourceEntity.Id);
if (targetEntity != null)
{
changeTracker.Attach(targetEntity);
sourceEntity.Patch(targetEntity);
}
else
{
repository.Add(sourceEntity);
}
}
var reviewIds = items.Select(x => x.CustomerReviewId).ToArray();
UpdateCustomerReviewVotesCount(repository, reviewIds);
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
}
}
protected virtual void InnerSaveChanges(IEnumerable <CatalogProduct> products, bool disableValidation = false)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <CatalogProduct> >();
ValidateProducts(products);
using (var repository = _repositoryFactory())
{
var dbExistProducts = repository.GetItemByIds(products.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray(), ItemResponseGroup.ItemLarge);
foreach (var product in products)
{
var modifiedEntity = AbstractTypeFactory <ItemEntity> .TryCreateInstance().FromModel(product, pkMap);
var originalEntity = dbExistProducts.FirstOrDefault(x => x.Id == product.Id);
if (originalEntity != null)
{
changedEntries.Add(new GenericChangedEntry <CatalogProduct>(product, originalEntity.ToModel(AbstractTypeFactory <CatalogProduct> .TryCreateInstance()), EntryState.Modified));
modifiedEntity.Patch(originalEntity);
//Force set ModifiedDate property to mark a product changed. Special for partial update cases when product table not have changes
originalEntity.ModifiedDate = DateTime.UtcNow;
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <CatalogProduct>(product, EntryState.Added));
}
}
//Raise domain events
_eventPublisher.Publish(new ProductChangingEvent(changedEntries));
//Save changes in database
repository.UnitOfWork.Commit();
pkMap.ResolvePrimaryKeys();
_eventPublisher.Publish(new ProductChangedEvent(changedEntries));
}
//Update SEO
var productsWithVariations = products.Concat(products.Where(x => x.Variations != null).SelectMany(x => x.Variations)).OfType <ISeoSupport>().ToArray();
_commerceService.UpsertSeoForObjects(productsWithVariations);
}
public virtual SubscriptionEntity FromModel(Subscription subscription, PrimaryKeyResolvingMap pkMap)
{
if (subscription == null)
{
throw new NullReferenceException("subscription");
}
pkMap.AddPair(subscription, this);
this.InjectFrom(subscription);
if (subscription.CustomerOrderPrototype != null)
{
this.CustomerOrderPrototypeId = subscription.CustomerOrderPrototype.Id;
}
this.Status = subscription.SubscriptionStatus.ToString();
this.Interval = subscription.Interval.ToString();
return(this);
}
public virtual CategoryEntity FromModel(Category category, PrimaryKeyResolvingMap pkMap)
{
if (category == null)
{
throw new ArgumentNullException(nameof(category));
}
pkMap.AddPair(category, this);
Id = category.Id;
CreatedBy = category.CreatedBy;
CreatedDate = category.CreatedDate;
ModifiedBy = category.ModifiedBy;
ModifiedDate = category.ModifiedDate;
Code = category.Code;
Name = category.Name;
Priority = category.Priority;
TaxType = category.TaxType;
CatalogId = category.CatalogId;
ParentCategoryId = category.ParentId;
EndDate = DateTime.UtcNow.AddYears(100);
StartDate = DateTime.UtcNow;
IsActive = category.IsActive ?? true;
if (category.PropertyValues != null)
{
CategoryPropertyValues = new ObservableCollection <PropertyValueEntity>(AbstractTypeFactory <PropertyValueEntity> .TryCreateInstance().FromModels(category.PropertyValues, pkMap));
}
if (category.Links != null)
{
OutgoingLinks = new ObservableCollection <CategoryRelationEntity>(category.Links.Select(x => AbstractTypeFactory <CategoryRelationEntity> .TryCreateInstance().FromModel(x)));
}
if (category.Images != null)
{
Images = new ObservableCollection <ImageEntity>(category.Images.Select(x => AbstractTypeFactory <ImageEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
return(this);
}
public async Task SaveChangesAsync(Core.Currency.Currency[] currencies)
{
if (currencies == null)
{
throw new ArgumentNullException(nameof(currencies));
}
var pkMap = new PrimaryKeyResolvingMap();
using (var repository = _repositoryFactory())
{
//Ensure that only one Primary currency
if (currencies.Any(x => x.IsPrimary))
{
var oldPrimaryCurrency = await repository.Currencies.FirstOrDefaultAsync(x => x.IsPrimary);
if (oldPrimaryCurrency != null)
{
oldPrimaryCurrency.IsPrimary = false;
}
}
foreach (var currency in currencies)
{
var sourceEntry = AbstractTypeFactory <CurrencyEntity> .TryCreateInstance().FromModel(currency);
var targetEntry = await repository.Currencies.FirstOrDefaultAsync(x => x.Code == currency.Code);
if (targetEntry == null)
{
repository.Add(sourceEntry);
}
else
{
sourceEntry.Patch(targetEntry);
}
}
await repository.UnitOfWork.CommitAsync();
CurrencyCacheRegion.ExpireRegion();
}
}
public void SaveChanges(IEnumerable <Property> properties)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <Property> >();
ValidateProperties(properties);
using (var repository = _repositoryFactory())
{
TryAddPredefinedValidationRules(properties);
var dbExistProperties = repository.GetPropertiesByIds(properties.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray());
foreach (var property in properties)
{
var modifiedEntity = AbstractTypeFactory <PropertyEntity> .TryCreateInstance().FromModel(property, pkMap);
var originalEntity = dbExistProperties.FirstOrDefault(x => x.Id == property.Id);
if (originalEntity != null)
{
changedEntries.Add(new GenericChangedEntry <Property>(property, originalEntity.ToModel(AbstractTypeFactory <Property> .TryCreateInstance()), EntryState.Modified));
modifiedEntity.Patch(originalEntity);
//Force set ModifiedDate property to mark a product changed. Special for partial update cases when product table not have changes
originalEntity.ModifiedDate = DateTime.UtcNow;
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <Property>(property, EntryState.Added));
}
}
//Raise domain events
_eventPublisher.Publish(new PropertyChangingEvent(changedEntries));
//Save changes in database
repository.UnitOfWork.Commit();
pkMap.ResolvePrimaryKeys();
_eventPublisher.Publish(new PropertyChangedEvent(changedEntries));
//Reset catalog cache
CatalogCacheRegion.ExpireRegion();
}
}
public virtual WebHookEventEntity FromModel(WebhookEvent webHookEvent, PrimaryKeyResolvingMap pkMap)
{
if (webHookEvent == null)
{
throw new ArgumentNullException(nameof(webHookEvent));
}
Id = webHookEvent.Id;
CreatedBy = webHookEvent.CreatedBy;
CreatedDate = webHookEvent.CreatedDate;
ModifiedBy = webHookEvent.ModifiedBy;
ModifiedDate = webHookEvent.ModifiedDate;
EventId = webHookEvent.EventId;
WebHookId = webHookEvent.WebHookId;
pkMap.AddPair(webHookEvent, this);
return(this);
}
public virtual PropertyEntity FromModel(Property property, PrimaryKeyResolvingMap pkMap)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
pkMap.AddPair(property, this);
Id = property.Id;
CreatedBy = property.CreatedBy;
CreatedDate = property.CreatedDate;
ModifiedBy = property.ModifiedBy;
ModifiedDate = property.ModifiedDate;
CatalogId = property.CatalogId;
CategoryId = property.CategoryId;
Name = property.Name;
PropertyValueType = (int)property.ValueType;
IsMultiValue = property.Multivalue;
IsLocaleDependant = property.Multilanguage;
IsEnum = property.Dictionary;
IsRequired = property.Required;
IsHidden = property.Hidden;
TargetType = property.Type.ToString();
if (property.Attributes != null)
{
PropertyAttributes = new ObservableCollection <PropertyAttributeEntity>(property.Attributes.Select(x => AbstractTypeFactory <PropertyAttributeEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (property.DisplayNames != null)
{
DisplayNames = new ObservableCollection <PropertyDisplayNameEntity>(property.DisplayNames.Select(x => AbstractTypeFactory <PropertyDisplayNameEntity> .TryCreateInstance().FromModel(x)));
}
if (property.ValidationRules != null)
{
ValidationRules = new ObservableCollection <PropertyValidationRuleEntity>(property.ValidationRules.Select(x => AbstractTypeFactory <PropertyValidationRuleEntity> .TryCreateInstance().FromModel(x)));
}
return(this);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var shipment = operation as Shipment;
if (shipment == null)
{
throw new NullReferenceException("shipment");
}
base.FromModel(shipment, pkMap);
//Allow to empty address
this.Addresses = new ObservableCollection <AddressEntity>();
if (shipment.ShippingMethod != null)
{
this.ShipmentMethodCode = shipment.ShippingMethod.Code;
this.ShipmentMethodOption = shipment.ShipmentMethodOption;
}
if (shipment.DeliveryAddress != null)
{
this.Addresses = new ObservableCollection <AddressEntity>(new AddressEntity[] { AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(shipment.DeliveryAddress) });
}
if (shipment.Items != null)
{
this.Items = new ObservableCollection <ShipmentItemEntity>(shipment.Items.Select(x => AbstractTypeFactory <ShipmentItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (shipment.Packages != null)
{
this.Packages = new ObservableCollection <ShipmentPackageEntity>(shipment.Packages.Select(x => AbstractTypeFactory <ShipmentPackageEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (shipment.TaxDetails != null)
{
this.TaxDetails = new ObservableCollection <TaxDetailEntity>(shipment.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
if (shipment.Discounts != null)
{
this.Discounts = new ObservableCollection <DiscountEntity>(shipment.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
this.Sum = shipment.TotalWithTax;
return(this);
}
public static ShoppingCartEntity ToDataModel(this ShoppingCart cart, PrimaryKeyResolvingMap pkMap)
{
if (cart == null)
{
throw new ArgumentNullException("cart");
}
var retVal = new ShoppingCartEntity();
pkMap.AddPair(cart, retVal);
retVal.InjectFrom(cart);
retVal.Currency = cart.Currency.ToString();
if (cart.Addresses != null)
{
retVal.Addresses = new ObservableCollection <AddressEntity>(cart.Addresses.Select(x => x.ToDataModel()));
}
if (cart.Items != null)
{
retVal.Items = new ObservableCollection <LineItemEntity>(cart.Items.Select(x => x.ToDataModel(pkMap)));
}
if (cart.Shipments != null)
{
retVal.Shipments = new ObservableCollection <ShipmentEntity>(cart.Shipments.Select(x => x.ToDataModel(retVal, pkMap)));
}
if (cart.Payments != null)
{
retVal.Payments = new ObservableCollection <PaymentEntity>(cart.Payments.Select(x => x.ToDataModel(pkMap)));
}
if (cart.TaxDetails != null)
{
retVal.TaxDetails = new ObservableCollection <TaxDetailEntity>();
retVal.TaxDetails.AddRange(cart.TaxDetails.Select(x => x.ToDataModel()));
}
if (cart.Discounts != null)
{
retVal.Discounts = new ObservableCollection <DiscountEntity>();
retVal.Discounts.AddRange(cart.Discounts.Select(x => x.ToDataModel(pkMap)));
}
return(retVal);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var order = operation as CustomerOrder;
if (order == null)
{
throw new NullReferenceException("order");
}
base.FromModel(order, pkMap);
if (order.Addresses != null)
{
this.Addresses = new ObservableCollection <AddressEntity>(order.Addresses.Select(x => AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(x)));
}
if (order.Items != null)
{
this.Items = new ObservableCollection <LineItemEntity>(order.Items.Select(x => AbstractTypeFactory <LineItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (order.Shipments != null)
{
this.Shipments = new ObservableCollection <ShipmentEntity>(order.Shipments.Select(x => AbstractTypeFactory <ShipmentEntity> .TryCreateInstance().FromModel(x, pkMap)).OfType <ShipmentEntity>());
//Link shipment item with order lineItem
foreach (var shipmentItemEntity in this.Shipments.SelectMany(x => x.Items))
{
shipmentItemEntity.LineItem = this.Items.FirstOrDefault(x => x.ModelLineItem == shipmentItemEntity.ModelLineItem);
}
}
if (order.InPayments != null)
{
this.InPayments = new ObservableCollection <PaymentInEntity>(order.InPayments.Select(x => AbstractTypeFactory <PaymentInEntity> .TryCreateInstance().FromModel(x, pkMap)).OfType <PaymentInEntity>());
}
if (order.Discounts != null)
{
this.Discounts = new ObservableCollection <DiscountEntity>(order.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
if (order.TaxDetails != null)
{
this.TaxDetails = new ObservableCollection <TaxDetailEntity>(order.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
this.Sum = order.Total;
return(this);
}
public override MemberDataEntity FromModel(Member member, PrimaryKeyResolvingMap pkMap)
{
var organization = member as Organization;
if (organization != null && organization.ParentId != null)
{
this.MemberRelations = new ObservableCollection <MemberRelationDataEntity>();
var memberRelation = new MemberRelationDataEntity
{
AncestorId = organization.ParentId,
DescendantId = organization.Id,
AncestorSequence = 1
};
this.MemberRelations.Add(memberRelation);
}
//Call base converter
return(base.FromModel(member, pkMap));
}
public void SaveCustomerReviews(CustomerReview[] items)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
List <string> productIds = new List <string>();
var pkMap = new PrimaryKeyResolvingMap();
using (var repository = _repositoryFactory())
{
using (var changeTracker = GetChangeTracker(repository))
{
var alreadyExistEntities = repository.GetByIds(items.Where(m => !m.IsTransient()).Select(x => x.Id).ToArray());
foreach (var derivativeContract in items)
{
var sourceEntity = AbstractTypeFactory <CustomerReviewEntity> .TryCreateInstance().FromModel(derivativeContract, pkMap);
var targetEntity = alreadyExistEntities.FirstOrDefault(x => x.Id == sourceEntity.Id);
if (targetEntity != null)
{
changeTracker.Attach(targetEntity);
sourceEntity.Patch(targetEntity);
}
else
{
repository.Add(sourceEntity);
}
productIds.Add(derivativeContract.ProductId);
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
IEnumerable <string> distinctProductIds = productIds.Distinct();
foreach (string productId in distinctProductIds)
{
repository.RecalcRatingForProduct(productId);
}
CommitChanges(repository);
}
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var payment = operation as PaymentIn;
if (payment == null)
{
throw new ArgumentException(@"operation argument must be of type PaymentIn", nameof(operation));
}
base.FromModel(payment, pkMap);
if (payment.PaymentMethod != null)
{
GatewayCode = payment.PaymentMethod != null ? payment.PaymentMethod.Code : payment.GatewayCode;
}
if (payment.BillingAddress != null)
{
Addresses = new ObservableCollection <AddressEntity>(new[] { AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(payment.BillingAddress) });
}
if (payment.TaxDetails != null)
{
TaxDetails = new ObservableCollection <TaxDetailEntity>(payment.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
if (payment.Discounts != null)
{
Discounts = new ObservableCollection <DiscountEntity>(payment.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
if (payment.Transactions != null)
{
Transactions = new ObservableCollection <PaymentGatewayTransactionEntity>(payment.Transactions.Select(x => AbstractTypeFactory <PaymentGatewayTransactionEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (payment.Status.IsNullOrEmpty())
{
Status = payment.PaymentStatus.ToString();
}
return(this);
}
public virtual async Task SavePlansAsync(PaymentPlan[] plans)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <PaymentPlan> >();
using (var repository = _subscriptionRepositoryFactory())
{
var existPlanEntities = await repository.GetPaymentPlansByIdsAsync(plans.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray());
foreach (var paymentPlan in plans)
{
var sourcePlanEntity = AbstractTypeFactory <PaymentPlanEntity> .TryCreateInstance();
if (sourcePlanEntity != null)
{
sourcePlanEntity = sourcePlanEntity.FromModel(paymentPlan, pkMap) as PaymentPlanEntity;
var targetPlanEntity = existPlanEntities.FirstOrDefault(x => x.Id == paymentPlan.Id);
if (targetPlanEntity != null)
{
changedEntries.Add(new GenericChangedEntry <PaymentPlan>(paymentPlan, targetPlanEntity.ToModel(AbstractTypeFactory <PaymentPlan> .TryCreateInstance()), EntryState.Modified));
sourcePlanEntity.Patch(targetPlanEntity);
}
else
{
repository.Add(sourcePlanEntity);
changedEntries.Add(new GenericChangedEntry <PaymentPlan>(paymentPlan, EntryState.Added));
}
}
}
//Raise domain events
await _eventPublisher.Publish(new PaymentPlanChangingEvent(changedEntries));
await repository.UnitOfWork.CommitAsync();
pkMap.ResolvePrimaryKeys();
ClearCacheFor(plans);
await _eventPublisher.Publish(new PaymentPlanChangedEvent(changedEntries));
}
}
public virtual async Task SaveChangesAsync(CatalogProduct[] products)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <CatalogProduct> >();
await ValidateProductsAsync(products);
using (var repository = _repositoryFactory())
{
var dbExistProducts = await repository.GetItemByIdsAsync(products.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray());
foreach (var product in products)
{
var modifiedEntity = AbstractTypeFactory <ItemEntity> .TryCreateInstance().FromModel(product, pkMap);
var originalEntity = dbExistProducts.FirstOrDefault(x => x.Id == product.Id);
if (originalEntity != null)
{
changedEntries.Add(new GenericChangedEntry <CatalogProduct>(product, originalEntity.ToModel(AbstractTypeFactory <CatalogProduct> .TryCreateInstance()), EntryState.Modified));
modifiedEntity.Patch(originalEntity);
//Force set ModifiedDate property to mark a product changed. Special for partial update cases when product table not have changes
originalEntity.ModifiedDate = DateTime.UtcNow;
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <CatalogProduct>(product, EntryState.Added));
}
}
await _eventPublisher.Publish(new ProductChangingEvent(changedEntries));
await repository.UnitOfWork.CommitAsync();
pkMap.ResolvePrimaryKeys();
await _eventPublisher.Publish(new ProductChangedEvent(changedEntries));
}
ClearCache(products);
}
public static CustomerOrderEntity ToDataModel(this CustomerOrder order, PrimaryKeyResolvingMap pkMap)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var retVal = new CustomerOrderEntity();
pkMap.AddPair(order, retVal);
retVal.InjectFrom(order);
retVal.Currency = order.Currency.ToString();
if (order.Addresses != null)
{
retVal.Addresses = new ObservableCollection <AddressEntity>(order.Addresses.Select(x => x.ToDataModel()));
}
if (order.Items != null)
{
retVal.Items = new ObservableCollection <LineItemEntity>(order.Items.Select(x => x.ToDataModel(pkMap)));
}
if (order.Shipments != null)
{
retVal.Shipments = new ObservableCollection <ShipmentEntity>(order.Shipments.Select(x => x.ToDataModel(retVal, pkMap)));
}
if (order.InPayments != null)
{
retVal.InPayments = new ObservableCollection <PaymentInEntity>(order.InPayments.Select(x => x.ToDataModel(retVal, pkMap)));
}
if (order.Discount != null)
{
retVal.Discounts = new ObservableCollection <DiscountEntity>(new DiscountEntity[] { order.Discount.ToDataModel() });
}
if (order.TaxDetails != null)
{
retVal.TaxDetails = new ObservableCollection <TaxDetailEntity>();
retVal.TaxDetails.AddRange(order.TaxDetails.Select(x => x.ToDataModel()));
}
return(retVal);
}
protected virtual void SaveChanges(Category[] categories)
{
var pkMap = new PrimaryKeyResolvingMap();
var changedEntries = new List <GenericChangedEntry <Category> >();
ValidateCategoryProperties(categories);
using (var repository = _repositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
var dbExistCategories = repository.GetCategoriesByIds(categories.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray(), CategoryResponseGroup.Full);
foreach (var category in categories)
{
var originalEntity = dbExistCategories.FirstOrDefault(x => x.Id == category.Id);
var modifiedEntity = AbstractTypeFactory <CategoryEntity> .TryCreateInstance().FromModel(category, pkMap);
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
changedEntries.Add(new GenericChangedEntry <Category>(category, originalEntity.ToModel(AbstractTypeFactory <Category> .TryCreateInstance()), EntryState.Modified));
modifiedEntity.Patch(originalEntity);
//Force set ModifiedDate property to mark a product changed. Special for partial update cases when product table not have changes
originalEntity.ModifiedDate = DateTime.UtcNow;
}
else
{
repository.Add(modifiedEntity);
changedEntries.Add(new GenericChangedEntry <Category>(category, EntryState.Added));
}
}
_eventPublisher.Publish(new CategoryChangingEvent(changedEntries));
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
//Reset cached categories and catalogs
ResetCache();
_eventPublisher.Publish(new CategoryChangedEvent(changedEntries));
}
//Need add seo separately
_commerceService.UpsertSeoForObjects(categories.OfType <ISeoSupport>().ToArray());
}
protected virtual void SaveChanges(CatalogProduct[] products, bool disableValidation = false)
{
var pkMap = new PrimaryKeyResolvingMap();
ValidateProducts(products);
using (var repository = _repositoryFactory())
using (var changeTracker = GetChangeTracker(repository))
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
var dbExistProducts = repository.GetItemByIds(products.Where(x => !x.IsTransient()).Select(x => x.Id).ToArray(), ItemResponseGroup.ItemLarge);
foreach (var product in products)
{
var modifiedEntity = AbstractTypeFactory <ItemEntity> .TryCreateInstance().FromModel(product, pkMap);
var originalEntity = dbExistProducts.FirstOrDefault(x => x.Id == product.Id);
if (originalEntity != null)
{
changeTracker.Attach(originalEntity);
modifiedEntity.Patch(originalEntity);
//Force set ModifiedDate property to mark a product changed. Special for partial update cases when product table not have changes
originalEntity.ModifiedDate = DateTime.UtcNow;
}
else
{
repository.Add(modifiedEntity);
}
}
((System.Data.Entity.DbContext)repository).ChangeTracker.DetectChanges();
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
//Update SEO
var productsWithVariations = products.Concat(products.Where(x => x.Variations != null).SelectMany(x => x.Variations)).OfType <ISeoSupport>().ToArray();
_commerceService.UpsertSeoForObjects(productsWithVariations);
}
public virtual DynamicPropertyEntity FromModel(DynamicProperty dynamicProp, PrimaryKeyResolvingMap pkMap)
{
if (dynamicProp == null)
{
throw new ArgumentNullException(nameof(dynamicProp));
}
pkMap.AddPair(dynamicProp, this);
Id = dynamicProp.Id;
CreatedBy = dynamicProp.CreatedBy;
CreatedDate = dynamicProp.CreatedDate;
ModifiedBy = dynamicProp.ModifiedBy;
ModifiedDate = dynamicProp.ModifiedDate;
Description = dynamicProp.Description;
DisplayOrder = dynamicProp.DisplayOrder;
IsArray = dynamicProp.IsArray;
IsDictionary = dynamicProp.IsDictionary;
IsMultilingual = dynamicProp.IsMultilingual;
IsRequired = dynamicProp.IsRequired;
Name = dynamicProp.Name;
ObjectType = dynamicProp.ObjectType;
ValueType = dynamicProp.ValueType.ToString();
if (dynamicProp.DisplayNames != null)
{
DisplayNames = new ObservableCollection <DynamicPropertyNameEntity>(dynamicProp.DisplayNames.Select(x => AbstractTypeFactory <DynamicPropertyNameEntity> .TryCreateInstance().FromModel(x)));
}
if (dynamicProp is DynamicObjectProperty dynamicObjectProp && dynamicObjectProp.Values != null)
{
//Force set these properties from owned property object
foreach (var value in dynamicObjectProp.Values)
{
value.ObjectId = dynamicObjectProp.ObjectId;
value.ObjectType = dynamicObjectProp.ObjectType;
value.ValueType = dynamicObjectProp.ValueType;
}
//ObjectValues = new ObservableCollection<DynamicPropertyObjectValueEntity>(dynamicObjectProp.Values.Select(x => AbstractTypeFactory<DynamicPropertyObjectValueEntity>.TryCreateInstance().FromModel(x)));
}
return(this);
}
public override MemberEntity FromModel(Member member, PrimaryKeyResolvingMap pkMap)
{
var contact = member as Contact;
if (contact != null)
{
FirstName = contact.FirstName;
MiddleName = contact.MiddleName;
LastName = contact.LastName;
BirthDate = contact.BirthDate;
DefaultLanguage = contact.DefaultLanguage;
FullName = contact.FullName;
Salutation = contact.Salutation;
TimeZone = contact.TimeZone;
TaxpayerId = contact.TaxPayerId;
PreferredCommunication = contact.PreferredCommunication;
PreferredDelivery = contact.PreferredDelivery;
PhotoUrl = contact.PhotoUrl;
if (string.IsNullOrEmpty(Name))
{
Name = contact.FullName;
}
if (contact.Organizations != null)
{
MemberRelations = new ObservableCollection <MemberRelationEntity>();
foreach (var organization in contact.Organizations)
{
var memberRelation = new MemberRelationEntity
{
AncestorId = organization,
AncestorSequence = 1,
DescendantId = Id,
};
MemberRelations.Add(memberRelation);
}
}
}
//Call base converter
return(base.FromModel(member, pkMap));
}
public static PaymentEntity ToDataModel(this Payment payment, PrimaryKeyResolvingMap pkMap)
{
if (payment == null)
{
throw new ArgumentNullException("payment");
}
var retVal = new PaymentEntity();
pkMap.AddPair(payment, retVal);
retVal.InjectFrom(payment);
retVal.Currency = payment.Currency.ToString();
if (payment.BillingAddress != null)
{
retVal.Addresses = new ObservableCollection <AddressEntity>(new AddressEntity[] { payment.BillingAddress.ToDataModel() });
}
return(retVal);
}
public virtual PaymentPlanEntity FromModel(PaymentPlan paymentPlan, PrimaryKeyResolvingMap pkMap)
{
if (paymentPlan == null)
{
throw new ArgumentNullException(nameof(paymentPlan));
}
pkMap.AddPair(paymentPlan, this);
Id = paymentPlan.Id;
CreatedBy = paymentPlan.CreatedBy;
CreatedDate = paymentPlan.CreatedDate;
ModifiedBy = paymentPlan.ModifiedBy;
ModifiedDate = paymentPlan.ModifiedDate;
IntervalCount = paymentPlan.IntervalCount;
TrialPeriodDays = paymentPlan.TrialPeriodDays;
Interval = paymentPlan.Interval.ToString();
return(this);
}
