public override async Task <Result> ImportAsync(string fileName, CancellationToken cancellationToken)
{
var result = await ReadAsXmlFromDiskAsync <List <TriggerBackup> >(fileName);
if (result.HasError)
{
return(Result.ReportError(result.Message));
}
var skippedCount = 0;
var newTriggers = new List <DeviceValueTrigger>();
using (var context = new ZvsContext(EntityContextConnection))
{
var existingTriggers = await context.DeviceValueTriggers.ToListAsync(cancellationToken);
var existingDeviceValues = await context.DeviceValues
.Include(o => o.Device)
.ToListAsync(cancellationToken);
foreach (var backupTrigger in result.Data)
{
if (existingTriggers.Any(o => o.Name == backupTrigger.Name))
{
skippedCount++;
continue;
}
var dv = existingDeviceValues.FirstOrDefault(o => o.Device.NodeNumber == backupTrigger.NodeNumber &&
o.Name == backupTrigger.DeviceValueName);
var cmd =
await
StoredCmdBackup.RestoreStoredCommandAsync(context, backupTrigger.StoredCommand,
cancellationToken);
if (dv == null || cmd == null)
{
continue;
}
var dvTrigger = new DeviceValueTrigger
{
Name = backupTrigger.Name,
DeviceValue = dv,
IsEnabled = backupTrigger.isEnabled
};
dvTrigger.Name = backupTrigger.Name;
dvTrigger.Argument = cmd.Argument;
dvTrigger.Argument2 = cmd.Argument2;
dvTrigger.CommandId = cmd.CommandId;
if (backupTrigger.Operator != null)
{
dvTrigger.Operator = (TriggerOperator)backupTrigger.Operator;
}
dvTrigger.Value = backupTrigger.Value;
newTriggers.Add(dvTrigger);
}
context.DeviceValueTriggers.AddRange(newTriggers);
if (newTriggers.Count > 0)
{
var saveResult = await context.TrySaveChangesAsync(cancellationToken);
if (saveResult.HasError)
{
return(Result.ReportError(saveResult.Message));
}
foreach (var cmd in newTriggers)
{
cmd.SetDescription();
await cmd.SetTargetObjectNameAsync(context);
cmd.SetTriggerDescription();
}
var r = await context.TrySaveChangesAsync(cancellationToken);
if (r.HasError)
{
return(Result.ReportError(r.Message));
}
}
}
return
(Result.ReportSuccess(
$"Imported {newTriggers.Count} triggers, skipped {skippedCount} from {Path.GetFileName(fileName)}"));
}
public async override Task <Result> ImportAsync(string fileName, CancellationToken cancellationToken)
{
var result = await ReadAsXmlFromDiskAsync <List <SceneBackup> >(fileName);
if (result.HasError)
{
return(Result.ReportError(result.Message));
}
var skippedCount = 0;
var newScene = new List <Scene>();
var importedCmdCount = 0;
using (var context = new ZvsContext(EntityContextConnection))
{
var existingScenes = await context.Scenes.ToListAsync(cancellationToken);
foreach (var backupScene in result.Data)
{
if (existingScenes.Any(o => o.Name == backupScene.Name))
{
skippedCount++;
continue;
}
var s = new Scene {
Name = backupScene.Name
};
foreach (var backupSceneCmd in backupScene.Commands)
{
var sc = await StoredCmdBackup.RestoreStoredCommandAsync(context, backupSceneCmd.StoredCommand, cancellationToken);
if (sc == null)
{
continue;
}
s.Commands.Add(new SceneStoredCommand
{
Argument = sc.Argument,
Argument2 = sc.Argument2,
CommandId = sc.CommandId,
SortOrder = backupSceneCmd.Order
});
importedCmdCount++;
}
newScene.Add(s);
}
context.Scenes.AddRange(newScene);
if (newScene.Count > 0)
{
var saveResult = await context.TrySaveChangesAsync(cancellationToken);
if (saveResult.HasError)
{
return(Result.ReportError(saveResult.Message));
}
}
}
return(Result.ReportSuccess(
$"Imported {newScene.Count} scenes with {importedCmdCount} scene commands. Skipped {skippedCount} scene from {Path.GetFileName(fileName)}"));
}
public async override Task <Result> ImportAsync(string fileName, CancellationToken cancellationToken)
{
var result = await ReadAsXmlFromDiskAsync <List <ScheduledTaskBackup> >(fileName);
if (result.HasError)
{
return(Result.ReportError(result.Message));
}
var skippedCount = 0;
var newSTs = new List <DataModel.ScheduledTask>();
using (var context = new ZvsContext(EntityContextConnection))
{
var existingScheduledTasks = await context.ScheduledTasks
.ToListAsync(cancellationToken);
foreach (var scheduledTaskBackup in result.Data)
{
if (existingScheduledTasks.Any(o => o.Name == scheduledTaskBackup.Name))
{
skippedCount++;
continue;
}
var cmd =
await
StoredCmdBackup.RestoreStoredCommandAsync(context, scheduledTaskBackup.StoredCommand,
cancellationToken);
if (cmd == null)
{
continue;
}
var task = new DataModel.ScheduledTask
{
Argument = cmd.Argument,
Argument2 = cmd.Argument2,
CommandId = cmd.CommandId,
Name = scheduledTaskBackup.Name,
IsEnabled = scheduledTaskBackup.isEnabled,
RepeatIntervalInDays = scheduledTaskBackup.RecurDays ?? 0,
RepeatIntervalInMonths = scheduledTaskBackup.RecurMonth ?? 0,
RepeatIntervalInSeconds = scheduledTaskBackup.RecurSeconds ?? 0,
RepeatIntervalInWeeks = scheduledTaskBackup.RecurWeeks ?? 0,
SortOrder = scheduledTaskBackup.sortOrder,
StartTime = scheduledTaskBackup.startTime ?? DateTime.Now
};
if (scheduledTaskBackup.Frequency != null)
{
task.TaskType = (ScheduledTaskType)scheduledTaskBackup.Frequency;
}
if (scheduledTaskBackup.DaysOfMonthToActivate != null)
{
task.DaysOfMonthToActivate = (DaysOfMonth)scheduledTaskBackup.DaysOfMonthToActivate;
}
if (scheduledTaskBackup.DaysOfWeekToActivate != null)
{
task.DaysOfWeekToActivate = (DaysOfWeek)scheduledTaskBackup.DaysOfWeekToActivate;
}
newSTs.Add(task);
}
context.ScheduledTasks.AddRange(newSTs);
if (newSTs.Count > 0)
{
var saveResult = await context.TrySaveChangesAsync(cancellationToken);
if (saveResult.HasError)
{
return(Result.ReportError(saveResult.Message));
}
foreach (var task in newSTs)
{
task.SetDescription();
await task.SetTargetObjectNameAsync(context);
}
var r = await context.TrySaveChangesAsync(cancellationToken);
if (r.HasError)
{
return(Result.ReportError(r.Message));
}
}
}
return(Result.ReportSuccess(
$"Imported {newSTs.Count} scheduled tasks, skipped {skippedCount} from {Path.GetFileName(fileName)}"));
}