/// <inheritdoc />
public async Task UpdateExecution(long id, DateTime?nextexecution)
{
if (await updateexecution.ExecuteAsync(DateTime.Now, nextexecution, id) == 0)
{
throw new NotFoundException(typeof(ScheduledTask), id);
}
}
/// <inheritdoc />
public async Task Delete(long id)
{
if (await delete.ExecuteAsync(id) == 0)
{
throw new NotFoundException(typeof(ScheduledTask), id);
}
}
/// <inheritdoc />
public async Task Schedule(long id, DateTime?time)
{
if (await updatescheduletime.ExecuteAsync(time, id) == 0)
{
throw new NotFoundException(typeof(ScheduledTask), id);
}
}
/// <inheritdoc />
public async Task <long> CreateWorkflow(WorkflowStructure data)
{
if (data.Transitions != null)
{
int nodecount = data.Nodes?.Length ?? 0;
foreach (IndexTransition transition in data.Transitions)
{
if (transition.OriginIndex < 0 || transition.OriginIndex >= nodecount)
{
throw new IndexOutOfRangeException("Transition origin index out of range");
}
if (transition.OriginIndex < 0 || transition.TargetIndex < 0 || transition.OriginIndex >= nodecount || transition.TargetIndex >= nodecount)
{
throw new IndexOutOfRangeException("Transition target index out of range");
}
if (transition.OriginIndex == transition.TargetIndex)
{
throw new InvalidOperationException("Transition target must not be the same node as origin");
}
}
}
using Transaction transaction = database.Transaction();
long workflowid = await insertworkflow.ExecuteAsync(1, data.Name, data.Language);
await CreateNodeAndTransitions(transaction, workflowid, data.Nodes, data.Transitions);
transaction.Commit();
return(workflowid);
}
/// <inheritdoc />
public async Task ArchiveObject <T>(Transaction transaction, long id, int revision, T objectdata, string typename = null)
{
typename ??= typeof(T).Name;
await using MemoryStream output = new MemoryStream();
await using (GZipStream gzip = new GZipStream(output, CompressionLevel.Optimal)) {
await Json.WriteAsync(objectdata, gzip);
}
await insert.ExecuteAsync(transaction, typename, id, revision, output.ToArray());
}
/// <inheritdoc />
public async Task DeleteScript(long scriptid)
{
Script script = await GetScript(scriptid);
using Transaction transaction = database.Transaction();
await archiveservice.ArchiveObject(transaction, script.Id, script.Revision, script);
await deletescript.ExecuteAsync(transaction, scriptid);
transaction.Commit();
}
/// <inheritdoc />
public Task <long> Create(ScheduledTaskData data)
{
ScheduledDays days = data.Days;
if (days == ScheduledDays.None)
{
days = ScheduledDays.All;
}
DateTime?nextexecution = data.FirstExecutionTime();
return(insert.ExecuteAsync(data.Name, data.WorkableType, data.WorkableName, data.WorkableRevision, nextexecution, days, data.Interval));
}
/// <inheritdoc />
public async Task DeleteWorkflow(long workflowid)
{
using Transaction transaction = database.Transaction();
await ArchiveWorkflow(transaction, workflowid);
await DeleteTransitions(transaction, workflowid);
await DeleteNodes(transaction, workflowid);
await deleteworkflow.ExecuteAsync(transaction, workflowid);
transaction.Commit();
}
/// <inheritdoc />
public Task StoreTask(WorkableTask task)
{
task.Finished ??= DateTime.Now;
return(insert.ExecuteAsync(task.Id,
task.Type,
task.WorkableId,
task.WorkableRevision,
task.WorkableName,
task.Parameters.Serialize(),
task.Started,
task.Finished,
task.Status,
task.Result.Serialize(),
task.Log.Serialize()));
}
/// <inheritdoc />
public Task <long> CreateScript(ScriptData script)
{
return(insertscript.ExecuteAsync(1, script.Name, script.Code, script.Language));
}
Task DeleteNodes(Transaction transaction, long workflowid)
{
return(deletenodes.ExecuteAsync(transaction, workflowid));
}
Task DeleteTransitions(Transaction transaction, long workflowid)
{
return(deletetransitions.ExecuteAsync(transaction, workflowid));
}
Task CreateTransition(Transaction transaction, long workflowid, Guid origin, Guid target, string condition, TransitionType type, string log)
{
return(inserttransition.ExecuteAsync(transaction, workflowid, origin, target, condition, type, log));
}
Task CreateNode(Transaction transaction, Guid nodeid, long workflowid, string name, string group, NodeType type, object parameters, string result)
{
return(insertnode.ExecuteAsync(transaction, nodeid, workflowid, name, type, parameters.Serialize(), group, result));
}
Task UpdateWorkflow(Transaction transaction, long workflowid, string name, ScriptLanguage?language)
{
return(updateworkflow.ExecuteAsync(transaction, name, language, workflowid));
}
