public override void SaveLinkedEntities(BaseEntity entity)
{
if (EnableSaveLinkedEntities)
base.SaveLinkedEntities (entity);
else
Console.WriteLine ("Bypassed DataLinker.SaveLinkedEntities for unit testing purposes.");
}
public virtual void FindAndFixDifferences(BaseEntity previousEntity, BaseEntity updatedEntity, PropertyInfo property)
{
if (Settings.IsVerbose)
Console.WriteLine (" Finding and fixing all differences between previous and updated '" + updatedEntity.GetType().Name + "' entity on '" + property.Name + "' property.");
var previousLinks = new BaseEntity[]{ };
if (previousEntity != null)
previousLinks = Linker.GetLinkedEntities (previousEntity, property);
var updatedLinks = Linker.GetLinkedEntities (updatedEntity, property);
var linksToAdd = IdentifyEntityLinksToAdd (previousLinks, updatedLinks);
var linksToRemove = IdentifyEntityLinksToRemove (previousLinks, updatedLinks);
if (Settings.IsVerbose) {
Console.WriteLine (" Links to add: " + linksToAdd.Length);
Console.WriteLine (" Links to remove: " + linksToRemove.Length);
}
if (linksToAdd.Length > 0)
CommitNewReverseLinks (updatedEntity, property, linksToAdd);
if (linksToRemove.Length > 0)
RemoveOldReverseLinks (updatedEntity, property, linksToRemove);
}
public override void CommitLinks(BaseEntity entity)
{
if (EnableCommitLinks)
base.CommitLinks (entity);
else
Console.WriteLine ("Bypassed DataLinker.CommitLinks for unit testing purposes.");
}
public void AddLinks(string propertyName, BaseEntity[] linkedEntities)
{
var adder = new EntityLinker ();
foreach (var linkedEntity in linkedEntities) {
adder.AddLink (this, propertyName, linkedEntity);
}
}
public void InternalSave(BaseEntity entity)
{
var key = Keys.GetKey (entity);
var json = Preparer.PrepareForStorage (entity).ToJson ();
Client.Set (key, json);
IdManager.Add (entity);
}
public virtual void CommitLinks(BaseEntity entity)
{
if (Settings.IsVerbose)
Console.WriteLine (" Committing all links for '" + entity.GetType().Name + "'.");
var previousEntity = Reader.Read(entity.GetType(), entity.Id);
FindAndFixDifferences (previousEntity, entity);
}
public void Remove(BaseEntity entity)
{
var ids = new List<string>(GetIds (entity.GetType().Name));
if (!ids.Contains (entity.Id))
ids.Remove (entity.Id);
SetIds (entity.GetType (), ids.ToArray ());
}
public virtual void FindAndFixDifferences(BaseEntity previousEntity, BaseEntity updatedEntity)
{
if (Settings.IsVerbose)
Console.WriteLine (" Finding and fixing all differences between previous and updated '" + updatedEntity.GetType().Name + "' entity.");
foreach (var property in updatedEntity.GetType().GetProperties()) {
if (Linker.IsLinkProperty (updatedEntity, property)) {
FindAndFixDifferences (previousEntity, updatedEntity, property);
}
}
}
public void Update(BaseEntity entity)
{
if (Checker.Exists (entity)) {
if (Settings.IsVerbose)
Console.WriteLine ("Updating: " + entity.GetType ().Name);
Linker.CommitLinks (entity);
InternalUpdate (entity);
} else// if (!Data.PendingSave.Contains(entity)) // TODO: Remove if not needed
throw new EntityNotFoundException (entity);
}
public void Delete(BaseEntity entity)
{
if (entity == null)
throw new ArgumentNullException ("entity");
//Console.WriteLine ("Deleting: " + entity.GetType ().Name);
Linker.RemoveLinks (entity);
Client.Del(Keys.GetKey(entity));
IdManager.Remove (entity);
}
public bool Exists(BaseEntity entity)
{
if (Settings.IsVerbose)
Console.WriteLine ("Checking if entity exists: " + entity.GetType().Name);
var entityType = entity.GetType ();
var foundEntity = Reader.Read(entityType, entity.Id);
var exists = foundEntity != null;
if (Settings.IsVerbose)
Console.WriteLine (" Exists: " + exists);
return exists;
}
public void Save(BaseEntity entity, bool commitLinks)
{
if (!Checker.Exists (entity)) {
var entityType = entity.GetType ();
if (Settings.IsVerbose)
Console.WriteLine ("Saving: " + entityType.Name);
TypeManager.EnsureExists (entityType);
// Commit links before saving, otherwise it will fail
if (commitLinks)
Linker.CommitLinks (entity);
InternalSave (entity);
} else
throw new EntityAlreadyExistsException (entity);
}
public virtual void CommitNewReverseLinks(BaseEntity entity, PropertyInfo property, BaseEntity[] newLinkedEntities)
{
if (Settings.IsVerbose)
Console.WriteLine (" Committing new reverse links for '" + entity.GetType ().Name + "' entity on '" + property.Name + "'.");
var otherPropertyName = Linker.GetOtherPropertyName (property);
if (!String.IsNullOrEmpty (otherPropertyName)) {
foreach (var newLinkedEntity in newLinkedEntities) {
if (!Saver.PendingSave.Contains (newLinkedEntity)
&& !Updater.PendingUpdate.Contains(newLinkedEntity)) {
Linker.AddReturnLink (entity, property, newLinkedEntity, otherPropertyName);
Updater.DelayUpdate (newLinkedEntity);
}
}
}
}
public void Add(BaseEntity entity)
{
Add (entity.GetType(), entity.Id);
}
public void DelayUpdate(BaseEntity entity)
{
if (!PendingUpdate.Contains(entity))
PendingUpdate.Add (entity);
}
public void InternalUpdate(BaseEntity entity)
{
var key = Keys.GetKey (entity);
Client.Set (key, Preparer.PrepareForStorage (entity).ToJson ());
}
public virtual void UpdateLinkedEntities(BaseEntity entity, PropertyInfo property)
{
if (Settings.IsVerbose)
Console.WriteLine ("Updating all entities linked to '" + entity.GetType().Name + "' on '" + property.Name + "' property.");
var linkedEntities = Linker.GetLinkedEntities (entity, property);
foreach (var e in linkedEntities) {
if (Checker.Exists(e))
Updater.Update (e);
}
}
public virtual void UpdateLinkedEntities(BaseEntity entity)
{
if (Settings.IsVerbose)
Console.WriteLine ("Updating all entities linked to '" + entity.GetType().Name + "'.");
foreach (var property in entity.GetType().GetProperties()) {
if (Linker.IsLinkProperty (entity, property)) {
UpdateLinkedEntities (entity, property);
}
}
}
public virtual void RemoveOldReverseLinks(BaseEntity entity, PropertyInfo property, BaseEntity[] oldLinkedEntities)
{
if (Settings.IsVerbose)
Console.WriteLine (" Removing obsolete reverse links for '" + entity.GetType ().Name + "' entity on '" + property.Name + "'.");
var otherPropertyName = Linker.GetOtherPropertyName (property);
if (!String.IsNullOrEmpty (otherPropertyName)) {
foreach (var oldLinkedEntity in oldLinkedEntities) {
Linker.RemoveReturnLink (entity, property, oldLinkedEntity, otherPropertyName);
if (!Updater.PendingUpdate.Contains (oldLinkedEntity))
Updater.DelayUpdate (oldLinkedEntity);
}
}
}
public virtual void RemoveLinks(BaseEntity entity)
{
if (Settings.IsVerbose)
{
Console.WriteLine (" Removing links between '" + entity.GetType().Name + "' and other entities");
}
foreach (var property in entity.GetType().GetProperties()) {
var otherPropertyName = "";
// TODO: Clean up if statement
if ((Linker.PropertyHasLinkAttribute(property, out otherPropertyName)
|| Linker.IsLinkProperty(entity, property))
&& !String.IsNullOrEmpty(otherPropertyName))
{
RemoveLinks (entity, property, otherPropertyName);
}
}
}
public virtual void RemoveLinks(BaseEntity entity, PropertyInfo property, string otherPropertyName)
{
if (Settings.IsVerbose)
Console.WriteLine (" Removing all links for '" + entity.GetType().Name + "' on '" + property.Name + "' property.");
if (!String.IsNullOrEmpty (otherPropertyName)) {
var linkedEntities = Linker.GetLinkedEntities (entity, property);
foreach (var linkedEntity in linkedEntities) {
if (linkedEntity != null) {
Linker.RemoveReturnLink (entity, property, linkedEntity, otherPropertyName);
// Delay update until all references are fixed
Updater.DelayUpdate (linkedEntity);
}
}
}
}
public void AddLink(string propertyName, BaseEntity linkedEntity)
{
var adder = new EntityLinker ();
adder.AddLink (this, propertyName, linkedEntity);
}
public void DelaySave(BaseEntity entity)
{
if (!PendingSave.Contains(entity))
PendingSave.Add (entity);
}
public EntityAlreadyExistsException(BaseEntity entity)
: base("'" + entity.GetType ().Name + "' with the same ID already exists in the data store.")
{
}
public BaseEntity PrepareForStorage(BaseEntity entity)
{
// TODO: Implement clean up of entity if needed
return entity;
}
public virtual void SaveLinkedEntities(BaseEntity entity, PropertyInfo property)
{
if (Settings.IsVerbose)
Console.WriteLine ("Saving all entities linked to '" + entity.GetType().Name + "' on '" + property.Name + "' property.");
var linkedEntities = Linker.GetLinkedEntities (entity, property);
foreach (var e in linkedEntities) {
if (!Checker.Exists (e)) {
Saver.Save(e, false); // Save without committing links otherwise it causes a loop
}
}
}
public string GetKey(BaseEntity entity)
{
return GetKey (entity.Id);
}
public void Save(BaseEntity entity)
{
Save (entity, true);
}
public EntityNotFoundException(BaseEntity entity)
: base("'" + entity.GetType ().Name + "' entity not found in data store.")
{
Entity = entity;
}
public virtual BaseEntity[] IdentifyEntityLinksToRemove(BaseEntity[] previousLinkedEntities, BaseEntity[] updatedLinkedEntities)
{
var linksToRemove = (from entity in previousLinkedEntities
where !Linker.EntityExists (updatedLinkedEntities, entity)
select entity).ToArray ();
return linksToRemove;
}
