public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_account))
{
_account = ReadUtils.GetString("Username:"******"Password:"******"you have successful logged in");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var status = _configService.Status;
if (status == null || string.IsNullOrEmpty(status.UserName) || string.IsNullOrEmpty(status.AccessToken))
{
await WriteUtils.PrintErrorAsync("you have not logged in");
return;
}
status = new ConfigStatus
{
UserName = string.Empty,
AccessToken = string.Empty
};
await _configService.SaveStatusAsync(status);
await WriteUtils.PrintSuccessAsync("you have successful logged out");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
await Console.Out.WriteLineAsync($"Cli version: {_settingsManager.Version}");
var entryAssembly = Assembly.GetExecutingAssembly();
await Console.Out.WriteLineAsync($"Cli location: {entryAssembly.Location}");
await Console.Out.WriteLineAsync($"Work location: {_settingsManager.ContentRootPath}");
var configPath = CliUtils.GetConfigPath(_settingsManager);
if (FileUtils.IsFileExists(configPath))
{
await Console.Out.WriteLineAsync($"Database type: {_settingsManager.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"Database connection string: {_settingsManager.DatabaseConnectionString}");
if (!string.IsNullOrEmpty(_settingsManager.DatabaseConnectionString))
{
var(isConnectionWorks, errorMessage) =
await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
await Console.Out.WriteLineAsync("Database status: Connection successful");
}
var plugins = _pluginManager.Plugins;
foreach (var plugin in plugins)
{
await Console.Out.WriteLineAsync($"PluginId: {plugin.PluginId}, Version: {plugin.Version}");
}
}
else
{
await Console.Out.WriteLineAsync($"The sscms.json file does not exist: {configPath}");
}
var(status, _) = _apiService.GetStatus();
if (status != null)
{
await Console.Out.WriteLineAsync($"Login user: {status.UserName}");
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (!await _configRepository.IsNeedInstallAsync())
{
await WriteUtils.PrintErrorAsync($"SS CMS has been installed in {_settingsManager.ContentRootPath}");
return;
}
var userName = string.IsNullOrEmpty(_userName)
? ReadUtils.GetString("Super administrator username:"******"Super administrator password:"******"index.html"), Constants.Html5Empty);
await WriteUtils.PrintSuccessAsync("Congratulations, SS CMS was installed successfully!");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var directory = _directory;
if (string.IsNullOrEmpty(directory))
{
directory = string.Empty;
}
var configPath = CliUtils.GetConfigPath(_settingsManager);
if (!FileUtils.IsFileExists(configPath))
{
await WriteUtils.PrintErrorAsync($"The sscms.json file does not exist: {configPath}");
return;
}
await Console.Out.WriteLineAsync($"Database type: {_settingsManager.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"Database connection string: {_settingsManager.DatabaseConnectionString}");
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message: {errorMessage}");
return;
}
var site = await _databaseManager.SiteRepository.GetSiteByDirectoryAsync(directory);
if (site == null)
{
await WriteUtils.PrintErrorAsync($"Unable to find the site, directory: {directory}");
return;
}
await Console.Out.WriteLineAsync($"site: {site.SiteName}");
//await _createManager.CreateByAllAsync(site.Id);
await _createManager.ExecuteAsync(site.Id, CreateType.All, 0, 0, 0, 0);
await WriteUtils.PrintSuccessAsync("create pages successfully!");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var pluginsPath = CliUtils.IsSsCmsExists(_settingsManager.ContentRootPath)
? _pathManager.PluginsPath
: _settingsManager.ContentRootPath;
var(status, _) = await _apiService.GetStatusAsync();
var publisher = status == null
? ReadUtils.GetString("What's the publisher of your plugin?")
: status.UserName;
if (status == null && !StringUtils.IsStrictName(publisher))
{
await WriteUtils.PrintErrorAsync(
$@"Invalid plugin publisher: ""{publisher}"", string does not match the pattern of ""{StringUtils.StrictNameRegex}""");
return;
}
var name = ReadUtils.GetString("What's the name of your plugin?");
if (!StringUtils.IsStrictName(name))
{
await WriteUtils.PrintErrorAsync(
$@"Invalid plugin name: ""{publisher}"", string does not match the pattern of ""{StringUtils.StrictNameRegex}""");
return;
}
var pluginId = PluginUtils.GetPluginId(publisher, name);
var pluginPath = PathUtils.Combine(pluginsPath, pluginId);
var dict = new Dictionary <string, object>
{
["name"] = name,
["publisher"] = publisher
};
var json = TranslateUtils.JsonSerialize(dict);
await FileUtils.WriteTextAsync(PathUtils.Combine(pluginPath, Constants.PackageFileName), json);
await WriteUtils.PrintSuccessAsync($@"The plugin ""{pluginId}"" was created successfully.");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
Process proc;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
var psi = new ProcessStartInfo("./SSCMS.Web")
{
RedirectStandardOutput = true
};
proc = Process.Start(psi);
}
else
{
proc = Process.Start("./SSCMS.Web");
}
if (proc == null)
{
await WriteUtils.PrintErrorAsync("Can not run SSCMS.");
}
else
{
Console.WriteLine("Starting SS CMS...");
Thread.Sleep(5000);
OpenUrl("http://localhost:5000/ss-admin/");
using var sr = proc.StandardOutput;
while (!sr.EndOfStream)
{
Console.WriteLine(sr.ReadLine());
}
if (!proc.HasExited)
{
proc.Kill();
}
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_name))
{
if (context.Extras != null && context.Extras.Length > 0)
{
_name = context.Extras[0];
}
}
if (string.IsNullOrEmpty(_name))
{
await WriteUtils.PrintErrorAsync("missing required name");
return;
}
var(status, failureMessage) = await _apiService.GetStatusAsync();
if (status == null)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
bool success;
(success, failureMessage) = await _apiService.ThemeUnPublishAsync(_name);
if (success)
{
await WriteUtils.PrintSuccessAsync($"Theme {_name} unpublished .");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var(status, failureMessage) = await _apiService.GetStatusAsync();
if (status == null)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
var(success, name, filePath) = await ThemePackageJob.PackageAsync(_pathManager, _cacheManager, _databaseManager,
_directory, false);
if (!success)
{
return;
}
var fileSize = FileUtils.GetFileSizeByFilePath(filePath);
await Console.Out.WriteLineAsync($"Theme Packaged: {filePath}");
await Console.Out.WriteLineAsync($"Publishing theme {name} ({fileSize})...");
(success, failureMessage) = await _apiService.ThemePublishAsync(filePath);
if (success)
{
await WriteUtils.PrintSuccessAsync($"Theme published, your theme will live at {CloudUtils.Www.GetThemeUrl(status.UserName, name)}.");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_userName))
{
await WriteUtils.PrintErrorAsync("missing required options '--username'");
return;
}
if (!StringUtils.IsStrictName(_userName))
{
await WriteUtils.PrintErrorAsync(
$@"Invalid username: ""{_userName}"", string does not match the pattern of ""{StringUtils.StrictNameRegex}""");
return;
}
if (string.IsNullOrEmpty(_password))
{
await WriteUtils.PrintErrorAsync("missing required options '--password'");
return;
}
var(success, failureMessage) = await _apiService.RegisterAsync(_userName, _mobile, _email, _password);
if (success)
{
await WriteUtils.PrintSuccessAsync("you have registered successfully, run sscms login to log in.");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (context.Extras == null || context.Extras.Length == 0)
{
await WriteUtils.PrintErrorAsync("missing required pluginId");
return;
}
var(status, failureMessage) = await _apiService.GetStatusAsync();
if (status == null)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
bool success;
(success, failureMessage) = await _apiService.PluginUnPublishAsync(context.Extras[0]);
if (success)
{
await WriteUtils.PrintSuccessAsync($"Plugin {context.Extras[0]} unpublished.");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var(success, _, filePath) =
await PackageAsync(_pathManager, _cacheManager, _databaseManager, _directory, true);
if (success)
{
var fileSize = FileUtils.GetFileSizeByFilePath(filePath);
await WriteUtils.PrintSuccessAsync($"Theme packaged: {filePath} ({fileSize})");
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var pluginId = string.Empty;
if (context.Extras != null && context.Extras.Length > 0)
{
pluginId = context.Extras[0];
}
var pluginPath = string.IsNullOrEmpty(pluginId)
? _settingsManager.ContentRootPath
: PathUtils.Combine(_pathManager.GetPluginPath(pluginId));
var(plugin, errorMessage) = await PluginUtils.ValidateManifestAsync(pluginPath);
if (plugin == null)
{
await WriteUtils.PrintErrorAsync(errorMessage);
return;
}
var zipPath = Package(_pathManager, plugin);
var fileSize = FileUtils.GetFileSizeByFilePath(zipPath);
await WriteUtils.PrintSuccessAsync($"Packaged: {zipPath} ({fileSize})");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var(success, pluginAndUserList, failureMessage) = await _apiService.PluginSearchAsync(string.Join(' ', context.Extras));
if (success)
{
await WriteUtils.PrintSuccessAsync(TranslateUtils.JsonSerialize(pluginAndUserList));
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var contentRootPath = _settingsManager.ContentRootPath;
if (!CliUtils.IsSsCmsExists(contentRootPath))
{
var(success, result, failureMessage) = await _apiService.GetReleasesAsync(_settingsManager.Version, null);
if (!success)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
var proceed = ReadUtils.GetYesNo($"Do you want to install SS CMS in {contentRootPath}?");
if (!proceed)
{
return;
}
Console.WriteLine($"Downloading SS CMS {result.Cms.Version}...");
var directoryPath = CloudUtils.Dl.DownloadCms(_pathManager, _settingsManager.OSArchitecture, result.Cms.Version);
await WriteUtils.PrintSuccessAsync($"{result.Cms.Version} download successfully!");
DirectoryUtils.Copy(directoryPath, contentRootPath, true);
}
InstallUtils.Init(contentRootPath);
if (!await _configRepository.IsNeedInstallAsync())
{
await WriteUtils.PrintErrorAsync($"SS CMS has been installed in {contentRootPath}");
return;
}
var databaseTypeInput = ReadUtils.GetSelect("Database type", new List <string>
{
DatabaseType.MySql.GetValue().ToLower(),
DatabaseType.SqlServer.GetValue().ToLower(),
DatabaseType.PostgreSql.GetValue().ToLower(),
DatabaseType.SQLite.GetValue().ToLower()
});
var databaseType = TranslateUtils.ToEnum(databaseTypeInput, DatabaseType.MySql);
var databaseName = string.Empty;
var databaseHost = string.Empty;
var isDatabaseDefaultPort = true;
var databasePort = 0;
var databaseUserName = string.Empty;
var databasePassword = string.Empty;
if (databaseType != DatabaseType.SQLite)
{
databaseHost = ReadUtils.GetString("Database hostname / IP:");
isDatabaseDefaultPort = ReadUtils.GetYesNo("Use default port?");
if (!isDatabaseDefaultPort)
{
databasePort = ReadUtils.GetInt("Database port:");
}
databaseUserName = ReadUtils.GetString("Database userName:"******"Database password:"******"Database name", databaseNames);
}
var databaseConnectionString = InstallUtils.GetDatabaseConnectionString(databaseType, databaseHost, isDatabaseDefaultPort, databasePort, databaseUserName, databasePassword, databaseName);
var isProtectData = ReadUtils.GetYesNo("Protect settings in sscms.json?");
_settingsManager.SaveSettings(isProtectData, false, false, databaseType, databaseConnectionString, string.Empty, string.Empty, null, null);
await WriteUtils.PrintSuccessAsync("SS CMS was download and ready for install, please run: sscms install database");
}
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 async Task ExecuteAsync(IPluginJobContext 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(_settingsManager, directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
var configPath = CliUtils.GetConfigPath(_settingsManager);
if (!FileUtils.IsFileExists(configPath))
{
await WriteUtils.PrintErrorAsync($"The sscms.json file does not exist: {configPath}");
return;
}
await Console.Out.WriteLineAsync($"Database type: {_settingsManager.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"Database connection string: {_settingsManager.DatabaseConnectionString}");
await Console.Out.WriteLineAsync($"Backup folder: {treeInfo.DirectoryPath}");
//WebConfigUtils.Load(_settingsManager.ContentRootPath, webConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{webConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
//await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
//var (isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
//if (!isConnectionWorks)
//{
// await CliUtils.PrintErrorAsync($"数据库连接错误：{errorMessage}");
// return;
//}
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
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 errorLogFilePath = CliUtils.DeleteErrorLogFileIfExists(CommandName, _settingsManager);
await Backup(_settingsManager, _databaseManager, _includes, _excludes, _maxRows, treeInfo, errorLogFilePath);
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintSuccessAsync("backup database to folder successfully!");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var contentRootPath = _settingsManager.ContentRootPath;
if (!CliUtils.IsSsCmsExists(contentRootPath) || await _configRepository.IsNeedInstallAsync())
{
await WriteUtils.PrintErrorAsync($"SS CMS has not been installed in {contentRootPath}");
return;
}
var(success, result, failureMessage) = _apiService.GetReleases(_settingsManager.Version, null);
if (!success)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
if (!SemVersion.TryParse(result.Cms.Version, out var version) || version <= _settingsManager.Version)
{
Console.WriteLine($"SS CMS {result.Cms.Version} is the latest version and no update is required");
var proceed = ReadUtils.GetYesNo("do you still want to update?");
if (!proceed)
{
return;
}
}
else
{
var proceed = ReadUtils.GetYesNo($"New version {result.Cms.Version} found, do you want to update?");
if (!proceed)
{
return;
}
}
Console.WriteLine($"Downloading SS CMS {result.Cms.Version}...");
var directoryPath = CloudUtils.Dl.DownloadCms(_pathManager, _settingsManager.OSArchitecture, result.Cms.Version);
FileUtils.DeleteFileIfExists(PathUtils.Combine(directoryPath, Constants.ConfigFileName));
FileUtils.DeleteFileIfExists(PathUtils.Combine(directoryPath, "wwwroot/404.html"));
FileUtils.DeleteFileIfExists(PathUtils.Combine(directoryPath, "wwwroot/favicon.ico"));
FileUtils.DeleteFileIfExists(PathUtils.Combine(directoryPath, "wwwroot/index.html"));
await WriteUtils.PrintSuccessAsync($"{result.Cms.Version} download successfully!");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Please stop website and override files and directories ");
Console.WriteLine($" {directoryPath}");
Console.WriteLine("to");
Console.WriteLine($" {contentRootPath}");
var offlinePath = _pathManager.GetPackagesPath("app_offline.htm");
FileUtils.WriteText(offlinePath, "down for maintenance");
//var unOverrides = new List<string>();
//foreach (var fileName in DirectoryUtils.GetFileNames(directoryPath))
//{
// if (!FileUtils.CopyFile(PathUtils.Combine(directoryPath, fileName),
// PathUtils.Combine(contentRootPath, fileName), true))
// {
// unOverrides.Add(fileName);
// }
//}
//foreach (var directoryName in DirectoryUtils.GetDirectoryNames(directoryPath))
//{
// DirectoryUtils.Copy(PathUtils.Combine(directoryPath, directoryName), PathUtils.Combine(contentRootPath, directoryName), true);
//}
//if (unOverrides.Count > 0)
//{
// Replacing(contentRootPath, directoryPath, unOverrides);
//}
//FileUtils.DeleteFileIfExists(offlinePath);
//await WriteUtils.PrintSuccessAsync($"Congratulations, SS CMS was updated to {result.Cms.Version} successfully!");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
if (string.IsNullOrEmpty(_directory))
{
await WriteUtils.PrintErrorAsync("Restore folder name not specified: --directory");
return;
}
var treeInfo = new TreeInfo(_settingsManager, _directory);
if (!DirectoryUtils.IsDirectoryExists(treeInfo.DirectoryPath))
{
await WriteUtils.PrintErrorAsync($"恢复数据的文件夹 {treeInfo.DirectoryPath} 不存在");
return;
}
var tablesFilePath = treeInfo.TablesFilePath;
if (!FileUtils.IsFileExists(tablesFilePath))
{
await WriteUtils.PrintErrorAsync($"恢复文件 {treeInfo.TablesFilePath} 不存在");
return;
}
var configPath = CliUtils.GetConfigPath(_settingsManager);
if (!FileUtils.IsFileExists(configPath))
{
await WriteUtils.PrintErrorAsync($"The sscms.json file does not exist: {configPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, webConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{webConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"连接字符串: {WebConfigUtils.ConnectionString}");
//await Console.Out.WriteLineAsync($"恢复文件夹: {treeInfo.DirectoryPath}");
await Console.Out.WriteLineAsync($"Database type: {_settingsManager.Database.DatabaseType.GetDisplayName()}");
await Console.Out.WriteLineAsync($"Database connection string: {_settingsManager.Database.ConnectionString}");
await Console.Out.WriteLineAsync($"Restore folder: {treeInfo.DirectoryPath}");
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
//if (!_dataOnly)
//{
// if (!await _configRepository.IsNeedInstallAsync())
// {
// await WriteUtils.PrintErrorAsync("The data could not be restored on the installed sscms database");
// return;
// }
// // 恢复前先创建表，确保系统在恢复的数据库中能够使用
// //await _databaseManager.CreateSiteServerTablesAsync();
// if (_settingsManager.DatabaseType == DatabaseType.SQLite)
// {
// var filePath = PathUtils.Combine(_settingsManager.ContentRootPath, Constants.DefaultLocalDbFileName);
// if (!FileUtils.IsFileExists(filePath))
// {
// await FileUtils.WriteTextAsync(filePath, string.Empty);
// }
// }
// await _databaseManager.SyncDatabaseAsync();
//}
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintRowAsync("Restore table name", "Count");
await WriteUtils.PrintRowLineAsync();
var errorLogFilePath = CliUtils.DeleteErrorLogFileIfExists(_settingsManager);
var errorTableNames = await _restoreService.RestoreAsync(_includes, _excludes, tablesFilePath, treeInfo, errorLogFilePath);
if (errorTableNames.Count == 0)
{
await WriteUtils.PrintSuccessAsync("restore database successfully!");
}
else
{
await WriteUtils.PrintErrorAsync($"Database restore failed and the following table was not successfully restored: {ListUtils.ToString(errorTableNames)}");
}
}
public async Task ExecuteAsync(IPluginJobContext 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(_settingsManager, directory);
DirectoryUtils.CreateDirectoryIfNotExists(treeInfo.DirectoryPath);
var backupConfigPath = PathUtils.Combine(_settingsManager.ContentRootPath, _from);
if (!FileUtils.IsFileExists(backupConfigPath))
{
await WriteUtils.PrintErrorAsync($"The sscms configuration file does not exist: {backupConfigPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, backupWebConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{backupWebConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"备份数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"备份连接字符串: {WebConfigUtils.ConnectionString}");
//await Console.Out.WriteLineAsync($"备份文件夹: {treeInfo.DirectoryPath}");
var(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
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 errorLogFilePath = CliUtils.DeleteErrorLogFileIfExists(CommandName, _settingsManager);
await DataBackupJob.Backup(_settingsManager, _databaseManager, _includes, _excludes, _maxRows, treeInfo, errorLogFilePath);
var restoreConfigPath = PathUtils.Combine(_settingsManager.ContentRootPath, _to);
if (!FileUtils.IsFileExists(restoreConfigPath))
{
await WriteUtils.PrintErrorAsync($"The sscms configuration file does not exist: {restoreConfigPath}");
return;
}
//WebConfigUtils.Load(_settingsManager.ContentRootPath, restoreWebConfigPath);
//if (string.IsNullOrEmpty(WebConfigUtils.ConnectionString))
//{
// await CliUtils.PrintErrorAsync($"{restoreWebConfigPath} 中数据库连接字符串 connectionString 未设置");
// return;
//}
//await Console.Out.WriteLineAsync($"恢复数据库类型: {_settingsManager.Database.DatabaseType.GetValue()}");
//await Console.Out.WriteLineAsync($"恢复连接字符串: {WebConfigUtils.ConnectionString}");
(isConnectionWorks, errorMessage) = await _settingsManager.Database.IsConnectionWorksAsync();
if (!isConnectionWorks)
{
await WriteUtils.PrintErrorAsync($"Unable to connect to database, error message:{errorMessage}");
return;
}
await _restoreService.RestoreAsync(_includes, _excludes, true, treeInfo.DirectoryPath, treeInfo, errorLogFilePath);
await WriteUtils.PrintRowLineAsync();
await WriteUtils.PrintSuccessAsync("恭喜，成功同步数据!");
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var(status, failureMessage) = _apiService.GetStatus();
if (status == null)
{
await WriteUtils.PrintErrorAsync(failureMessage);
return;
}
var pluginId = string.Empty;
if (context.Extras != null && context.Extras.Length > 0)
{
pluginId = context.Extras[0];
}
var pluginPath = string.IsNullOrEmpty(pluginId)
? _settingsManager.ContentRootPath
: PathUtils.Combine(_pathManager.GetPluginPath(pluginId));
var(plugin, errorMessage) = await PluginUtils.ValidateManifestAsync(pluginPath);
if (plugin == null)
{
await WriteUtils.PrintErrorAsync(errorMessage);
return;
}
if (!string.IsNullOrEmpty(_version))
{
SemVersion.TryParse(plugin.Version, out var pluginVersion);
string versionChanged;
if (_version == "major")
{
versionChanged = pluginVersion.Change(pluginVersion.Major + 1).ToString();
}
else if (_version == "minor")
{
versionChanged = pluginVersion.Change(pluginVersion.Major, pluginVersion.Minor + 1).ToString();
}
else if (_version == "patch")
{
versionChanged = pluginVersion.Change(pluginVersion.Major, pluginVersion.Minor, pluginVersion.Patch + 1).ToString();
}
else if (PluginUtils.IsSemVersion(_version))
{
versionChanged = _version;
}
else
{
await WriteUtils.PrintErrorAsync($"Invalid plugin version '{_version}'");
return;
}
if (versionChanged != plugin.Version)
{
await PluginUtils.UpdateVersionAsync(pluginPath, versionChanged);
(plugin, errorMessage) = await PluginUtils.ValidateManifestAsync(pluginPath);
if (plugin == null)
{
await WriteUtils.PrintErrorAsync(errorMessage);
return;
}
}
}
var packageId = PluginUtils.GetPackageId(plugin.Publisher, plugin.Name, plugin.Version);
var zipPath = PluginPackageJob.Package(_pathManager, plugin);
var fileSize = FileUtils.GetFileSizeByFilePath(zipPath);
await Console.Out.WriteLineAsync($"Packaged: {zipPath}");
await Console.Out.WriteLineAsync($"Publishing {packageId} ({fileSize})...");
bool success;
(success, failureMessage) = _apiService.PluginPublish(plugin.Publisher, zipPath);
if (success)
{
await WriteUtils.PrintSuccessAsync($"Published {packageId}, your plugin will live at {CloudUtils.Www.GetPluginUrl(plugin.PluginId)} (might take a few minutes for it to show up).");
}
else
{
await WriteUtils.PrintErrorAsync(failureMessage);
}
}
