602 lines
22 KiB
C#
602 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Text;
|
|
using Microsoft.Win32;
|
|
using Lskj.Business;
|
|
using Lskj.Business.Impl;
|
|
using Lskj.Control.Model;
|
|
using Lskj.Core;
|
|
using Lskj.Data;
|
|
using Lskj.Main.Model;
|
|
using Lskj.Model;
|
|
using Lskj.Util;
|
|
|
|
namespace Lskj.Main.Hosting
|
|
{
|
|
public sealed partial class LegacyLoginRuntime
|
|
{
|
|
private const string RegistryFilePath = @"AA_LS_Erp V2.0\File";
|
|
private const string SystemResourcesIniName = "SystemResources.ini";
|
|
private const string SystemResourcesSection = "SystemResources";
|
|
private const string DirectHistoryPrefix = "DownloadAESStr_";
|
|
private const string DirectLastHostKey = "LocalLastIP";
|
|
private const string DirectLastPortKey = "LocalLastPort";
|
|
private const string DirectLastNameKey = "LocalLastPortName";
|
|
private const string ConnectionModeKey = "FrmConfigFlag";
|
|
private const int DirectRequestTimeoutMilliseconds = 5000;
|
|
|
|
public DataSet LoadConnectionSettings()
|
|
{
|
|
var result = new DataSet("LoginConnectionSettings");
|
|
DataTable settings = CreateSettingsTable();
|
|
DataTable savedConnections = CreateSavedConnectionsTable();
|
|
|
|
string directHost = IniHelper.Read(
|
|
SystemResourcesIniName,
|
|
DirectLastHostKey);
|
|
string directPort = IniHelper.Read(
|
|
SystemResourcesIniName,
|
|
DirectLastPortKey);
|
|
string directName = IniHelper.Read(
|
|
SystemResourcesIniName,
|
|
DirectLastNameKey);
|
|
bool directMode = string.Equals(
|
|
IniHelper.Read(SystemResourcesIniName, ConnectionModeKey),
|
|
"1",
|
|
StringComparison.Ordinal);
|
|
|
|
settings.Rows.Add(
|
|
directMode ? "Direct" : "Database",
|
|
ReadRegistryValue("ServerName"),
|
|
ReadRegistryValue("datastr"),
|
|
directHost,
|
|
directPort,
|
|
directName);
|
|
|
|
Dictionary<string, string> entries = IniHelper.GetSectionKeys(
|
|
SystemResourcesIniName,
|
|
SystemResourcesSection);
|
|
foreach (KeyValuePair<string, string> entry in entries)
|
|
{
|
|
if (!entry.Key.StartsWith(
|
|
DirectHistoryPrefix,
|
|
StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string endpoint = entry.Key.Substring(
|
|
DirectHistoryPrefix.Length);
|
|
string host;
|
|
int port;
|
|
if (!TrySplitEndpoint(endpoint, out host, out port))
|
|
continue;
|
|
|
|
string displayName = ReadHistoryDisplayName(entry.Value);
|
|
if (string.IsNullOrWhiteSpace(displayName))
|
|
continue;
|
|
|
|
savedConnections.Rows.Add(
|
|
entry.Key,
|
|
displayName,
|
|
host,
|
|
port);
|
|
}
|
|
|
|
result.Tables.Add(settings);
|
|
result.Tables.Add(savedConnections);
|
|
return result;
|
|
}
|
|
|
|
public string ApplyDatabaseConnection(
|
|
string serverName,
|
|
string databaseName)
|
|
{
|
|
try
|
|
{
|
|
ConnectionCandidate candidate = CreateDatabaseCandidate(
|
|
serverName,
|
|
databaseName);
|
|
return ApplyConnection(
|
|
candidate,
|
|
delegate { CommitDatabaseConnection(); });
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
LogSanitized(exception);
|
|
return ToSafeConnectionError(exception);
|
|
}
|
|
}
|
|
|
|
public string ApplyDirectConnection(
|
|
string host,
|
|
int port,
|
|
string accountBookName)
|
|
{
|
|
try
|
|
{
|
|
Uri resourceUri = BuildDirectResourceUri(host, port);
|
|
string encryptedPayload = DownloadDirectPayload(resourceUri);
|
|
string decryptedPayload = AESUtil.Decrypt(encryptedPayload);
|
|
string[] parts = ParseDirectPayload(decryptedPayload);
|
|
ConnectionCandidate candidate = CreateDirectCandidate(
|
|
parts,
|
|
host,
|
|
port,
|
|
accountBookName,
|
|
encryptedPayload);
|
|
return ApplyConnection(
|
|
candidate,
|
|
delegate { CommitDirectConnection(candidate); });
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
LogSanitized(exception);
|
|
return ToSafeConnectionError(exception);
|
|
}
|
|
}
|
|
|
|
private string ApplyConnection(
|
|
ConnectionCandidate candidate,
|
|
Action commit)
|
|
{
|
|
LegacyConnectionStateSnapshot snapshot =
|
|
LegacyConnectionStateSnapshot.Capture(this);
|
|
try
|
|
{
|
|
ApplyCandidate(candidate);
|
|
ValidateDatabase(candidate);
|
|
ValidateDelphi(candidate);
|
|
SystemInfo.RefreshSystemParam();
|
|
BaseResources.Localization(LocalizationType.CHS);
|
|
commit();
|
|
|
|
_ledgerTable = null;
|
|
SelectedLedgerName = candidate.AccountBookName;
|
|
ERPInfo.Instance.AccountBook = candidate.AccountBookName;
|
|
_connectionInitialized = true;
|
|
return string.Empty;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
snapshot.Restore(this);
|
|
LogSanitized(exception);
|
|
return ToSafeConnectionError(exception);
|
|
}
|
|
}
|
|
|
|
private static ConnectionCandidate CreateDatabaseCandidate(
|
|
string serverName,
|
|
string databaseName)
|
|
{
|
|
serverName = (serverName ?? string.Empty).Trim();
|
|
databaseName = (databaseName ?? string.Empty).Trim();
|
|
if (string.IsNullOrWhiteSpace(serverName))
|
|
throw new ArgumentException("请输入数据库服务器地址。");
|
|
if (string.IsNullOrWhiteSpace(databaseName))
|
|
throw new ArgumentException("请输入数据库名称。");
|
|
|
|
return new ConnectionCandidate
|
|
{
|
|
ServerName = serverName,
|
|
DatabaseName = databaseName,
|
|
AccountBookName = DBConfig.Instance.DataBook ?? string.Empty,
|
|
ServerType = DBConfig.Instance.ServerType ?? "SqlServer",
|
|
ConnectionTemplate = string.Empty,
|
|
DelphiConnectionTemplate = string.Empty
|
|
};
|
|
}
|
|
|
|
private static ConnectionCandidate CreateDirectCandidate(
|
|
string[] parts,
|
|
string host,
|
|
int port,
|
|
string accountBookName,
|
|
string encryptedPayload)
|
|
{
|
|
accountBookName = (accountBookName ?? string.Empty).Trim();
|
|
if (string.IsNullOrWhiteSpace(accountBookName))
|
|
throw new ArgumentException("请输入直连账套名称。");
|
|
|
|
string connectionTemplate =
|
|
"Server={0};Database={1};Persist Security Info=True;" +
|
|
"User ID=" + parts[2] + ";Password=" + parts[3] + ";" +
|
|
"Connection Timeout=5;MultipleActiveResultSets=true";
|
|
string delphiTemplate =
|
|
"Provider=SQLOLEDB.1;Server={0};Database={1};" +
|
|
"Persist Security Info=True;User ID=" + parts[2] +
|
|
";Password=" + parts[3] + ";Connection Timeout=5";
|
|
|
|
return new ConnectionCandidate
|
|
{
|
|
ServerName = parts[0],
|
|
DatabaseName = parts[1],
|
|
AccountBookName = accountBookName,
|
|
ServerType = DBConfig.Instance.ServerType ?? "SqlServer",
|
|
ConnectionTemplate = AESUtil.Encrypt(connectionTemplate),
|
|
DelphiConnectionTemplate = AESUtil.Encrypt(delphiTemplate),
|
|
DirectHost = (host ?? string.Empty).Trim().TrimEnd('/'),
|
|
DirectPort = port,
|
|
DirectEncryptedPayload = encryptedPayload
|
|
};
|
|
}
|
|
|
|
private static void ApplyCandidate(ConnectionCandidate candidate)
|
|
{
|
|
DBConfig.Instance.ServerName = candidate.ServerName;
|
|
DBConfig.Instance.DataBase = candidate.DatabaseName;
|
|
DBConfig.Instance.DataBook = candidate.AccountBookName;
|
|
DBConfig.Instance.ServerType = candidate.ServerType;
|
|
DBConfig.Instance.Connection = candidate.ConnectionTemplate;
|
|
DBConfig.Instance.dephiConnection =
|
|
candidate.DelphiConnectionTemplate;
|
|
}
|
|
|
|
private static void ValidateDatabase(ConnectionCandidate candidate)
|
|
{
|
|
if (!DBConfig.Instance.CreateConnection(
|
|
candidate.ConnectionTemplate))
|
|
{
|
|
throw new LegacyConnectionSettingsException(
|
|
"无法连接数据库，请检查服务器和数据库配置。");
|
|
}
|
|
}
|
|
|
|
private static void ValidateDelphi(ConnectionCandidate candidate)
|
|
{
|
|
if (string.Equals(
|
|
candidate.ServerType,
|
|
"达梦数据库",
|
|
StringComparison.Ordinal))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string connection = DBConfig.Instance.GetDelphiConnection(
|
|
candidate.DelphiConnectionTemplate);
|
|
if (DelphiHelper.Delphi_Init(new StringBuilder(connection)) == 0)
|
|
{
|
|
throw new LegacyConnectionSettingsException(
|
|
"数据库已连接，但 Delphi 组件初始化失败。");
|
|
}
|
|
}
|
|
|
|
private static void CommitDatabaseConnection()
|
|
{
|
|
DBConfig.Instance.WriteConfig();
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
ConnectionModeKey,
|
|
"0");
|
|
}
|
|
|
|
private static void CommitDirectConnection(
|
|
ConnectionCandidate candidate)
|
|
{
|
|
string endpoint = candidate.DirectHost + ":" +
|
|
candidate.DirectPort;
|
|
string historyValue = candidate.AccountBookName + "^" +
|
|
candidate.DirectEncryptedPayload;
|
|
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
DirectHistoryPrefix + endpoint,
|
|
historyValue);
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
DirectLastHostKey,
|
|
candidate.DirectHost);
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
DirectLastPortKey,
|
|
candidate.DirectPort.ToString());
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
DirectLastNameKey,
|
|
candidate.AccountBookName);
|
|
IniHelper.Write(
|
|
SystemResourcesIniName,
|
|
ConnectionModeKey,
|
|
"1");
|
|
|
|
DBConfig.Instance.WriteConfig(
|
|
DirectLastHostKey,
|
|
candidate.DirectHost);
|
|
DBConfig.Instance.WriteConfig(
|
|
DirectLastPortKey,
|
|
candidate.DirectPort.ToString());
|
|
DBConfig.Instance.WriteConfig(
|
|
DirectLastNameKey,
|
|
candidate.AccountBookName);
|
|
}
|
|
|
|
private static Uri BuildDirectResourceUri(string host, int port)
|
|
{
|
|
host = (host ?? string.Empty).Trim();
|
|
if (string.IsNullOrWhiteSpace(host))
|
|
throw new ArgumentException("请输入直连服务器地址。");
|
|
if (port < 1 || port > 65535)
|
|
throw new ArgumentOutOfRangeException(
|
|
"port",
|
|
"直连端口必须介于 1 和 65535 之间。");
|
|
|
|
if (!host.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
|
|
!host.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
host = "http://" + host;
|
|
}
|
|
|
|
Uri baseUri;
|
|
if (!Uri.TryCreate(host, UriKind.Absolute, out baseUri) ||
|
|
(baseUri.Scheme != Uri.UriSchemeHttp &&
|
|
baseUri.Scheme != Uri.UriSchemeHttps))
|
|
{
|
|
throw new ArgumentException("直连服务器地址格式无效。");
|
|
}
|
|
|
|
var builder = new UriBuilder(baseUri)
|
|
{
|
|
Port = port,
|
|
Path = "/SystemResources.txt",
|
|
Query = string.Empty,
|
|
Fragment = string.Empty
|
|
};
|
|
return builder.Uri;
|
|
}
|
|
|
|
private static string DownloadDirectPayload(Uri resourceUri)
|
|
{
|
|
var request = (HttpWebRequest)WebRequest.Create(resourceUri);
|
|
request.Method = "GET";
|
|
request.Timeout = DirectRequestTimeoutMilliseconds;
|
|
request.ReadWriteTimeout = DirectRequestTimeoutMilliseconds;
|
|
|
|
using (var response = (HttpWebResponse)request.GetResponse())
|
|
using (Stream stream = response.GetResponseStream())
|
|
{
|
|
if (stream == null)
|
|
{
|
|
throw new InvalidDataException(
|
|
"直连服务器未返回连接配置。");
|
|
}
|
|
|
|
using (var reader = new StreamReader(
|
|
stream,
|
|
Encoding.UTF8,
|
|
true))
|
|
{
|
|
string payload = reader.ReadToEnd().Trim();
|
|
if (string.IsNullOrWhiteSpace(payload))
|
|
{
|
|
throw new InvalidDataException(
|
|
"直连服务器返回的连接配置为空。");
|
|
}
|
|
|
|
return payload;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string[] ParseDirectPayload(string decryptedPayload)
|
|
{
|
|
string[] parts = (decryptedPayload ?? string.Empty).Split('^');
|
|
if (parts.Length != 5)
|
|
{
|
|
throw new InvalidDataException(
|
|
"直连服务器返回的连接配置格式无效。");
|
|
}
|
|
|
|
for (int index = 0; index < parts.Length; index++)
|
|
{
|
|
parts[index] = (parts[index] ?? string.Empty).Trim();
|
|
if (string.IsNullOrWhiteSpace(parts[index]))
|
|
{
|
|
throw new InvalidDataException(
|
|
"直连服务器返回的连接配置不完整。");
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
private static string ToSafeConnectionError(Exception exception)
|
|
{
|
|
if (exception is ArgumentException ||
|
|
exception is InvalidDataException ||
|
|
exception is LegacyConnectionSettingsException)
|
|
{
|
|
return exception.Message;
|
|
}
|
|
if (exception is WebException)
|
|
{
|
|
return "无法读取直连配置，请检查地址、端口和网络连接。";
|
|
}
|
|
|
|
return "连接设置失败，请检查配置和网络连接。";
|
|
}
|
|
|
|
private static void LogSanitized(Exception exception)
|
|
{
|
|
string exceptionType = exception == null
|
|
? "Unknown"
|
|
: exception.GetType().FullName;
|
|
LogHelper.Instance.WriteLog(
|
|
"WPF 登录连接设置失败。异常类型：" + exceptionType);
|
|
}
|
|
|
|
private static DataTable CreateSettingsTable()
|
|
{
|
|
var table = new DataTable("Settings");
|
|
table.Columns.Add("Mode", typeof(string));
|
|
table.Columns.Add("ServerName", typeof(string));
|
|
table.Columns.Add("DatabaseName", typeof(string));
|
|
table.Columns.Add("DirectHost", typeof(string));
|
|
table.Columns.Add("DirectPort", typeof(string));
|
|
table.Columns.Add("DirectAccountBookName", typeof(string));
|
|
return table;
|
|
}
|
|
|
|
private static DataTable CreateSavedConnectionsTable()
|
|
{
|
|
var table = new DataTable("SavedDirectConnections");
|
|
table.Columns.Add("Key", typeof(string));
|
|
table.Columns.Add("DisplayName", typeof(string));
|
|
table.Columns.Add("Host", typeof(string));
|
|
table.Columns.Add("Port", typeof(int));
|
|
return table;
|
|
}
|
|
|
|
private static string ReadRegistryValue(string valueName)
|
|
{
|
|
try
|
|
{
|
|
using (RegistryKey key = Registry.CurrentUser.OpenSubKey(
|
|
RegistryFilePath,
|
|
false))
|
|
{
|
|
object value = key == null
|
|
? null
|
|
: key.GetValue(valueName, string.Empty);
|
|
return value == null ? string.Empty : value.ToString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
private static bool TrySplitEndpoint(
|
|
string endpoint,
|
|
out string host,
|
|
out int port)
|
|
{
|
|
host = string.Empty;
|
|
port = 0;
|
|
if (string.IsNullOrWhiteSpace(endpoint))
|
|
return false;
|
|
|
|
int separatorIndex = endpoint.LastIndexOf(':');
|
|
if (separatorIndex <= 0 ||
|
|
separatorIndex >= endpoint.Length - 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
host = endpoint.Substring(0, separatorIndex).Trim();
|
|
return !string.IsNullOrWhiteSpace(host) &&
|
|
int.TryParse(endpoint.Substring(separatorIndex + 1), out port) &&
|
|
port >= 1 &&
|
|
port <= 65535;
|
|
}
|
|
|
|
private static string ReadHistoryDisplayName(string value)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
return string.Empty;
|
|
|
|
int separatorIndex = value.IndexOf('^');
|
|
return separatorIndex < 0
|
|
? string.Empty
|
|
: value.Substring(0, separatorIndex).Trim();
|
|
}
|
|
|
|
private sealed class ConnectionCandidate
|
|
{
|
|
public string ServerName;
|
|
public string DatabaseName;
|
|
public string AccountBookName;
|
|
public string ServerType;
|
|
public string ConnectionTemplate;
|
|
public string DelphiConnectionTemplate;
|
|
public string DirectHost;
|
|
public int DirectPort;
|
|
public string DirectEncryptedPayload;
|
|
}
|
|
|
|
private sealed class LegacyConnectionStateSnapshot
|
|
{
|
|
private string _serverName;
|
|
private string _databaseName;
|
|
private string _dataBook;
|
|
private string _loginName;
|
|
private string _serverType;
|
|
private string _connectionTemplate;
|
|
private string _delphiConnectionTemplate;
|
|
private string _selectedLedgerName;
|
|
private string _accountBook;
|
|
private bool _connectionInitialized;
|
|
|
|
public static LegacyConnectionStateSnapshot Capture(
|
|
LegacyLoginRuntime runtime)
|
|
{
|
|
return new LegacyConnectionStateSnapshot
|
|
{
|
|
_serverName = DBConfig.Instance.ServerName,
|
|
_databaseName = DBConfig.Instance.DataBase,
|
|
_dataBook = DBConfig.Instance.DataBook,
|
|
_loginName = DBConfig.Instance.LoginName,
|
|
_serverType = DBConfig.Instance.ServerType,
|
|
_connectionTemplate = DBConfig.Instance.Connection,
|
|
_delphiConnectionTemplate =
|
|
DBConfig.Instance.dephiConnection,
|
|
_selectedLedgerName = runtime.SelectedLedgerName,
|
|
_accountBook = ERPInfo.Instance.AccountBook,
|
|
_connectionInitialized = runtime._connectionInitialized
|
|
};
|
|
}
|
|
|
|
public void Restore(LegacyLoginRuntime runtime)
|
|
{
|
|
DBConfig.Instance.ServerName = _serverName;
|
|
DBConfig.Instance.DataBase = _databaseName;
|
|
DBConfig.Instance.DataBook = _dataBook;
|
|
DBConfig.Instance.LoginName = _loginName;
|
|
DBConfig.Instance.ServerType = _serverType;
|
|
DBConfig.Instance.Connection = _connectionTemplate;
|
|
DBConfig.Instance.dephiConnection =
|
|
_delphiConnectionTemplate;
|
|
runtime.SelectedLedgerName = _selectedLedgerName;
|
|
runtime._ledgerTable = null;
|
|
runtime._connectionInitialized = _connectionInitialized;
|
|
ERPInfo.Instance.AccountBook = _accountBook;
|
|
|
|
try
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(_serverName) &&
|
|
!string.IsNullOrWhiteSpace(_databaseName))
|
|
{
|
|
DBConfig.Instance.CreateConnection(
|
|
_connectionTemplate);
|
|
if (!string.Equals(
|
|
_serverType,
|
|
"达梦数据库",
|
|
StringComparison.Ordinal))
|
|
{
|
|
DelphiHelper.Delphi_Init(new StringBuilder(
|
|
DBConfig.Instance.GetDelphiConnection(
|
|
_delphiConnectionTemplate)));
|
|
}
|
|
SystemInfo.RefreshSystemParam();
|
|
}
|
|
}
|
|
catch (Exception restoreException)
|
|
{
|
|
LogSanitized(restoreException);
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class LegacyConnectionSettingsException : Exception
|
|
{
|
|
public LegacyConnectionSettingsException(string message)
|
|
: base(message)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|