public async Task ExportFilesAsync(string filePath)
{
var filesDirectoryPath = PathUtils.Combine(DirectoryUtils.GetDirectoryPath(filePath), PathUtils.GetFileNameWithoutExtension(filePath));
DirectoryUtils.DeleteDirectoryIfExists(filesDirectoryPath);
FileUtils.DeleteFileIfExists(filePath);
var sitePath = await _pathManager.GetSitePathAsync(_site);
DirectoryUtils.Copy(sitePath, filesDirectoryPath);
_pathManager.CreateZip(filePath, filesDirectoryPath);
DirectoryUtils.DeleteDirectoryIfExists(filesDirectoryPath);
}
public static async Task BackupSiteAsync(IPathManager pathManager, IDatabaseManager databaseManager, CacheUtils caching, Site site, string filePath)
{
var exportObject = new ExportObject(pathManager, databaseManager, caching, site);
var siteTemplateDir = PathUtils.GetFileNameWithoutExtension(filePath);
var siteTemplatePath = PathUtils.Combine(DirectoryUtils.GetDirectoryPath(filePath), siteTemplateDir);
DirectoryUtils.DeleteDirectoryIfExists(siteTemplatePath);
FileUtils.DeleteFileIfExists(filePath);
var metadataPath = pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, string.Empty);
await exportObject.ExportFilesToSiteAsync(siteTemplatePath, true, null, null, true);
var siteContentDirectoryPath = PathUtils.Combine(metadataPath, DirectoryUtils.SiteFiles.SiteTemplates.SiteContent);
await exportObject.ExportSiteContentAsync(siteContentDirectoryPath, true, true, new List <int>());
var templateFilePath = PathUtils.Combine(metadataPath, DirectoryUtils.SiteFiles.SiteTemplates.FileTemplate);
await exportObject.ExportTemplatesAsync(templateFilePath);
var tableDirectoryPath = PathUtils.Combine(metadataPath, DirectoryUtils.SiteFiles.SiteTemplates.Table);
await exportObject.ExportTablesAndStylesAsync(tableDirectoryPath);
var configurationFilePath = PathUtils.Combine(metadataPath, DirectoryUtils.SiteFiles.SiteTemplates.FileConfiguration);
await exportObject.ExportConfigurationAsync(configurationFilePath);
exportObject.ExportMetadata(site.SiteName, await pathManager.GetWebUrlAsync(site), string.Empty, string.Empty, metadataPath);
pathManager.CreateZip(filePath, siteTemplatePath);
DirectoryUtils.DeleteDirectoryIfExists(siteTemplatePath);
}
public static async Task <string> ExportRelatedFieldListAsync(IPathManager pathManager, IDatabaseManager databaseManager, int siteId)
{
var directoryPath = pathManager.GetTemporaryFilesPath("relatedField");
var filePath = pathManager.GetTemporaryFilesPath("relatedField.zip");
FileUtils.DeleteFileIfExists(filePath);
DirectoryUtils.DeleteDirectoryIfExists(directoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(directoryPath);
var site = await databaseManager.SiteRepository.GetAsync(siteId);
var relatedFieldInfoList = await databaseManager.RelatedFieldRepository.GetRelatedFieldsAsync(siteId);
var relatedFieldIe = new RelatedFieldIe(databaseManager, site, directoryPath);
foreach (var relatedFieldInfo in relatedFieldInfoList)
{
await relatedFieldIe.ExportRelatedFieldAsync(relatedFieldInfo);
}
pathManager.CreateZip(filePath, directoryPath);
DirectoryUtils.DeleteDirectoryIfExists(directoryPath);
return(PathUtils.GetFileName(filePath));
}
public async Task <ActionResult <StringResult> > Download([FromBody] SpecialIdRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.Specials))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var specialInfo = await _specialRepository.GetSpecialAsync(request.SiteId, request.SpecialId);
var directoryPath = await _pathManager.GetSpecialDirectoryPathAsync(site, specialInfo.Url);
var srcDirectoryPath = _pathManager.GetSpecialSrcDirectoryPath(directoryPath);
var zipFilePath = _pathManager.GetSpecialZipFilePath(specialInfo.Title, directoryPath);
FileUtils.DeleteFileIfExists(zipFilePath);
_pathManager.CreateZip(zipFilePath, srcDirectoryPath);
var url = await _pathManager.GetSpecialZipFileUrlAsync(site, specialInfo);
return(new StringResult
{
Value = url
});
}
public static async Task <string> ExportRootSingleTableStyleAsync(IPathManager pathManager, IDatabaseManager databaseManager, int siteId, string tableName, List <int> relatedIdentities)
{
var filePath = pathManager.GetTemporaryFilesPath("tableStyle.zip");
var styleDirectoryPath = pathManager.GetTemporaryFilesPath("TableStyle");
await TableStyleIe.SingleExportTableStylesAsync(databaseManager, siteId, tableName, relatedIdentities, styleDirectoryPath);
pathManager.CreateZip(filePath, styleDirectoryPath);
DirectoryUtils.DeleteDirectoryIfExists(styleDirectoryPath);
return(PathUtils.GetFileName(filePath));
}
public static string Package(IPathManager pathManager, Plugin plugin)
{
var outputPath = PathUtils.Combine(plugin.ContentRootPath, plugin.Output);
var packageId = PluginUtils.GetPackageId(plugin.Publisher, plugin.Name, plugin.Version);
var publishPath = CliUtils.GetOsUserPluginsDirectoryPath(packageId);
DirectoryUtils.DeleteDirectoryIfExists(publishPath);
var zipPath = CliUtils.GetOsUserPluginsDirectoryPath($"{packageId}.zip");
FileUtils.DeleteFileIfExists(zipPath);
foreach (var directoryName in DirectoryUtils.GetDirectoryNames(outputPath))
{
if (//StringUtils.EqualsIgnoreCase(directoryName, "bin") ||
StringUtils.EqualsIgnoreCase(directoryName, "obj") ||
StringUtils.EqualsIgnoreCase(directoryName, "node_modules") ||
StringUtils.EqualsIgnoreCase(directoryName, ".git") ||
StringUtils.EqualsIgnoreCase(directoryName, ".vs") ||
StringUtils.EqualsIgnoreCase(directoryName, ".vscode")
)
{
continue;
}
DirectoryUtils.Copy(PathUtils.Combine(outputPath, directoryName), PathUtils.Combine(publishPath, directoryName));
}
foreach (var fileName in DirectoryUtils.GetFileNames(outputPath))
{
if (StringUtils.EqualsIgnoreCase(fileName, Constants.PluginConfigFileName) ||
StringUtils.EndsWithIgnoreCase(fileName, ".csproj") ||
StringUtils.EndsWithIgnoreCase(fileName, ".csproj.user") ||
StringUtils.EndsWithIgnoreCase(fileName, ".sln") ||
StringUtils.EndsWithIgnoreCase(fileName, ".DotSettings.user") ||
StringUtils.EndsWithIgnoreCase(fileName, ".csproj.user") ||
StringUtils.EndsWithIgnoreCase(fileName, ".csproj.user") ||
StringUtils.EndsWithIgnoreCase(fileName, ".cs") ||
StringUtils.EndsWithIgnoreCase(fileName, ".zip")
)
{
continue;
}
FileUtils.CopyFile(PathUtils.Combine(outputPath, fileName), PathUtils.Combine(publishPath, fileName));
}
if (!PathUtils.IsEquals(outputPath, plugin.ContentRootPath))
{
FileUtils.CopyFile(PathUtils.Combine(plugin.ContentRootPath, Constants.PackageFileName),
PathUtils.Combine(publishPath, Constants.PackageFileName));
if (!FileUtils.IsFileExists(PathUtils.Combine(plugin.ContentRootPath, Constants.ReadmeFileName)))
{
FileUtils.CopyFile(PathUtils.Combine(plugin.ContentRootPath, Constants.ReadmeFileName),
PathUtils.Combine(publishPath, Constants.ReadmeFileName));
}
if (!FileUtils.IsFileExists(PathUtils.Combine(plugin.ContentRootPath, Constants.ChangeLogFileName)))
{
FileUtils.CopyFile(PathUtils.Combine(plugin.ContentRootPath, Constants.ChangeLogFileName),
PathUtils.Combine(publishPath, Constants.ChangeLogFileName));
}
}
pathManager.CreateZip(zipPath, publishPath);
DirectoryUtils.DeleteDirectoryIfExists(publishPath);
return(zipPath);
}
public static async Task <(bool Success, string name, string filePath)> PackageAsync(IPathManager pathManager, ICacheManager cacheManager, IDatabaseManager databaseManager, string directory, bool isOverride)
{
var site = await databaseManager.SiteRepository.GetSiteByDirectoryAsync(directory);
var sitePath = await pathManager.GetSitePathAsync(site);
if (site == null || !DirectoryUtils.IsDirectoryExists(sitePath))
{
await WriteUtils.PrintErrorAsync($@"Invalid site directory path: ""{directory}""");
return(false, null, null);
}
var readme = string.Empty;
Theme theme = null;
var readmePath = PathUtils.Combine(sitePath, "README.md");
if (FileUtils.IsFileExists(readmePath))
{
readme = FileUtils.ReadText(readmePath);
var yaml = MarkdownUtils.GetYamlFrontMatter(readme);
if (!string.IsNullOrEmpty(yaml))
{
readme = MarkdownUtils.RemoveYamlFrontMatter(readme);
theme = YamlUtils.Deserialize <Theme>(yaml);
}
}
var writeReadme = false;
if (theme == null || string.IsNullOrEmpty(theme.Name) || string.IsNullOrEmpty(theme.CoverUrl))
{
writeReadme = true;
theme = new Theme
{
Name = ReadUtils.GetString("name:"),
CoverUrl = ReadUtils.GetString("cover image url:"),
Summary = ReadUtils.GetString("repository url:"),
Tags = ReadUtils.GetStringList("tags:"),
ThumbUrls = ReadUtils.GetStringList("thumb image urls:"),
Compatibilities = ReadUtils.GetStringList("compatibilities:"),
Price = ReadUtils.GetYesNo("is free?") ? 0 : ReadUtils.GetDecimal("price:"),
};
}
if (writeReadme)
{
readme = @$ "---
{YamlUtils.Serialize(theme)}
---
" + readme;
FileUtils.WriteText(readmePath, readme);
}
var packageName = "T_" + theme.Name.Replace(" ", "_");
var packagePath = pathManager.GetSiteTemplatesPath(packageName);
var fileName = packageName + ".zip";
var filePath = pathManager.GetSiteTemplatesPath(fileName);
if (!isOverride && FileUtils.IsFileExists(filePath))
{
return(true, theme.Name, filePath);
}
FileUtils.DeleteFileIfExists(filePath);
DirectoryUtils.DeleteDirectoryIfExists(packagePath);
await Console.Out.WriteLineAsync($"Theme name: {theme.Name}");
await Console.Out.WriteLineAsync($"Theme folder: {packagePath}");
await Console.Out.WriteLineAsync("Theme packaging...");
var caching = new CacheUtils(cacheManager);
var manager = new SiteTemplateManager(pathManager, databaseManager, caching);
if (manager.IsSiteTemplateDirectoryExists(packageName))
{
manager.DeleteSiteTemplate(packageName);
}
var directoryNames = DirectoryUtils.GetDirectoryNames(sitePath);
var directories = new List <string>();
var siteDirList = await databaseManager.SiteRepository.GetSiteDirsAsync(0);
foreach (var directoryName in directoryNames)
{
var isSiteDirectory = false;
if (site.Root)
{
foreach (var siteDir in siteDirList)
{
if (StringUtils.EqualsIgnoreCase(siteDir, directoryName))
{
isSiteDirectory = true;
}
}
}
if (!isSiteDirectory && !pathManager.IsSystemDirectory(directoryName))
{
directories.Add(directoryName);
}
}
var files = DirectoryUtils.GetFileNames(sitePath);
var exportObject = new ExportObject(pathManager, databaseManager, caching, site);
await exportObject.ExportFilesToSiteAsync(packagePath, true, directories, files, true);
var siteContentDirectoryPath = pathManager.GetSiteTemplateMetadataPath(packagePath, DirectoryUtils.SiteFiles.SiteTemplates.SiteContent);
await exportObject.ExportSiteContentAsync(siteContentDirectoryPath, true, true, new List <int>());
await SiteTemplateManager.ExportSiteToSiteTemplateAsync(pathManager, databaseManager, caching, site, packageName);
var siteTemplateInfo = new SiteTemplateInfo
{
SiteTemplateName = theme.Name,
PicFileName = string.Empty,
WebSiteUrl = string.Empty,
Description = string.Empty
};
var xmlPath = pathManager.GetSiteTemplateMetadataPath(packagePath,
DirectoryUtils.SiteFiles.SiteTemplates.FileMetadata);
XmlUtils.SaveAsXml(siteTemplateInfo, xmlPath);
pathManager.CreateZip(filePath, packagePath);
return(true, theme.Name, filePath);
}