/// <summary>
/// Save (insert/update) a ControlledUpdateThing into the store
/// </summary>
/// <param name="entitiesBeingHandled">Entities already being saved further up the save stack</param>
/// <param name="controlledUpdateThings">The ControlledUpdateThings to save</param>
/// <param name="toSave">Entity types to cascade to, if they are loaded</param>
internal void Save(List <Entity> entitiesBeingHandled, Flags toSave, params ControlledUpdateThing[] controlledUpdateThings)
{
if (controlledUpdateThings == null)
{
throw new ArgumentNullException("controlledUpdateThings");
}
Log("Save", controlledUpdateThings.Select <ControlledUpdateThing, int>(entity => entity.Identity).ToArray <int>(), EntityType.None);
// Copy the list of entities being handled, and add this new set of entities to it.
// We're handling those now.
List <Entity> entitiesNowBeingHandled = new List <Entity>(entitiesBeingHandled);
entitiesNowBeingHandled.AddRange(controlledUpdateThings);
// Loop over each entity and save it.
foreach (ControlledUpdateThing controlledUpdateThing in controlledUpdateThings)
{
using (PebblecodeUpdateContexts.PebbleAdmin(controlledUpdateThing)) {
// Already being saved higher up the stack?
if (entitiesBeingHandled.ContainsEntity(controlledUpdateThing))
{
continue;
}
// Allow derived/partial class to do extra work
OnBeforeSaveEntity(controlledUpdateThing);
bool saved = false;
try
{
// Save the entity
if (controlledUpdateThing.IsNew)
{
this.Mapper.Insert("InsertControlledUpdateThing", controlledUpdateThing);
saved = true;
}
else if (controlledUpdateThing.IsChanged)
{
if (this.Mapper.Update("UpdateControlledUpdateThing", controlledUpdateThing) != 1)
{
ThrowControlledUpdateThingEntityException(controlledUpdateThing.Identity);
}
saved = true;
}
}
catch (Exception ex)
{
throw EntityLogger.WriteUnexpectedException(
ex,
"Failed to insert/update Entity",
Category.EntityFramework,
controlledUpdateThing);
}
// Post save protocol
if (saved)
{
// Allow derived/partial class to do extra work
OnAfterSaveEntity(controlledUpdateThing);
try
{
VersionedEntityInfo versionInfo = this.Mapper.QueryForObject <VersionedEntityInfo>(
"SelectControlledUpdateThingVersionInfo",
controlledUpdateThing.Identity);
controlledUpdateThing.Reset(versionInfo);
}
catch (Exception ex)
{
throw EntityLogger.WriteUnexpectedException(
ex,
"Failed to reset version information",
Category.EntityFramework,
controlledUpdateThing);
}
//The insert/update will have resulted in a new database_update row, inform interested parties
RaiseModelChanged();
}
}
}
}
/// <summary>
/// Save (insert/update) a NodeBuilderTest into the store
/// </summary>
/// <param name="entitiesBeingHandled">Entities already being saved further up the save stack</param>
/// <param name="nodeBuilderTests">The NodeBuilderTests to save</param>
/// <param name="toSave">Entity types to cascade to, if they are loaded</param>
internal void Save(List <Entity> entitiesBeingHandled, Flags toSave, params NodeBuilderTest[] nodeBuilderTests)
{
if (nodeBuilderTests == null)
{
throw new ArgumentNullException("nodeBuilderTests");
}
Log("Save", nodeBuilderTests.Select <NodeBuilderTest, int>(entity => entity.Identity).ToArray <int>(), EntityType.None);
// Copy the list of entities being handled, and add this new set of entities to it.
// We're handling those now.
List <Entity> entitiesNowBeingHandled = new List <Entity>(entitiesBeingHandled);
entitiesNowBeingHandled.AddRange(nodeBuilderTests);
// Loop over each entity and save it.
foreach (NodeBuilderTest nodeBuilderTest in nodeBuilderTests)
{
// Already being saved higher up the stack?
if (entitiesBeingHandled.ContainsEntity(nodeBuilderTest))
{
continue;
}
// Allow derived/partial class to do extra work
OnBeforeSaveEntity(nodeBuilderTest);
bool saved = false;
try
{
// Save the entity
if (nodeBuilderTest.IsNew)
{
this.Mapper.Insert("InsertNodeBuilderTest", nodeBuilderTest);
saved = true;
}
else if (nodeBuilderTest.IsChanged)
{
if (this.Mapper.Update("UpdateNodeBuilderTest", nodeBuilderTest) != 1)
{
ThrowNodeBuilderTestEntityException(nodeBuilderTest.Identity);
}
saved = true;
}
}
catch (Exception ex)
{
throw EntityLogger.WriteUnexpectedException(
ex,
"Failed to insert/update Entity",
Category.EntityFramework,
nodeBuilderTest);
}
// Post save protocol
if (saved)
{
// Allow derived/partial class to do extra work
OnAfterSaveEntity(nodeBuilderTest);
nodeBuilderTest.Reset();
//The insert/update will have resulted in a new database_update row, inform interested parties
RaiseModelChanged();
}
}
}
/// <summary>
/// Save (insert/update) a Widget into the store
/// </summary>
/// <param name="entitiesBeingHandled">Entities already being saved further up the save stack</param>
/// <param name="widgets">The Widgets to save</param>
/// <param name="toSave">Entity types to cascade to, if they are loaded</param>
internal void Save(List <Entity> entitiesBeingHandled, Flags toSave, params Widget[] widgets)
{
if (widgets == null)
{
throw new ArgumentNullException("widgets");
}
Log("Save", widgets.Select <Widget, int>(entity => entity.Identity).ToArray <int>(), EntityType.None);
// Copy the list of entities being handled, and add this new set of entities to it.
// We're handling those now.
List <Entity> entitiesNowBeingHandled = new List <Entity>(entitiesBeingHandled);
entitiesNowBeingHandled.AddRange(widgets);
// Loop over each entity and save it.
foreach (Widget widget in widgets)
{
// Already being saved higher up the stack?
if (entitiesBeingHandled.ContainsEntity(widget))
{
continue;
}
// Allow derived/partial class to do extra work
OnBeforeSaveEntity(widget);
// Save parent entity... so we can update our key to it
if ((toSave & EntityType.Thing) == EntityType.Thing &&
widget.ThingPopulated)
{
if (!entitiesBeingHandled.ContainsEntity(widget.Thing))
{
ThingRepo.Save(entitiesNowBeingHandled, toSave, widget.Thing);
widget.ThingId = widget.Thing.Identity;
}
}
bool saved = false;
try
{
// Save the entity
if (widget.IsNew)
{
this.Mapper.Insert("InsertWidget", widget);
saved = true;
}
else if (widget.IsChanged)
{
if (this.Mapper.Update("UpdateWidget", widget) != 1)
{
ThrowWidgetEntityException(widget.Identity);
}
saved = true;
}
}
catch (Exception ex)
{
throw EntityLogger.WriteUnexpectedException(
ex,
"Failed to insert/update Entity",
Category.EntityFramework,
widget);
}
// Save child entities... update their key to us
if ((toSave & EntityType.FieldTest) == EntityType.FieldTest &&
widget.FieldTestListUsingForeignKeyFieldPopulated)
{
foreach (FieldTest childFieldTest in widget.FieldTestListUsingForeignKeyField)
{
childFieldTest.ForeignKeyField = widget.Identity;
if (!entitiesBeingHandled.ContainsEntity(childFieldTest))
{
if (childFieldTest.IsDeleted)
{
FieldTestRepo.Delete(entitiesNowBeingHandled, toSave, childFieldTest);
}
else
{
FieldTestRepo.Save(entitiesNowBeingHandled, toSave, childFieldTest);
}
}
}
}
// Save child entities... update their key to us
if ((toSave & EntityType.FieldTest) == EntityType.FieldTest &&
widget.FieldTestListUsingForeignKeyFieldNullablePopulated)
{
foreach (FieldTest childFieldTest in widget.FieldTestListUsingForeignKeyFieldNullable)
{
childFieldTest.ForeignKeyFieldNullable = widget.Identity;
if (!entitiesBeingHandled.ContainsEntity(childFieldTest))
{
if (childFieldTest.IsDeleted)
{
FieldTestRepo.Delete(entitiesNowBeingHandled, toSave, childFieldTest);
}
else
{
FieldTestRepo.Save(entitiesNowBeingHandled, toSave, childFieldTest);
}
}
}
}
// Post save protocol
if (saved)
{
// Allow derived/partial class to do extra work
OnAfterSaveEntity(widget);
widget.Reset();
//The insert/update will have resulted in a new database_update row, inform interested parties
RaiseModelChanged();
}
}
}
/// <summary>
/// Save (insert/update) a Thing into the store
/// </summary>
/// <param name="entitiesBeingHandled">Entities already being saved further up the save stack</param>
/// <param name="things">The Things to save</param>
/// <param name="toSave">Entity types to cascade to, if they are loaded</param>
internal void Save(List <Entity> entitiesBeingHandled, Flags toSave, params Thing[] things)
{
if (things == null)
{
throw new ArgumentNullException("things");
}
Log("Save", things.Select <Thing, int>(entity => entity.Identity).ToArray <int>(), EntityType.None);
// Copy the list of entities being handled, and add this new set of entities to it.
// We're handling those now.
List <Entity> entitiesNowBeingHandled = new List <Entity>(entitiesBeingHandled);
entitiesNowBeingHandled.AddRange(things);
// Loop over each entity and save it.
foreach (Thing thing in things)
{
// Already being saved higher up the stack?
if (entitiesBeingHandled.ContainsEntity(thing))
{
continue;
}
// Allow derived/partial class to do extra work
OnBeforeSaveEntity(thing);
bool saved = false;
try
{
// Save the entity
if (thing.IsNew)
{
this.Mapper.Insert("InsertThing", thing);
saved = true;
}
else if (thing.IsChanged)
{
if (this.Mapper.Update("UpdateThing", thing) != 1)
{
ThrowThingEntityException(thing.Identity);
}
saved = true;
}
}
catch (Exception ex)
{
throw EntityLogger.WriteUnexpectedException(
ex,
"Failed to insert/update Entity",
Category.EntityFramework,
thing);
}
// Save child entities... update their key to us
if ((toSave & EntityType.Widget) == EntityType.Widget &&
thing.WidgetListPopulated)
{
foreach (Widget childWidget in thing.WidgetList)
{
childWidget.ThingId = thing.Identity;
if (!entitiesBeingHandled.ContainsEntity(childWidget))
{
if (childWidget.IsDeleted)
{
WidgetRepo.Delete(entitiesNowBeingHandled, toSave, childWidget);
}
else
{
WidgetRepo.Save(entitiesNowBeingHandled, toSave, childWidget);
}
}
}
}
// Post save protocol
if (saved)
{
// Allow derived/partial class to do extra work
OnAfterSaveEntity(thing);
thing.Reset();
//The insert/update will have resulted in a new database_update row, inform interested parties
RaiseModelChanged();
}
}
}