public async Task <ActionResult <BoolResult> > Add([FromBody] AddRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(RestrictionManager.PermissionsSettings))
{
return(Unauthorized());
}
if (request.IsAllowList)
{
var list = new List <string>(_settingsManager.AdminRestrictionAllowList ?? new string[] { });
if (ListUtils.Contains(list, request.Range))
{
return(this.Error("添加失败，Ip 段已存在"));
}
list.Add(request.Range);
_settingsManager.SaveSettings(_settingsManager.IsProtectData, _settingsManager.IsDisablePlugins, _settingsManager.DatabaseType, _settingsManager.DatabaseConnectionString, _settingsManager.RedisConnectionString, _settingsManager.AdminRestrictionHost, list.ToArray(), _settingsManager.AdminRestrictionBlockList);
}
else
{
var list = new List <string>(_settingsManager.AdminRestrictionBlockList ?? new string[] { });
if (ListUtils.Contains(list, request.Range))
{
return(this.Error("添加失败，Ip 段已存在"));
}
list.Add(request.Range);
_settingsManager.SaveSettings(_settingsManager.IsProtectData, _settingsManager.IsDisablePlugins, _settingsManager.DatabaseType, _settingsManager.DatabaseConnectionString, _settingsManager.RedisConnectionString, _settingsManager.AdminRestrictionHost, _settingsManager.AdminRestrictionAllowList, list.ToArray());
}
return(new BoolResult
{
Value = true
});
}
public async Task <ActionResult <ListImageResult> > ListImage([FromQuery] ListImageRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var directoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var files = Directory.GetFiles(directoryPath, "*", SearchOption.AllDirectories).Where(x =>
_pathManager.IsImageExtensionAllowed(site, PathUtils.GetExtension(x))).OrderByDescending(x => x);
var list = new List <ImageResult>();
foreach (var x in files.Skip(request.Start).Take(request.Size))
{
list.Add(new ImageResult
{
Url = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, x, true)
});
}
return(new ListImageResult
{
State = "SUCCESS",
Size = request.Size,
Start = request.Start,
Total = files.Count(),
List = list
});
}
public async Task <ActionResult <Options> > Get([FromQuery] SiteRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var options = TranslateUtils.JsonDeserialize(site.Get <string>($"Home.{nameof(LayerImageUploadController)}"), new Options
{
IsEditor = true,
IsThumb = false,
ThumbWidth = 1024,
ThumbHeight = 1024,
IsLinkToOriginal = true
});
return(options);
}
public async Task <ActionResult <NameTitle> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
if (file == null)
{
return(this.Error(Constants.ErrorUpload));
}
var title = PathUtils.GetFileNameWithoutExtension(file.FileName);
var fileName = PathUtils.GetUploadFileName(file.FileName, true);
var extendName = PathUtils.GetExtension(fileName);
if (!FileUtils.IsWord(extendName))
{
return(this.Error("文件只能是 Word 格式，请选择有效的文件上传!"));
}
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
await _pathManager.UploadAsync(file, filePath);
return(new NameTitle
{
FileName = fileName,
Title = title
});
}
public async Task <ActionResult <BoolResult> > Submit([FromBody] SubmitRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.SettingsContentTag))
{
return(Unauthorized());
}
var tagNames = await _contentTagRepository.GetTagNamesAsync(request.SiteId);
foreach (var tagName in ListUtils.GetStringListByReturnAndNewline(request.TagNames))
{
if (ListUtils.Contains(tagNames, tagName))
{
continue;
}
await _contentTagRepository.InsertAsync(request.SiteId, tagName);
}
await _authManager.AddSiteLogAsync(request.SiteId, "新增内容标签");
return(new BoolResult
{
Value = true
});
}
private static bool IsEnabled(IPlugin plugin, int siteId)
{
if (plugin == null || plugin.Disabled)
{
return(false);
}
return(plugin.ApplyToSites && (plugin.AllSites || ListUtils.Contains(plugin.SiteIds, siteId)));
}
public async Task <ActionResult <UploadImageResult> > UploadImage([FromQuery] SiteRequest request, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(new UploadImageResult
{
Error = Constants.ErrorUpload
});
}
var original = Path.GetFileName(file.FileName);
var fileName = _pathManager.GetUploadFileName(site, original);
if (!_pathManager.IsImageExtensionAllowed(site, PathUtils.GetExtension(fileName)))
{
return(new UploadImageResult
{
Error = Constants.ErrorImageExtensionAllowed
});
}
if (!_pathManager.IsImageSizeAllowed(site, file.Length))
{
return(new UploadImageResult
{
Error = Constants.ErrorImageSizeAllowed
});
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var filePath = PathUtils.Combine(localDirectoryPath, fileName);
await _pathManager.UploadAsync(file, filePath);
await _pathManager.AddWaterMarkAsync(site, filePath);
var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true);
return(new UploadImageResult
{
State = "SUCCESS",
Url = imageUrl,
Title = original,
Original = original,
Error = null
});
}
public async Task <ActionResult <List <SubmitResult> > > Submit([FromBody] SubmitRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var result = new List <SubmitResult>();
foreach (var filePath in request.FilePaths)
{
if (string.IsNullOrEmpty(filePath))
{
continue;
}
var fileName = PathUtils.GetFileName(filePath);
var virtualUrl = await _pathManager.GetVirtualUrlByPhysicalPathAsync(site, filePath);
var fileUrl = await _pathManager.ParseSiteUrlAsync(site, virtualUrl, true);
result.Add(new SubmitResult
{
FileUrl = fileUrl,
FileVirtualUrl = virtualUrl
});
}
var options = TranslateUtils.JsonDeserialize(site.Get <string>($"Home.{nameof(LayerFileUploadController)}"), new Options
{
IsChangeFileName = true
});
options.IsChangeFileName = request.IsChangeFileName;
site.Set($"Home.{nameof(LayerFileUploadController)}", TranslateUtils.JsonSerialize(options));
await _siteRepository.UpdateAsync(site);
return(result);
}
private static bool IsEnabled(IPlugin plugin, int siteId, int channelId)
{
if (!IsEnabled(plugin, siteId))
{
return(false);
}
var siteConfig = plugin.SiteConfigs?.FirstOrDefault(x => x.SiteId == siteId);
if (siteConfig == null)
{
return(false);
}
return(siteConfig.AllChannels || ListUtils.Contains(siteConfig.ChannelIds, channelId));
}
public async Task <ActionResult <ConfigResult> > GetConfig([FromQuery] SiteRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
return(new ConfigResult
{
ImageActionName = "uploadImage",
ImageFieldName = "file",
ImageMaxSize = site.ImageUploadTypeMaxSize * 1024,
ImageAllowFiles = ListUtils.GetStringList(site.ImageUploadExtensions),
ImageCompressEnable = false,
ImageCompressBorder = 1600,
ImageInsertAlign = "none",
ImageUrlPrefix = "",
ImagePathFormat = "",
ScrawlActionName = "uploadScrawl",
ScrawlFieldName = "file",
ScrawlPathFormat = "",
ScrawlMaxSize = site.ImageUploadTypeMaxSize * 1024,
ScrawlUrlPrefix = "",
ScrawlInsertAlign = "none",
VideoActionName = "uploadVideo",
VideoFieldName = "file",
VideoUrlPrefix = "",
VideoMaxSize = site.VideoUploadTypeMaxSize * 1024,
VideoAllowFiles = ListUtils.GetStringList(site.VideoUploadExtensions),
FileActionName = "uploadFile",
FileFieldName = "file",
FileUrlPrefix = "",
FileMaxSize = site.FileUploadTypeMaxSize * 1024,
FileAllowFiles = ListUtils.GetStringList($"{site.ImageUploadExtensions},{site.VideoUploadExtensions},{site.FileUploadExtensions}"),
ImageManagerActionName = "listImage",
ImageManagerListSize = 20,
ImageManagerUrlPrefix = "",
ImageManagerInsertAlign = "none",
ImageManagerAllowFiles = ListUtils.GetStringList(site.ImageUploadExtensions),
FileManagerActionName = "listFile",
FileManagerListSize = 20,
FileManagerUrlPrefix = "",
FileManagerAllowFiles = ListUtils.GetStringList($"{site.ImageUploadExtensions},{site.VideoUploadExtensions},{site.FileUploadExtensions}")
});
}
public async Task <ActionResult <UploadScrawlResult> > UploadScrawl([FromQuery] int siteId, [FromForm] UploadScrawlRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, siteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(siteId);
var bytes = Convert.FromBase64String(request.File);
var original = "scrawl.png";
var fileName = _pathManager.GetUploadFileName(site, original);
if (!_pathManager.IsImageExtensionAllowed(site, PathUtils.GetExtension(fileName)))
{
return(new UploadScrawlResult
{
Error = Constants.ErrorImageExtensionAllowed
});
}
if (!_pathManager.IsImageSizeAllowed(site, request.File.Length))
{
return(new UploadScrawlResult
{
Error = Constants.ErrorImageSizeAllowed
});
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var filePath = PathUtils.Combine(localDirectoryPath, fileName);
await _pathManager.UploadAsync(bytes, filePath);
var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true);
return(new UploadScrawlResult
{
State = "SUCCESS",
Url = imageUrl,
Title = original,
Original = original,
Error = null
});
}
public async Task <bool> IsAncestorOrSelfAsync(int siteId, int parentId, int childId)
{
if (parentId == childId)
{
return(true);
}
var channel = await GetAsync(childId);
if (channel == null)
{
return(false);
}
if (ListUtils.Contains(channel.ParentsPath, parentId))
{
return(true);
}
return(false);
}
public async Task <ActionResult <UploadResult> > UploadImage([FromQuery] SiteRequest request, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(this.Error(Constants.ErrorUpload));
}
var fileName = Path.GetFileName(file.FileName);
var extName = PathUtils.GetExtension(fileName);
if (!_pathManager.IsImageExtensionAllowed(site, extName))
{
return(this.Error(Constants.ErrorImageExtensionAllowed));
}
if (!_pathManager.IsImageSizeAllowed(site, file.Length))
{
return(this.Error(Constants.ErrorImageSizeAllowed));
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var filePath = PathUtils.Combine(localDirectoryPath, _pathManager.GetUploadFileName(site, fileName));
await _pathManager.UploadAsync(file, filePath);
var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true);
return(new UploadResult
{
Name = fileName,
Path = filePath,
Url = imageUrl
});
}
public async Task <List <string> > GetTableNamesAsync(Site site)
{
var tableNames = new List <string> {
site.TableName
};
var channelSummaries = await _channelRepository.GetSummariesAsync(site.Id);
var pluginTableNames = _settingsManager.GetContentTableNames();
foreach (var summary in channelSummaries)
{
if (!string.IsNullOrEmpty(summary.TableName))
{
if (ListUtils.Contains(pluginTableNames, summary.TableName))
{
tableNames.Add(summary.TableName);
}
}
}
return(tableNames);
}
public async Task <ActionResult <UploadResult> > Upload([FromQuery] UploadRequest request, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(this.Error(Constants.ErrorUpload));
}
var fileName = Path.GetFileName(file.FileName);
if (!_pathManager.IsVideoExtensionAllowed(site, PathUtils.GetExtension(fileName)))
{
return(this.Error(Constants.ErrorVideoExtensionAllowed));
}
if (!_pathManager.IsVideoSizeAllowed(site, file.Length))
{
return(this.Error(Constants.ErrorVideoSizeAllowed));
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.File);
var localFileName = PathUtils.GetUploadFileName(fileName, request.IsChangeFileName);
var filePath = PathUtils.Combine(localDirectoryPath, localFileName);
await _pathManager.UploadAsync(file, filePath);
return(new UploadResult
{
Name = localFileName,
Path = filePath
});
}
public static bool IsAdvertisement(IParseContext context, Models.Advertisement advertisement)
{
if (advertisement.IsDateLimited)
{
if (DateTime.Now < advertisement.StartDate || DateTime.Now > advertisement.EndDate)
{
return(false);
}
}
if (advertisement.ScopeType == ScopeType.All)
{
return(true);
}
if (advertisement.ScopeType == ScopeType.Templates)
{
return(ListUtils.Contains(advertisement.TemplateIds, context.TemplateId));
}
if (advertisement.ScopeType == ScopeType.Channels)
{
if (context.TemplateType == TemplateType.FileTemplate)
{
return(false);
}
if (!advertisement.IsChannels && (context.TemplateType == TemplateType.ContentTemplate || context.TemplateType == TemplateType.FileTemplate))
{
return(false);
}
if (!advertisement.IsContents && context.TemplateType == TemplateType.ContentTemplate)
{
return(false);
}
return(ListUtils.Contains(advertisement.ChannelIds, context.ChannelId));
}
return(false);
}
public async Task <ActionResult <UploadResult> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(this.Error("请选择有效的文件上传"));
}
var fileName = PathUtils.GetFileName(file.FileName);
if (!PathUtils.IsExtension(PathUtils.GetExtension(fileName), ".jpg", ".jpeg", ".bmp", ".gif", ".png", ".webp"))
{
return(this.Error("文件只能是 Image 格式，请选择有效的文件上传!"));
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var filePath = PathUtils.Combine(localDirectoryPath, _pathManager.GetUploadFileName(site, fileName));
await _pathManager.UploadAsync(file, filePath);
await _pathManager.AddWaterMarkAsync(site, filePath);
var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true);
return(new UploadResult
{
Name = fileName,
Path = filePath,
Url = imageUrl
});
}
public async Task <ActionResult <StringResult> > Submit([FromBody] SubmitRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var builder = new StringBuilder();
foreach (var file in request.Files)
{
if (string.IsNullOrEmpty(file.FileName) || string.IsNullOrEmpty(file.Title))
{
continue;
}
var filePath = _pathManager.GetTemporaryFilesPath(file.FileName);
var(_, _, wordContent) = await WordManager.GetWordAsync(_pathManager, site, false, request.IsClearFormat, request.IsFirstLineIndent, request.IsClearFontSize, request.IsClearFontFamily, request.IsClearImages, filePath, file.Title);
wordContent = await _pathManager.DecodeTextEditorAsync(site, wordContent, true);
builder.Append(wordContent);
FileUtils.DeleteFileIfExists(filePath);
}
return(new StringResult
{
Value = builder.ToString()
});
}
public async Task <ActionResult <UploadResult> > Upload([FromQuery] int siteId, [FromForm] IFormFile file)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, siteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(siteId);
if (file == null)
{
return(this.Error("请选择有效的文件上传"));
}
var fileName = PathUtils.GetFileName(file.FileName);
var extName = PathUtils.GetExtension(fileName);
if (!_pathManager.IsImageExtensionAllowed(site, extName))
{
return(this.Error("此图片格式已被禁止上传，请转换格式后上传!"));
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image);
var filePath = PathUtils.Combine(localDirectoryPath, _pathManager.GetUploadFileName(site, fileName));
await _pathManager.UploadAsync(file, filePath);
await _pathManager.AddWaterMarkAsync(site, filePath);
return(new UploadResult
{
Name = fileName,
Path = filePath
});
}
public async Task <ActionResult <QueryResult> > List([FromBody] QueryRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var groups = await _materialGroupRepository.GetAllAsync(MaterialType.Message);
var count = await _materialArticleRepository.GetCountAsync(request.GroupId, request.Keyword);
var items = await _materialArticleRepository.GetAllAsync(request.GroupId, request.Keyword, request.Page, request.PerPage);
return(new QueryResult
{
Groups = groups,
Count = count,
Items = items
});
}
public async Task <ActionResult <Options> > Get([FromQuery] SiteRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var options = TranslateUtils.JsonDeserialize(site.Get <string>($"Home.{nameof(LayerVideoUploadController)}"), new Options
{
IsChangeFileName = true
});
return(options);
}
public async Task ImportAsync(AtomFeed feed, int siteId, string guid)
{
var contentTags = new List <ContentTag>();
var tagNames = await _databaseManager.ContentTagRepository.GetTagNamesAsync(siteId);
foreach (AtomEntry entry in feed.Entries)
{
var isContentTag = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(entry.AdditionalElements, "IsContentTag"));
if (!isContentTag)
{
continue;
}
var tagName = AtomUtility.GetDcElementContent(entry.AdditionalElements, nameof(ContentTag.TagName));
if (string.IsNullOrEmpty(tagName) || ListUtils.Contains(tagNames, tagName))
{
continue;
}
var useNum = TranslateUtils.ToInt(AtomUtility.GetDcElementContent(entry.AdditionalElements, nameof(ContentTag.UseNum)));
var level = TranslateUtils.ToInt(AtomUtility.GetDcElementContent(entry.AdditionalElements, nameof(ContentTag.Level)));
contentTags.Add(new ContentTag
{
TagName = tagName,
SiteId = siteId,
UseNum = useNum,
Level = level
});
}
foreach (var contentTag in contentTags)
{
_caching.SetProcess(guid, $"导入内容标签: {contentTag.TagName}");
await _databaseManager.ContentTagRepository.InsertAsync(contentTag);
}
}
public async Task <(int Total, int Count, List <string> Results)> GetPageOpenIds(int siteId, int tagId, string keyword, int page, int perPage)
{
var users = await GetAllAsync(siteId);
var total = users.Count;
if (tagId != 0)
{
users = users.Where(x => ListUtils.Contains(x.TagIdList, tagId)).ToList();
}
if (!string.IsNullOrEmpty(keyword))
{
users = users.Where(x =>
StringUtils.ContainsIgnoreCase(x.Nickname, keyword) ||
StringUtils.ContainsIgnoreCase(x.Remark, keyword)).ToList();
}
var count = users.Count;
var results = users.Skip((page - 1) * perPage).Take(perPage).Select(x => x.OpenId).ToList();
return(total, count, results);
}
public async Task <ActionResult <List <SubmitResult> > > Submit([FromBody] SubmitRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var result = new List <SubmitResult>();
foreach (var filePath in request.FilePaths)
{
if (string.IsNullOrEmpty(filePath))
{
continue;
}
var fileName = PathUtils.GetFileName(filePath);
var fileExtName = StringUtils.ToLower(PathUtils.GetExtension(filePath));
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, fileExtName);
var virtualUrl = await _pathManager.GetVirtualUrlByPhysicalPathAsync(site, filePath);
var imageUrl = await _pathManager.ParseSiteUrlAsync(site, virtualUrl, true);
if (request.IsThumb)
{
var localSmallFileName = Constants.SmallImageAppendix + fileName;
var localSmallFilePath = PathUtils.Combine(localDirectoryPath, localSmallFileName);
var thumbnailVirtualUrl = await _pathManager.GetVirtualUrlByPhysicalPathAsync(site, localSmallFilePath);
var thumbnailUrl = await _pathManager.ParseSiteUrlAsync(site, thumbnailVirtualUrl, true);
_pathManager.ResizeImageByMax(filePath, localSmallFilePath, request.ThumbWidth, request.ThumbHeight);
if (request.IsLinkToOriginal)
{
result.Add(new SubmitResult
{
ImageUrl = thumbnailUrl,
ImageVirtualUrl = thumbnailVirtualUrl,
PreviewUrl = imageUrl,
PreviewVirtualUrl = virtualUrl
});
}
else
{
FileUtils.DeleteFileIfExists(filePath);
result.Add(new SubmitResult
{
ImageUrl = thumbnailUrl,
ImageVirtualUrl = thumbnailVirtualUrl
});
}
}
else
{
result.Add(new SubmitResult
{
ImageUrl = imageUrl,
ImageVirtualUrl = virtualUrl
});
}
}
var options = TranslateUtils.JsonDeserialize(site.Get <string>($"Home.{nameof(LayerImageUploadController)}"), new Options
{
IsEditor = true,
IsThumb = false,
ThumbWidth = 1024,
ThumbHeight = 1024,
IsLinkToOriginal = true,
});
options.IsEditor = request.IsEditor;
options.IsThumb = request.IsThumb;
options.ThumbWidth = request.ThumbWidth;
options.ThumbHeight = request.ThumbHeight;
options.IsLinkToOriginal = request.IsLinkToOriginal;
site.Set($"Home.{nameof(LayerImageUploadController)}", TranslateUtils.JsonSerialize(options));
await _siteRepository.UpdateAsync(site);
return(result);
}
public async Task <ActionResult <List <SubmitResult> > > Submit([FromBody] SubmitRequest request)
{
var siteIds = await _authManager.GetSiteIdsAsync();
if (!ListUtils.Contains(siteIds, request.SiteId))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(this.Error("无法确定内容对应的站点"));
}
var result = new List <SubmitResult>();
foreach (var filePath in request.FilePaths)
{
if (string.IsNullOrEmpty(filePath))
{
continue;
}
var fileName = PathUtils.GetFileName(filePath);
var fileExtName = StringUtils.ToLower(PathUtils.GetExtension(filePath));
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, fileExtName);
var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true);
if (request.IsThumb)
{
var localSmallFileName = Constants.SmallImageAppendix + fileName;
var localSmallFilePath = PathUtils.Combine(localDirectoryPath, localSmallFileName);
var thumbnailUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, localSmallFilePath, true);
var width = request.ThumbWidth;
var height = request.ThumbHeight;
OldImageUtils.MakeThumbnail(filePath, localSmallFilePath, width, height, true);
if (request.IsLinkToOriginal)
{
result.Add(new SubmitResult
{
ImageUrl = thumbnailUrl,
PreviewUrl = imageUrl
});
}
else
{
FileUtils.DeleteFileIfExists(filePath);
result.Add(new SubmitResult
{
ImageUrl = thumbnailUrl
});
}
}
else
{
result.Add(new SubmitResult
{
ImageUrl = imageUrl
});
}
}
return(result);
}
public async Task <ActionResult <GetResult> > Get()
{
var config = await _configRepository.GetAsync();
if (config.IsHomeClosed)
{
return(this.Error("对不起，用户中心已被禁用！"));
}
var menus = new List <Menu>();
var user = await _authManager.GetUserAsync();
var userMenus = await _userMenuRepository.GetUserMenusAsync();
foreach (var menuInfo1 in userMenus)
{
if (menuInfo1.Disabled || menuInfo1.ParentId != 0)
{
continue;
}
if (menuInfo1.IsGroup)
{
if (!ListUtils.Contains(menuInfo1.GroupIds, user.GroupId))
{
continue;
}
}
var children = new List <Menu>();
foreach (var menuInfo2 in userMenus)
{
if (menuInfo2.Disabled || menuInfo2.ParentId != menuInfo1.Id)
{
continue;
}
if (menuInfo2.IsGroup)
{
if (!ListUtils.Contains(menuInfo2.GroupIds, user.GroupId))
{
continue;
}
}
children.Add(new Menu
{
Id = menuInfo2.Id.ToString(),
Text = menuInfo2.Text,
IconClass = menuInfo2.IconClass,
Link = menuInfo2.Link,
Target = menuInfo2.Target
});
}
menus.Add(new Menu
{
Id = menuInfo1.Id.ToString(),
Text = menuInfo1.Text,
IconClass = menuInfo1.IconClass,
Link = menuInfo1.Link,
Target = menuInfo1.Target,
Children = children
});
}
return(new GetResult
{
User = user,
HomeTitle = config.HomeTitle,
HomeLogoUrl = config.HomeLogoUrl,
Menus = menus
});
}
public async Task UpdateTagsAsync(List <string> previousTags, List <string> nowTags, int siteId, int contentId)
{
if (ListUtils.Equals(previousTags, nowTags))
{
return;
}
var tagsToRemove = new List <string>();
var tagsToAdd = new List <string>();
if (previousTags != null)
{
foreach (var tag in previousTags)
{
if (!nowTags.Contains(tag))
{
tagsToRemove.Add(tag);
}
}
}
if (nowTags != null)
{
foreach (var tag in nowTags)
{
if (previousTags == null || !previousTags.Contains(tag))
{
tagsToAdd.Add(tag);
}
}
}
var tags = await GetTagsAsync(siteId);
foreach (var tagName in tagsToRemove)
{
var tag = ListUtils.FirstOrDefault(tags, x => x.TagName == tagName);
if (tag == null)
{
continue;
}
ListUtils.Remove(tag.ContentIds, contentId);
tag.UseNum = ListUtils.Count(tag.ContentIds);
if (tag.UseNum == 0)
{
await DeleteAsync(siteId, tagName);
}
else
{
await UpdateAsync(tag);
}
}
foreach (var tagName in tagsToAdd)
{
var tag = ListUtils.FirstOrDefault(tags, x => x.TagName == tagName);
if (tag != null)
{
if (!ListUtils.Contains(tag.ContentIds, contentId))
{
tag.ContentIds = ListUtils.Add(tag.ContentIds, contentId);
tag.UseNum = tag.ContentIds.Count;
await UpdateAsync(tag);
}
}
else
{
tag = new ContentTag
{
SiteId = siteId,
TagName = tagName,
ContentIds = new List <int>(contentId),
UseNum = 1
};
await InsertAsync(tag);
}
}
}
private static async Task <string> ParseImplAsync(IParseManager parseManager, int tagLevel, int totalNum, bool isOrderByCount)
{
var innerHtml = StringUtils.StripTags(parseManager.ContextInfo.OuterHtml, ElementName);
var tagsBuilder = new StringBuilder();
if (parseManager.ContextInfo.ContextType == ParseType.Undefined)
{
parseManager.ContextInfo.ContextType = parseManager.ContextInfo.ContentId != 0 ? ParseType.Content : ParseType.Channel;
}
var contentId = 0;
if (parseManager.ContextInfo.ContextType == ParseType.Content)
{
contentId = parseManager.ContextInfo.ContentId;
}
var tags =
await parseManager.DatabaseManager.ContentTagRepository.GetTagsAsync(parseManager.PageInfo.SiteId);
var tagInfoList = tags;
if (contentId > 0)
{
tagInfoList = tags.Where(x => ListUtils.Contains(x.ContentIds, contentId)).ToList();
}
if (!isOrderByCount)
{
tagInfoList = tagInfoList.OrderBy(x => x.TagName).ToList();
}
if (totalNum > 0)
{
tagInfoList = tagInfoList.Take(totalNum).ToList();
}
tagInfoList = parseManager.DatabaseManager.ContentTagRepository.GetTagsByLevel(tagInfoList, totalNum, tagLevel);
var contentInfo = parseManager.ContextInfo.Content;
if (parseManager.ContextInfo.ContextType == ParseType.Content && contentInfo != null)
{
var tagInfoList2 = new List <ContentTag>();
var tagNameList = new List <string>(contentInfo.TagNames);
foreach (var tagName in tagNameList)
{
if (!string.IsNullOrEmpty(tagName))
{
var isAdd = false;
foreach (var tagInfo in tagInfoList)
{
if (tagInfo.TagName == tagName)
{
isAdd = true;
tagInfoList2.Add(tagInfo);
break;
}
}
if (!isAdd)
{
var tagInfo = new ContentTag
{
Id = 0,
SiteId = parseManager.PageInfo.SiteId,
ContentIds = new List <int> {
contentId
},
TagName = tagName,
UseNum = 1
};
tagInfoList2.Add(tagInfo);
}
}
}
tagInfoList = tagInfoList2;
}
foreach (var tagInfo in tagInfoList)
{
var tagHtml = innerHtml;
tagHtml = StringUtils.ReplaceIgnoreCase(tagHtml, "{Tag.Name}", tagInfo.TagName);
tagHtml = StringUtils.ReplaceIgnoreCase(tagHtml, "{Tag.Count}", tagInfo.UseNum.ToString());
tagHtml = StringUtils.ReplaceIgnoreCase(tagHtml, "{Tag.Level}", tagInfo.Level.ToString());
var innerBuilder = new StringBuilder(tagHtml);
await parseManager.ParseInnerContentAsync(innerBuilder);
tagsBuilder.Append(innerBuilder);
}
return(tagsBuilder.ToString());
}
public async Task <int> GetChannelIdByParentIdAndChannelNameAsync(int siteId, int parentId, string channelName, bool recursive)
{
if (parentId <= 0 || string.IsNullOrEmpty(channelName))
{
return(0);
}
var summaries = await GetSummariesAsync(siteId);
IChannelSummary channel;
if (recursive)
{
if (siteId == parentId)
{
channel = summaries.FirstOrDefault(x => x.ChannelName == channelName);
//sqlString = $"SELECT Id FROM siteserver_Channel WHERE (SiteId = {siteId} AND ChannelName = '{AttackUtils.FilterSql(channelName)}') ORDER BY Taxis";
}
else
{
channel = summaries.FirstOrDefault(x => (x.ParentId == parentId || ListUtils.Contains(x.ParentsPath, parentId)) && x.ChannelName == channelName);
// sqlString = $@"SELECT Id
//FROM siteserver_Channel
//WHERE ((ParentId = {parentId}) OR
// (ParentsPath = '{parentId}') OR
// (ParentsPath LIKE '{parentId},%') OR
// (ParentsPath LIKE '%,{parentId},%') OR
// (ParentsPath LIKE '%,{parentId}')) AND ChannelName = '{AttackUtils.FilterSql(channelName)}'
//ORDER BY Taxis";
}
}
else
{
channel = summaries.FirstOrDefault(x => x.ParentId == parentId && x.ChannelName == channelName);
//sqlString = $"SELECT Id FROM siteserver_Channel WHERE (ParentId = {parentId} AND ChannelName = '{AttackUtils.FilterSql(channelName)}') ORDER BY Taxis";
}
return(channel?.Id ?? 0);
}
