/// <summary>
/// Получить относительные пути конфигурации, соответствующие заданным частям
/// </summary>
private List <RelPath> GetConfigPaths(ConfigParts configParts)
{
List <RelPath> configPaths = new List <RelPath>();
if (configParts.HasFlag(ConfigParts.Base))
{
configPaths.Add(new RelPath(ConfigParts.Base, AppFolder.Root));
}
if (configParts.HasFlag(ConfigParts.Interface))
{
configPaths.Add(new RelPath(ConfigParts.Interface, AppFolder.Root));
}
if (configParts.HasFlag(ConfigParts.Server))
{
configPaths.Add(new RelPath(ConfigParts.Server, AppFolder.Config));
}
if (configParts.HasFlag(ConfigParts.Comm))
{
configPaths.Add(new RelPath(ConfigParts.Comm, AppFolder.Config));
}
if (configParts.HasFlag(ConfigParts.Web))
{
configPaths.Add(new RelPath(ConfigParts.Web, AppFolder.Config));
configPaths.Add(new RelPath(ConfigParts.Web, AppFolder.Storage));
}
return(configPaths);
}
/// <summary>
/// Получить доступные части конфигурации
/// </summary>
public bool GetAvailableConfig(out ConfigParts configParts)
{
try
{
configParts = ConfigParts.None;
foreach (ConfigParts configPart in AllConfigParts)
{
string configPartDir = Settings.Directory +
GetConfigPartDir(configPart, Path.DirectorySeparatorChar);
if (Directory.Exists(configPartDir))
{
configParts |= configPart;
}
}
return(true);
}
catch (Exception ex)
{
log.WriteException(ex, Localization.UseRussian ?
"Ошибка при получении доступных частей конфигурации" :
"Error getting available parts of the configuration");
configParts = ConfigParts.None;
return(false);
}
}
/// <summary>
/// Получить доступные части конфигурации
/// </summary>
public bool GetAvailableConfig(out ConfigParts configParts)
{
try
{
configParts = ConfigParts.None;
foreach (ConfigParts configPart in AllConfigParts)
{
if (Directory.Exists(Path.Combine(Settings.Directory, DirectoryBuilder.GetDirectory(configPart))))
{
configParts |= configPart;
}
}
return(true);
}
catch (Exception ex)
{
log.WriteException(ex, Localization.UseRussian ?
"Ошибка при получении доступных частей конфигурации" :
"Error getting available parts of the configuration");
configParts = ConfigParts.None;
return(false);
}
}
/// <summary>
/// Получить абсолютный путь из относительного
/// </summary>
public string GetAbsPath(ConfigParts configPart, AppFolder appFolder, string path)
{
return(Path.Combine(Settings.Directory,
GetConfigPartDir(configPart, Path.DirectorySeparatorChar),
GetAppFolderDir(appFolder, Path.DirectorySeparatorChar, configPart == ConfigParts.Webstation),
path));
}
public void ReturnsDeclarationsWithDelimiterWithLeadingSpaces()
{
// Given
string configScript = @"A=
=B
===
=C
D
---
-E
F";
// When
ConfigParts configParts = ConfigSplitter.Split(configScript);
// Then
Assert.IsNull(configParts.Setup);
Assert.IsNull(configParts.Declarations);
Assert.AreEqual(@"#line 1
A=
=B
===
=C
D
---
-E
F", configParts.Config);
}
public void ReturnsBothPartsWithDelimiterWithExtraLines()
{
// Given
string configScript = @"A=
=B
===
=C
D";
// When
ConfigParts configParts = ConfigSplitter.Split(configScript);
// Then
Assert.AreEqual(@"#line 1
A=
=B
", configParts.Setup);
Assert.IsNull(configParts.Declarations);
Assert.AreEqual(@"#line 5
=C
D", configParts.Config);
}
/// <summary>
/// Gets available parts of the configuration.
/// </summary>
public bool GetAvailableConfig(out ConfigParts configParts)
{
RestoreConnection();
bool result = client.GetAvailableConfig(out configParts, sessionID);
RegisterActivity();
return(result);
}
/// <summary>
/// Распаковать архив конфигурации
/// </summary>
public bool UnpackConfig(string srcFileName, ConfigOptions configOptions)
{
try
{
// удаление существующей конфигурации
List <RelPath> configPaths = GetConfigPaths(configOptions.ConfigParts);
PathDict pathDict = PrepareIgnoredPaths(configOptions.IgnoredPaths);
foreach (RelPath relPath in configPaths)
{
ClearDir(relPath, pathDict);
}
// определение допустимых директорий для распаковки
ConfigParts configParts = configOptions.ConfigParts;
List <string> allowedEntries = new List <string>(AllConfigParts.Length);
foreach (ConfigParts configPart in AllConfigParts)
{
if (configParts.HasFlag(configPart))
{
allowedEntries.Add(DirectoryBuilder.GetDirectory(configPart, '/'));
}
}
// распаковка новой конфигурации
using (FileStream fileStream =
new FileStream(srcFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (ZipArchive zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read))
{
string instanceDir = Settings.Directory;
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
if (StartsWith(entry.FullName, allowedEntries, StringComparison.Ordinal))
{
string relPath = entry.FullName.Replace('/', Path.DirectorySeparatorChar);
string destFileName = instanceDir + relPath;
Directory.CreateDirectory(Path.GetDirectoryName(destFileName));
entry.ExtractToFile(destFileName, true);
}
}
return(true);
}
}
}
catch (Exception ex)
{
log.WriteException(ex, Localization.UseRussian ?
"Ошибка при распаковке конфигурации из архива" :
"Error unpacking configuration from archive");
return(false);
}
}
public bool GetAvailableConfig(long sessionID, out ConfigParts configParts)
{
if (TryGetScadaInstance(sessionID, out var scadaInstance))
{
return(scadaInstance.GetAvailableConfig(out configParts));
}
else
{
configParts = ConfigParts.None;
return(false);
}
}
protected ConfigParts GetConfigParts()
{
ConfigParts configParts = ConfigParts.None;
configParts |= IncludeSettings ? ConfigParts.Settings : ConfigParts.None;
configParts |= IncludeStyles ? ConfigParts.Styles : ConfigParts.None;
configParts |= IncludeInstruments ? ConfigParts.Instruments : ConfigParts.None;
configParts |= IncludeChordQualities ? ConfigParts.Qualities : ConfigParts.None;
configParts |= IncludeScales ? ConfigParts.Scales : ConfigParts.None;
configParts |= IncludeLibrary ? ConfigParts.Library : ConfigParts.None;
return(configParts);
}
/// <summary>
/// Convert this transfer settings to Agent transfer options.
/// </summary>
public ConfigOptions ToConfigOpions()
{
ConfigParts configParts = ConfigParts.None;
List <RelPath> ignoredPaths = new List <RelPath>();
if (IncludeBase)
{
configParts |= ConfigParts.Base;
}
if (IncludeInterface)
{
configParts |= ConfigParts.Interface;
}
if (IncludeServer)
{
configParts |= ConfigParts.Server;
}
if (IncludeComm)
{
configParts |= ConfigParts.Comm;
}
if (IncludeWeb)
{
configParts |= ConfigParts.Web;
}
if (IgnoreRegKeys)
{
ignoredPaths.Add(new RelPath(ConfigParts.Server, AppFolder.Config, "*_Reg.xml"));
ignoredPaths.Add(new RelPath(ConfigParts.Server, AppFolder.Config, "CompCode.txt"));
ignoredPaths.Add(new RelPath(ConfigParts.Comm, AppFolder.Config, "*_Reg.xml"));
ignoredPaths.Add(new RelPath(ConfigParts.Comm, AppFolder.Config, "CompCode.txt"));
ignoredPaths.Add(new RelPath(ConfigParts.Web, AppFolder.Config, "*_Reg.xml"));
}
if (IgnoreWebStorage)
{
ignoredPaths.Add(new RelPath(ConfigParts.Web, AppFolder.Storage));
}
return(new ConfigOptions()
{
ConfigParts = configParts,
IgnoredPaths = ignoredPaths
});
}
public void ReturnsConfigWithoutDelimiter()
{
// Given
string configScript = @"A=
=B
C";
// When
ConfigParts configParts = ConfigSplitter.Split(configScript);
// Then
Assert.IsNull(configParts.Setup);
Assert.IsNull(configParts.Declarations);
Assert.AreEqual(@"#line 1
A=
=B
C", configParts.Config);
}
private void TryImport()
{
try
{
ConfigParts configParts = GetConfigParts();
ConfigFile importedConfigFile = new ConfigFile("Imported");
using (_inputStream)
{
importedConfigFile.LoadFile(_inputStream, configParts);
}
AppVM.UserConfig.ImportConfig(importedConfigFile, configParts);
}
catch (Exception ex)
{
ExceptionUtils.HandleException(ex);
}
}
public void LoadFile(Stream inputStream, ConfigParts configParts)
{
if (null == inputStream)
{
throw new ArgumentNullException(nameof(inputStream));
}
using (XmlReader reader = XmlReader.Create(inputStream))
{
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Name == "settings" && ((configParts & ConfigParts.Settings) == ConfigParts.Settings))
{
ChordiousSettings.Read(reader.ReadSubtree());
}
else if (reader.Name == "styles" && ((configParts & ConfigParts.Styles) == ConfigParts.Styles))
{
DiagramStyle.Read(reader.ReadSubtree());
}
else if (reader.Name == "instruments" && ((configParts & ConfigParts.Instruments) == ConfigParts.Instruments))
{
Instruments.Read(reader.ReadSubtree());
}
else if (reader.Name == "qualities" && ((configParts & ConfigParts.Qualities) == ConfigParts.Qualities))
{
ChordQualities.Read(reader.ReadSubtree());
}
else if (reader.Name == "scales" && ((configParts & ConfigParts.Scales) == ConfigParts.Scales))
{
Scales.Read(reader.ReadSubtree());
}
else if (reader.Name == "library" && ((configParts & ConfigParts.Library) == ConfigParts.Library))
{
DiagramLibrary.Read(reader.ReadSubtree());
}
}
}
}
}
/// <summary>
/// Получить или добавить новый список путей
/// </summary>
public PathList GetOrAdd(ConfigParts configPart, AppFolder appFolder)
{
Dictionary <AppFolder, PathList> subDict;
PathList pathList;
if (TryGetValue(configPart, out subDict))
{
if (subDict.TryGetValue(appFolder, out pathList))
{
return(pathList);
}
}
else
{
subDict = new Dictionary <AppFolder, PathList>();
this[configPart] = subDict;
}
pathList = new PathList();
subDict[appFolder] = pathList;
return(pathList);
}
/// <summary>
/// Gets a directory corresponding to the configuration part.
/// </summary>
public static string GetDirectory(ConfigParts configPart, char?directorySeparator)
{
switch (configPart)
{
case ConfigParts.Base:
return("BaseDAT" + directorySeparator);
case ConfigParts.Interface:
return("Interface" + directorySeparator);
case ConfigParts.Server:
return("ScadaServer" + directorySeparator);
case ConfigParts.Comm:
return("ScadaComm" + directorySeparator);
case ConfigParts.Web:
return("ScadaWeb" + directorySeparator);
default:
throw new ArgumentException("Unknown configuration part.");
}
}
/// <summary>
/// Получить директорию части конфигурации
/// </summary>
private string GetConfigPartDir(ConfigParts configPart, char?directorySeparator)
{
switch (configPart)
{
case ConfigParts.Base:
return("BaseDAT" + directorySeparator);
case ConfigParts.Interface:
return("Interface" + directorySeparator);
case ConfigParts.Server:
return("ScadaServer" + directorySeparator);
case ConfigParts.Communicator:
return("ScadaComm" + directorySeparator);
case ConfigParts.Webstation:
return("ScadaWeb" + directorySeparator);
default:
throw new ArgumentException("Incorrect configuration part.");
}
}
public void ImportConfig(ConfigFile configFile, ConfigParts configParts)
{
if (null == configFile)
{
throw new ArgumentNullException(nameof(configFile));
}
if ((configParts & ConfigParts.Settings) == ConfigParts.Settings)
{
ChordiousSettings.CopyFrom(configFile.ChordiousSettings);
}
if ((configParts & ConfigParts.Styles) == ConfigParts.Styles)
{
DiagramStyle.CopyFrom(configFile.DiagramStyle);
}
if ((configParts & ConfigParts.Instruments) == ConfigParts.Instruments)
{
Instruments.CopyFrom(configFile.Instruments);
}
if ((configParts & ConfigParts.Qualities) == ConfigParts.Qualities)
{
ChordQualities.CopyFrom(configFile.ChordQualities);
}
if ((configParts & ConfigParts.Scales) == ConfigParts.Scales)
{
Scales.CopyFrom(configFile.Scales);
}
if ((configParts & ConfigParts.Library) == ConfigParts.Library)
{
DiagramLibrary.CopyFrom(configFile.DiagramLibrary);
}
}
private void PromptForExport()
{
ConfigParts configParts = GetConfigParts();
Messenger.Default.Send(new PromptForConfigOutputStreamMessage((outputStream) =>
{
try
{
if (null != outputStream)
{
using (outputStream)
{
AppVM.UserConfig.SaveFile(outputStream, configParts);
}
OnRequestClose();
}
}
catch (Exception ex)
{
ExceptionUtils.HandleException(ex);
}
}));
}
/// <summary>
/// Imports the configuration from the specified archive.
/// </summary>
public void ImportArchive(string srcFileName, ScadaProject project, Instance instance,
out ConfigParts foundConfigParts)
{
if (srcFileName == null)
{
throw new ArgumentNullException("srcFileName");
}
if (project == null)
{
throw new ArgumentNullException("project");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
foundConfigParts = ConfigParts.None;
string extractDir = Path.Combine(Path.GetDirectoryName(srcFileName),
Path.GetFileNameWithoutExtension(srcFileName));
try {
// extract the configuration
ExtractArchive(srcFileName, extractDir);
// import the configuration database
string srcBaseDir = Path.Combine(extractDir, DirectoryBuilder.GetDirectory(ConfigParts.Base));
if (Directory.Exists(srcBaseDir))
{
foundConfigParts |= ConfigParts.Base;
foreach (IBaseTable destTable in project.ConfigBase.AllTables)
{
string datFileName = Path.Combine(srcBaseDir, destTable.Name.ToLowerInvariant() + ".dat");
if (File.Exists(datFileName))
{
try {
BaseAdapter baseAdapter = new BaseAdapter()
{
FileName = datFileName
};
var srcTable = new DataTable();
baseAdapter.Fill(srcTable, true);
ImportBaseTable(srcTable, destTable);
} catch (Exception ex) {
throw new ScadaException(string.Format(
AdminPhrases.ImportBaseTableError, destTable.Name), ex);
}
}
}
}
// import the interface files
string srcInterfaceDir = Path.Combine(extractDir, DirectoryBuilder.GetDirectory(ConfigParts.Interface));
if (Directory.Exists(srcInterfaceDir))
{
foundConfigParts |= ConfigParts.Interface;
MergeDirectory(srcInterfaceDir, project.Interface.InterfaceDir);
}
// import the Server settings
if (instance.ServerApp.Enabled)
{
string srcServerDir = Path.Combine(extractDir, DirectoryBuilder.GetDirectory(ConfigParts.Server));
if (Directory.Exists(srcServerDir))
{
foundConfigParts |= ConfigParts.Server;
MergeDirectory(srcServerDir, instance.ServerApp.AppDir);
if (!instance.ServerApp.LoadSettings(out string errMsg))
{
throw new ScadaException(errMsg);
}
}
}
// import the Communicator settings
if (instance.CommApp.Enabled)
{
string srcCommDir = Path.Combine(extractDir, DirectoryBuilder.GetDirectory(ConfigParts.Comm));
if (Directory.Exists(srcCommDir))
{
foundConfigParts |= ConfigParts.Comm;
MergeDirectory(srcCommDir, instance.CommApp.AppDir);
if (!instance.CommApp.LoadSettings(out string errMsg))
{
throw new ScadaException(errMsg);
}
}
}
// import the Webstation settings
if (instance.WebApp.Enabled)
{
string srcWebDir = Path.Combine(extractDir, DirectoryBuilder.GetDirectory(ConfigParts.Web));
if (Directory.Exists(srcWebDir))
{
foundConfigParts |= ConfigParts.Web;
MergeDirectory(srcWebDir, instance.WebApp.AppDir);
}
}
} catch (Exception ex) {
throw new ScadaException(AdminPhrases.ImportArchiveError, ex);
} finally {
// delete the extracted files
if (Directory.Exists(extractDir))
{
Directory.Delete(extractDir, true);
}
}
}
/// <summary>
/// Распаковать архив конфигурации
/// </summary>
public bool UnpackConfig(string srcFileName, ConfigOptions configOptions)
{
try
{
// delete the existing configuration
List <RelPath> configPaths = GetConfigPaths(configOptions.ConfigParts);
PathDict pathDict = PrepareIgnoredPaths(configOptions.IgnoredPaths);
foreach (RelPath relPath in configPaths)
{
ClearDir(relPath, pathDict);
}
// delete a project information file
string instanceDir = Settings.Directory;
string projectInfoFileName = Path.Combine(instanceDir, ProjectInfoEntryName);
File.Delete(projectInfoFileName);
// define allowed directories to unpack
ConfigParts configParts = configOptions.ConfigParts;
List <string> allowedEntries = new List <string> {
ProjectInfoEntryName
};
foreach (ConfigParts configPart in AllConfigParts)
{
if (configParts.HasFlag(configPart))
{
allowedEntries.Add(DirectoryBuilder.GetDirectory(configPart, '/'));
}
}
// unpack the new configuration
using (FileStream fileStream =
new FileStream(srcFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (ZipArchive zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read))
{
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
if (StartsWith(entry.FullName, allowedEntries, StringComparison.Ordinal))
{
string relPath = entry.FullName.Replace('/', Path.DirectorySeparatorChar);
string destFileName = instanceDir + relPath;
Directory.CreateDirectory(Path.GetDirectoryName(destFileName));
entry.ExtractToFile(destFileName, true);
}
}
return(true);
}
}
}
catch (Exception ex)
{
log.WriteException(ex, Localization.UseRussian ?
"Ошибка при распаковке конфигурации из архива" :
"Error unpacking configuration from archive");
return(false);
}
}
/// <summary>
/// Gets a directory corresponding to the configuration part.
/// </summary>
public static string GetDirectory(ConfigParts configPart)
{
return(GetDirectory(configPart, null));
}
/// <summary>
/// Получить директорию папки приложения
/// </summary>
private string GetAppFolderDir(ConfigParts configPart, AppFolder appFolder, char directorySeparator)
{
return(GetConfigPartDir(configPart, directorySeparator) +
GetAppFolderDir(appFolder, directorySeparator, configPart == ConfigParts.Webstation));
}
/// <summary>
/// Gets a directory corresponding to the configuration part and application folder.
/// </summary>
public static string GetDirectory(ConfigParts configPart, AppFolder appFolder, char directorySeparator)
{
return(GetDirectory(configPart, directorySeparator) +
GetDirectory(appFolder, directorySeparator, configPart == ConfigParts.Web));
}
/// <summary>
/// Gets a directory corresponding to the configuration part and application folder.
/// </summary>
public static string GetDirectory(ConfigParts configPart, AppFolder appFolder)
{
return(Path.Combine(GetDirectory(configPart), GetDirectory(appFolder, configPart == ConfigParts.Web)));
}
public void SaveFile(Stream outputStream, ConfigParts configParts)
{
if (null == outputStream)
{
throw new ArgumentNullException(nameof(outputStream));
}
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true
};
using (XmlWriter writer = XmlWriter.Create(outputStream, settings))
{
writer.WriteStartElement("chordious");
writer.WriteAttributeString("version", AppInfo.ProgramTitle);
writer.WriteAttributeString("date", DateTime.UtcNow.ToString());
if ((configParts & ConfigParts.Settings) == ConfigParts.Settings)
{
writer.WriteStartElement("settings");
ChordiousSettings.Write(writer);
writer.WriteEndElement();
}
if ((configParts & ConfigParts.Styles) == ConfigParts.Styles)
{
writer.WriteStartElement("styles");
DiagramStyle.Write(writer);
writer.WriteEndElement();
}
if ((configParts & ConfigParts.Instruments) == ConfigParts.Instruments)
{
writer.WriteStartElement("instruments");
Instruments.Write(writer);
writer.WriteEndElement();
}
if ((configParts & ConfigParts.Qualities) == ConfigParts.Qualities)
{
writer.WriteStartElement("qualities");
ChordQualities.Write(writer);
writer.WriteEndElement();
}
if ((configParts & ConfigParts.Scales) == ConfigParts.Scales)
{
writer.WriteStartElement("scales");
Scales.Write(writer);
writer.WriteEndElement();
}
if ((configParts & ConfigParts.Library) == ConfigParts.Library)
{
writer.WriteStartElement("library");
DiagramLibrary.Write(writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
/// <summary>
/// Конструктор
/// </summary>
public RelPath(ConfigParts configPart, AppFolder appFolder, string path = "")
{
ConfigPart = configPart;
AppFolder = appFolder;
Path = path ?? "";
}
/// <summary>
/// Получить абсолютный путь из относительного
/// </summary>
public string GetAbsPath(ConfigParts configPart, AppFolder appFolder, string path)
{
return(Path.Combine(Settings.Directory, DirectoryBuilder.GetDirectory(configPart, appFolder), path));
}
