public static void LoadSites(TreeInfo oldTreeInfo, List <int> siteIdList, List <string> tableNameListForContent, List <string> tableNameListForGovPublic, List <string> tableNameListForGovInteract, List <string> tableNameListForJob)
{
foreach (string oldSiteTableName in TableSite.OldTableNames)
{
var siteMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldSiteTableName);
if (FileUtils.IsFileExists(siteMetadataFilePath))
{
var siteTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(siteMetadataFilePath, Encoding.UTF8));
foreach (var fileName in siteTableInfo.RowFiles)
{
var filePath = oldTreeInfo.GetTableContentFilePath(oldSiteTableName, fileName);
var rows = TranslateUtils.JsonDeserialize <List <JObject> >(FileUtils.ReadText(filePath, Encoding.UTF8));
foreach (var row in rows)
{
var dict = TranslateUtils.ToDictionaryIgnoreCase(row);
if (dict.ContainsKey(nameof(TableSite.PublishmentSystemId)))
{
var value = Convert.ToInt32(dict[nameof(TableSite.PublishmentSystemId)]);
if (value > 0 && !siteIdList.Contains(value))
{
siteIdList.Add(value);
}
}
if (dict.ContainsKey(nameof(TableSite.AuxiliaryTableForContent)))
{
var value = Convert.ToString(dict[nameof(TableSite.AuxiliaryTableForContent)]);
if (!string.IsNullOrEmpty(value) && !tableNameListForContent.Contains(value))
{
tableNameListForContent.Add(value);
}
}
if (dict.ContainsKey(nameof(TableSite.AuxiliaryTableForGovInteract)))
{
var value = Convert.ToString(dict[nameof(TableSite.AuxiliaryTableForGovInteract)]);
if (!string.IsNullOrEmpty(value) && !tableNameListForGovInteract.Contains(value))
{
tableNameListForGovInteract.Add(value);
}
}
if (dict.ContainsKey(nameof(TableSite.AuxiliaryTableForGovPublic)))
{
var value = Convert.ToString(dict[nameof(TableSite.AuxiliaryTableForGovPublic)]);
if (!string.IsNullOrEmpty(value) && !tableNameListForGovPublic.Contains(value))
{
tableNameListForGovPublic.Add(value);
}
}
if (dict.ContainsKey(nameof(TableSite.AuxiliaryTableForJob)))
{
var value = Convert.ToString(dict[nameof(TableSite.AuxiliaryTableForJob)]);
if (!string.IsNullOrEmpty(value) && !tableNameListForJob.Contains(value))
{
tableNameListForJob.Add(value);
}
}
}
}
}
}
}
public static async Task UpdateSitesSplitTableNameAsync(IDatabaseManager databaseManager, TreeInfo newTreeInfo, Dictionary <int, TableInfo> splitSiteTableDict)
{
var siteMetadataFilePath = newTreeInfo.GetTableMetadataFilePath(databaseManager.SiteRepository.TableName);
if (FileUtils.IsFileExists(siteMetadataFilePath))
{
var siteTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(siteMetadataFilePath, Encoding.UTF8));
foreach (var fileName in siteTableInfo.RowFiles)
{
var filePath = newTreeInfo.GetTableContentFilePath(databaseManager.SiteRepository.TableName, fileName);
var oldRows = TranslateUtils.JsonDeserialize <List <JObject> >(FileUtils.ReadText(filePath, Encoding.UTF8));
var newRows = new List <Dictionary <string, object> >();
foreach (var row in oldRows)
{
var dict = TranslateUtils.ToDictionaryIgnoreCase(row);
if (dict.ContainsKey(nameof(Site.Id)))
{
//var siteId = Convert.ToInt32(dict[nameof(Site.Id)]);
dict[nameof(Site.TableName)] = await databaseManager.ContentRepository.GetNewContentTableNameAsync();
}
newRows.Add(dict);
}
await FileUtils.WriteTextAsync(filePath, TranslateUtils.JsonSerialize(newRows));
}
}
//foreach (var siteId in splitSiteTableDict.Keys)
//{
// var siteTableInfo = splitSiteTableDict[siteId];
// var siteTableName = UpdateUtils.GetSplitContentTableName(siteId);
// siteTableInfo.Columns
//}
//var tableFilePath = newTreeInfo.GetTableMetadataFilePath(DataProvider.TableDao.TableName);
//if (FileUtils.IsFileExists(tableFilePath))
//{
// var siteTableInfo = TranslateUtils.JsonDeserialize<TableInfo>(FileUtils.ReadText(tableFilePath, Encoding.UTF8));
// var filePath = newTreeInfo.GetTableContentFilePath(DataProvider.SiteRepository.TableName, siteTableInfo.RowFiles[siteTableInfo.RowFiles.Count]);
// var tableInfoList = TranslateUtils.JsonDeserialize<List<CMS.Model.TableInfo>>(FileUtils.ReadText(filePath, Encoding.UTF8));
// await FileUtils.WriteTextAsync(filePath, Encoding.UTF8, TranslateUtils.JsonSerialize(tableInfoList));
//}
}
public static void Execute(string[] args)
{
if (!CliUtils.ParseArgs(Options, args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
if (string.IsNullOrEmpty(_webConfigFileName))
{
_webConfigFileName = "web.config";
}
var treeInfo = new TreeInfo(_directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, _webConfigFileName);
Console.WriteLine($"Database Type: {WebConfigUtils.DatabaseType.Value}");
Console.WriteLine($"Connection String: {WebConfigUtils.ConnectionString}");
Console.WriteLine($"Backup Directory: {treeInfo.DirectoryPath}");
var tableNames = DataProvider.DatabaseDao.GetTableNameList();
FileUtils.WriteText(treeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(tableNames));
CliUtils.PrintLine();
CliUtils.PrintRow("Backup Table Name", "Total Count");
CliUtils.PrintLine();
foreach (var tableName in tableNames)
{
var tableInfo = new TableInfo
{
Columns = DataProvider.DatabaseDao.GetTableColumnInfoListLowercase(WebConfigUtils.ConnectionString, tableName),
TotalCount = DataProvider.DatabaseDao.GetCount(tableName),
RowFiles = new List <string>()
};
CliUtils.PrintRow(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName = DataProvider.DatabaseDao.AddIdentityColumnIdIfNotExists(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliUtils.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliUtils.PageSize);
for (; current <= pageCount; current++)
{
CliUtils.PrintProgressBar(current - 1, pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliUtils.PageSize;
var limit = CliUtils.PageSize;
var rows = DataProvider.DatabaseDao.GetPageObjects(tableName, identityColumnName, offset, limit);
FileUtils.WriteText(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
CliUtils.PrintProgressBarEnd();
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = DataProvider.DatabaseDao.GetObjects(tableName);
FileUtils.WriteText(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
FileUtils.WriteText(treeInfo.GetTableMetadataFilePath(tableName), Encoding.UTF8, TranslateUtils.JsonSerialize(tableInfo));
}
CliUtils.PrintLine();
Console.WriteLine("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Restore(List <string> includes, List <string> excludes, bool dataOnly, string tablesFilePath, TreeInfo treeInfo, string errorLogFilePath)
{
var tableNames =
TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
foreach (var tableName in tableNames)
{
try
{
if (includes != null)
{
if (!StringUtils.ContainsIgnoreCase(includes, tableName))
{
continue;
}
}
if (excludes != null)
{
if (StringUtils.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo =
TranslateUtils.JsonDeserialize <TableInfo>(
await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (DataProvider.DatabaseDao.IsTableExists(tableName))
{
DataProvider.DatabaseDao.DropTable(tableName);
}
if (!DataProvider.DatabaseDao.CreateTable(tableName, tableInfo.Columns, out var ex, out var sqlString))
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"创建表 {tableName}: {sqlString}",
Exception = ex
});
continue;
}
if (tableInfo.RowFiles.Count > 0)
{
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception exception)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = exception
});
}
}
}
}
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}",
Exception = ex
});
}
}
await CliUtils.PrintRowLineAsync();
if (WebConfigUtils.DatabaseType == DatabaseType.Oracle)
{
var tableNameList = DataProvider.DatabaseDao.GetTableNameList();
foreach (var tableName in tableNameList)
{
DataProvider.DatabaseDao.AlterOracleAutoIncresementIdToMaxValue(tableName);
}
}
if (!dataOnly)
{
// 恢复后同步表，确保内容辅助表字段与系统一致
SystemManager.SyncContentTables();
SystemManager.UpdateConfigVersion();
}
}
public static void Execute(string[] args)
{
if (!CliUtils.ParseArgs(Options, args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var treeInfo = new TreeInfo(_directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
ConfigInfo configInfo;
if (!string.IsNullOrEmpty(_databaseType) && !string.IsNullOrEmpty(_connectionString))
{
configInfo = CliUtils.LoadConfigByArgs(_databaseType, _connectionString);
}
else
{
configInfo = CliUtils.LoadConfigByFile(_configFileName);
}
if (configInfo == null)
{
CliUtils.PrintError("Error, config not exists");
return;
}
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
CliUtils.PrintError("Error, connection string is empty");
return;
}
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
CliUtils.PrintError("Error, can not connect to the database");
return;
}
Console.WriteLine($"Database Type: {WebConfigUtils.DatabaseType.Value}");
Console.WriteLine($"Connection String: {WebConfigUtils.ConnectionString}");
Console.WriteLine($"Backup Directory: {treeInfo.DirectoryPath}");
var tableNames = DataProvider.DatabaseDao.GetTableNameList();
FileUtils.WriteText(treeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(tableNames));
CliUtils.PrintLine();
CliUtils.PrintRow("Backup Table Name", "Total Count");
CliUtils.PrintLine();
foreach (var tableName in tableNames)
{
if (configInfo.BackupConfig.Includes != null)
{
if (!StringUtils.ContainsIgnoreCase(configInfo.BackupConfig.Includes, tableName))
{
continue;
}
}
if (configInfo.BackupConfig.Excludes != null)
{
if (StringUtils.ContainsIgnoreCase(configInfo.BackupConfig.Includes, tableName))
{
continue;
}
}
var tableInfo = new TableInfo
{
Columns = DataProvider.DatabaseDao.GetTableColumnInfoList(WebConfigUtils.ConnectionString, tableName),
TotalCount = DataProvider.DatabaseDao.GetCount(tableName),
RowFiles = new List <string>()
};
CliUtils.PrintRow(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName = DataProvider.DatabaseDao.AddIdentityColumnIdIfNotExists(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliUtils.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliUtils.PageSize);
using (var progress = new ProgressBar())
{
for (; current <= pageCount; current++)
{
progress.Report((double)(current - 1) / pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliUtils.PageSize;
var limit = CliUtils.PageSize;
var rows = DataProvider.DatabaseDao.GetPageObjects(tableName, identityColumnName, offset, limit);
FileUtils.WriteText(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = DataProvider.DatabaseDao.GetObjects(tableName);
FileUtils.WriteText(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
FileUtils.WriteText(treeInfo.GetTableMetadataFilePath(tableName), Encoding.UTF8, TranslateUtils.JsonSerialize(tableInfo));
}
CliUtils.PrintLine();
Console.WriteLine("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("需要指定恢复数据的文件夹名称：directory");
return;
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var webConfigPath = PathUtils.Combine(CliUtils.PhysicalApplicationPath, "web.config");
if (!FileUtils.IsFileExists(webConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{webConfigPath}！");
return;
}
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("web.config 中数据库连接字符串 connectionString 未设置");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, "web.config");
await Console.Out.WriteLineAsync($"数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("系统无法连接到 web.config 中设置的数据库");
return;
}
if (!SystemManager.IsNeedInstall())
{
await CliUtils.PrintErrorAsync("数据无法在已安装系统的数据库中恢复，命令执行失败");
return;
}
// 恢复前先创建表，确保系统在恢复的数据库中能够使用
SystemManager.CreateSiteServerTables();
var tableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("恢复表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
foreach (var tableName in tableNames)
{
var logs = new List <TextLogInfo>();
if (_includes != null)
{
if (!StringUtils.ContainsIgnoreCase(_includes, tableName))
{
continue;
}
}
if (_excludes != null)
{
if (StringUtils.ContainsIgnoreCase(_excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!DataProvider.DatabaseDao.IsTableExists(tableName))
{
if (!DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns, out var ex, out var sqlString))
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"创建表 {tableName}: {sqlString}",
Exception = ex
});
continue;
}
}
else
{
DataProvider.DatabaseDao.AlterSystemTable(tableName, tableInfo.Columns);
}
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception ex)
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = ex
});
}
}
}
await CliUtils.AppendErrorLogsAsync(errorLogFilePath, logs);
}
await CliUtils.PrintRowLineAsync();
// 恢复后同步表，确保内容辅助表字段与系统一致
SystemManager.SyncContentTables();
SystemManager.UpdateConfigVersion();
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据！");
}
public static void Execute(string[] args)
{
if (!CliUtils.ParseArgs(Options, args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
if (string.IsNullOrEmpty(_webConfigFileName))
{
_webConfigFileName = "web.config";
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
CliUtils.PrintError($"Error, Directory {treeInfo.DirectoryPath} Not Exists");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
CliUtils.PrintError($"Error, File {treeInfo.TablesFilePath} Not Exists");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, _webConfigFileName);
Console.WriteLine($"Database Type: {WebConfigUtils.DatabaseType.Value}");
Console.WriteLine($"Connection String: {WebConfigUtils.ConnectionString}");
Console.WriteLine($"Restore Directory: {treeInfo.DirectoryPath}");
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
CliUtils.PrintError("Error, Connection String Is Empty");
return;
}
List <string> databaseNameList;
string errorMessage;
var isConnectValid = DataProvider.DatabaseDao.ConnectToServer(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString, out databaseNameList, out errorMessage);
if (!isConnectValid)
{
CliUtils.PrintError("Error, Connection String Not Correct");
return;
}
var tableNames = TranslateUtils.JsonDeserialize <List <string> >(FileUtils.ReadText(tablesFilePath, Encoding.UTF8));
CliUtils.PrintLine();
CliUtils.PrintRow("Import Table Name", "Total Count");
CliUtils.PrintLine();
var logs = new List <TextLogInfo>();
foreach (var tableName in tableNames)
{
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(metadataFilePath, Encoding.UTF8));
CliUtils.PrintRow(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!DataProvider.DatabaseDao.IsTableExists(tableName))
{
DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns);
}
else
{
DataProvider.DatabaseDao.AlterSystemTable(tableName, tableInfo.Columns);
}
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(FileUtils.ReadText(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception ex)
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"tableName {tableName}, fileName {fileName}",
Exception = ex
});
}
}
}
}
CliUtils.PrintLine();
SystemManager.SyncDatabase();
CliUtils.LogErrors(CommandName, logs);
Console.WriteLine("Well done! Thanks for Using SiteServer Cli Tool");
}
public static void Execute(string[] args)
{
if (!CliUtils.ParseArgs(Options, args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_version))
{
Console.WriteLine("Error, Please input the version to update");
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var oldTreeInfo = new TreeInfo(_directory);
var newTreeInfo = new TreeInfo(Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
CliUtils.PrintError($"Error, Directory {oldTreeInfo.DirectoryPath} Not Exists");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
UpdaterBase updater = null;
if (_version == Updater36.Version)
{
updater = new Updater36(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater40.Version)
{
updater = new Updater40(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater41.Version)
{
updater = new Updater41(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater50.Version)
{
updater = new Updater50(oldTreeInfo, newTreeInfo);
}
if (updater == null)
{
Console.WriteLine($"Error, The currently supported update versions are {Updater36.Version}");
return;
}
var newVersion = "latest";
Console.WriteLine($"Old Version: {_version}, Old Directory: {oldTreeInfo.DirectoryPath}");
Console.WriteLine($"New Version: {newVersion}, New Directory: {newTreeInfo.DirectoryPath}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(FileUtils.ReadText(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
CliUtils.PrintLine();
CliUtils.PrintRow("Old Table Name", "New Table Name", "Total Count");
CliUtils.PrintLine();
var contentTableNameList = new List <string>();
var siteMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath("siteserver_PublishmentSystem");
if (FileUtils.IsFileExists(siteMetadataFilePath))
{
var siteTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(siteMetadataFilePath, Encoding.UTF8));
foreach (var fileName in siteTableInfo.RowFiles)
{
var filePath = oldTreeInfo.GetTableContentFilePath("siteserver_PublishmentSystem", fileName);
var rows = TranslateUtils.JsonDeserialize <List <JObject> >(FileUtils.ReadText(filePath, Encoding.UTF8));
foreach (var row in rows)
{
var dict = TranslateUtils.JsonGetDictionaryIgnorecase(row);
object obj;
if (dict.TryGetValue(nameof(TableSite.AuxiliaryTableForContent),
out obj))
{
if (obj != null)
{
contentTableNameList.Add(obj.ToString());
}
}
}
}
}
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(oldMetadataFilePath, Encoding.UTF8));
var kvp = updater.UpdateTableInfo(oldTableName, oldTableInfo, contentTableNameList);
var newTableName = kvp.Key;
var newTableInfo = kvp.Value;
CliUtils.PrintRow(oldTableName, newTableName, oldTableInfo.TotalCount.ToString("#,0"));
newTableNames.Add(newTableName);
FileUtils.WriteText(newTreeInfo.GetTableMetadataFilePath(newTableName), Encoding.UTF8, TranslateUtils.JsonSerialize(newTableInfo));
//DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns);
//foreach (var rowFileName in tableInfo.RowFiles)
//{
// var filePath = PathUtils.Combine(oldDbFilesDirectoryPath, rowFileName);
// var objects = TranslateUtils.JsonDeserialize<List<JObject>>(FileUtils.ReadText(filePath, Encoding.UTF8));
// DataProvider.DatabaseDao.SyncObjects(tableName, objects, tableInfo.Columns);
//}
}
FileUtils.WriteText(newTreeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(newTableNames));
CliUtils.PrintLine();
Console.WriteLine("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var treeInfo = new TreeInfo(_directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
var webConfigPath = CliUtils.GetWebConfigPath(_configFile);
if (!FileUtils.IsFileExists(webConfigPath))
{
await CliUtils.PrintErrorAsync($"系统配置文件不存在：{webConfigPath}！");
return;
}
WebConfigUtils.Load(CliUtils.PhysicalApplicationPath, webConfigPath);
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"{webConfigPath} 中数据库连接字符串 connectionString 未设置");
return;
}
await Console.Out.WriteLineAsync($"数据库类型: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync($"系统无法连接到 {webConfigPath} 中设置的数据库");
return;
}
if (_excludes == null)
{
_excludes = new List <string>();
}
_excludes.Add("bairong_Log");
_excludes.Add("bairong_ErrorLog");
_excludes.Add("siteserver_ErrorLog");
_excludes.Add("siteserver_Log");
_excludes.Add("siteserver_Tracking");
var allTableNames = DataProvider.DatabaseDao.GetTableNameList();
var tableNames = new List <string>();
foreach (var tableName in allTableNames)
{
if (_includes != null && !StringUtils.ContainsIgnoreCase(_includes, tableName))
{
continue;
}
if (StringUtils.ContainsIgnoreCase(_excludes, tableName))
{
continue;
}
if (StringUtils.ContainsIgnoreCase(tableNames, tableName))
{
continue;
}
tableNames.Add(tableName);
}
await FileUtils.WriteTextAsync(treeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(tableNames));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("备份表名称", "总条数");
await CliUtils.PrintRowLineAsync();
foreach (var tableName in tableNames)
{
var tableInfo = new TableInfo
{
Columns = DataProvider.DatabaseDao.GetTableColumnInfoList(WebConfigUtils.ConnectionString, tableName),
TotalCount = DataProvider.DatabaseDao.GetCount(tableName),
RowFiles = new List <string>()
};
if (_maxRows > 0 && tableInfo.TotalCount > _maxRows)
{
tableInfo.TotalCount = _maxRows;
}
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName = DataProvider.DatabaseDao.AddIdentityColumnIdIfNotExists(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliUtils.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliUtils.PageSize);
using (var progress = new ProgressBar())
{
for (; current <= pageCount; current++)
{
progress.Report((double)(current - 1) / pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliUtils.PageSize;
var limit = tableInfo.TotalCount - offset < CliUtils.PageSize ? tableInfo.TotalCount - offset : CliUtils.PageSize;
var rows = DataProvider.DatabaseDao.GetPageObjects(tableName, identityColumnName, offset, limit);
await FileUtils.WriteTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = DataProvider.DatabaseDao.GetObjects(tableName);
await FileUtils.WriteTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
await FileUtils.WriteTextAsync(treeInfo.GetTableMetadataFilePath(tableName), Encoding.UTF8, TranslateUtils.JsonSerialize(tableInfo));
}
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功备份数据库至文件夹：{treeInfo.DirectoryPath}！");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("Error, the restore {directory} name is empty");
return;
}
var treeInfo = new TreeInfo(_directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"Error, directory {treeInfo.DirectoryPath} not exists");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"Error, file {treeInfo.TablesFilePath} not exists");
return;
}
ConfigInfo configInfo;
if (!string.IsNullOrEmpty(_databaseType) && !string.IsNullOrEmpty(_connectionString))
{
configInfo = CliUtils.LoadConfigByArgs(_databaseType, _connectionString);
}
else
{
configInfo = await CliUtils.LoadConfigByFileAsync(_configFileName);
}
if (configInfo == null)
{
await CliUtils.PrintErrorAsync("Error, config not exists");
return;
}
if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("Error, connection string is empty");
return;
}
if (!DataProvider.DatabaseDao.IsConnectionStringWork(WebConfigUtils.DatabaseType, WebConfigUtils.ConnectionString))
{
await CliUtils.PrintErrorAsync("Error, can not connect to the database");
return;
}
await Console.Out.WriteLineAsync($"Database Type: {WebConfigUtils.DatabaseType.Value}");
await Console.Out.WriteLineAsync($"Connection String: {WebConfigUtils.ConnectionString}");
await Console.Out.WriteLineAsync($"Restore Directory: {treeInfo.DirectoryPath}");
var tableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("Import Table Name", "Total Count");
await CliUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.CreateErrorLogFile(CommandName);
foreach (var tableName in tableNames)
{
var logs = new List <TextLogInfo>();
if (configInfo.RestoreConfig.Includes != null)
{
if (!StringUtils.ContainsIgnoreCase(configInfo.RestoreConfig.Includes, tableName))
{
continue;
}
}
if (configInfo.RestoreConfig.Excludes != null)
{
if (StringUtils.ContainsIgnoreCase(configInfo.RestoreConfig.Excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!DataProvider.DatabaseDao.IsTableExists(tableName))
{
if (!DataProvider.DatabaseDao.CreateSystemTable(tableName, tableInfo.Columns, out var ex, out var sqlString))
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"create table {tableName}: {sqlString}",
Exception = ex
});
continue;
}
}
else
{
DataProvider.DatabaseDao.AlterSystemTable(tableName, tableInfo.Columns);
}
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
Encoding.UTF8));
try
{
DataProvider.DatabaseDao.InsertMultiple(tableName, objects, tableInfo.Columns);
}
catch (Exception ex)
{
logs.Add(new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"insert table {tableName}, fileName {fileName}",
Exception = ex
});
}
}
}
await CliUtils.AppendErrorLogsAsync(errorLogFilePath, logs);
}
await CliUtils.PrintRowLineAsync();
if (configInfo.RestoreConfig.SyncDatabase)
{
SystemManager.SyncDatabase();
}
await Console.Out.WriteLineAsync("Well done! Thanks for Using SiteServer Cli Tool");
}
private async Task RunAsync(IJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var directory = _directory;
if (string.IsNullOrEmpty(directory))
{
directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var treeInfo = new TreeInfo(_settings.ContentRootPath, directory);
if (!Directory.Exists(treeInfo.DirectoryPath))
{
Directory.CreateDirectory(treeInfo.DirectoryPath);
}
var(isConnectionWorks, errorMessage) = await CliUtils.CheckSettingsAsync(_settings);
if (!isConnectionWorks)
{
await CliUtils.PrintErrorAsync(errorMessage);
return;
}
await Console.Out.WriteLineAsync($"数据库类型: {_settings.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"连接字符串: {_settings.Database.ConnectionString}");
await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
var includes = new List <string>(_settings.Includes);
var excludes = new List <string>(_settings.Excludes);
var allTableNames = await _settings.Database.GetTableNamesAsync();
var tableNames = new List <string>();
foreach (var tableName in allTableNames)
{
if (includes.Count > 0 && !Utilities.ContainsIgnoreCase(includes, tableName))
{
continue;
}
if (excludes.Count > 0 && Utilities.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
if (Utilities.ContainsIgnoreCase(tableNames, tableName))
{
continue;
}
tableNames.Add(tableName);
}
await CliUtils.WriteAllTextAsync(treeInfo.TablesFilePath, Utilities.JsonSerialize(tableNames));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("备份表名称", "总条数");
await CliUtils.PrintRowLineAsync();
foreach (var tableName in tableNames)
{
treeInfo.CreateTableDirectoryPath(tableName);
var repository = new Repository(_settings.Database, tableName);
var tableInfo = new TableInfo
{
Columns = await _settings.Database.GetTableColumnsAsync(tableName),
TotalCount = await repository.CountAsync(),
RowFiles = new List <string>()
};
if (_maxRows > 0 && tableInfo.TotalCount > _maxRows)
{
tableInfo.TotalCount = _maxRows;
}
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName = await _settings.Database.AddIdentityColumnIdIfNotExistsAsync(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliUtils.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliUtils.PageSize);
using (var progress = new ProgressBar())
{
for (; current <= pageCount; current++)
{
progress.Report((double)(current - 1) / pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliUtils.PageSize;
var limit = tableInfo.TotalCount - offset < CliUtils.PageSize ? tableInfo.TotalCount - offset : CliUtils.PageSize;
var rows = GetPageObjects(repository.Database, tableName, identityColumnName, offset, limit);
await CliUtils.WriteAllTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Utilities.JsonSerialize(rows));
}
}
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = GetObjects(repository.Database, tableName);
await CliUtils.WriteAllTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Utilities.JsonSerialize(rows));
}
}
await CliUtils.WriteAllTextAsync(treeInfo.GetTableMetadataFilePath(tableName), Utilities.JsonSerialize(tableInfo));
}
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功备份数据库至文件夹：{treeInfo.DirectoryPath}！");
}
private async Task RunAsync(IJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("需要指定恢复数据的文件夹名称：directory");
return;
}
var treeInfo = new TreeInfo(_settings.ContentRootPath, _directory);
if (!Directory.Exists(treeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!CliUtils.FileExists(tablesFilePath))
{
await CliUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var(isConnectionWorks, errorMessage) = await CliUtils.CheckSettingsAsync(_settings);
if (!isConnectionWorks)
{
await CliUtils.PrintErrorAsync(errorMessage);
return;
}
await Console.Out.WriteLineAsync($"数据库类型: {_settings.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"连接字符串: {_settings.Database.ConnectionString}");
await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
var tableNames = Utilities.JsonDeserialize <List <string> >(await CliUtils.ReadAllTextAsync(tablesFilePath));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("恢复表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var includes = new List <string>(_settings.Includes);
var excludes = new List <string>(_settings.Excludes);
var errorLogFilePath = CliUtils.CreateErrorLogFile(_settings.ContentRootPath, CommandName);
foreach (var tableName in tableNames)
{
try
{
if (includes.Count > 0 && !Utilities.ContainsIgnoreCase(includes, tableName))
{
continue;
}
if (excludes.Count > 0 && Utilities.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!CliUtils.FileExists(metadataFilePath))
{
continue;
}
var tableInfo = Utilities.JsonDeserialize <TableInfo>(await CliUtils.ReadAllTextAsync(metadataFilePath));
var repository = new Repository(_settings.Database, tableName, tableInfo.Columns);
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (!await _settings.Database.IsTableExistsAsync(tableName))
{
try
{
await _settings.Database.CreateTableAsync(tableName, tableInfo.Columns);
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"创建表 {tableName}",
Exception = ex
});
continue;
}
}
else
{
await _settings.Database.AlterTableAsync(tableName, tableInfo.Columns);
}
if (tableInfo.RowFiles.Count > 0)
{
using (var progress = new ProgressBar())
{
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = Utilities.JsonDeserialize <List <JObject> >(
await CliUtils.ReadAllTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName)));
try
{
await repository.BulkInsertAsync(objects);
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = ex
});
}
}
}
}
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}",
Exception = ex
});
}
}
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功从文件夹：{treeInfo.DirectoryPath} 恢复数据！");
}
public async Task <List <string> > RestoreAsync(List <string> includes, List <string> excludes, string tablesFilePath, TreeInfo treeInfo, string errorLogFilePath)
{
var tableNames =
TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(tablesFilePath, Encoding.UTF8));
var errorTableNames = new List <string>();
foreach (var tableName in tableNames)
{
try
{
if (includes != null)
{
if (!ListUtils.ContainsIgnoreCase(includes, tableName))
{
continue;
}
}
if (excludes != null)
{
if (ListUtils.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
}
var metadataFilePath = treeInfo.GetTableMetadataFilePath(tableName);
if (!FileUtils.IsFileExists(metadataFilePath))
{
continue;
}
var tableInfo =
TranslateUtils.JsonDeserialize <TableInfo>(
await FileUtils.ReadTextAsync(metadataFilePath, Encoding.UTF8));
await WriteUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
if (await _settingsManager.Database.IsTableExistsAsync(tableName))
{
await _settingsManager.Database.DropTableAsync(tableName);
}
await _settingsManager.Database.CreateTableAsync(tableName, tableInfo.Columns);
if (tableInfo.RowFiles.Count > 0)
{
using var progress = new ProgressBar();
for (var i = 0; i < tableInfo.RowFiles.Count; i++)
{
progress.Report((double)i / tableInfo.RowFiles.Count);
var fileName = tableInfo.RowFiles[i];
var objects = TranslateUtils.JsonDeserialize <List <JObject> >(
await FileUtils.ReadTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8));
try
{
var repository = new Repository(_settingsManager.Database, tableName,
tableInfo.Columns);
await repository.BulkInsertAsync(objects);
}
catch (Exception exception)
{
errorTableNames.Add(tableName);
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}, 文件名 {fileName}",
Exception = exception
});
}
}
}
}
catch (Exception ex)
{
errorTableNames.Add(tableName);
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
DateTime = DateTime.Now,
Detail = $"插入表 {tableName}",
Exception = ex
});
}
}
await WriteUtils.PrintRowLineAsync();
return(errorTableNames);
//if (!dataOnly)
//{
// // 恢复后同步表，确保内容辅助表字段与系统一致
// await _databaseManager.SyncDatabaseAsync();
// //await _databaseManager.SyncContentTablesAsync();
// await _configRepository.UpdateConfigVersionAsync(_settingsManager.Version);
//}
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_version))
{
await CliUtils.PrintErrorAsync("未指定需要转换的备份数据版本号： version");
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("未指定需要转换至最新版本的备份数据文件夹：directory");
return;
}
var oldTreeInfo = new TreeInfo(_directory);
var newTreeInfo = new TreeInfo(Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"备份数据的文件夹 {oldTreeInfo.DirectoryPath} 不存在");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
UpdaterBase updater = null;
if (_version == Updater36.Version)
{
updater = new Updater36(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater40.Version)
{
updater = new Updater40(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater41.Version)
{
updater = new Updater41(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater50.Version)
{
updater = new Updater50(oldTreeInfo, newTreeInfo);
}
if (updater == null)
{
await Console.Out.WriteLineAsync($"当前支持的升级版本号必须是 {Updater36.Version},{Updater40.Version},{Updater41.Version},{Updater50.Version} 中的一项");
return;
}
var newVersion = "latest";
await Console.Out.WriteLineAsync($"备份版本: {_version}, 备份数据文件夹: {oldTreeInfo.DirectoryPath}");
await Console.Out.WriteLineAsync($"升级版本: {newVersion}, 升级数据文件夹: {newTreeInfo.DirectoryPath}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("备份表名称", "升级表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var contentTableNameList = new List <string>();
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "siteserver_PublishmentSystem",
contentTableNameList);
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "wcm_PublishmentSystem",
contentTableNameList);
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(oldMetadataFilePath, Encoding.UTF8));
var tuple = await updater.UpdateTableInfoAsync(oldTableName, oldTableInfo, contentTableNameList);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), Encoding.UTF8, TranslateUtils.JsonSerialize(tuple.Item2));
}
}
await FileUtils.WriteTextAsync(newTreeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(newTableNames));
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功从备份文件夹：{oldTreeInfo.DirectoryPath} 升级至新版本：{newTreeInfo.DirectoryPath} ！");
}
public static void Execute(string[] args)
{
if (!CliUtils.ParseArgs(Options, args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_version))
{
Console.WriteLine("Error, Please input the version to update");
return;
}
if (string.IsNullOrEmpty(_directory))
{
_directory = $"backup/{DateTime.Now:yyyy-MM-dd}";
}
var oldTreeInfo = new TreeInfo(_directory);
var newTreeInfo = new TreeInfo(Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
CliUtils.PrintError($"Error, Directory {oldTreeInfo.DirectoryPath} Not Exists");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
UpdaterBase updater = null;
if (_version == Updater36.Version)
{
updater = new Updater36(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater40.Version)
{
updater = new Updater40(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater41.Version)
{
updater = new Updater41(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater50.Version)
{
updater = new Updater50(oldTreeInfo, newTreeInfo);
}
if (updater == null)
{
Console.WriteLine($"Error, The currently supported update versions are {Updater36.Version}");
return;
}
var newVersion = "latest";
Console.WriteLine($"Old Version: {_version}, Old Directory: {oldTreeInfo.DirectoryPath}");
Console.WriteLine($"New Version: {newVersion}, New Directory: {newTreeInfo.DirectoryPath}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(FileUtils.ReadText(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
CliUtils.PrintLine();
CliUtils.PrintRow("Old Table Name", "New Table Name", "Total Count");
CliUtils.PrintLine();
var contentTableNameList = new List <string>();
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "siteserver_PublishmentSystem",
contentTableNameList);
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "wcm_PublishmentSystem",
contentTableNameList);
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(FileUtils.ReadText(oldMetadataFilePath, Encoding.UTF8));
var kvp = updater.UpdateTableInfo(oldTableName, oldTableInfo, contentTableNameList);
var newTableName = kvp.Key;
var newTableInfo = kvp.Value;
newTableNames.Add(newTableName);
FileUtils.WriteText(newTreeInfo.GetTableMetadataFilePath(newTableName), Encoding.UTF8, TranslateUtils.JsonSerialize(newTableInfo));
}
FileUtils.WriteText(newTreeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(newTableNames));
CliUtils.PrintLine();
Console.WriteLine("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Backup(ISettingsManager settingsManager, IDatabaseManager databaseManager, List <string> includes, List <string> excludes, int maxRows, TreeInfo treeInfo, string errorLogFilePath)
{
var allTableNames = await settingsManager.Database.GetTableNamesAsync();
var tableNames = new List <string>();
foreach (var tableName in allTableNames)
{
if (includes != null && !ListUtils.ContainsIgnoreCase(includes, tableName))
{
continue;
}
if (ListUtils.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
if (ListUtils.ContainsIgnoreCase(tableNames, tableName))
{
continue;
}
tableNames.Add(tableName);
}
await FileUtils.WriteTextAsync(treeInfo.TablesFilePath, TranslateUtils.JsonSerialize(tableNames));
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintRowAsync("Backup table name", "Count");
await WriteUtils.PrintRowLineAsync();
foreach (var tableName in tableNames)
{
try
{
var columns = await settingsManager.Database.GetTableColumnsAsync(tableName);
var repository = new Repository(settingsManager.Database, tableName, columns);
var tableInfo = new TableInfo
{
Columns = repository.TableColumns,
TotalCount = await repository.CountAsync(),
RowFiles = new List <string>()
};
if (maxRows > 0 && tableInfo.TotalCount > maxRows)
{
tableInfo.TotalCount = maxRows;
}
await WriteUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName =
await settingsManager.Database.AddIdentityColumnIdIfNotExistsAsync(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliConstants.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliConstants.PageSize);
using (var progress = new ProgressBar())
{
for (; current <= pageCount; current++)
{
progress.Report((double)(current - 1) / pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliConstants.PageSize;
var limit = tableInfo.TotalCount - offset < CliConstants.PageSize
? tableInfo.TotalCount - offset
: CliConstants.PageSize;
var rows = await databaseManager.GetPageObjectsAsync(tableName, identityColumnName, offset,
limit);
await FileUtils.WriteTextAsync(
treeInfo.GetTableContentFilePath(tableName, fileName),
TranslateUtils.JsonSerialize(rows));
}
}
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = await databaseManager.GetObjectsAsync(tableName);
await FileUtils.WriteTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
TranslateUtils.JsonSerialize(rows));
}
}
await FileUtils.WriteTextAsync(treeInfo.GetTableMetadataFilePath(tableName),
TranslateUtils.JsonSerialize(tableInfo));
}
catch (Exception ex)
{
await CliUtils.AppendErrorLogAsync(errorLogFilePath, new TextLogInfo
{
Exception = ex,
DateTime = DateTime.Now,
Detail = tableName
});
}
}
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_version))
{
await CliUtils.PrintErrorAsync("Error, the {version} to update is empty");
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("Error, the update {directory} name is empty");
return;
}
var oldTreeInfo = new TreeInfo(_directory);
var newTreeInfo = new TreeInfo(Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"Error, directory {oldTreeInfo.DirectoryPath} not exists");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
UpdaterBase updater = null;
if (_version == Updater36.Version)
{
updater = new Updater36(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater40.Version)
{
updater = new Updater40(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater41.Version)
{
updater = new Updater41(oldTreeInfo, newTreeInfo);
}
else if (_version == Updater50.Version)
{
updater = new Updater50(oldTreeInfo, newTreeInfo);
}
if (updater == null)
{
await Console.Out.WriteLineAsync($"Error, the currently supported update versions are {Updater36.Version},{Updater40.Version},{Updater41.Version},{Updater50.Version}");
return;
}
var newVersion = "latest";
await Console.Out.WriteLineAsync($"Old Version: {_version}, Old Directory: {oldTreeInfo.DirectoryPath}");
await Console.Out.WriteLineAsync($"New Version: {newVersion}, New Directory: {newTreeInfo.DirectoryPath}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("Old Table Name", "New Table Name", "Total Count");
await CliUtils.PrintRowLineAsync();
var contentTableNameList = new List <string>();
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "siteserver_PublishmentSystem",
contentTableNameList);
UpdateUtils.LoadContentTableNameList(oldTreeInfo, "wcm_PublishmentSystem",
contentTableNameList);
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(oldMetadataFilePath, Encoding.UTF8));
var tuple = await updater.UpdateTableInfoAsync(oldTableName, oldTableInfo, contentTableNameList);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), Encoding.UTF8, TranslateUtils.JsonSerialize(tuple.Item2));
}
}
await FileUtils.WriteTextAsync(newTreeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(newTableNames));
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync("Well done! Thanks for Using SiteServer Cli Tool");
}
public static async Task Execute(IJobContext context)
{
if (!CliUtils.ParseArgs(Options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await CliUtils.PrintErrorAsync("未指定需要转换至最新版本的备份数据文件夹：directory");
return;
}
var oldTreeInfo = new TreeInfo(_directory);
var newTreeInfo = new TreeInfo(Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
await CliUtils.PrintErrorAsync($"备份数据的文件夹 {oldTreeInfo.DirectoryPath} 不存在");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
var updater = new UpdaterManager(oldTreeInfo, newTreeInfo);
var version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
await Console.Out.WriteLineAsync($"备份数据文件夹: {oldTreeInfo.DirectoryPath}，升级数据文件夹: {newTreeInfo.DirectoryPath}，升级版本: {version.Substring(0, version.Length - 2)}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("备份表名称", "升级表名称", "总条数");
await CliUtils.PrintRowLineAsync();
var siteIdList = new List <int>();
var tableNameListForContent = new List <string>();
var tableNameListForGovPublic = new List <string>();
var tableNameListForGovInteract = new List <string>();
var tableNameListForJob = new List <string>();
UpdateUtils.LoadSites(oldTreeInfo, siteIdList,
tableNameListForContent, tableNameListForGovPublic, tableNameListForGovInteract, tableNameListForJob);
var splitSiteTableDict = new Dictionary <int, TableInfo>();
if (_contentSplit)
{
var converter = ContentConverter.GetSplitConverter();
foreach (var siteId in siteIdList)
{
splitSiteTableDict.Add(siteId, new TableInfo
{
Columns = converter.NewColumns,
TotalCount = 0,
RowFiles = new List <string>()
});
}
}
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(oldMetadataFilePath, Encoding.UTF8));
if (StringUtils.ContainsIgnoreCase(tableNameListForContent, oldTableName))
{
if (_contentSplit)
{
var converter = ContentConverter.GetConverter(oldTableName, oldTableInfo.Columns);
await updater.UpdateSplitContentsTableInfoAsync(splitSiteTableDict, siteIdList, oldTableName,
oldTableInfo, converter);
}
else
{
var converter = ContentConverter.GetConverter(oldTableName, oldTableInfo.Columns);
var tuple = await updater.GetNewTableInfoAsync(oldTableName, oldTableInfo, converter);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), Encoding.UTF8, TranslateUtils.JsonSerialize(tuple.Item2));
}
}
}
else
{
var tuple = await updater.UpdateTableInfoAsync(oldTableName, oldTableInfo, tableNameListForGovPublic, tableNameListForGovInteract, tableNameListForJob);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), Encoding.UTF8, TranslateUtils.JsonSerialize(tuple.Item2));
}
}
}
if (_contentSplit)
{
foreach (var siteId in siteIdList)
{
var siteTableInfo = splitSiteTableDict[siteId];
var siteTableName = ContentDao.GetContentTableName(siteId);
newTableNames.Add(siteTableName);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(siteTableName), Encoding.UTF8, TranslateUtils.JsonSerialize(siteTableInfo));
}
await UpdateUtils.UpdateSitesSplitTableNameAsync(newTreeInfo, splitSiteTableDict);
}
await FileUtils.WriteTextAsync(newTreeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(newTableNames));
await CliUtils.PrintRowLineAsync();
await Console.Out.WriteLineAsync($"恭喜，成功从备份文件夹：{oldTreeInfo.DirectoryPath} 升级至新版本：{newTreeInfo.DirectoryPath} ！");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await WriteUtils.PrintErrorAsync("Backup folder name not specified: --directory");
return;
}
var oldTreeInfo = new TreeInfo(_settingsManager, _directory);
var newTreeInfo = new TreeInfo(_settingsManager, Folder);
if (!DirectoryUtils.IsDirectoryExists(oldTreeInfo.DirectoryPath))
{
await WriteUtils.PrintErrorAsync($"The backup folder does not exist: {oldTreeInfo.DirectoryPath}");
return;
}
DirectoryUtils.CreateDirectoryIfNotExists(newTreeInfo.DirectoryPath);
_updateService.Load(oldTreeInfo, newTreeInfo);
await Console.Out.WriteLineAsync($"Backup folder: {oldTreeInfo.DirectoryPath}, Update folder: {newTreeInfo.DirectoryPath}, Update to SSCMS version: {_settingsManager.Version}");
var oldTableNames = TranslateUtils.JsonDeserialize <List <string> >(await FileUtils.ReadTextAsync(oldTreeInfo.TablesFilePath, Encoding.UTF8));
var newTableNames = new List <string>();
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintRowAsync("Backup table name", "Update table Name", "Count");
await WriteUtils.PrintRowLineAsync();
var siteIdList = new List <int>();
var tableNames = new List <string>();
UpdateUtils.LoadSites(_settingsManager, oldTreeInfo, siteIdList, tableNames);
var table = new TableContentConverter(_settingsManager);
var splitSiteTableDict = new Dictionary <int, TableInfo>();
if (_contentSplit)
{
var converter = table.GetSplitConverter();
foreach (var siteId in siteIdList)
{
splitSiteTableDict.Add(siteId, new TableInfo
{
Columns = converter.NewColumns,
TotalCount = 0,
RowFiles = new List <string>()
});
}
}
foreach (var oldTableName in oldTableNames)
{
var oldMetadataFilePath = oldTreeInfo.GetTableMetadataFilePath(oldTableName);
if (!FileUtils.IsFileExists(oldMetadataFilePath))
{
continue;
}
var oldTableInfo = TranslateUtils.JsonDeserialize <TableInfo>(await FileUtils.ReadTextAsync(oldMetadataFilePath, Encoding.UTF8));
if (ListUtils.ContainsIgnoreCase(tableNames, oldTableName))
{
if (_contentSplit)
{
var converter = table.GetConverter(oldTableName, oldTableInfo.Columns);
await _updateService.UpdateSplitContentsTableInfoAsync(splitSiteTableDict, siteIdList, oldTableName,
oldTableInfo, converter);
}
else
{
var converter = table.GetConverter(oldTableName, oldTableInfo.Columns);
var tuple = await _updateService.GetNewTableInfoAsync(oldTableName, oldTableInfo, converter);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), TranslateUtils.JsonSerialize(tuple.Item2));
}
}
}
else
{
var tuple = await _updateService.UpdateTableInfoAsync(oldTableName, oldTableInfo);
if (tuple != null)
{
newTableNames.Add(tuple.Item1);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(tuple.Item1), TranslateUtils.JsonSerialize(tuple.Item2));
}
}
}
if (_contentSplit)
{
foreach (var siteId in siteIdList)
{
var siteTableInfo = splitSiteTableDict[siteId];
var siteTableName = UpdateUtils.GetSplitContentTableName(siteId);
newTableNames.Add(siteTableName);
await FileUtils.WriteTextAsync(newTreeInfo.GetTableMetadataFilePath(siteTableName), TranslateUtils.JsonSerialize(siteTableInfo));
}
await UpdateUtils.UpdateSitesSplitTableNameAsync(_databaseManager, newTreeInfo, splitSiteTableDict);
}
await FileUtils.WriteTextAsync(newTreeInfo.TablesFilePath, TranslateUtils.JsonSerialize(newTableNames));
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintSuccessAsync("Update the backup data to the new version successfully!");
}
public static async Task Backup(List <string> includes, List <string> excludes, int maxRows, TreeInfo treeInfo)
{
var allTableNames = DataProvider.DatabaseDao.GetTableNameList();
var tableNames = new List <string>();
foreach (var tableName in allTableNames)
{
if (includes != null && !StringUtils.ContainsIgnoreCase(includes, tableName))
{
continue;
}
if (StringUtils.ContainsIgnoreCase(excludes, tableName))
{
continue;
}
if (StringUtils.ContainsIgnoreCase(tableNames, tableName))
{
continue;
}
tableNames.Add(tableName);
}
await FileUtils.WriteTextAsync(treeInfo.TablesFilePath, Encoding.UTF8, TranslateUtils.JsonSerialize(tableNames));
await CliUtils.PrintRowLineAsync();
await CliUtils.PrintRowAsync("备份表名称", "总条数");
await CliUtils.PrintRowLineAsync();
foreach (var tableName in tableNames)
{
var tableInfo = new TableInfo
{
Columns = DataProvider.DatabaseDao.GetTableColumnInfoList(WebConfigUtils.ConnectionString, tableName),
TotalCount = DataProvider.DatabaseDao.GetCount(tableName),
RowFiles = new List <string>()
};
if (maxRows > 0 && tableInfo.TotalCount > maxRows)
{
tableInfo.TotalCount = maxRows;
}
await CliUtils.PrintRowAsync(tableName, tableInfo.TotalCount.ToString("#,0"));
var identityColumnName = DataProvider.DatabaseDao.AddIdentityColumnIdIfNotExists(tableName, tableInfo.Columns);
if (tableInfo.TotalCount > 0)
{
var current = 1;
if (tableInfo.TotalCount > CliUtils.PageSize)
{
var pageCount = (int)Math.Ceiling((double)tableInfo.TotalCount / CliUtils.PageSize);
using (var progress = new ProgressBar())
{
for (; current <= pageCount; current++)
{
progress.Report((double)(current - 1) / pageCount);
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var offset = (current - 1) * CliUtils.PageSize;
var limit = tableInfo.TotalCount - offset < CliUtils.PageSize
? tableInfo.TotalCount - offset
: CliUtils.PageSize;
var rows = DataProvider.DatabaseDao.GetPageObjects(tableName, identityColumnName, offset,
limit);
await FileUtils.WriteTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName),
Encoding.UTF8, TranslateUtils.JsonSerialize(rows));
}
}
}
else
{
var fileName = $"{current}.json";
tableInfo.RowFiles.Add(fileName);
var rows = DataProvider.DatabaseDao.GetObjects(tableName);
await FileUtils.WriteTextAsync(treeInfo.GetTableContentFilePath(tableName, fileName), Encoding.UTF8,
TranslateUtils.JsonSerialize(rows));
}
}
await FileUtils.WriteTextAsync(treeInfo.GetTableMetadataFilePath(tableName), Encoding.UTF8,
TranslateUtils.JsonSerialize(tableInfo));
}
}