public async Task ImportChannelsAndContentsByZipFileAsync(int parentId, string zipFilePath, bool isOverride, string guid)
{
var siteContentDirectoryPath = _pathManager.GetTemporaryFilesPath(BackupType.ChannelsAndContents.GetValue());
DirectoryUtils.DeleteDirectoryIfExists(siteContentDirectoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(siteContentDirectoryPath);
_pathManager.ExtractZip(zipFilePath, siteContentDirectoryPath);
await ImportChannelsAndContentsFromZipAsync(parentId, siteContentDirectoryPath, isOverride, guid);
var uploadFolderPath = PathUtils.Combine(siteContentDirectoryPath, BackupUtility.UploadFolderName);
var uploadFilePath = PathUtils.Combine(uploadFolderPath, BackupUtility.UploadFileName);
if (!FileUtils.IsFileExists(uploadFilePath))
{
return;
}
var sitePath = await _pathManager.GetSitePathAsync(_site);
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(uploadFilePath));
if (feed != null)
{
AtomEntry entry = feed.Entries[0];
string imageUploadDirectoryPath = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ImageUploadDirectoryName");
if (imageUploadDirectoryPath != null)
{
DirectoryUtils.MoveDirectory(PathUtils.Combine(siteContentDirectoryPath, imageUploadDirectoryPath), PathUtils.Combine(sitePath, _site.ImageUploadDirectoryName), isOverride);
}
string videoUploadDirectoryPath = AtomUtility.GetDcElementContent(entry.AdditionalElements, "VideoUploadDirectoryName");
if (videoUploadDirectoryPath != null)
{
DirectoryUtils.MoveDirectory(PathUtils.Combine(siteContentDirectoryPath, videoUploadDirectoryPath), PathUtils.Combine(sitePath, _site.VideoUploadDirectoryName), isOverride);
}
string fileUploadDirectoryPath = AtomUtility.GetDcElementContent(entry.AdditionalElements, "FileUploadDirectoryName");
if (fileUploadDirectoryPath != null)
{
DirectoryUtils.MoveDirectory(PathUtils.Combine(siteContentDirectoryPath, fileUploadDirectoryPath), PathUtils.Combine(sitePath, _site.FileUploadDirectoryName), isOverride);
}
}
}
public static async Task <string> ImportTableStyleByZipFileAsync(IPathManager pathManager, IDatabaseManager databaseManager, string tableName, List <int> relatedIdentities, string zipFilePath)
{
var styleDirectoryPath = pathManager.GetTemporaryFilesPath("TableStyle");
DirectoryUtils.DeleteDirectoryIfExists(styleDirectoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(styleDirectoryPath);
pathManager.ExtractZip(zipFilePath, styleDirectoryPath);
await TableStyleIe.SingleImportTableStyleAsync(databaseManager, tableName, styleDirectoryPath, relatedIdentities);
return(styleDirectoryPath);
}
public static async Task <string> ImportRelatedFieldByZipFileAsync(IPathManager pathManager, IDatabaseManager databaseManager, Site site, string zipFilePath)
{
var directoryPath = pathManager.GetTemporaryFilesPath("RelatedField");
DirectoryUtils.DeleteDirectoryIfExists(directoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(directoryPath);
pathManager.ExtractZip(zipFilePath, directoryPath);
var relatedFieldIe = new RelatedFieldIe(databaseManager, site, directoryPath);
await relatedFieldIe.ImportRelatedFieldAsync(true);
return(directoryPath);
}
public static string DownloadCms(IPathManager pathManager, string osArchitecture, string version)
{
var packagesPath = pathManager.GetPackagesPath();
var name = GetCmsDownloadName(osArchitecture, version);
var directoryPath = PathUtils.Combine(packagesPath, name);
//if (IsCmsDownload(pathManager, osArchitecture, version))
//{
// return directoryPath;
//}
var directoryNames = DirectoryUtils.GetDirectoryNames(packagesPath);
foreach (var directoryName in directoryNames.Where(directoryName => StringUtils.StartsWithIgnoreCase(directoryName, "sscms-")))
{
DirectoryUtils.DeleteDirectoryIfExists(PathUtils.Combine(packagesPath, directoryName));
}
DirectoryUtils.CreateDirectoryIfNotExists(directoryPath);
var filePath = PathUtils.Combine(packagesPath, $"{GetCmsDownloadName(osArchitecture, version)}.zip");
FileUtils.WriteText(filePath, string.Empty);
using (var writer = File.OpenWrite(filePath))
{
var client = new RestClient(GetCmsDownloadUrl(osArchitecture, version));
var request = new RestRequest
{
ResponseWriter = responseStream =>
{
using (responseStream)
{
responseStream.CopyTo(writer);
}
}
};
client.DownloadData(request);
}
pathManager.ExtractZip(filePath, directoryPath);
FileUtils.DeleteFileIfExists(filePath);
return(directoryPath);
}
public static async Task RecoverySiteAsync(ICacheManager cacheManager, IPathManager pathManager, IDatabaseManager databaseManager, CacheUtils caching, Site site, bool isDeleteChannels, bool isDeleteTemplates, bool isDeleteFiles, bool isZip, string path, bool isOverride, bool isUseTable, int adminId, string guid)
{
var importObject = new ImportObject(pathManager, databaseManager, caching, site, adminId);
var siteTemplatePath = path;
if (isZip)
{
//解压文件
siteTemplatePath = pathManager.GetTemporaryFilesPath(BackupType.Site.GetValue());
DirectoryUtils.DeleteDirectoryIfExists(siteTemplatePath);
DirectoryUtils.CreateDirectoryIfNotExists(siteTemplatePath);
pathManager.ExtractZip(path, siteTemplatePath);
}
var siteTemplateMetadataPath = PathUtils.Combine(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.SiteTemplateMetadata);
if (isDeleteChannels)
{
var channelIdList = await databaseManager.ChannelRepository.GetChannelIdsAsync(site.Id, site.Id, ScopeType.Children);
foreach (var channelId in channelIdList)
{
await databaseManager.ContentRepository.TrashContentsAsync(site, channelId, adminId);
await databaseManager.ChannelRepository.DeleteAsync(site, channelId, adminId);
}
}
if (isDeleteTemplates)
{
var summaries = await databaseManager.TemplateRepository.GetSummariesAsync(site.Id);
foreach (var summary in summaries)
{
if (summary.DefaultTemplate == false)
{
await databaseManager.TemplateRepository.DeleteAsync(pathManager, site, summary.Id);
}
}
}
if (isDeleteFiles)
{
await pathManager.DeleteSiteFilesAsync(site);
}
//导入文件
await importObject.ImportFilesAsync(siteTemplatePath, isOverride, guid);
//导入模板
var templateFilePath = PathUtils.Combine(siteTemplateMetadataPath, DirectoryUtils.SiteFiles.SiteTemplates.FileTemplate);
await importObject.ImportTemplatesAsync(templateFilePath, isOverride, adminId, guid);
//导入辅助表
var tableDirectoryPath = PathUtils.Combine(siteTemplateMetadataPath, DirectoryUtils.SiteFiles.SiteTemplates.Table);
//导入站点设置
var configurationFilePath = PathUtils.Combine(siteTemplateMetadataPath, DirectoryUtils.SiteFiles.SiteTemplates.FileConfiguration);
await importObject.ImportConfigurationAsync(configurationFilePath, guid);
//导入栏目及内容
var siteContentDirectoryPath = PathUtils.Combine(siteTemplateMetadataPath, DirectoryUtils.SiteFiles.SiteTemplates.SiteContent);
await importObject.ImportChannelsAndContentsAsync(0, siteContentDirectoryPath, isOverride, guid);
//导入表样式及清除缓存
if (isUseTable)
{
await importObject.ImportTableStylesAsync(tableDirectoryPath, guid);
}
cacheManager.Clear();
}
public async Task <ActionResult <ObjectResult <IEnumerable <Special> > > > SpecialSubmit([FromBody] SubmitRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.Specials))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var specialId = request.Id;
if (specialId > 0 && request.IsEditOnly)
{
var specialInfo = await _specialRepository.GetSpecialAsync(request.SiteId, specialId);
var oldDirectoryPath = string.Empty;
var newDirectoryPath = string.Empty;
if (specialInfo.Title != request.Title && await _specialRepository.IsTitleExistsAsync(request.SiteId, request.Title))
{
return(this.Error("专题修改失败，专题名称已存在！"));
}
if (specialInfo.Url != request.Url)
{
if (await _specialRepository.IsUrlExistsAsync(request.SiteId, request.Url))
{
return(this.Error("专题修改失败，专题访问地址已存在！"));
}
oldDirectoryPath = await _pathManager.GetSpecialDirectoryPathAsync(site, specialInfo.Url);
newDirectoryPath = await _pathManager.GetSpecialDirectoryPathAsync(site, request.Url);
}
specialInfo.Title = request.Title;
specialInfo.Url = request.Url;
await _specialRepository.UpdateAsync(specialInfo);
if (oldDirectoryPath != newDirectoryPath)
{
DirectoryUtils.MoveDirectory(oldDirectoryPath, newDirectoryPath, true);
}
}
else if (specialId > 0 && request.IsUploadOnly)
{
var specialInfo = await _specialRepository.GetSpecialAsync(request.SiteId, specialId);
var directoryPath = await _pathManager.GetSpecialDirectoryPathAsync(site, specialInfo.Url);
var srcDirectoryPath = _pathManager.GetSpecialSrcDirectoryPath(directoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(srcDirectoryPath);
var uploadDirectoryPath = _pathManager.GetTemporaryFilesPath(request.Guid);
foreach (var filePath in DirectoryUtils.GetFilePaths(uploadDirectoryPath))
{
var fileName = PathUtils.GetFileName(filePath);
if (!ListUtils.ContainsIgnoreCase(request.FileNames, fileName))
{
continue;
}
if (FileUtils.IsZip(PathUtils.GetExtension(filePath)))
{
_pathManager.ExtractZip(filePath, srcDirectoryPath);
}
else
{
FileUtils.MoveFile(filePath, PathUtils.Combine(srcDirectoryPath, fileName), true);
}
}
DirectoryUtils.Copy(srcDirectoryPath, directoryPath);
}
else if (specialId == 0)
{
if (await _specialRepository.IsTitleExistsAsync(request.SiteId, request.Title))
{
return(this.Error("专题添加失败，专题名称已存在！"));
}
if (await _specialRepository.IsUrlExistsAsync(request.SiteId, request.Url))
{
return(this.Error("专题添加失败，专题访问地址已存在！"));
}
var directoryPath = await _pathManager.GetSpecialDirectoryPathAsync(site, request.Url);
var srcDirectoryPath = _pathManager.GetSpecialSrcDirectoryPath(directoryPath);
DirectoryUtils.CreateDirectoryIfNotExists(srcDirectoryPath);
var uploadDirectoryPath = _pathManager.GetTemporaryFilesPath(request.Guid);
foreach (var filePath in DirectoryUtils.GetFilePaths(uploadDirectoryPath))
{
var fileName = PathUtils.GetFileName(filePath);
if (!ListUtils.ContainsIgnoreCase(request.FileNames, fileName))
{
continue;
}
if (FileUtils.IsZip(PathUtils.GetExtension(filePath)))
{
_pathManager.ExtractZip(filePath, srcDirectoryPath);
}
else
{
FileUtils.MoveFile(filePath, PathUtils.Combine(srcDirectoryPath, fileName), true);
}
}
DirectoryUtils.Copy(srcDirectoryPath, directoryPath);
specialId = await _specialRepository.InsertAsync(new Special
{
Id = 0,
SiteId = request.SiteId,
Title = request.Title,
Url = request.Url,
AddDate = DateTime.Now
});
await _authManager.AddSiteLogAsync(request.SiteId, "新建专题", $"专题名称:{request.Title}");
}
await _createManager.CreateSpecialAsync(request.SiteId, specialId);
var specialInfoList = await _specialRepository.GetSpecialsAsync(request.SiteId);
return(new ObjectResult <IEnumerable <Special> >
{
Value = specialInfoList
});
}