private void RemoveConfig(SkylineBatchConfig config)
{
CheckIfExists(config, true, Operation.Remove);
_configList.Remove(config);
_configRunners[config.Name].Cancel();
_configRunners.Remove(config.Name);
}
public SkylineBatchConfigForm(IMainUiControl mainControl, SkylineBatchConfig config, ConfigAction action, bool isBusy)
{
InitializeComponent();
_action = action;
_initialCreated = config?.Created ?? DateTime.MinValue;
_newReportList = new List <ReportInfo>();
_mainControl = mainControl;
_isBusy = isBusy;
_canEditSkylineSettings = !Installations.HasLocalSkylineCmd;
InitSkylineTab();
InitInputFieldsFromConfig(config);
lblConfigRunning.Hide();
if (isBusy)
{
lblConfigRunning.Show();
btnSaveConfig.Hide(); // save and cancel buttons are replaced with OK button
btnCancelConfig.Hide();
btnOkConfig.Show();
AcceptButton = btnOkConfig;
DisableUserInputs();
}
ActiveControl = textConfigName;
}
public ConfigRunner(SkylineBatchConfig config, ISkylineBatchLogger logger, IMainUiControl uiControl = null)
{
_runnerStatus = RunnerStatus.Stopped;
Config = config;
_uiControl = uiControl;
_logger = logger;
}
private void CheckIfExists(SkylineBatchConfig config, bool expectedValue, Operation typeOperation)
{
bool exists = _configRunners.Keys.Contains(config.Name);
if (exists != expectedValue)
{
var message = expectedValue
? string.Format(Resources.ConfigManager_Operation_fail_config_nonexistant, typeOperation.ToString(), config.Name)
: string.Format(Resources.ConfigManager_Operation_fail_config_exists, typeOperation.ToString(), config.Name);
throw new ArgumentException(message);
}
}
private void InsertConfiguration(SkylineBatchConfig config, int index, Operation operation = Operation.Insert)
{
lock (_lock)
{
CheckIfExists(config, false, operation);
Program.LogInfo(string.Format("Adding configuration \"{0}\"", config.Name));
_configList.Insert(index, config);
var newRunner = new ConfigRunner(config, _logger, _uiControl);
_configRunners.Add(config.Name, newRunner);
}
}
private void InitReportsFromConfig(SkylineBatchConfig config)
{
if (_action == ConfigAction.Add)
{
return;
}
foreach (var report in config.ReportSettings.Reports)
{
_newReportList.Add(report);
gridReportSettings.Rows.Add(report.AsArray());
}
}
public void ReplaceSelectedConfig(SkylineBatchConfig newConfig)
{
lock (_lock)
{
CheckConfigSelected();
var oldConfig = _configList[SelectedConfig];
if (!string.Equals(oldConfig.Name, newConfig.Name))
{
CheckIfExists(newConfig, false, Operation.Replace);
}
RemoveConfig(oldConfig);
InsertConfiguration(newConfig, SelectedConfig);
}
}
private void InitInputFieldsFromConfig(SkylineBatchConfig config)
{
if (config == null)
{
return;
}
var mainSettings = config.MainSettings;
textConfigName.Text = config.Name;
textAnalysisPath.Text = mainSettings.AnalysisFolderPath;
textNamingPattern.Text = mainSettings.ReplicateNamingPattern;
InitReportsFromConfig(config);
if (_action != ConfigAction.Edit)
{
textConfigName.Text = "";
if (_action == ConfigAction.Add)
{
textAnalysisPath.Text = Path.GetDirectoryName(mainSettings.AnalysisFolderPath) + @"\";
textNamingPattern.Text = "";
}
}
textSkylinePath.Text = mainSettings.TemplateFilePath;
textDataPath.Text = mainSettings.DataFolderPath;
textConfigName.TextChanged += textConfigName_TextChanged;
if (!_canEditSkylineSettings)
{
return;
}
radioButtonSkyline.Checked = config.UsesSkyline;
radioButtonSkylineDaily.Checked = config.UsesSkylineDaily;
radioButtonSpecifySkylinePath.Checked = config.UsesCustomSkylinePath;
if (config.UsesCustomSkylinePath)
{
textSkylineInstallationPath.Text = Path.GetDirectoryName(config.SkylineSettings.CmdPath);
}
else if (!string.IsNullOrEmpty(Settings.Default.SkylineCustomCmdPath))
{
textSkylineInstallationPath.Text = Path.GetDirectoryName(Settings.Default.SkylineCustomCmdPath);
}
}
protected bool Equals(SkylineBatchConfig other)
{
return(string.Equals(Name, other.Name) &&
Equals(MainSettings, other.MainSettings) &&
Equals(ReportSettings, other.ReportSettings));
}
public void AddConfiguration(SkylineBatchConfig config)
{
configManager.AddConfiguration(config);
UpdateUiConfigurations();
}
public void EditSelectedConfiguration(SkylineBatchConfig newVersion)
{
configManager.ReplaceSelectedConfig(newVersion);
UpdateUiConfigurations();
}
public void Import(string filePath)
{
var readConfigs = new List <SkylineBatchConfig>();
var validationErrors = new List <string>();
try
{
using (var stream = new FileStream(filePath, FileMode.Open))
{
using (var reader = XmlReader.Create(stream))
{
while (reader.Name != "skylinebatch_config")
{
if (reader.Name == "userSettings" && !reader.IsStartElement()) // there are no configurations in the file
{
break;
}
reader.Read();
}
while (reader.IsStartElement())
{
if (reader.Name == "skylinebatch_config")
{
SkylineBatchConfig config = null;
try
{
config = SkylineBatchConfig.ReadXml(reader);
}
catch (Exception ex)
{
validationErrors.Add(ex.Message);
}
if (config != null)
{
readConfigs.Add(config);
}
}
reader.Read();
reader.Read();
}
}
}
}
catch (Exception)
{
DisplayError(Resources.ConfigManager_Import_configs_error_title, string.Format(Resources.ConfigManager_No_configs_imported, filePath));
return;
}
if (readConfigs.Count == 0 && validationErrors.Count == 0)
{
DisplayWarning(Resources.ConfigManager_Import_configs_error_title,
string.Format(Resources.ConfigManager_No_configs_imported, filePath));
return;
}
var duplicateConfigs = new List <string>();
var numAdded = 0;
foreach (SkylineBatchConfig config in readConfigs)
{
// Make sure that the configuration name is unique
if (_configRunners.Keys.Contains(config.Name))
{
// If a configuration with the same name already exists, don't add it
duplicateConfigs.Add(config.Name);
continue;
}
AddConfiguration(config);
numAdded++;
}
var message = new StringBuilder(Resources.ConfigManager_Number_configs_imported);
message.Append(numAdded).Append(Environment.NewLine);
if (duplicateConfigs.Count > 0)
{
message.Append(Resources.ConfigManager_Number_configs_duplicates)
.Append(Environment.NewLine);
foreach (var name in duplicateConfigs)
{
message.Append("\"").Append(name).Append("\"").Append(Environment.NewLine);
}
}
if (validationErrors.Count > 0)
{
message.Append(Resources.ConfigManager_Number_configs_not_valid)
.Append(Environment.NewLine);
foreach (var error in validationErrors)
{
message.Append(error).Append(Environment.NewLine);
}
}
DisplayInfo(Resources.ConfigManager_Import_configurations, message.ToString());
}
public void AddConfiguration(SkylineBatchConfig config)
{
InsertConfiguration(config, _configList.Count, Operation.Add);
}
