private static string GetFilesetPath(Fileset fileset)
{
string fileName = fileset.Id.ToString() + ".fis";
string filePath = Path.Combine(AppConstants.FileSetsFolder, fileName);
return(filePath);
}
public Task <Fileset> Add()
{
return(Task.Factory.StartNew(() =>
{
var fs = new Fileset
{
Id = Guid.NewGuid(),
Name = "New fileset"
};
fs.OnCopyScripts.Add(new ScriptFile
{
Path = Path.Combine("Scripts", "Events", "Copy.rb")
});
fs.OnCopyErrorScripts.Add(new ScriptFile
{
Path = Path.Combine("Scripts", "Events", "CopyError.rb")
});
fs.OnCopySuccessScripts.Add(new ScriptFile
{
Path = Path.Combine("Scripts", "Events", "CopySuccess.rb")
});
_filesets.Add(fs);
_filesetAdded.OnNext(fs);
return fs;
}));
}
public Task <Fileset> Save(Fileset fileset)
{
return(Task.Factory.StartNew(() =>
{
SaveFileset(fileset);
return fileset;
}));
}
private void FilesetRemoved(Fileset fileset)
{
fileset.IsEnabledChanged -= OnFilesetIsEnabledChanged;
if (fileset.IsEnabled)
{
DeactivateFileset(fileset);
}
}
private void FilesetAdded(Fileset fileset)
{
fileset.IsEnabledChanged += OnFilesetIsEnabledChanged;
if (fileset.IsEnabled)
{
ActivateFileset(fileset);
}
}
private static string GetBalloonTipTitle(Fileset fileset)
{
string title = string.Empty;
if (!string.IsNullOrEmpty(fileset.Category))
{
title += "[" + fileset.Category + "] ";
}
title += fileset.Name;
return(title);
}
private void OnFilesetIsEnabledChanged(object sender, EventArgs e)
{
Fileset fileset = (Fileset)sender;
if (fileset.IsEnabled)
{
ActivateFileset(fileset);
}
else
{
DeactivateFileset(fileset);
}
}
private void DeactivateFileset(Fileset fileset)
{
List <IDisposable> watchers;
if (!_watchers.TryGetValue(fileset, out watchers))
{
watchers = new List <IDisposable>();
_watchers.TryAdd(fileset, watchers);
}
watchers.ForEach(watcher => watcher.Dispose());
watchers.Clear();
}
private static void SaveFileset(Fileset fileset)
{
var filePath = GetFilesetPath(fileset);
using (var stream = File.Create(filePath))
using (var textWriter = new StreamWriter(stream))
using (var jsonWriter = new JsonTextWriter(textWriter))
{
jsonWriter.Formatting = Formatting.Indented;
var serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.Objects;
serializer.Serialize(jsonWriter, fileset);
}
}
public void Execute(Fileset fileset)
{
_activityLogService.Log(fileset.Id, "Executing manual copy");
foreach (var item in fileset.Includes)
{
var fileName = Path.GetFileName(item.RelativePath);
var filePath = FilesetItem.GetFullPath(fileset.SourcePath, item.RelativePath);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
if (fileset.Excludes.Any())
{
var relativePath = fileset.Excludes.FirstOrDefault().RelativePath;
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, relativePath);
var directoryName = Path.GetDirectoryName(fullPath);
if (!string.IsNullOrEmpty(directoryName))
{
IEnumerable <string> files = Directory.GetFiles(directoryName);
files = files.Except(fileset.Excludes.Select(f =>
{
return(FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath));
}));
foreach (var file in files)
{
var fileName = Path.GetFileName(file);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = file,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
}
}
}
public Task Save(Fileset fileset, Func <Stream> streamFactory)
{
return(Task.Factory.StartNew(s =>
{
var factory = (Func <Stream>)s;
using (var stream = factory())
using (var textWriter = new StreamWriter(stream))
using (var jsonWriter = new JsonTextWriter(textWriter))
{
jsonWriter.Formatting = Formatting.Indented;
var serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.Objects;
serializer.Serialize(jsonWriter, fileset);
}
}, streamFactory));
}
public Task Remove(Fileset fileset)
{
return(Task.Factory.StartNew(() =>
{
string path = GetFilesetPath(fileset);
if (File.Exists(path))
{
File.Delete(path);
}
if (_filesets.Remove(fileset))
{
_filesetRemoved.OnNext(fileset);
}
}));
}
public FilesetViewModel(Fileset fileset)
{
_fileset = fileset;
PropertyChangedEventManager.AddListener(_fileset, this, string.Empty);
OnCopyScript = new ScriptViewModel(_fileset.OnCopyScripts)
{
Title = "On copy-event scripts"
};
OnCopyErrorScript = new ScriptViewModel(_fileset.OnCopyErrorScripts)
{
Title = "On copy-error-event scripts"
};
OnCopySuccessScript = new ScriptViewModel(_fileset.OnCopySuccessScripts)
{
Title = "On copy-success-event scripts"
};
}
/// <summary>
/// Adds a file to the group's fileset.
/// </summary>
/// <param name="type">The type of file to add.</param>
/// <param name="file">The location of the file to add.</param>
public void AddFile(FileTypes type, string file)
{
Fileset.Add(new File(type, file));
}
/// <summary>
/// Adds a file reference that will point to the name of the reference using it.
/// </summary>
/// <typeparam name="T"></typeparam>
public void AddFile <T>() where T : CommandSet
{
Fileset.Add(new File {
Reference = typeof(T), Type = FileTypes.Reference
});
}
private void ActivateFileset(Fileset fileset)
{
List <IDisposable> watchers;
if (!_watchers.TryGetValue(fileset, out watchers))
{
watchers = new List <IDisposable>();
_watchers.TryAdd(fileset, watchers);
}
DeactivateFileset(fileset);
var distinctIncludeFolders = fileset.Includes.Select(f =>
{
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath);
return(new FileInfo(fullPath).DirectoryName);
}).Distinct();
var distinctExcludeFolders = fileset.Excludes.Select(f =>
{
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath);
return(new FileInfo(fullPath).DirectoryName);
}).Distinct();
var foldersToWatch = distinctIncludeFolders.Union(distinctExcludeFolders);
foreach (var folderToWatch in foldersToWatch)
{
if (Directory.Exists(folderToWatch))
{
IDisposable observable = GetObservable(folderToWatch)
.Buffer(TimeSpan.FromSeconds(2))
.Subscribe(t =>
{
if (t.Any())
{
var fileNames = t.Distinct();
foreach (var filePath in fileNames)
{
var relativePath = FilesetItem.GetRelativePath(fileset.SourcePath, filePath);
if (fileset.Includes.Any(f => f.RelativePath == relativePath))
{
var fileName = Path.GetFileName(filePath);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
if (fileset.Excludes.Any())
{
string directoryName = Path.GetDirectoryName(filePath);
if (!string.IsNullOrEmpty(directoryName))
{
IEnumerable <string> files = Directory.GetFiles(directoryName);
files = files.Except(fileset.Excludes.Select(f =>
{
return(FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath));
}));
foreach (var file in files)
{
var fileName = Path.GetFileName(file);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
}
}
}
}
});
watchers.Add(observable);
}
}
}
