/// <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(); } } }