public void ObjectTypeFolderNotFound()
{
var configuration = FolderConfiguration.FromFile("./Data/FolderConfiguration.json");
configuration.Path = "Z:\\Dummy";
Processor.ClientServerLoop(configuration);
}
public HiDriveSyncTask(FolderConfiguration folderConfiguration, IHiDriveClient hiDriveClient,
AccountService accountService)
{
_folderConfiguration = folderConfiguration;
_hiDriveClient = hiDriveClient;
_accountService = accountService;
}
private void btnSave_Click(object sender, EventArgs e)
{
FolderConfiguration save = new FolderConfiguration();
save.Title = txtTitle.Text;
save.Enabled = chkEnabled.Checked;
foreach (DataGridViewRow row in grdFolders.Rows)
{
if (row.Cells["Path"].Value == null || string.IsNullOrWhiteSpace(row.Cells["Path"].Value.ToString()))
{
continue;
}
FolderItemConfiguration config = new FolderItemConfiguration();
config.Path = row.Cells["Path"].Value.ToString();
config.Filter = row.Cells["Filter"].Value.ToString();
config.Log = row.Cells["Log"].Value.ToString();
config.Recursive = row.Cells["Recursive"].Value == null ? false : row.Cells["Recursive"].Value.ToString().Equals("true", StringComparison.CurrentCultureIgnoreCase);
save.Folders.Add(config);
}
save.Save();
this.Close();
}
public Manager()
{
var folderConfiguration = new FolderConfiguration();
var fileService = new FileService(folderConfiguration);
_mediaService = new MediaService(fileService, folderConfiguration);
}
public void AddToMonitor(FolderConfiguration folder)
{
FolderMonitorWorker worker = new FolderMonitorWorker(folder);
worker.Start();
monitors.Add(folder.FullPath, worker);
}
/// <summary>
/// Initializes a new instance of the <see cref="FolderViewViewModell"/> class.
/// </summary>
/// <param name="parent">The parent viewmodel.</param>
/// <param name="basePath">The base path this viewmodel is based on.</param>
public FolderViewModel(NavigateableViewModelBase parent, string basePath)
: base(parent)
{
m_basePath = basePath;
// Set default folder configuration
m_folderConfig = FolderConfiguration.Default;
}
public void Save(FolderConfiguration folderConfiguration)
{
if (_configs.Contains(folderConfiguration))
{
Save();
_configurationUpdatedSubject.OnNext(folderConfiguration);
}
}
public void ChangeMonitor(string path)
{
RemoveMonitor(path);
FolderConfiguration folder = FolderConfiguration.Deserialize(path);
AddToMonitor(folder);
}
public void DeleteConfig(FolderConfiguration folderConfiguration)
{
if (_configs.Remove(folderConfiguration))
{
Save();
_configurationDeletedSubject.OnNext(folderConfiguration);
}
}
public void Update(FolderConfiguration folderConfiguration)
{
Log.Debug("Update HiDrive Sync task for {@folder}", _folderConfiguration);
_schedule = CrontabSchedule.Parse(folderConfiguration.Schedule);
_nextOccurrence = _schedule.GetNextOccurrence(DateTime.Now);
Log.Debug("Next Occurrence is now: {@NextOccurence}", _nextOccurrence);
_folderConfiguration = folderConfiguration;
}
public FileService(IHostingEnvironment appEnvironment, IOptions <MediaSettings> mediaOptions,
FolderConfiguration folderConfiguration, ILogger <FileService> logger)
{
MediaOptions = mediaOptions.Value;
AppEnvironment = appEnvironment;
_folderConfiguration = folderConfiguration;
_logger = logger;
InitConfiguration();
}
static void Main(string[] args)
{
if (args.Length > 0 && (args[0].Equals("gui", StringComparison.CurrentCultureIgnoreCase) || args[0].Equals("g", StringComparison.CurrentCultureIgnoreCase)))
{
ConfigurationListWindow mainWindow = new ConfigurationListWindow();
Application.Run(mainWindow);
return;
}
FolderManager folder = new FolderManager();
FolderConfigurationManager config = new FolderConfigurationManager();
foreach (FolderConfiguration item in config.GetCurrentConfigurations())
{
folder.AddToMonitor(item);
}
config.OnConfigChanged((path, action) =>
{
try
{
Console.WriteLine(action.ToString() + "> " + path);
switch (action)
{
case System.IO.WatcherChangeTypes.Created:
folder.AddToMonitor(FolderConfiguration.Deserialize(path));
break;
case System.IO.WatcherChangeTypes.Deleted:
folder.RemoveMonitor(path);
break;
case System.IO.WatcherChangeTypes.Changed:
folder.ChangeMonitor(path);
break;
case System.IO.WatcherChangeTypes.Renamed:
break;
case System.IO.WatcherChangeTypes.All:
break;
default:
break;
}
}
catch (Exception ex)
{
string contentLog = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + " $ " + ex.Message + Environment.NewLine;
System.IO.File.AppendAllText("Log" + DateTime.Now.ToString("yyyy/MM/dd") + ".txt", contentLog);
}
});
Console.ReadLine();
}
public NewEditMirrorForm(bool isNew, FolderConfiguration folderConfiguration)
{
InitializeComponent();
Text = isNew ? "New mirror configuration" : "Edit mirror configuration";
Configuration = folderConfiguration;
txtSource.Text = folderConfiguration.SourcePath;
txtMirror.Text = folderConfiguration.MirrorPath;
}
public IActionResult OnPostCreate()
{
if (!ModelState.IsValid)
{
Data.SmptAccounts = _accountService.Accounts.SmtpAccounts.Select(account =>
new SelectListItem(account.Label, account.Id.ToString()))
.Concat(new[] { new SelectListItem("Add New", Guid.Empty.ToString()) }).ToList();
Data.Accounts = new List <SelectListItem>
{
new SelectListItem(_accountService.Accounts.HiDriveAccount.UserName,
_accountService.Accounts.HiDriveAccount.AccountId)
};
return(Page());
}
if (Data.SmptAccountId == Guid.Empty.ToString() && Data.NewSmtpAccount != null)
{
var smtpAccount = new SmtpAccount
{
Id = Guid.NewGuid(),
Label = Data.NewSmtpAccount.Label,
Server = Data.NewSmtpAccount.Server,
Username = Data.NewSmtpAccount.Username,
Password = Data.NewSmtpAccount.Password,
EmailTo = Data.NewSmtpAccount.EmailTo
};
_accountService.AddSmtpAccount(smtpAccount);
Data.SmptAccountId = smtpAccount.Id.ToString();
}
Data.Id = Guid.NewGuid();
var folderConfiguration = new FolderConfiguration
{
Id = Data.Id,
Label = Data.Label,
SourcePath = Data.SourcePath,
DestinationPath = Data.DestinationPath,
LogPath = Data.LogPath,
LogLevel = Data.LogLevel,
Schedule = Data.Schedule,
AccountId = Data.AccountId,
NotificationConfiguration = new FolderNotificationConfiguration
{
EmailConfigurationId = Guid.Parse(Data.SmptAccountId),
SendEmail = Data.SendEmail,
SendEmailOnlyOnError = Data.SendEmailOnlyOnError
}
};
_folderConfigService.AddFolderConfig(folderConfiguration);
return(RedirectToPage("/Index"));
}
public void PostFolderMetaData()
{
var configuration = FolderConfiguration.FromFile("/../../Data/FolderConfiguration.json");
var request = Utilities.FileSystem.LoadFolderMetaData(configuration);
request = Processor.AddCommonRequestFields(configuration, request);
Assert.AreEqual(configuration.DerivedMachineHash, request[Constants.Configuration.DerivedMachineHash].ToString());
Assert.AreEqual(configuration.LocationKey, request[Constants.Configuration.LocationKey].ToString());
Assert.AreEqual(configuration.SequenceId, request[Constants.Configuration.SequenceId].ToString());
var response = RestClient.PostJson <dynamic>(configuration.Uri, request);
Assert.IsNotNull(response);
}
public List <FolderConfiguration> GetCurrentConfigurations()
{
List <FolderConfiguration> ret = new List <FolderConfiguration>();
string[] files = System.IO.Directory.GetFiles(ConfigurationData.ConfiurationFolder);
foreach (string item in files)
{
ret.Add(FolderConfiguration.Deserialize(item));
}
return(ret);
}
public static IDictionary <string, object> LoadFolderMetaData(FolderConfiguration configuration)
{
var files = Directory.EnumerateFiles(configuration.Path, "*.*", SearchOption.TopDirectoryOnly).Select(
file => new Dictionary <string, object>()
{
{ Constants.Configuration.Path, file }
}
);
var subFolders = Directory.EnumerateDirectories(configuration.Path, "*", SearchOption.TopDirectoryOnly).Select(folder =>
new Dictionary <string, object>()
{
{ Constants.Configuration.Path, folder }
}
);
var lastModified = new DirectoryInfo(configuration.Path).GetDirectories("*", SearchOption.AllDirectories)
.OrderByDescending(d => d.LastWriteTimeUtc)
.Select(d => d.LastWriteTimeUtc)
.FirstOrDefault();
var fileSizes = Directory.EnumerateFiles(configuration.Path, "*.*", SearchOption.AllDirectories)
.AsParallel()
.Select(file =>
{
try
{
var size = FileSystem.GetFileInfo(file).Length;
return(size);
}
catch (Exception ex)
{
Utilities.Logger.Log(ex);
return(0.0);
}
});
return(new Dictionary <string, object>()
{
{ Constants.Configuration.ObjectType, Constants.ObjectType.Folder },
{ Constants.Configuration.Path, configuration.Path },
{ Constants.Configuration.FolderSize, fileSizes.Sum() },
{ Constants.Configuration.Modified, lastModified },
{ Constants.Configuration.SubFoldersCount, subFolders.Count() },
{ Constants.Configuration.SubFolders, subFolders },
{ Constants.Configuration.FilesCount, files.Count() },
{ Constants.Configuration.Files, files }
});
}
public void LoadFolderInfo()
{
var config = FolderConfiguration.FromFile("/../../Data/FolderConfiguration.json");
var info = Utilities.FileSystem.LoadFolderMetaData(config);
Assert.AreEqual(Constants.ObjectType.Folder, info[Constants.Configuration.ObjectType]);
Assert.IsTrue(((double)info[Constants.Configuration.FolderSize]) > 0);
Assert.IsTrue(((int)info[Constants.Configuration.SubFoldersCount]) > 0);
Assert.IsTrue(((int)info[Constants.Configuration.FilesCount]) > 0);
Assert.IsTrue(((IEnumerable <IDictionary <string, object> >)info[Constants.Configuration.Files]).Count() > 0);
Assert.AreEqual(config.Path, info[Constants.Configuration.Path]);
IEnumerable <IDictionary <string, object> > subFolders = info[Constants.Configuration.SubFolders] as IEnumerable <IDictionary <string, object> >;
Assert.IsNotNull(subFolders.Where(sf => (string)sf[Constants.Configuration.Path] == config.Path + @"\Help"));
Assert.IsTrue(((DateTime)info[Constants.Configuration.Modified]) > DateTime.MinValue);
}
public void SetItem(FolderConfiguration folderConfiguration)
{
txtTitle.Text = folderConfiguration.Title;
chkEnabled.Checked = folderConfiguration.Enabled;
txtTitle.Enabled = false;
grdFolders.AutoGenerateColumns = false;
foreach (var config in folderConfiguration.Folders)
{
int row = grdFolders.Rows.Add();
grdFolders.Rows[row].Cells["Path"].Value = config.Path;
grdFolders.Rows[row].Cells["Filter"].Value = config.Filter;
grdFolders.Rows[row].Cells["Log"].Value = config.Log;
grdFolders.Rows[row].Cells["Recursive"].Value = config.Recursive;
}
}
public void CreateFolders(FolderConfiguration config, string mediaFolder)
{
IList <string> paths = new List <string>();
var type = config.GetType();
foreach (var property in type.GetProperties()
.Where(x => x.CustomAttributes.Any(y => y.AttributeType == typeof(FolderAttribute))).ToList())
{
var t = property.GetValue(config);
var baseFolder = (BaseFolder)property.GetValue(config);
GetSubFolder(baseFolder, paths);
}
foreach (var path in paths)
{
Directory.CreateDirectory(Path.Combine(mediaFolder, path));
}
}
private void btnEdit_Click(object sender, EventArgs e)
{
var item = lstFolders.SelectedItems[0];
var configuration = new FolderConfiguration
{
SourcePath = item.SubItems[0].Text,
MirrorPath = item.SubItems[1].Text
};
var form = new NewEditMirrorForm(false, configuration);
if (form.ShowDialog() == DialogResult.OK)
{
var folder = form.Configuration;
item.SubItems[0].Text = folder.SourcePath;
item.SubItems[1].Text = folder.MirrorPath;
}
}
public void LoadFolderInfoNotFound()
{
var config = FolderConfiguration.FromFile("/../../Data/FolderConfiguration.json");
config.Path = "Z:\\Dummy";
var info = Utilities.FileSystem.LoadFolderMetaData(config);
Assert.AreEqual(Constants.ObjectType.Folder, info[Constants.Configuration.ObjectType]);
Assert.IsTrue(((double)info[Constants.Configuration.FolderSize]) == 0);
Assert.IsTrue(((int)info[Constants.Configuration.SubFoldersCount]) == 0);
Assert.IsTrue(((int)info[Constants.Configuration.FilesCount]) == 0);
Assert.IsNull(info[Constants.Configuration.Files]);
Assert.AreEqual(config.Path, info[Constants.Configuration.Path]);
Assert.IsNull(info[Constants.Configuration.SubFolders]);
Assert.IsNull(info[Constants.Configuration.Modified]);
Assert.AreEqual((int)info[Constants.Configuration.ExitCode], 1);
Assert.IsTrue(((string)info[Constants.Configuration.ErrorMessage]).Length > 0);
}
private void ConfigurationListWindow_Load(object sender, EventArgs e)
{
FolderConfigurationManager folders = new FolderConfigurationManager();
grdConfigurations.DataSource = folders.GetCurrentConfigurations();
folders.OnConfigChanged((file, action) =>
{
switch (action)
{
case System.IO.WatcherChangeTypes.Created:
List <FolderConfiguration> obj = ((List <FolderConfiguration>)grdConfigurations.DataSource);
obj.Add(FolderConfiguration.Deserialize(file));
grdConfigurations.Invoke(new Action(() => { grdConfigurations.DataSource = null; grdConfigurations.DataSource = obj; }));
break;
case System.IO.WatcherChangeTypes.Deleted:
List <FolderConfiguration> objD = ((List <FolderConfiguration>)grdConfigurations.DataSource);
grdConfigurations.Invoke(new Action(() => { grdConfigurations.DataSource = null; grdConfigurations.DataSource = objD.Where(q => q.FullPath != file).ToList(); }));
break;
case System.IO.WatcherChangeTypes.Changed:
if (((List <FolderConfiguration>)grdConfigurations.DataSource).Count(q => q.FullPath == file) > 0)
{
List <FolderConfiguration> objC = ((List <FolderConfiguration>)grdConfigurations.DataSource);
int index = objC.IndexOf(objC.First(q => q.FullPath == file));
objC[index] = FolderConfiguration.Deserialize(file);
grdConfigurations.Invoke(new Action(() => { grdConfigurations.DataSource = null; grdConfigurations.DataSource = objC; }));
}
break;
case System.IO.WatcherChangeTypes.Renamed:
grdConfigurations.Invoke(new Action(() => { grdConfigurations.DataSource = null; grdConfigurations.DataSource = folders.GetCurrentConfigurations(); }));
break;
case System.IO.WatcherChangeTypes.All:
break;
default:
break;
}
});
}
public void PostFolderMetaData()
{
var configuration = FolderConfiguration.FromFile("./Data/FolderConfiguration.json");
var request = Processor.LoadFolderMetaData(configuration);
#region Validate Request
validateCommonRequestFields(request);
Assert.AreEqual(Constants.ObjectType.Folder, request[Constants.Configuration.ObjectType].ToString());
Assert.IsTrue(
string.Compare(
request[Constants.Configuration.Path].ToString(),
configuration.Path, System.StringComparison.CurrentCultureIgnoreCase) == 0
);
Assert.IsTrue((int.Parse(request[Constants.Configuration.FolderSize].ToString())) > 0);
Assert.IsTrue((int.Parse(request[Constants.Configuration.SubFoldersCount].ToString())) > 0);
Assert.IsTrue((int.Parse(request[Constants.Configuration.FilesCount].ToString())) > 0);
Assert.IsTrue(
string.Compare(
request[Constants.Configuration.Path].ToString(),
configuration.Path, System.StringComparison.CurrentCultureIgnoreCase) == 0
);
Assert.IsTrue(((DateTime)request[Constants.Configuration.Modified]) > DateTime.MinValue);
Assert.IsTrue(
((IEnumerable <IDictionary <string, object> >)request[Constants.Configuration.SubFolders]).Count() > 0
);
Assert.IsTrue(
((IEnumerable <IDictionary <string, object> >)request[Constants.Configuration.Files]).Count() > 0
);
#endregion
var response = Utilities.RestClient.PostJson <Dictionary <string, object> >(configuration.Uri, request);
#region Validate Response
Assert.AreEqual(Constants.ObjectType.Folder, response[Constants.Configuration.ObjectType].ToString());
Assert.IsFalse(string.IsNullOrWhiteSpace(response[Constants.Configuration.ThreadTimeToLiveSec].ToString()));
Assert.IsFalse(string.IsNullOrWhiteSpace(response[Constants.Configuration.Path].ToString()));
validateCommonResponseFields(response);
#endregion
}
private void SaveConfiguration()
{
var configuration = new Configuration();
configuration.RunAppOnStartup = chkOnWindowsStart.Checked;
configuration.MirrorInterval = nudMirrorEvery.Value;
configuration.MirrorConfiguration.DeleteFromDest = chkDeleteFromDestination.Checked;
foreach (ListViewItem item in lstFolders.Items)
{
var folderConfiguration = new FolderConfiguration
{
SourcePath = item.SubItems[0].Text,
MirrorPath = item.SubItems[1].Text
};
configuration.Folders.Add(folderConfiguration);
}
Configuration = configuration;
}
public FolderMonitorWorker(FolderConfiguration configuration)
{
Configuration = configuration;
}
/// <summary>
/// Prevents a default instance of the <see cref="FolderViewModel"/> class from being created.
/// </summary>
private FolderViewModel()
: base(null)
{
m_basePath = string.Empty;
m_folderConfig = FolderConfiguration.Default;
}
public MediaService(FileService fileManager, FolderConfiguration folderConfiguration, ILogger <MediaService> logger)
{
_fileManager = fileManager;
_folderConfiguration = folderConfiguration;
_logger = logger;
}
public FolderConfiguration(FolderConfiguration other)
{
this.ID = other.ID;
this.IsWatched = other.IsWatched;
this.NotificationsEnabled = other.NotificationsEnabled;
}
public void ObjectTypeFolder()
{
var configuration = FolderConfiguration.FromFile("./Data/FolderConfiguration.json");
Processor.ClientServerLoop(configuration);
}
public MediaService(FileService fileManager, FolderConfiguration folderConfiguration)
{
_fileManager = fileManager;
_folderConfiguration = folderConfiguration;
}
/// <summary>
/// Unloads all inner configuration.
/// </summary>
protected override void UnloadPreviewContentInternal()
{
m_folderConfig = null;
}
public FolderConfiguration(FolderConfiguration other)
{
this.ID = other.ID;
this.IsWatched = other.IsWatched;
this.NotificationsEnabled = other.NotificationsEnabled;
}
public FileService(FolderConfiguration folderConfiguration)
{
_folderConfiguration = folderConfiguration;
InitConfiguration();
}
/// <summary>
/// Loads the inner configuration internal asynchronous.
/// </summary>
protected override async Task LoadPreviewContentInternalAsync(CancellationToken cancelToken)
{
if (string.IsNullOrEmpty(m_basePath)) { return; }
// Load configuration object
string configFilePath = Path.Combine(m_basePath, Constants.BROWSING_FOLDER_CONFIG_FILE);
if (File.Exists(configFilePath))
{
try
{
m_folderConfig = await CommonTools.DeserializeFromXmlFileAsync<FolderConfiguration>(configFilePath);
}
catch (Exception) { }
}
if (m_folderConfig == null) { m_folderConfig = FolderConfiguration.Default; }
}
