public bool Update(
TNew newValue,
TDb value,
Dictionary <int, IUpdateRecords <TUserId> > updateValues)
{
UpdateRecordImpl <TUserId, TDb, TKey, TNew> updateRecord;
if (updateValues.TryGetValue(this.NodeId, out var temp))
{
updateRecord = (UpdateRecordImpl <TUserId, TDb, TKey, TNew>)temp;
}
else
{
updateRecord = new UpdateRecordImpl <TUserId, TDb, TKey, TNew>(
this.NodeId,
this.diffRepository);
updateValues[this.NodeId] = updateRecord;
}
var changed = false;
var createdNew = false;
if (value == null)
{
value = new TDb();
value.NewValue = newValue;
createdNew = true;
}
foreach (var updateValue in this.updateValues)
{
changed = updateValue.Update(newValue, value) || changed;
}
changed = (this.RunManyToOneUpdate(newValue, value, updateValues) && this.immutable) || changed;
if (changed)
{
if (this.immutable || createdNew)
{
updateRecord.Add(value);
}
else
{
updateRecord.Update(value);
}
}
this.RunManyToManyUpdate(newValue, value, updateValues);
return(changed);
}
public bool Update(
TNew newValue,
TDbValue value,
Dictionary <int, IUpdateRecords <TUserId> > updateValues)
{
var newModel = this.newProp(newValue);
var dbValue = this.dbValue(value);
if (newModel == null)
{
this.setDbValue(value, null);
return(true);
}
if (dbValue == null)
{
dbValue = new TDbProp();
}
var changed = false;
foreach (var updateValue in childValues)
{
changed = updateValue.Update(newModel, dbValue) || changed;
}
// Need to run this first.
changed = this.RunManyToOneUpdate(
newModel,
dbValue,
updateValues) || changed;
if (changed)
{
UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp> updateNode;
if (updateValues.TryGetValue(this.NodeId, out var node))
{
updateNode = (UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp>)node;
}
else
{
updateNode = new UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp>(this.NodeId, this.diffRepository);
updateValues[this.NodeId] = updateNode;
}
if (this.immutable)
{
updateNode.Add(dbValue);
dbValue.NewRecord();
}
else
{
updateNode.Update(dbValue);
dbValue.UpdateRecord();
}
}
changed = this.RunManyToManyUpdate(
newModel,
dbValue,
updateValues) || changed;
return(changed);
}
public bool Update(
TNew newValue,
TDbValue value,
Dictionary <int, IUpdateRecords <TUserId> > updateValues)
{
var changed = false;
UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp> updateNode;
if (updateValues.TryGetValue(this.NodeId, out var temp))
{
updateNode = (UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp>)temp;
}
else
{
updateNode = new UpdateRecordImpl <TUserId, TDbProp, TChildKey, TNewProp>(
this.NodeId,
this.diffRepository);
updateValues[this.NodeId] = updateNode;
}
var newValues = this.newProp(newValue);
var dbValues = this.dbValue(value).ToKeyValue(
(v) => v.Id);
var hashSetSeen = new HashSet <TChildKey>();
foreach (var nV in newValues)
{
var newKey = this.newPropKey(nV);
if (dbValues.TryGetValue(newKey, out var dbValue))
{
if (!hashSetSeen.Contains(newKey))
{
hashSetSeen.Add(newKey);
}
if (this.UpdateValues(nV, dbValue) ||
value.IsNew())
{
if (this.immutable)
{
dbValue.NewRecord();
updateNode.Add(dbValue);
}
else
{
dbValue.UpdateRecord();
updateNode.Update(dbValue);
}
}
}
else
{
dbValue = new TDbProp();
dbValue.NewRecord();
this.UpdateValues(nV, dbValue);
this.setParent(dbValue, value);
updateNode.Add(dbValue);
}
this.RunManyToOneUpdate(
nV,
dbValue,
updateValues);
this.RunManyToManyUpdate(
nV,
dbValue,
updateValues);
}
var dbSet = new HashSet <TChildKey>(dbValues.Keys);
dbSet.ExceptWith(hashSetSeen);
foreach (var key in dbSet)
{
updateNode.Delete(dbValues[key]);
}
return(false);
}
