public void Save(SyncPlan plan, string path)
{
//path = @"C:\Users\Alexandr\Desktop\TEST\save";
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
formatter.Serialize(fs, plan);
}
}
public static void PrintPlan(SyncPlan plan)
{
Console.WriteLine("Builded plan:");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(plan);
Console.ResetColor();
}
public void Apply(SyncPlan syncPlan, bool isAgreed)
{
var source = Substitute.For <IExternalWorksheetRepository>();
var target = Substitute.For <IJiraRepository>();
var sut = new WorksheetSyncService(source, target)
{
AgreeToAdd = (items) => isAgreed,
AgreeToUpdate = (items) => isAgreed,
AgreeToDeleteDuplicates = (items) => isAgreed,
AgreeToDeleteOrphaned = (items) => isAgreed
};
var report = sut.Apply(syncPlan);
//assert that appropriate operation took place only if agreed
target.Received(isAgreed ? syncPlan.ToAdd.Count : 0).AddWorkLog(Arg.Any <WorkLogEntry>());
target.Received(isAgreed ? syncPlan.ToUpdate.Count : 0).UpdateWorkLog(Arg.Any <WorkLogEntry>());
target.Received(isAgreed ? syncPlan.ToDeleteDuplicates.Count + syncPlan.ToDeleteOrphaned.Count : 0).DeleteWorkLog(Arg.Any <WorkLogEntry>());
//sert report reflect the numbers
Assert.AreEqual(report.AddedEntries.Count, isAgreed ? syncPlan.ToAdd.Count : 0);
Assert.AreEqual(report.UpdatedEntries.Count, isAgreed ? syncPlan.ToUpdate.Count : 0);
Assert.AreEqual(report.DeletedDuplicateEntries.Count, isAgreed ? syncPlan.ToDeleteDuplicates.Count : 0);
Assert.AreEqual(report.DeletedOrphanedEntries.Count, isAgreed ? syncPlan.ToDeleteOrphaned.Count : 0);
Assert.AreEqual(report.NoChanges.Count, syncPlan.NoChanges.Count);
}
public void Save(SyncPlan plan, string path)
{
//path = @"C:\Users\Alexandr\Desktop\TEST\save";
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
formatter.Serialize(fs, plan);
}
}
public SyncPlanScenario(
string testName,
IEnumerable <WorkLogEntry> sourceEntries,
IEnumerable <WorkLogEntry> targetEntries,
bool doPurge,
SyncPlan expectedResult
) : base(sourceEntries, targetEntries, doPurge, expectedResult)
{
this.SetName(testName);
}
public void Sync(SyncPlan plan)
{
foreach (var item in plan)
{
if (_tager.Load(item.FilePath))
{
Sync(_tager.CurrentFile, item.Mask, item.Rule);
}
else
{
ErrorFiles.Add(item.FilePath, "load error");
}
}
}
public async Task <SyncReport> ApplyAsync(SyncPlan syncPlan)
{
var syncReport = new SyncReport();
if (syncPlan.ToAdd.Any() && _options.Value.AgreeToAdd(syncPlan.ToAdd))
{
foreach (var workLog in syncPlan.ToAdd)
{
syncReport.AddedEntries.Add(await _target.AddWorkLogAsync(workLog));
}
}
if (syncPlan.ToUpdate.Any() && _options.Value.AgreeToUpdate(syncPlan.ToUpdate))
{
foreach (var workLog in syncPlan.ToUpdate)
{
syncReport.UpdatedEntries.Add(await _target.UpdateWorkLogAsync(workLog));
}
}
if (syncPlan.ToDeleteOrphaned.Any() && _options.Value.AgreeToDeleteOrphaned(syncPlan.ToDeleteOrphaned))
{
foreach (var workLog in syncPlan.ToDeleteOrphaned)
{
syncReport.DeletedOrphanedEntries.Add(await _target.DeleteWorkLogAsync(workLog));
}
}
if (syncPlan.ToDeleteDuplicates.Any() && _options.Value.AgreeToDeleteDuplicates(syncPlan.ToDeleteDuplicates))
{
foreach (var workLog in syncPlan.ToDeleteDuplicates)
{
syncReport.DeletedDuplicateEntries.Add(await _target.DeleteWorkLogAsync(workLog));
}
}
syncReport.NoChanges = syncPlan.NoChanges;
return(syncReport);
}
internal SyncPlan Build(IEnumerable<IMp3File> files)
{
var plan = new SyncPlan();
foreach (var mp3File in files)
{
_tager.CurrentFile = mp3File;
var fileProblems = _tager.GetFileProblems(_mask);
if (fileProblems.Any())
{
if (fileProblems.Count > 1)
{
ErrorFiles.Add(mp3File.Name, "bad name and tags");
continue;
}
switch (fileProblems.First())
{
case FileProblem.BadName:
plan.Add(new PlanItem(_mask, mp3File.Path, new DefaultSyncRule(),
_tager.CurrentFile.Name + " rename to " + _tager.GenerateName(_mask)));
break;
case FileProblem.BadTags:
plan.Add(new PlanItem(_mask, mp3File.Path, new DefaultSyncRule(), GetBadTagsMessage()));
break;
}
}
else
{
plan.Add(new PlanItem(_mask, mp3File.Path, new DefaultSyncRule(),
_tager.CurrentFile.Name + " rename to " + _tager.GenerateName(_mask)));
}
}
return plan;
}
public void Sync(SyncPlan plan)
{
foreach (var item in plan)
{
if (_tager.Load(item.FilePath))
Sync(_tager.CurrentFile, item.Mask, item.Rule);
else
{
ErrorFiles.Add(item.FilePath, "load error");
}
}
}
public void CreateSyncPlan(WorkLogEntry[] sourceEntries, WorkLogEntry[] targetEntries, bool doPurge, SyncPlan expectedResult)
{
var result = WorksheetSyncService.CreateSyncPlan(sourceEntries, targetEntries, doPurge);
result.ShouldBeEquivalentTo(expectedResult);
}
public static void PrintPlan(SyncPlan plan)
{
Console.WriteLine("Builded plan:");
Console.ForegroundColor=ConsoleColor.Red;
Console.WriteLine(plan);
Console.ResetColor();
}
public static SyncPlan CreateSyncPlan(WorkLogEntry[] sourceEntries, ICollection <WorkLogEntry> existingWorkLogs, bool doPurge)
{
var syncPlan = new SyncPlan();
if (!doPurge)
{
syncPlan.ToAdd.AddRange(sourceEntries);
return(syncPlan);
}
var withoutSourceId = existingWorkLogs.Where(e => string.IsNullOrEmpty(e.SourceId)).ToArray();
syncPlan.ToDeleteOrphaned.AddRange(withoutSourceId);
existingWorkLogs = existingWorkLogs.Except(withoutSourceId).ToArray();
var duplicates = existingWorkLogs
.GroupBy(e => e.SourceId)
.Where(g => g.Count() > 1)
.SelectMany(g => g.ToList())
.ToList();
syncPlan.ToDeleteDuplicates.AddRange(duplicates);
existingWorkLogs = existingWorkLogs.Except(duplicates).ToArray();
var orphaned =
existingWorkLogs.Where(target => !sourceEntries.Any(source => source.SourceId == target.SourceId && source.IssueKey == target.IssueKey)).ToArray();
syncPlan.ToDeleteOrphaned.AddRange(orphaned);
existingWorkLogs = existingWorkLogs.Except(orphaned).ToArray();
var newSourceEntries =
sourceEntries.Where(source => existingWorkLogs.All(target => target.SourceId != source.SourceId)).ToArray();
syncPlan.ToAdd.AddRange(newSourceEntries);
sourceEntries = sourceEntries.Except(newSourceEntries).ToArray();
var sourceLookup = sourceEntries.ToDictionary(s => s.SourceId);
var toUpdateTargetEntries = existingWorkLogs
.Where(target => sourceLookup.ContainsKey(target.SourceId) && target.DifferentFrom(sourceLookup[target.SourceId]))
.Select(target =>
{
target.Synchronize(sourceLookup[target.SourceId]);
return(target);
}).ToList();
syncPlan.ToUpdate.AddRange(toUpdateTargetEntries);
existingWorkLogs = existingWorkLogs.Except(toUpdateTargetEntries).ToArray();
sourceEntries = sourceEntries.Except(sourceEntries.Where(source => toUpdateTargetEntries.Any(e => e.SourceId == source.SourceId))).ToArray();
var entriesWithNoChanges = existingWorkLogs
.Where(target => sourceLookup.ContainsKey(target.SourceId) && !target.DifferentFrom(sourceLookup[target.SourceId])).ToArray();
syncPlan.NoChanges.AddRange(entriesWithNoChanges);
existingWorkLogs = existingWorkLogs.Except(entriesWithNoChanges).ToArray();
sourceEntries = sourceEntries.Except(sourceEntries.Where(source => entriesWithNoChanges.Any(e => e.SourceId == source.SourceId))).ToArray();
//at this point only new source entries left
syncPlan.ToAdd.AddRange(sourceEntries);
return(syncPlan);
}
