public void UseSqlServer()
{
this._createCommand = new SqlServerCreateCommand();
this._updateCommand = new SqlServerUpdateCommand();
this._findCommand = new SqlServerFindCommand();
this._deleteCommand = new SqlServerDeleteCommand();
}
public QuickPadCommands(
IShowGoToCommand <TStorageFile, TStream> showGotoCommand
, IShareCommand <TStorageFile, TStream> shareCommand
, ICutCommand <TStorageFile, TStream> cutCommand
, ICopyCommand <TStorageFile, TStream> copyCommand
, IPasteCommand <TStorageFile, TStream> pasteCommand
, IDeleteCommand <TStorageFile, TStream> deleteCommand
, IContentChangedCommand <TStorageFile, TStream> contentChangedCommand
, IEmojiCommand <TStorageFile, TStream> emojiCommand
, ICompactOverlayCommand <TStorageFile, TStream> compactOverlayCommand
, IRateAndReviewCommand <TStorageFile, TStream> rateAndReviewCommand)
{
_commands = this;
ShareCommand = shareCommand;
CutCommand = cutCommand;
CopyCommand = copyCommand;
PasteCommand = pasteCommand;
DeleteCommand = deleteCommand;
ContentChangedCommand = contentChangedCommand;
EmojiCommand = emojiCommand;
CompactOverlayCommand = compactOverlayCommand;
RateAndReviewCommand = rateAndReviewCommand;
ShowGoToCommand = showGotoCommand;
}
public async Task <IActionResult> Delete([FromRoute] Guid storyId, [FromRoute] int id,
[FromServices] IDeleteCommand <Guid, int, Option> deleteOptionCommand)
{
await deleteOptionCommand.Execute(storyId, id);
return(Ok());
}
public async Task <IActionResult> Delete([FromRoute] Guid id,
[FromServices] IDeleteCommand <Guid, Story> storyDeleteCommand)
{
await storyDeleteCommand.Execute(id);
return(Ok());
}
public T Delete <T>(IDeleteCommand <T> command)
{
if (command.RequiresTransaction && _transaction == null)
{
throw new Exception($"The command {command.GetType()} requires a transaction");
}
return(Retry.Invoke(() => command.Execute(_connection, _transaction), _options));
}
public DeleteCommandTests()
{
sqlExecutor = new Mock <ISqlExecutorWithGeneric>();
sqlBuilder = new SqlBuilder();
command = new DeleteCommand(
sqlBuilder: sqlBuilder,
sqlExecutor: sqlExecutor.Object);
}
public async Task <bool> Handle(IDeleteCommand <T> command)
{
var filter = command.FilterDefinition();
var actionResult = await Collection
.DeleteOneAsync(filter);
return(actionResult.IsSuccess());
}
public UserService(IQuery <UserData, User> query,
ICreateCommand <UserData> createCommand,
IUpdateCommand <UserData> updateCommand,
IDeleteCommand <UserData> deleteCommand)
{
_query = query;
_createCommand = createCommand;
_updateCommand = updateCommand;
_deleteCommand = deleteCommand;
}
public RoleService(IQuery <RoleData, Role> query,
ICreateCommand <RoleData> createCommand,
IUpdateCommand <RoleData> updateCommand,
IDeleteCommand <RoleData> deleteCommand)
{
_query = query;
_createCommand = createCommand;
_updateCommand = updateCommand;
_deleteCommand = deleteCommand;
}
public async Task <IActionResult> Delete([FromRoute] Guid storyId,
[FromRoute] int featureId,
[FromRoute] int optionId,
[FromRoute] OptionValueType type,
[FromServices] IDeleteCommand <Guid, int, int, OptionValueType, OptionValue> deleteCommand)
{
await deleteCommand.Execute(storyId, featureId, optionId, type);
return(Ok());
}
/// <summary>
/// Invoked when disposing or finalizing this instance.
/// </summary>
/// <param name="disposing">True if the object is being disposed, false otherwise.</param>
protected override void OnDispose(bool disposing)
{
try { if (_Command != null)
{
_Command.Dispose();
}
}
catch { }
_Command = null;
base.OnDispose(disposing);
}
private DataBase(
ISelectCommand selectCommand,
IInsertCommand insertCommand,
IDeleteCommand deleteCommand,
IUpdateCommand updateCommand,
ISqlExecutorWithGeneric sqlExecutor)
{
this.selectCommand = selectCommand;
this.insertCommand = insertCommand;
this.deleteCommand = deleteCommand;
this.updateCommand = updateCommand;
this.sqlExecutor = sqlExecutor;
}
public string GenerateSqlCommand <TEntity, TParams>(IDeleteCommand <TEntity, TParams> command, IQueryMetadata metadata)
{
var commandText = new StringBuilder();
// Generate 'delete from ...'
commandText
.Append("delete from ")
.Append(Quoter.QuoteTableName(metadata.TableSchema, metadata.TableName));
// Generate 'where ...'
commandText.Append(" where ");
command.Predicate.GenerateWhereClause(commandText, Quoter, metadata, ParameterSyntaxType.None);
return(commandText.ToString());
}
/// <summary>
/// Generates a delete core command for the given entity, or returns null if such
/// command cannot be generated for whatever reasons.
/// </summary>
internal static IDeleteCommand GenerateDeleteCommand(this IUberMap map, object entity)
{
if (entity == null)
{
return(null);
}
if (map == null || map.IsDisposed || !map.IsValidated)
{
return(null);
}
IDeleteCommand cmd = null;
MetaEntity meta = MetaEntity.Locate(entity, create: true); if (meta.Record == null)
{
var record = new Core.Concrete.Record(map.Schema);
map.WriteRecord(entity, record);
meta.Record = record;
}
var id = map.ExtractId(meta.Record);
if (id != null)
{
cmd = map.Link.Engine.CreateDeleteCommand(map.Link, x => map.Table);
if (map.Discriminator != null)
{
cmd.Where(map.Discriminator);
}
var tag = new DynamicNode.Argument("x");
for (int i = 0; i < id.Count; i++)
{
var left = new DynamicNode.GetMember(tag, id.Schema[i].ColumnName);
var bin = new DynamicNode.Binary(left, ExpressionType.Equal, id[i]);
cmd.Where(x => bin);
left.Dispose();
bin.Dispose();
}
tag.Dispose();
id.Dispose();
}
return(cmd);
}
//TODO: update this to return a type showing what objects got deleted e.g. IObjectId[]
//the "reuest" dataset is assumed to have the Object ID values. However,
//an extended implementation might send a query dataset and this method will query the DB and generate multiple Object IDs
//Example: the request dataset has a date range, wild-card or SOP Class UID...
public DCloudCommandResult Delete
(
fo.DicomDataset request,
ObjectQueryLevel level
)
{
DCloudCommandResult deleteResult = null;
IDeleteCommand deleteCommand = CommandFactory.CreateDeleteCommand( );
DeleteCommandData deleteData = new DeleteCommandData( )
{
Instances = new List <ObjectId> ( )
{
new ObjectId(request)
},
DeleteLevel = level
};
return(deleteResult = deleteCommand.Execute(deleteData));
}
public DeleteCommand(IDeleteCommand command)
{
fullPath = command.FullPath;
}
/// <summary> /// Add From command to query /// </summary> /// <param name="deleteCommand">Delete command instance</param> /// <param name="table">Table name</param> /// <returns></returns> public static IFromCommand From(this IDeleteCommand deleteCommand, string table) => deleteCommand.To((s, p) => new FromCommand(s, p, table));
public DeleteCommand(IDeleteCommand command)
{
fullPath = command.FullPath;
}
/// <summary> /// Add From command to query /// </summary> /// <param name="deleteCommand">Delete command instance</param> /// <param name="table">Table name</param> /// <returns></returns> public static IFromCommand From(this IDeleteCommand deleteCommand, string table) => deleteCommand is IFromCommand command?command.FromCommand(table) : null;
/// <summary>
/// Invoked to execute this operation.
/// </summary>
internal void OnExecute(object origin = null)
{
lock (Repository.MasterLock)
{
List <object> list = null;
ChangeEntry change = null;
IDeleteCommand cmd = null;
DebugEx.IndentWriteLine("\n- Preparing 'Delete({0})'...", MetaEntity);
try
{
list = MetaEntity.GetRemovedChilds(forgetRemoved: true);
foreach (var obj in list)
{
if (obj == null)
{
continue;
}
if (object.ReferenceEquals(obj, origin))
{
continue;
}
var type = obj.GetType(); if (!type.IsClass && !type.IsInterface)
{
continue;
}
var meta = MetaEntity.Locate(obj);
var map = meta.UberMap ?? Repository.LocateUberMap(type);
if (map == null)
{
throw new NotFoundException("Cannot find map for type '{0}'.".FormatWith(type.EasyName()));
}
var op = map.Delete(obj);
try { ((IUberOperation)op).OnExecute(origin: Entity); }
finally { op.Dispose(); }
}
list.Clear(); list = null;
list = MetaEntity.GetDependencies(Map, MemberDependencyMode.Child);
foreach (var obj in list)
{
if (obj == null)
{
continue;
}
if (object.ReferenceEquals(obj, origin))
{
continue;
}
var type = obj.GetType(); if (!type.IsClass && !type.IsInterface)
{
continue;
}
var meta = MetaEntity.Locate(obj);
var map = meta.UberMap ?? Repository.LocateUberMap(type);
if (map == null)
{
throw new NotFoundException("Cannot find map for type '{0}'.".FormatWith(type.EasyName()));
}
var op = map.Delete(obj);
try { ((IUberOperation)op).OnExecute(origin: Entity); }
finally { op.Dispose(); }
}
list.Clear(); list = null;
cmd = Map.GenerateDeleteCommand(Entity);
if (cmd != null)
{
DebugEx.IndentWriteLine("\n- Executing '{0}'...", cmd);
try
{
MetaEntity.ValidateRowVersion();
int n = cmd.Execute();
}
finally { DebugEx.Unindent(); }
}
Map.Detach(Entity);
change = new ChangeEntry(ChangeType.Delete, Map, Entity);
Repository.ChangeEntries.Add(change);
list = MetaEntity.GetDependencies(Map, MemberDependencyMode.Parent);
foreach (var obj in list)
{
if (obj == null)
{
continue;
}
if (object.ReferenceEquals(obj, origin))
{
continue;
}
var type = obj.GetType(); if (!type.IsClass && !type.IsInterface)
{
continue;
}
var meta = MetaEntity.Locate(obj);
var map = meta.UberMap ?? Repository.LocateUberMap(type);
if (map == null)
{
throw new NotFoundException("Cannot find map for type '{0}'.".FormatWith(type.EasyName()));
}
change = new ChangeEntry(ChangeType.Refresh, map, obj);
Repository.ChangeEntries.Add(change);
}
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
cmd = null;
if (list != null)
{
list.Clear();
}
list = null;
DebugEx.Unindent();
}
}
}
