/// <summary>
/// Patch CatalogLanguage type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.PropertyAttribute source, dataModel.PropertyAttribute target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.PropertyAttribute>(x => x.PropertyAttributeName, x => x.PropertyAttributeValue);
target.InjectFrom(patchInjectionPolicy, source);
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.EditorialReview source, dataModel.EditorialReview target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.EditorialReview>(x => x.Content, x => x.Locale, x=>x.Source);
target.InjectFrom(patchInjectionPolicy, source);
}
/// <summary>
/// Patch CatalogLanguage type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.CatalogLanguage source, dataModel.CatalogLanguage target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.CatalogLanguage>(x => x.Language);
target.InjectFrom(patchInjectionPolicy, source);
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.ItemAsset source, dataModel.ItemAsset target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.ItemAsset>(x => x.AssetType, x=> x.SortOrder );
target.InjectFrom(patchInjectionPolicy, source);
}
/// <summary>
/// Patch AssociationGroup type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.AssociationGroup source, dataModel.AssociationGroup target)
{
var patchInjectionPolicy = new PatchInjection<dataModel.AssociationGroup>(x => x.Name, x => x.Description);
target.InjectFrom(patchInjectionPolicy, source);
if (!source.Associations.IsNullCollection())
{
var associationComparer = AnonymousComparer.Create((dataModel.Association x) => x.ItemId);
source.Associations.Patch(target.Associations, associationComparer,
(sourceAssociation, targetAssociation) => sourceAssociation.Patch(targetAssociation));
}
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.PropertyValue source, dataModel.PropertyValue target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
var patchInjectionPolicy = new PatchInjection<dataModel.PropertyValue>(x => x.BooleanValue, x => x.DateTimeValue,
x => x.DecimalValue, x => x.IntegerValue,
x => x.KeyValue, x => x.LongTextValue, x => x.ShortTextValue);
target.InjectFrom(patchInjectionPolicy, source);
}
/// <summary>
/// Patch CatalogBase type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.Catalog source, dataModel.Catalog target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.Catalog>(x => x.Name, x => x.DefaultLanguage);
target.InjectFrom(patchInjectionPolicy, source);
//Languages patch
var sourceCatalog = source as dataModel.Catalog;
var targetCatalog = target as dataModel.Catalog;
if (sourceCatalog != null && targetCatalog != null && !sourceCatalog.CatalogLanguages.IsNullCollection())
{
var languageComparer = AnonymousComparer.Create((dataModel.CatalogLanguage x) => x.Language);
sourceCatalog.CatalogLanguages.Patch(targetCatalog.CatalogLanguages, languageComparer,
(sourceLang, targetlang) => sourceLang.Patch(targetlang));
}
//Property values
if (sourceCatalog != null && !sourceCatalog.CatalogPropertyValues.IsNullCollection())
{
sourceCatalog.CatalogPropertyValues.Patch(targetCatalog.CatalogPropertyValues, (sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this coreModel.CatalogProduct source, dataModel.Item target)
{
if (target == null)
throw new ArgumentNullException("target");
//TODO: temporary solution because partial update replaced not nullable properties in db entity
if (source.IsBuyable != null)
target.IsBuyable = source.IsBuyable.Value;
if (source.IsActive != null)
target.IsActive = source.IsActive.Value;
if (source.TrackInventory != null)
target.TrackInventory = source.TrackInventory.Value;
if (source.MinQuantity != null)
target.MinQuantity = source.MinQuantity.Value;
if (source.MaxQuantity != null)
target.MaxQuantity = source.MaxQuantity.Value;
//Handle three valuable states (null, empty and have value states) for case when need reset catalog or category
if (source.CatalogId == String.Empty)
target.CatalogId = null;
if (source.CategoryId == String.Empty)
target.CategoryId = null;
var patchInjectionPolicy = new PatchInjection<dataModel.Item>(x => x.Name, x => x.Code, x => x.ManufacturerPartNumber, x => x.Gtin, x => x.ProductType,
x => x.WeightUnit, x => x.Weight, x => x.MeasureUnit, x => x.Height, x => x.Length, x => x.Width, x => x.EnableReview, x => x.MaxNumberOfDownload,
x => x.DownloadExpiration, x => x.DownloadType, x => x.HasUserAgreement, x => x.ShippingType, x => x.TaxType, x => x.Vendor, x => x.CatalogId, x => x.CategoryId);
var dbSource = source.ToDataModel();
target.InjectFrom(patchInjectionPolicy, dbSource);
#region Assets
if (!dbSource.Assets.IsNullCollection())
{
dbSource.Assets.Patch(target.Assets, (sourceAsset, targetAsset) => sourceAsset.Patch(targetAsset));
}
#endregion
#region Images
if (!dbSource.Images.IsNullCollection())
{
dbSource.Images.Patch(target.Images, (sourceImage, targetImage) => sourceImage.Patch(targetImage));
}
#endregion
#region ItemPropertyValues
if (!dbSource.ItemPropertyValues.IsNullCollection())
{
//Need skip inherited properties without overridden value
if (source.MainProduct != null)
{
var dbParent = source.MainProduct.ToDataModel();
var parentPropValues = dbParent.ItemPropertyValues.ToLookup(x => x.Name + "-" + x.ToString());
var variationPropValues = dbSource.ItemPropertyValues.ToLookup(x => x.Name + "-" + x.ToString());
dbSource.ItemPropertyValues = new ObservableCollection<dataModel.ItemPropertyValue>(variationPropValues.Where(x => !parentPropValues.Contains(x.Key)).SelectMany(x => x));
}
dbSource.ItemPropertyValues.Patch(target.ItemPropertyValues, (sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
#endregion
#region Links
if (!dbSource.CategoryLinks.IsNullCollection())
{
dbSource.CategoryLinks.Patch(target.CategoryLinks, new CategoryItemRelationComparer(),
(sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
#endregion
#region EditorialReviews
if (!dbSource.EditorialReviews.IsNullCollection())
{
dbSource.EditorialReviews.Patch(target.EditorialReviews, (sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
#endregion
#region Association
if (!dbSource.AssociationGroups.IsNullCollection())
{
var associationComparer = AnonymousComparer.Create((dataModel.AssociationGroup x) => x.Name);
dbSource.AssociationGroups.Patch(target.AssociationGroups, associationComparer,
(sourceGroup, targetGroup) => sourceGroup.Patch(targetGroup));
}
#endregion
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.Property source, dataModel.Property target)
{
if (target == null)
throw new ArgumentNullException("target");
var patchInjectionPolicy = new PatchInjection<dataModel.Property>(x => x.PropertyValueType, x => x.IsEnum, x => x.IsMultiValue, x => x.IsLocaleDependant,
x => x.IsRequired, x => x.TargetType, x => x.Name);
target.InjectFrom(patchInjectionPolicy, source);
//Attributes patch
if (!source.PropertyAttributes.IsNullCollection())
{
var attributeComparer = AnonymousComparer.Create((dataModel.PropertyAttribute x) => x.IsTransient() ? x.PropertyAttributeName : x.Id);
source.PropertyAttributes.Patch(target.PropertyAttributes, attributeComparer, (sourceAsset, targetAsset) => sourceAsset.Patch(targetAsset));
}
//Property dict values
if (!source.PropertyValues.IsNullCollection())
{
source.PropertyValues.Patch(target.PropertyValues, (sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
}
/// <summary>
/// Patch changes
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this coreModel.Category source, dataModel.Category target)
{
if (target == null)
throw new ArgumentNullException("target");
//TODO: temporary solution because partial update replaced not nullable properties in db entity
if (source.IsActive != null)
target.IsActive = source.IsActive.Value;
var dbSource = source.ToDataModel() as dataModel.Category;
var dbTarget = target as dataModel.Category;
if (dbSource != null && dbTarget != null)
{
var patchInjectionPolicy = new PatchInjection<dataModel.Category>(x => x.Code, x=>x.Name, x=>x.TaxType);
target.InjectFrom(patchInjectionPolicy, source);
if (!dbSource.CategoryPropertyValues.IsNullCollection())
{
dbSource.CategoryPropertyValues.Patch(dbTarget.CategoryPropertyValues, (sourcePropValue, targetPropValue) => sourcePropValue.Patch(targetPropValue));
}
if(!dbSource.OutgoingLinks.IsNullCollection())
{
dbSource.OutgoingLinks.Patch(dbTarget.OutgoingLinks, new LinkedCategoryComparer(), (sourceLink, targetLink) => sourceLink.Patch(targetLink));
}
if (!dbSource.Images.IsNullCollection())
{
dbSource.Images.Patch(dbTarget.Images, (sourceImage, targetImage) => sourceImage.Patch(targetImage));
}
}
}
/// <summary>
/// Patch Association type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this dataModel.Association source, dataModel.Association target)
{
var patchInjectionPolicy = new PatchInjection<dataModel.Association>(x => x.Priority);
target.InjectFrom(patchInjectionPolicy, source);
}
