public DSClientBase(Uri serviceUri, IFactory factory, ISecurityTokenInjector securityTokenInjector)
: base(serviceUri, DataServiceProtocolVersion.V3)
{
_securityTokenInjector = securityTokenInjector;
this.MergeOption = MergeOption.PreserveChanges;
this.IgnoreResourceNotFoundException = true;
_entityFactory = factory;
ResolveName = (clientType =>
{
clientType = _entityFactory.GetBaseType(clientType);
return(string.Concat(this.GetType().Namespace + ".", clientType.Name));
//return string.Concat(clientType.Namespace + ".", clientType.Name);
});
ResolveType = (entitySetName =>
{
return(_entityFactory.GetEntityTypeByStringName(entitySetName.Split('.').Last()));
});
IgnoreResourceNotFoundException = true;
WritingEntity += this.DSCatalogClient_WritingEntity;
SendingRequest += DSClientBase_SendingRequest;
ReadingEntity += this.DSCatalogClient_ReadingEntity;
ChangeTracker = CreateChangeTracker();
}
public void SaveSettings(SettingEntry[] settings)
{
if (settings != null && settings.Any())
{
var settingKeys = settings.Select(x => String.Join("-", x.Name, x.ObjectType, x.ObjectId)).Distinct().ToArray();
using (var repository = _repositoryFactory())
using (var changeTracker = new ObservableChangeTracker())
{
var alreadyExistSettings = repository.Settings
.Include(s => s.SettingValues)
.Where(x => settingKeys.Contains(x.Name + "-" + x.ObjectType + "-" + x.ObjectId))
.ToList();
changeTracker.AddAction = x => repository.Add(x);
//Need for real remove object from nested collection (because EF default remove references only)
changeTracker.RemoveAction = x => repository.Remove(x);
var target = new { Settings = new ObservableCollection <SettingEntity>(alreadyExistSettings) };
var source = new { Settings = new ObservableCollection <SettingEntity>(settings.Select(x => AbstractTypeFactory <SettingEntity> .TryCreateInstance().FromModel(x))) };
changeTracker.Attach(target);
var settingComparer = AnonymousComparer.Create((SettingEntity x) => String.Join("-", x.Name, x.ObjectType, x.ObjectId));
source.Settings.Patch(target.Settings, settingComparer, (sourceSetting, targetSetting) => sourceSetting.Patch(targetSetting));
repository.UnitOfWork.Commit();
}
ClearCache(settings);
}
}
public void CatalogPatchTest()
{
var chageTracker = new ObservableChangeTracker
{
RemoveAction = (x) =>
{
Console.WriteLine(x.ToString());
}
};
var dbCatalog1 = new dataModel.Catalog
{
Name = "catalog1",
DefaultLanguage = "en-us"
};
dbCatalog1.CatalogLanguages.Add(new dataModel.CatalogLanguage {
Language = "en-us"
});
dbCatalog1.CatalogLanguages.Add(new dataModel.CatalogLanguage {
Language = "fr-fr"
});
var dbCatalog2 = new dataModel.Catalog
{
Name = "unknow"
};
dbCatalog2.CatalogLanguages.Add(new dataModel.CatalogLanguage {
Language = "ru-ru"
});
chageTracker.Attach(dbCatalog2);
dbCatalog1.Patch(dbCatalog2);
}
public void SaveSettings(SettingEntry[] settings)
{
if (settings != null && settings.Any())
{
var settingKeys = settings.Select(x => String.Join("-", x.Name, x.ObjectType, x.Id)).Distinct().ToArray();
using (var changeTracker = new ObservableChangeTracker())
{
var alreadyExistSettings = _baseUnitOfWork.BaseWorkArea.Setting.Query()
.Include(s => s.SettingValues)
.Where(x => settingKeys.Contains(x.Name + "-" + x.ObjectType + "-" + x.Id))
.ToList();
changeTracker.AddAction = x => _baseUnitOfWork.ExecuteAndCommit(uow => { uow.BaseWorkArea.Setting.Add((SettingEntity)x); });
//Need for real remove object from nested collection (because EF default remove references only)
changeTracker.RemoveAction = x => _baseUnitOfWork.ExecuteAndCommit(uow => { uow.BaseWorkArea.Setting.Delete((SettingEntity)x); });
var target = new { Settings = new List <SettingEntity>(alreadyExistSettings) };
var source = new { Settings = new List <SettingEntity>(settings.Select(x => x.ToEntity())) };
changeTracker.Attach(target);
var settingComparer = AnonymousComparer.Create((SettingEntity x) => String.Join("-", x.Name, x.ObjectType, x.Id));
source.Settings.Patch(target.Settings, settingComparer, (sourceSetting, targetSetting) => sourceSetting.Patch(targetSetting));
}
ClearCache();
}
}
private ObservableChangeTracker CreateChangeTracker()
{
var retVal = new ObservableChangeTracker();
retVal.AddAction = (x) =>
{
var entry = ChangeTracker.GetTrackingEntry(x);
_delayedActions.Add(() => SaveEntryChanges(entry));
};
retVal.RemoveAction = (x) =>
{
var entry = ChangeTracker.GetTrackingEntry(x);
entry.EntryState = EntryState.Detached;
var clonedEntry = new TrackingEntry {
Entity = x.DeepClone(new AssetEntityFactoryExt()), EntryState = EntryState.Deleted
};
_delayedActions.Add(() => SaveEntryChanges(clonedEntry));
};
retVal.AddNewOneToManyRelationAction = (source, property, target) =>
{
var folder = source as Folder;
if (folder != null && property == "SubFolders")
{
if (folder.FolderId != null)
{
((Folder)target).ParentFolderId = folder.FolderId;
}
}
else if (folder != null && property == "FolderItems")
{
if (folder.FolderId != null)
{
((FolderItem)target).FolderId = folder.FolderId;
}
}
};
retVal.PropertyChangedAction = (source, property, target) =>
{
var folder = source as Folder;
if (folder != null)
{
if (property == "FolderId")
{
foreach (var subFolder in folder.Subfolders)
{
subFolder.ParentFolderId = folder.FolderId;
}
foreach (var folderItem in folder.FolderItems)
{
folderItem.FolderId = folder.FolderId;
}
}
}
};
return(retVal);
}
public void Can_changetracker_manipulatecollection()
{
var tracker = new ObservableChangeTracker();
var entity = new TestEntity();
tracker.Add(entity);
tracker.Remove(entity);
tracker.Add(entity);
}
protected virtual ObservableChangeTracker GetChangeTracker(IRepository repository)
{
var retVal = new ObservableChangeTracker
{
RemoveAction = x => repository.Remove(x),
AddAction = x => repository.Add(x)
};
return(retVal);
}
public void SaveCustomerReview(CustomerReview item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
var pkMap = new PrimaryKeyResolvingMap();
using (ICustomerReviewRepository repository = _repositoryFactory())
{
using (ObservableChangeTracker changeTracker = GetChangeTracker(repository))
{
if (!item.IsTransient())
{
var sourceEntity = AbstractTypeFactory <CustomerReviewEntity> .TryCreateInstance().FromModel(item, pkMap);
var existsEntity = repository.GetCustomerReview(item.Id);
if (existsEntity != null)
{
changeTracker.Attach(existsEntity);
sourceEntity.Patch(existsEntity);
}
else
{
repository.Add(sourceEntity);
}
}
else
{
item.Id = Guid.NewGuid().ToString("N");
foreach (var value in item.PropertyValues)
{
value.ReviewId = item.Id;
}
var sourceEntity = AbstractTypeFactory <CustomerReviewEntity> .TryCreateInstance().FromModel(item, pkMap);
repository.Add(sourceEntity);
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
}
}
private ObservableChangeTracker GetChangeTracker(IRepository repository, CustomerOrderEntity customerOrderEntity)
{
var retVal = new ObservableChangeTracker
{
RemoveAction = (x) =>
{
repository.Remove(x);
},
AddAction = (x) =>
{
var address = x as AddressEntity;
var shipment = x as ShipmentEntity;
var lineItem = x as LineItemEntity;
if (address != null)
{
address.CustomerOrder = customerOrderEntity;
}
if (shipment != null)
{
foreach (var shipmentItem in shipment.Items)
{
var orderLineItem = customerOrderEntity.Items.FirstOrDefault(item => item.Id == shipmentItem.Id);
if (orderLineItem != null)
{
orderLineItem.Shipment = shipment;
}
else
{
shipmentItem.CustomerOrder = customerOrderEntity;
}
}
shipment.Items = new NullCollection <LineItemEntity>();
}
if (lineItem != null)
{
lineItem.CustomerOrder = customerOrderEntity;
lineItem.CustomerOrderId = customerOrderEntity.Id;
}
repository.Add(x);
}
};
return(retVal);
}
private ObservableChangeTracker CreateChangeTracker()
{
var retVal = new ObservableChangeTracker();
retVal.KeySelector = (x) =>
{
string key = null;
if (x != null)
{
//old version
var propInfo = x.GetType().FindPropertiesWithAttribute(typeof(KeyAttribute)).First();
key = String.Format("{0}-{1}", x.GetType(), propInfo.GetValue(x, null));
//var propInfo = x.GetType().FindPropertiesWithAttribute(typeof (KeyAttribute)).FirstOrDefault();
//if (propInfo != null)
//{
// key = String.Format("{0}-{1}", x.GetType(), propInfo.GetValue(x, null));
//}
}
return(key);
};
retVal.AddAction = (x) =>
{
var name = ResolveEntitySetName(x);
AddObject(name, x);
};
retVal.AttachAction = (x) =>
{
if (GetEntityDescriptor(x) == null)
{
var name = ResolveEntitySetName(x);
AttachTo(name, x);
}
};
retVal.DettachAction = (x) =>
{
if (GetEntityDescriptor(x) != null)
{
Detach(x);
}
};
retVal.RemoveAction = (x) =>
{
DeleteObject(x);
};
retVal.UpdateAction = (x) =>
{
if (GetEntityDescriptor(x) != null)
{
UpdateObject(x);
}
};
retVal.AttachRelationAction = (source, property, target) =>
AttachRelation(source, property, target);
retVal.AddNewOneToManyRelationAction = (source, property, target) =>
AddNewOneToManyRelation(source, property, target);
retVal.SetManyToOneRelationAction = (source, property, target) =>
{
this.SetLink(source, property, target);
};
retVal.RemoveManyToOneRelationAction = (source, property, target) =>
{
SetLink(source, property, null);
};
retVal.RemoveOneToManyRelationAction = (source, property, target) =>
{
// this code generates a lot of deletes which should be handled by the cascade deletes instead
//DeleteLink(source, property, target);
// mark target object updated, so we can send it to the server and delete it if it can't exist without parent
//Update(target);
};
return(retVal);
}
public FileSystemBlobAssetRepository(string storagePath, IAssetEntityFactory assetEntityFactory)
{
_storagePath = storagePath;
_entityFactory = assetEntityFactory;
ChangeTracker = CreateChangeTracker();
}
public FileSystemRepository()
{
ChangeTracker = CreateChangeTracker();
}
