private async Task <List <string> > GetTableNamesAsync(bool includeSiteTables, bool includePluginTables)
{
var tableNames = new List <string>();
if (includeSiteTables)
{
var summaries = await GetSummariesAsync();
foreach (var summary in summaries)
{
if (!string.IsNullOrEmpty(summary.TableName) && !ListUtils.ContainsIgnoreCase(tableNames, summary.TableName))
{
tableNames.Add(summary.TableName);
}
}
}
if (includePluginTables)
{
var pluginTableNames = _settingsManager.GetContentTableNames();
foreach (var pluginTableName in pluginTableNames)
{
if (!string.IsNullOrEmpty(pluginTableName) && !ListUtils.ContainsIgnoreCase(tableNames, pluginTableName))
{
tableNames.Add(pluginTableName);
}
}
}
return(tableNames);
}
public async Task <List <string> > GetAppPermissionsAsync()
{
var administrator = await GetAdminAsync();
if (administrator == null || administrator.Locked)
{
return(new List <string>());
}
var appPermissions = new List <string>();
var roles = await GetRolesAsync();
if (_databaseManager.RoleRepository.IsConsoleAdministrator(roles))
{
appPermissions.AddRange(_permissions
.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.App))
.Select(permission => permission.Id));
}
else if (_databaseManager.RoleRepository.IsSystemAdministrator(roles))
{
appPermissions = new List <string>
{
Types.AppPermissions.SettingsAdministrators
};
}
else
{
appPermissions = await _databaseManager.PermissionsInRolesRepository.GetAppPermissionsAsync(roles);
}
return(appPermissions);
}
public async Task <ActionResult <DeleteResult> > Delete([FromBody] DeleteRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(Types.AppPermissions.SettingsUsersStyle))
{
return(Unauthorized());
}
await _tableStyleRepository.DeleteAsync(_userRepository.TableName, 0, request.AttributeName);
var allAttributes = _userRepository.TableColumns.Select(x => x.AttributeName).ToList();
var styles = new List <InputStyle>();
foreach (var style in await _tableStyleRepository.GetUserStylesAsync())
{
styles.Add(new InputStyle
{
Id = style.Id,
AttributeName = style.AttributeName,
DisplayName = style.DisplayName,
InputType = style.InputType,
Rules = TranslateUtils.JsonDeserialize <List <InputStyleRule> >(style.RuleValues),
Taxis = style.Taxis,
IsSystem = ListUtils.ContainsIgnoreCase(allAttributes, style.AttributeName)
});
}
return(new DeleteResult
{
Styles = styles
});
}
public async Task <ActionResult <GetResult> > Get()
{
var config = await _configRepository.GetAsync();
if (config.IsHomeClosed)
{
return(this.Error("对不起，用户中心已被禁用！"));
}
if (!config.IsUserRegistrationAllowed)
{
return(this.Error("对不起，系统已禁止新用户注册！"));
}
var userStyles = await _tableStyleRepository.GetUserStylesAsync();
var styles = userStyles
.Where(x => ListUtils.ContainsIgnoreCase(config.UserRegistrationAttributes, x.AttributeName))
.Select(x => new InputStyle(x));
return(new GetResult
{
IsUserRegistrationGroup = config.IsUserRegistrationGroup,
IsHomeAgreement = config.IsHomeAgreement,
HomeAgreementHtml = config.HomeAgreementHtml,
Styles = styles,
Groups = await _userGroupRepository.GetUserGroupsAsync()
});
}
private async Task <Dictionary <string, List <string> > > GetContentPermissionDictAsync()
{
var administrator = await GetAdminAsync();
if (administrator == null || administrator.Locked)
{
return(new Dictionary <string, List <string> >());
}
var contentPermissionDict = new Dictionary <string, List <string> >();
var roles = await GetRolesAsync();
if (_databaseManager.RoleRepository.IsSystemAdministrator(roles))
{
var allContentPermissionList = _permissions
.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Channel))
.Select(permission => permission.Id).ToList();
var siteIdList = await GetSiteIdsAsync();
foreach (var siteId in siteIdList)
{
contentPermissionDict[GetPermissionDictKey(siteId, siteId)] = allContentPermissionList;
}
}
else
{
contentPermissionDict = await _databaseManager.SitePermissionsRepository.GetContentPermissionDictionaryAsync(roles);
}
return(contentPermissionDict);
}
private async Task CreateContentTemplateAsync(Site site, CreateRequest request)
{
var defaultContentTemplateId = await _templateRepository.GetDefaultTemplateIdAsync(request.SiteId, TemplateType.ContentTemplate);
var relatedFileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.SiteId, TemplateType.ContentTemplate);
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.SiteId, TemplateType.ContentTemplate);
foreach (var channelId in request.ChannelIds)
{
var nodeInfo = await _channelRepository.GetAsync(channelId);
var contentTemplateId = nodeInfo.ContentTemplateId;
if (contentTemplateId != 0 && contentTemplateId != defaultContentTemplateId)
{
if (await _templateRepository.GetAsync(contentTemplateId) == null)
{
contentTemplateId = -1;
}
}
if (contentTemplateId != -1)
{
var template = new Template
{
Id = 0,
SiteId = request.SiteId,
TemplateName = nodeInfo.ChannelName,
TemplateType = TemplateType.ContentTemplate,
RelatedFileName = "T_" + nodeInfo.ChannelName + ".html",
CreatedFileFullName = "index.html",
CreatedFileExtName = ".html",
DefaultTemplate = false
};
if (ListUtils.ContainsIgnoreCase(relatedFileNameList, template.RelatedFileName))
{
continue;
}
if (templateNameList.Contains(template.TemplateName))
{
continue;
}
var insertedTemplateId = await _templateRepository.InsertAsync(template);
template.Id = insertedTemplateId;
var channelInfo = await _channelRepository.GetAsync(channelId);
channelInfo.ContentTemplateId = insertedTemplateId;
await _channelRepository.UpdateContentTemplateIdAsync(channelInfo);
await _pathManager.WriteContentToTemplateFileAsync(site, template, string.Empty, _authManager.AdminId);
//TemplateManager.UpdateContentTemplateId(SiteId, channelId, insertedTemplateId);
//DataProvider.BackgroundNodeDAO.UpdateContentTemplateID(channelId, insertedTemplateID);
}
}
}
public async Task <bool> IsScopeAsync(string token, string scope)
{
if (string.IsNullOrEmpty(token))
{
return(false);
}
var tokenInfo = await GetByTokenAsync(token);
return(tokenInfo != null && ListUtils.ContainsIgnoreCase(ListUtils.GetStringList(tokenInfo.Scopes), scope));
}
public async Task <ActionResult <GetResult> > Copy([FromBody] TemplateRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.Templates))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var template = await _templateRepository.GetAsync(request.TemplateId);
var templateName = template.TemplateName + "_复件";
var relatedFileName = PathUtils.RemoveExtension(template.RelatedFileName) + "_复件";
var createdFileFullName = PathUtils.RemoveExtension(template.CreatedFileFullName) + "_复件";
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.SiteId, template.TemplateType);
if (templateNameList.Contains(templateName))
{
return(this.Error("模板复制失败，模板名称已存在！"));
}
var fileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.SiteId, template.TemplateType);
if (ListUtils.ContainsIgnoreCase(fileNameList, relatedFileName))
{
return(this.Error("模板复制失败，模板文件已存在！"));
}
var templateInfo = new Template
{
SiteId = request.SiteId,
TemplateName = templateName,
TemplateType = template.TemplateType,
RelatedFileName = relatedFileName + template.CreatedFileExtName,
CreatedFileExtName = template.CreatedFileExtName,
CreatedFileFullName = createdFileFullName + template.CreatedFileExtName,
DefaultTemplate = false
};
var content = await _pathManager.GetTemplateContentAsync(site, template);
var adminId = _authManager.AdminId;
templateInfo.Id = await _templateRepository.InsertAsync(templateInfo);
await _pathManager.WriteContentToTemplateFileAsync(site, template, content, adminId);
return(await GetResultAsync(site));
}
private string GetTableName(Site site, string tableName)
{
if (string.IsNullOrEmpty(tableName))
{
return(site.TableName);
}
var tableNames = _settingsManager.GetContentTableNames();
return(ListUtils.ContainsIgnoreCase(tableNames, tableName) ? tableName : site.TableName);
}
public async Task <List <TableColumn> > GetTableColumnInfoListAsync(string tableName, List <string> excludeAttributeNameList)
{
var list = await _settingsManager.Database.GetTableColumnsAsync(tableName);
if (excludeAttributeNameList == null || excludeAttributeNameList.Count == 0)
{
return(list);
}
return(list.Where(tableColumnInfo =>
!ListUtils.ContainsIgnoreCase(excludeAttributeNameList, tableColumnInfo.AttributeName)).ToList());
}
public static async Task <Dictionary <string, object> > SaveAttributesAsync(IPathManager pathManager, Site site, List <TableStyle> styleList, NameValueCollection formCollection, List <string> dontAddAttributes)
{
var dict = new Dictionary <string, object>();
if (dontAddAttributes == null)
{
dontAddAttributes = new List <string>();
}
foreach (var style in styleList)
{
if (ListUtils.ContainsIgnoreCase(dontAddAttributes, style.AttributeName))
{
continue;
}
//var theValue = GetValueByForm(style, site, formCollection);
var theValue = formCollection[style.AttributeName] ?? string.Empty;
var inputType = style.InputType;
if (inputType == InputType.TextEditor)
{
theValue = await pathManager.EncodeTextEditorAsync(site, theValue);
theValue = UEditorUtils.TranslateToStlElement(theValue);
}
if (inputType != InputType.TextEditor && inputType != InputType.Image && inputType != InputType.File && inputType != InputType.Video && !StringUtils.EqualsIgnoreCase(style.AttributeName, nameof(Content.LinkUrl)))
{
theValue = AttackUtils.FilterXss(theValue);
}
dict[style.AttributeName] = theValue;
if (style.IsFormatString)
{
var formatString = TranslateUtils.ToBool(formCollection[style.AttributeName + "_formatStrong"]);
var formatEm = TranslateUtils.ToBool(formCollection[style.AttributeName + "_formatEM"]);
var formatU = TranslateUtils.ToBool(formCollection[style.AttributeName + "_formatU"]);
var formatColor = formCollection[style.AttributeName + "_formatColor"];
var theFormatString = ContentUtility.GetTitleFormatString(formatString, formatEm, formatU, formatColor);
dict[GetFormatStringAttributeName(style.AttributeName)] = theFormatString;
}
//if (inputType == InputType.Image || inputType == InputType.File || inputType == InputType.Video)
//{
// var attributeName = GetExtendAttributeName(style.AttributeName);
// dict[attributeName] = formCollection[attributeName];
//}
}
return(dict);
}
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsSites))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (!site.Root && await _siteRepository.IsRootExistsAsync())
{
return(this.Error($"根目录站点已经存在，站点{site.SiteName}不能转移到根目录"));
}
var siteDirList = await _siteRepository.GetSiteDirsAsync(0);
var directories = new List <string>();
var directoryNames = DirectoryUtils.GetDirectoryNames(_settingsManager.WebRootPath);
foreach (var directoryName in directoryNames)
{
if (!_pathManager.IsSystemDirectory(directoryName) && !ListUtils.ContainsIgnoreCase(siteDirList, directoryName))
{
directories.Add(directoryName);
}
}
var files = DirectoryUtils.GetFileNames(_settingsManager.WebRootPath);
//var fileSystems = FileUtility.GetFileSystemInfoExtendCollection(_settingsManager.WebRootPath);
//foreach (FileSystemInfoExtend fileSystem in fileSystems)
//{
// if (fileSystem.IsDirectory)
// {
// if (!_pathManager.IsSystemDirectory(fileSystem.Name) && ! StringUtils.ContainsIgnoreCase(siteDirList, fileSystem.Name))
// {
// directories.Add(fileSystem.Name);
// }
// }
// else
// {
// files.Add(fileSystem.Name);
// }
//}
return(new GetResult
{
Site = site,
Directories = directories,
Files = files
});
}
public async Task ImportFilesAsync(string siteTemplatePath, bool isOverride, string guid)
{
var sitePath = await _pathManager.GetSitePathAsync(_site);
IList <string> siteDirList = new List <string>();
var filePaths = DirectoryUtils.GetFilePaths(siteTemplatePath);
foreach (var filePath in filePaths)
{
var fileName = PathUtils.GetFileName(filePath);
if (StringUtils.StartsWithIgnoreCase(fileName, "T_"))
{
continue;
}
var destFilePath = PathUtils.Combine(sitePath, fileName);
_caching.SetProcess(guid, $"导入站点文件: {filePath}");
FileUtils.MoveFile(filePath, destFilePath, isOverride);
}
if (_site.Root)
{
siteDirList = await _databaseManager.SiteRepository.GetSiteDirsAsync(0);
}
var directoryPaths = DirectoryUtils.GetDirectoryPaths(siteTemplatePath);
foreach (var subDirectoryPath in directoryPaths)
{
var directoryName = PathUtils.GetDirectoryName(subDirectoryPath, false);
if (StringUtils.EqualsIgnoreCase(directoryName, "Template"))
{
continue;
}
if (_site.Root && (_pathManager.IsSystemDirectory(directoryName) || ListUtils.ContainsIgnoreCase(siteDirList, directoryName)))
{
continue;
}
_caching.SetProcess(guid, $"导入站点文件夹: {subDirectoryPath}");
var destDirectoryPath = PathUtils.Combine(sitePath, directoryName);
DirectoryUtils.MoveDirectory(subDirectoryPath, destDirectoryPath, isOverride);
}
var siteTemplateMetadataPath = PathUtils.Combine(sitePath, DirectoryUtils.SiteFiles.SiteTemplates.SiteTemplateMetadata);
DirectoryUtils.DeleteDirectoryIfExists(siteTemplateMetadataPath);
}
private async Task CreateContentChildrenTemplateAsync(Site site, CreateRequest request)
{
var relatedFileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.SiteId, TemplateType.ContentTemplate);
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.SiteId, TemplateType.ContentTemplate);
foreach (var channelId in request.ChannelIds)
{
var nodeInfo = await _channelRepository.GetAsync(channelId);
var template = new Template
{
Id = 0,
SiteId = request.SiteId,
TemplateName = nodeInfo.ChannelName + "_下级",
TemplateType = TemplateType.ContentTemplate,
RelatedFileName = "T_" + nodeInfo.ChannelName + "_下级.html",
CreatedFileFullName = "index.html",
CreatedFileExtName = ".html",
DefaultTemplate = false
};
if (ListUtils.ContainsIgnoreCase(relatedFileNameList, template.RelatedFileName))
{
continue;
}
if (templateNameList.Contains(template.TemplateName))
{
continue;
}
var insertedTemplateId = await _templateRepository.InsertAsync(template);
template.Id = insertedTemplateId;
var childChannelIdList = await _channelRepository.GetChannelIdsAsync(request.SiteId, channelId, ScopeType.Descendant);
foreach (var childChannelId in childChannelIdList)
{
var childChannelInfo = await _channelRepository.GetAsync(childChannelId);
childChannelInfo.ContentTemplateId = insertedTemplateId;
await _channelRepository.UpdateContentTemplateIdAsync(childChannelInfo);
//TemplateManager.UpdateContentTemplateId(SiteId, childChannelId, insertedTemplateId);
//DataProvider.BackgroundNodeDAO.UpdateContentTemplateID(childChannelId, insertedTemplateID);
}
await _pathManager.WriteContentToTemplateFileAsync(site, template, Constants.Html5Empty, _authManager.AdminId);
}
}
public async Task <List <ContentColumn> > GetChannelListColumnsAsync(Site site)
{
var columns = new List <ContentColumn>();
var listColumns = ListUtils.GetStringList(site.ChannelListColumns);
if (listColumns.Count == 0)
{
listColumns.Add(nameof(Channel.ChannelName));
listColumns.Add(nameof(Channel.IndexName));
listColumns.Add(nameof(Channel.GroupNames));
}
var styles = GetChannelListStyles(await _databaseManager.TableStyleRepository.GetChannelStylesAsync(await _databaseManager.ChannelRepository.GetAsync(site.Id)));
foreach (var style in styles)
{
if (string.IsNullOrEmpty(style.DisplayName) || style.InputType == InputType.TextEditor)
{
continue;
}
var column = new ContentColumn
{
AttributeName = style.AttributeName,
DisplayName = style.DisplayName,
InputType = style.InputType
};
if (style.AttributeName == nameof(Channel.ChannelName))
{
column.IsList = true;
}
else
{
if (ListUtils.ContainsIgnoreCase(listColumns, style.AttributeName))
{
column.IsList = true;
}
}
if (!ListUtils.ContainsIgnoreCase(UnSearchableAttributes, style.AttributeName))
{
column.IsSearchable = true;
}
columns.Add(column);
}
return(columns);
}
public async Task <ActionResult <BoolResult> > Submit([FromBody] SubmitRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsSites))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var root = site.Root;
if (root)
{
if (_pathManager.IsSystemDirectory(request.SiteDir))
{
return(this.Error("文件夹名称不能为系统文件夹名称，请更改文件夹名称！"));
}
if (!DirectoryUtils.IsDirectoryNameCompliant(request.SiteDir))
{
return(this.Error("文件夹名称不符合系统要求，请更改文件夹名称！"));
}
var rootPath = _pathManager.GetRootPath();
var directories = DirectoryUtils.GetDirectoryNames(rootPath);
if (ListUtils.ContainsIgnoreCase(directories, request.SiteDir))
{
return(this.Error("已存在相同的文件夹，请更改文件夹名称！"));
}
var list = await _siteRepository.GetSiteDirsAsync(0);
if (ListUtils.ContainsIgnoreCase(list, request.SiteDir))
{
return(this.Error("已存在相同的站点文件夹，请更改文件夹名称！"));
}
await _pathManager.ChangeToSubSiteAsync(site, request.SiteDir, request.CheckedDirectories, request.CheckedFiles);
}
else
{
await _pathManager.ChangeToRootAsync(site, request.IsMoveFiles);
}
await _authManager.AddAdminLogAsync(root? "转移到子目录" : "转移到根目录",
$"站点:{site.SiteName}");
return(new BoolResult
{
Value = true
});
}
public async Task <List <int> > GetChannelIdsAsync(Channel channel, ScopeType scopeType, string group, string groupNot, string contentModelPluginId)
{
if (channel == null)
{
return(new List <int>());
}
var channelIds = await GetChannelIdsAsync(channel.SiteId, channel.Id, scopeType);
if (string.IsNullOrEmpty(group) && string.IsNullOrEmpty(groupNot) &&
string.IsNullOrEmpty(contentModelPluginId))
{
return(channelIds);
}
var filteredChannelIds = new List <int>();
foreach (var channelId in channelIds)
{
var channelInfo = await GetAsync(channelId);
if (!string.IsNullOrEmpty(group))
{
if (!ListUtils.ContainsIgnoreCase(channelInfo.GroupNames, group))
{
continue;
}
}
if (!string.IsNullOrEmpty(groupNot))
{
if (ListUtils.ContainsIgnoreCase(channelInfo.GroupNames, groupNot))
{
continue;
}
}
if (!string.IsNullOrEmpty(contentModelPluginId))
{
if (!StringUtils.EqualsIgnoreCase(channelInfo.ContentModelPluginId, contentModelPluginId))
{
continue;
}
}
filteredChannelIds.Add(channelInfo.Id);
}
return(filteredChannelIds);
}
public async Task <ActionResult <GetResult> > Get()
{
var config = await _configRepository.GetAsync();
if (config.IsHomeClosed)
{
return(this.Error("对不起，用户中心已被禁用！"));
}
if (!config.IsUserRegistrationAllowed)
{
return(this.Error("对不起，系统已禁止新用户注册！"));
}
var userStyles = await _tableStyleRepository.GetUserStylesAsync();
var styles = userStyles
.Where(x => ListUtils.ContainsIgnoreCase(config.UserRegistrationAttributes, x.AttributeName))
.Select(x => new InputStyle(x));
var isUserVerifyMobile = false;
var isSmsEnabled = await _smsManager.IsEnabledAsync();
if (isSmsEnabled && config.IsUserForceVerifyMobile)
{
isUserVerifyMobile = true;
}
return(new GetResult
{
IsSmsEnabled = isSmsEnabled,
IsUserVerifyMobile = isUserVerifyMobile,
IsUserRegistrationMobile = config.IsUserRegistrationMobile,
IsUserRegistrationEmail = config.IsUserRegistrationEmail,
IsUserRegistrationGroup = config.IsUserRegistrationGroup,
IsHomeAgreement = config.IsHomeAgreement,
HomeAgreementHtml = config.HomeAgreementHtml,
Styles = styles,
Groups = await _userGroupRepository.GetUserGroupsAsync()
});
}
public async Task CreateExcelFileForContentsAsync(string filePath, Site site,
Channel channel, List <Content> contentInfoList, List <string> columnNames)
{
DirectoryUtils.CreateDirectoryIfNotExists(DirectoryUtils.GetDirectoryPath(filePath));
FileUtils.DeleteFileIfExists(filePath);
var head = new List <string>();
var rows = new List <List <string> >();
var columnsManager = new ColumnsManager(_databaseManager, _pathManager);
var columns = await columnsManager.GetContentListColumnsAsync(site, channel, ColumnsManager.PageType.Contents);
foreach (var column in columns)
{
if (ListUtils.ContainsIgnoreCase(columnNames, column.AttributeName))
{
head.Add(column.DisplayName);
}
}
foreach (var contentInfo in contentInfoList)
{
var row = new List <string>();
foreach (var column in columns)
{
if (ListUtils.ContainsIgnoreCase(columnNames, column.AttributeName))
{
var value = contentInfo.Get <string>(column.AttributeName);
row.Add(StringUtils.StripTags(value));
}
}
rows.Add(row);
}
CsvUtils.Export(filePath, head, rows);
}
private async Task <Dictionary <int, List <string> > > GetSitePermissionDictAsync()
{
var administrator = await GetAdminAsync();
if (administrator == null || administrator.Locked)
{
return(new Dictionary <int, List <string> >());
}
var sitePermissionDict = new Dictionary <int, List <string> >();
if (await IsSiteAdminAsync())
{
var siteIdList = await GetSiteIdsAsync();
foreach (var siteId in siteIdList)
{
var site = await _databaseManager.SiteRepository.GetAsync(siteId);
var siteType = _settingsManager.GetSiteType(site.SiteType).Id;
var sitePermissions = _permissions
.Where(x => ListUtils.ContainsIgnoreCase(x.Type, siteType))
.Select(permission => permission.Id).ToList();
sitePermissionDict[siteId] = sitePermissions;
}
}
else
{
var roles = await GetRolesAsync();
sitePermissionDict = await _databaseManager.SitePermissionsRepository.GetSitePermissionDictionaryAsync(roles);
}
return(sitePermissionDict);
}
public async Task <ActionResult <GetResult> > Get([FromQuery] GetRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.Contents) ||
!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId, Types.ContentPermissions.Add) ||
!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId, Types.ContentPermissions.Edit))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.ChannelId);
if (channel == null)
{
return(NotFound());
}
var groupNames = await _contentGroupRepository.GetGroupNamesAsync(site.Id);
var tagNames = await _contentTagRepository.GetTagNamesAsync(site.Id);
var allStyles = await _tableStyleRepository.GetContentStylesAsync(site, channel);
var styles = allStyles
.Where(style =>
!string.IsNullOrEmpty(style.DisplayName) &&
!ListUtils.ContainsIgnoreCase(ColumnsManager.MetadataAttributes.Value, style.AttributeName))
.Select(x => new InputStyle(x));
var(userIsChecked, userCheckedLevel) = await CheckManager.GetUserCheckLevelAsync(_authManager, site, site.Id);
var checkedLevels = CheckManager.GetCheckedLevelOptions(site, userIsChecked, userCheckedLevel, true);
Content content;
if (request.ContentId > 0)
{
content = await _pathManager.DecodeContentAsync(site, channel, request.ContentId);
}
else
{
content = new Content
{
Id = 0,
SiteId = site.Id,
ChannelId = channel.Id,
AddDate = DateTime.Now,
CheckedLevel = site.CheckContentDefaultLevel
};
}
//await ContentUtility.TextEditorContentDecodeAsync(parseManager.PathManager, pageInfo.Site, content.Get<string>(ContentAttribute.Content), pageInfo.IsLocal);
return(new GetResult
{
Content = content,
Site = site,
Channel = channel,
GroupNames = groupNames,
TagNames = tagNames,
Styles = styles,
CheckedLevels = checkedLevels
});
}
public async Task <ActionResult <ListResult> > List([FromBody] ListRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.Contents) ||
!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId,
MenuUtils.ContentPermissions.View,
MenuUtils.ContentPermissions.Add,
MenuUtils.ContentPermissions.Edit,
MenuUtils.ContentPermissions.Delete,
MenuUtils.ContentPermissions.Translate,
MenuUtils.ContentPermissions.Arrange,
MenuUtils.ContentPermissions.CheckLevel1,
MenuUtils.ContentPermissions.CheckLevel2,
MenuUtils.ContentPermissions.CheckLevel3,
MenuUtils.ContentPermissions.CheckLevel4,
MenuUtils.ContentPermissions.CheckLevel5))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.ChannelId);
if (channel == null)
{
return(this.Error("无法确定内容对应的栏目"));
}
var columnsManager = new ColumnsManager(_databaseManager, _pathManager);
var columns = await columnsManager.GetContentListColumnsAsync(site, channel, ColumnsManager.PageType.Contents);
var pageContents = new List <Content>();
List <ContentSummary> summaries;
if (!string.IsNullOrEmpty(request.SearchType) &&
!string.IsNullOrEmpty(request.SearchText) ||
request.IsAdvanced)
{
summaries = await _contentRepository.Search(site, channel, channel.IsAllContents, request.SearchType, request.SearchText, request.IsAdvanced, request.CheckedLevels, request.IsTop, request.IsRecommend, request.IsHot, request.IsColor, request.GroupNames, request.TagNames);
}
else
{
summaries = await _contentRepository.GetSummariesAsync(site, channel, channel.IsAllContents);
}
var total = summaries.Count;
var channelPlugins = _pluginManager.GetPlugins(request.SiteId, request.ChannelId);
var contentMenus = new List <Menu>();
foreach (var plugin in channelPlugins)
{
var pluginMenus = plugin.GetMenus()
.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Content)).ToList();
if (pluginMenus.Count == 0)
{
continue;
}
contentMenus.AddRange(pluginMenus);
}
if (total > 0)
{
var offset = site.PageSize * (request.Page - 1);
var pageSummaries = summaries.Skip(offset).Take(site.PageSize).ToList();
var sequence = offset + 1;
foreach (var summary in pageSummaries)
{
var content = await _contentRepository.GetAsync(site, summary.ChannelId, summary.Id);
if (content == null)
{
continue;
}
var pageContent =
await columnsManager.CalculateContentListAsync(sequence ++, site, request.ChannelId, content, columns);
pageContents.Add(pageContent);
}
}
var(isChecked, checkedLevel) = await CheckManager.GetUserCheckLevelAsync(_authManager, site, request.ChannelId);
var checkedLevels = ElementUtils.GetCheckBoxes(CheckManager.GetCheckedLevels(site, isChecked, checkedLevel, true));
var permissions = new Permissions
{
IsAdd = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Add),
IsDelete = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Delete),
IsEdit = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Edit),
IsArrange = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Arrange),
IsTranslate = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Translate),
IsCheck = await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.CheckLevel1),
IsCreate = await _authManager.HasSitePermissionsAsync(site.Id, MenuUtils.SitePermissions.CreateContents) || await _authManager.HasContentPermissionsAsync(site.Id, channel.Id, MenuUtils.ContentPermissions.Create),
IsChannelEdit = await _authManager.HasChannelPermissionsAsync(site.Id, channel.Id, MenuUtils.ChannelPermissions.Edit)
};
return(new ListResult
{
PageContents = pageContents,
Total = total,
PageSize = site.PageSize,
Columns = columns,
IsAllContents = channel.IsAllContents,
CheckedLevels = checkedLevels,
Permissions = permissions,
Menus = contentMenus
});
}
public static string GetSelect(string text, List <string> options)
{
var option = Prompt.GetString($"{text}({ListUtils.ToString(options)}):");
return(ListUtils.ContainsIgnoreCase(options, option) ? option : GetSelect(text, options));
}
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 <ActionResult <GetResult> > Get([FromQuery] GetRequest request)
{
if (_settingsManager.Containerized)
{
var envSecurityKey = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvSecurityKey);
var envDatabaseType = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabaseType);
var envDatabaseHost = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabaseHost);
var envDatabasePort = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabasePort);
var envDatabaseUser = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabaseUser);
var envDatabasePassword = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabasePassword);
var envDatabaseName = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabaseName);
var envDatabaseConnectionString = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvDatabaseConnectionString);
var envRedisConnectionString = SettingsManager.GetEnvironmentVariable(SettingsManager.EnvRedisConnectionString);
var isEnvironment = SettingsManager.IsEnvironment(envSecurityKey, envDatabaseType, envDatabaseConnectionString,
envDatabaseHost, envDatabaseUser, envDatabasePassword, envDatabaseName);
if (!isEnvironment)
{
return(this.Error("系统启动失败，请检查 SS CMS 容器运行环境变量设置"));
}
}
var allowed = true;
if (!string.IsNullOrEmpty(_settingsManager.AdminRestrictionHost))
{
var currentHost = PageUtils.RemoveProtocolFromUrl(PageUtils.GetHost(Request));
if (!StringUtils.StartsWithIgnoreCase(currentHost, PageUtils.RemoveProtocolFromUrl(_settingsManager.AdminRestrictionHost)))
{
allowed = false;
}
}
if (!allowed)
{
var ipAddress = PageUtils.GetIpAddress(Request);
allowed = PageUtils.IsAllowed(ipAddress,
new List <string>(_settingsManager.AdminRestrictionBlockList),
new List <string>(_settingsManager.AdminRestrictionAllowList));
}
if (!allowed)
{
return(this.Error($"访问已被禁止，IP地址：{PageUtils.GetIpAddress(Request)}，请与网站管理员联系开通访问权限"));
}
var(redirect, redirectUrl) = await AdminRedirectCheckAsync();
if (redirect)
{
return(new GetResult
{
Value = false,
RedirectUrl = redirectUrl
});
}
var admin = await _authManager.GetAdminAsync();
if (admin == null)
{
return(Unauthorized());
}
var cacheKey = Constants.GetSessionIdCacheKey(admin.Id);
var sessionId = await _dbCacheRepository.GetValueAsync(cacheKey);
if (string.IsNullOrEmpty(request.SessionId) || sessionId != request.SessionId)
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var isSuperAdmin = await _authManager.IsSuperAdminAsync();
var siteIdListWithPermissions = await _authManager.GetSiteIdsAsync();
if (site == null || !siteIdListWithPermissions.Contains(site.Id))
{
if (siteIdListWithPermissions.Contains(admin.SiteId))
{
return(new GetResult
{
Value = false,
RedirectUrl = $"{_pathManager.GetAdminUrl()}?siteId={admin.SiteId}"
});
}
if (siteIdListWithPermissions.Count > 0)
{
return(new GetResult
{
Value = false,
RedirectUrl = $"{_pathManager.GetAdminUrl()}?siteId={siteIdListWithPermissions[0]}"
});
}
if (isSuperAdmin)
{
return(new GetResult
{
Value = false,
RedirectUrl = _pathManager.GetAdminUrl(SitesAddController.Route)
});
}
//return this.Error(_local["You do not have a site to manage, please contact the super administrator for assistance"]);
}
var enabledPlugins = _pluginManager.EnabledPlugins;
var allMenus = _settingsManager.GetMenus();
var menus = new List <Menu>();
var siteType = new SiteType();
var siteUrl = string.Empty;
var previewUrl = string.Empty;
if (site != null)
{
siteType = _settingsManager.GetSiteType(site.SiteType);
if (await _authManager.HasSitePermissionsAsync(site.Id))
{
var sitePlugins = _pluginManager.GetPlugins(site.Id);
var allPluginMenus = new List <Menu>();
var sitePluginMenus = new List <Menu>();
foreach (var enabledPlugin in enabledPlugins)
{
var pluginMenus = enabledPlugin.GetMenus()
.Where(x => ListUtils.ContainsIgnoreCase(x.Type, siteType.Id)).ToList();
if (pluginMenus.Count == 0)
{
continue;
}
allPluginMenus.AddRange(pluginMenus);
if (sitePlugins.Exists(x => x.PluginId == enabledPlugin.PluginId))
{
sitePluginMenus.AddRange(pluginMenus);
}
}
var siteMenus = allMenus
.Where(menu => ListUtils.ContainsIgnoreCase(menu.Type, siteType.Id))
.Where(menu => !allPluginMenus.Exists(x => x.Id == menu.Id))
.ToList();
siteMenus.AddRange(sitePluginMenus);
var siteMenu = new Menu
{
Id = IdSite,
Text = site.SiteName,
Type = new List <string>
{
siteType.Id
},
Children = siteMenus
};
var sitePermissions = await _authManager.GetSitePermissionsAsync(site.Id);
var query = new NameValueCollection {
{ "siteId", site.Id.ToString() }
};
siteMenu.Children = GetChildren(siteMenu, sitePermissions, x =>
{
x.Link = PageUtils.AddQueryStringIfNotExists(x.Link, query);
return(x);
});
menus.Add(siteMenu);
if (siteIdListWithPermissions.Count > 1)
{
var switchMenus = new List <Menu>();
var allSiteMenus = new List <Menu>();
var siteIdListLatestAccessed = await _administratorRepository.UpdateSiteIdAsync(admin, site.Id);
var siteIdList = await _siteRepository.GetLatestSiteIdsAsync(siteIdListLatestAccessed, siteIdListWithPermissions);
foreach (var siteId in siteIdList)
{
var theSite = await _siteRepository.GetAsync(siteId);
if (theSite == null)
{
continue;
}
var theSiteType = _settingsManager.GetSiteType(theSite.SiteType);
allSiteMenus.Add(new Menu
{
Id = $"site_switch_{theSite.Id}",
IconClass = theSiteType.IconClass,
Link = $"{_pathManager.GetAdminUrl()}?siteId={theSite.Id}",
Target = "_top",
Text = theSite.SiteName
});
}
switchMenus.Add(new Menu
{
Id = "site_switch_select",
IconClass = "ion-android-funnel",
Link = _pathManager.GetAdminUrl(SitesLayerSelectController.Route),
Target = "_layer",
//Text = _local["Select site"]
Text = "选择站点"
});
switchMenus.Add(new Menu
{
Id = "site_switch_all",
IconClass = "ion-clock",
//Text = _local["Recently site"],
Text = "最近访问",
Children = allSiteMenus.ToArray()
});
menus.Add(new Menu
{
Id = "site_switch",
//Text = _local["Switch site"],
Text = "切换站点",
Children = switchMenus.ToArray()
});
}
}
siteUrl = await _pathManager.GetSiteUrlAsync(site, false);
previewUrl = _pathManager.GetPreviewSiteUrl(site.Id);
}
var appPermissions = await _authManager.GetAppPermissionsAsync();
var appMenus = allMenus.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.App) && _authManager.IsMenuValid(x, appPermissions)).ToList();
foreach (var appMenu in appMenus)
{
appMenu.Children = GetChildren(appMenu, appPermissions);
}
menus.AddRange(appMenus);
var config = await _configRepository.GetAsync();
var requestCulture = HttpContext.Features.Get <IRequestCultureFeature>();
var culture = requestCulture.RequestCulture.UICulture.Name;
var plugins = enabledPlugins.Select(plugin => new GetPlugin {
PluginId = plugin.PluginId, DisplayName = plugin.DisplayName, Version = plugin.Version
}).ToList();
return(new GetResult
{
Value = true,
CmsVersion = _settingsManager.Version,
OSArchitecture = _settingsManager.OSArchitecture,
AdminLogoUrl = config.AdminLogoUrl,
AdminTitle = config.AdminTitle,
IsSuperAdmin = isSuperAdmin,
Culture = culture,
Plugins = plugins,
Menus = menus,
SiteType = siteType,
SiteUrl = siteUrl,
PreviewUrl = previewUrl,
Local = new Local
{
UserId = admin.Id,
UserName = admin.UserName,
AvatarUrl = admin.AvatarUrl,
Level = await _authManager.GetAdminLevelAsync()
}
});
}
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 async Task <ActionResult <SitePermissionResult> > SitePermission([FromBody] SitePermissionRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsAdministratorsRole))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var allPermissions = _settingsManager.GetPermissions();
SitePermissions sitePermissionsInfo = null;
if (request.RoleId > 0)
{
var roleInfo = await _roleRepository.GetRoleAsync(request.RoleId);
sitePermissionsInfo = await _sitePermissionsRepository.GetAsync(roleInfo.RoleName, request.SiteId);
}
if (sitePermissionsInfo == null)
{
sitePermissionsInfo = new SitePermissions();
}
var sitePermissions = new List <Option>();
var channelPermissions = new List <Option>();
var contentPermissions = new List <Option>();
if (await _authManager.IsSuperAdminAsync())
{
foreach (var permission in allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, site.SiteType)))
{
sitePermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.Permissions, permission.Id)
});
}
//foreach (var permission in permissions.WebsitePluginPermissions)
//{
// pluginPermissions.Add(new Permission
// {
// Name = permission.Name,
// Text = permission.Text,
// Selected = StringUtils.ContainsIgnoreCase(sitePermissionsInfo.WebsitePermissions, permission.Name)
// });
//}
var channelPermissionList = allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Channel));
foreach (var permission in channelPermissionList)
{
channelPermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.ChannelPermissions, permission.Id)
});
}
var contentPermissionList = allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Content));
foreach (var permission in contentPermissionList)
{
if (permission.Id == MenuUtils.ContentPermissions.CheckLevel1)
{
if (site.CheckContentLevel < 1)
{
continue;
}
}
else if (permission.Id == MenuUtils.ContentPermissions.CheckLevel2)
{
if (site.CheckContentLevel < 2)
{
continue;
}
}
else if (permission.Id == MenuUtils.ContentPermissions.CheckLevel3)
{
if (site.CheckContentLevel < 3)
{
continue;
}
}
else if (permission.Id == MenuUtils.ContentPermissions.CheckLevel4)
{
if (site.CheckContentLevel < 4)
{
continue;
}
}
else if (permission.Id == MenuUtils.ContentPermissions.CheckLevel5)
{
if (site.CheckContentLevel < 5)
{
continue;
}
}
contentPermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.ContentPermissions, permission.Id)
});
}
}
else
{
if (await _authManager.HasSitePermissionsAsync(request.SiteId))
{
var websitePermissionList = await _authManager.GetSitePermissionsAsync(request.SiteId);
foreach (var websitePermission in websitePermissionList)
{
foreach (var permission in allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, site.SiteType)))
{
if (permission.Id == websitePermission)
{
sitePermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.Permissions, permission.Id)
});
}
}
//foreach (var permission in instance.WebsitePluginPermissions)
//{
// if (permission.Name == websitePermission)
// {
// pluginPermissions.Add(new Permission
// {
// Name = permission.Name,
// Text = permission.Text,
// Selected = StringUtils.ContainsIgnoreCase(sitePermissionsInfo.WebsitePermissions, permission.Name)
// });
// }
//}
}
}
var channelPermissionList = await _authManager.GetChannelPermissionsAsync(request.SiteId);
foreach (var channelPermission in channelPermissionList)
{
foreach (var permission in allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Channel)))
{
if (permission.Id == channelPermission)
{
channelPermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.ChannelPermissions, permission.Id)
});
}
}
}
var contentPermissionList = await _authManager.GetContentPermissionsAsync(request.SiteId);
foreach (var contentPermission in contentPermissionList)
{
foreach (var permission in allPermissions.Where(x => ListUtils.ContainsIgnoreCase(x.Type, Types.Resources.Content)))
{
if (permission.Id == contentPermission)
{
if (contentPermission == MenuUtils.ContentPermissions.CheckLevel1)
{
if (site.CheckContentLevel < 1)
{
continue;
}
}
else if (contentPermission == MenuUtils.ContentPermissions.CheckLevel2)
{
if (site.CheckContentLevel < 2)
{
continue;
}
}
else if (contentPermission == MenuUtils.ContentPermissions.CheckLevel3)
{
if (site.CheckContentLevel < 3)
{
continue;
}
}
else if (contentPermission == MenuUtils.ContentPermissions.CheckLevel4)
{
if (site.CheckContentLevel < 4)
{
continue;
}
}
else if (contentPermission == MenuUtils.ContentPermissions.CheckLevel5)
{
if (site.CheckContentLevel < 5)
{
continue;
}
}
contentPermissions.Add(new Option
{
Name = permission.Id,
Text = permission.Text,
Selected = ListUtils.ContainsIgnoreCase(sitePermissionsInfo.ContentPermissions, permission.Id)
});
}
}
}
}
var channelInfo = await _channelRepository.GetAsync(request.SiteId);
channelInfo.Children = await _channelRepository.GetChildrenAsync(request.SiteId, request.SiteId);
var checkedChannelIdList = new List <int>();
if (sitePermissionsInfo.ChannelIds != null)
{
foreach (var i in sitePermissionsInfo.ChannelIds)
{
if (!checkedChannelIdList.Contains(i))
{
checkedChannelIdList.Add(i);
}
}
}
return(new SitePermissionResult
{
Site = site,
SitePermissions = sitePermissions,
ChannelPermissions = channelPermissions,
ContentPermissions = contentPermissions,
Channel = channelInfo,
CheckedChannelIds = checkedChannelIdList
});
}
public async Task <ActionResult <IntResult> > Submit([FromBody] SubmitRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsSitesAdd))
{
return(Unauthorized());
}
if (!request.Root)
{
if (_pathManager.IsSystemDirectory(request.SiteDir))
{
return(this.Error("文件夹名称不能为系统文件夹名称，请更改文件夹名称！"));
}
if (!DirectoryUtils.IsDirectoryNameCompliant(request.SiteDir))
{
return(this.Error("文件夹名称不符合系统要求，请更改文件夹名称！"));
}
var sitePath = await _pathManager.GetSitePathAsync(request.ParentId);
var directories = DirectoryUtils.GetDirectoryNames(sitePath);
if (ListUtils.ContainsIgnoreCase(directories, request.SiteDir))
{
return(this.Error("已存在相同的文件夹，请更改文件夹名称！"));
}
var list = await _siteRepository.GetSiteDirsAsync(request.ParentId);
if (ListUtils.ContainsIgnoreCase(list, request.SiteDir))
{
return(this.Error("已存在相同的站点文件夹，请更改文件夹名称！"));
}
}
var channelInfo = new Channel();
channelInfo.ChannelName = channelInfo.IndexName = "首页";
channelInfo.ParentId = 0;
channelInfo.ContentModelPluginId = string.Empty;
var tableName = string.Empty;
if (StringUtils.EqualsIgnoreCase(request.SiteType, Types.SiteTypes.Web) || StringUtils.EqualsIgnoreCase(request.SiteType, Types.SiteTypes.Wx))
{
if (request.TableRule == TableRule.Choose)
{
tableName = request.TableChoose;
}
else if (request.TableRule == TableRule.HandWrite)
{
tableName = request.TableHandWrite;
if (!await _settingsManager.Database.IsTableExistsAsync(tableName))
{
await _contentRepository.CreateContentTableAsync(tableName, _contentRepository.GetTableColumns(tableName));
}
else
{
await _settingsManager.Database.AlterTableAsync(tableName, _contentRepository.GetTableColumns(tableName));
}
}
}
var adminId = _authManager.AdminId;
var siteId = await _siteRepository.InsertSiteAsync(channelInfo, new Site
{
SiteName = request.SiteName,
SiteType = request.SiteType,
SiteDir = request.SiteDir,
TableName = tableName,
ParentId = request.ParentId,
Root = request.Root
}, adminId);
if (string.IsNullOrEmpty(tableName))
{
tableName = await _contentRepository.CreateNewContentTableAsync();
await _siteRepository.UpdateTableNameAsync(siteId, tableName);
}
if (await _authManager.IsSiteAdminAsync() && !await _authManager.IsSuperAdminAsync())
{
var siteIdList = await _authManager.GetSiteIdsAsync() ?? new List <int>();
siteIdList.Add(siteId);
var adminInfo = await _administratorRepository.GetByUserIdAsync(adminId);
await _administratorRepository.UpdateSiteIdsAsync(adminInfo, siteIdList);
}
var caching = new CacheUtils(_cacheManager);
var site = await _siteRepository.GetAsync(siteId);
caching.SetProcess(request.Guid, "任务初始化...");
if (request.CreateType == "local")
{
var manager = new SiteTemplateManager(_pathManager, _databaseManager, caching);
await manager.ImportSiteTemplateToEmptySiteAsync(site, request.LocalDirectoryName, request.IsImportContents, request.IsImportTableStyles, adminId, request.Guid);
caching.SetProcess(request.Guid, "生成站点页面...");
await _createManager.CreateByAllAsync(site.Id);
caching.SetProcess(request.Guid, "清除系统缓存...");
_cacheManager.Clear();
}
else if (request.CreateType == "cloud")
{
caching.SetProcess(request.Guid, "开始下载模板压缩包，可能需要几分钟，请耐心等待...");
var filePath = _pathManager.GetSiteTemplatesPath($"T_{request.CloudThemeName}.zip");
FileUtils.DeleteFileIfExists(filePath);
var downloadUrl = CloudUtils.Dl.GetThemesDownloadUrl(request.CloudThemeUserName, request.CloudThemeName);
WebClientUtils.Download(downloadUrl, filePath);
caching.SetProcess(request.Guid, "模板压缩包下载成功，开始解压缩，可能需要几分钟，请耐心等待...");
var siteTemplateDir = $"T_{request.CloudThemeName}";
var directoryPath = _pathManager.GetSiteTemplatesPath(siteTemplateDir);
DirectoryUtils.DeleteDirectoryIfExists(directoryPath);
_pathManager.ExtractZip(filePath, directoryPath);
caching.SetProcess(request.Guid, "模板压缩包解压成功，正在导入数据...");
var manager = new SiteTemplateManager(_pathManager, _databaseManager, caching);
await manager.ImportSiteTemplateToEmptySiteAsync(site, siteTemplateDir, request.IsImportContents, request.IsImportTableStyles, adminId, request.Guid);
caching.SetProcess(request.Guid, "生成站点页面...");
await _createManager.CreateByAllAsync(site.Id);
caching.SetProcess(request.Guid, "清除系统缓存...");
_cacheManager.Clear();
}
return(new IntResult
{
Value = siteId
});
}
public async Task <ActionResult <GetResult> > Get([FromQuery] GetRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.Contents) ||
!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId,
MenuUtils.ContentPermissions.Add, MenuUtils.ContentPermissions.Edit))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.ChannelId);
if (channel == null)
{
return(NotFound());
}
var groupNames = await _contentGroupRepository.GetGroupNamesAsync(site.Id);
var tagNames = await _contentTagRepository.GetTagNamesAsync(site.Id);
var allStyles = await _tableStyleRepository.GetContentStylesAsync(site, channel);
var styles = allStyles
.Where(style =>
!string.IsNullOrEmpty(style.DisplayName) &&
!ListUtils.ContainsIgnoreCase(ColumnsManager.MetadataAttributes.Value, style.AttributeName)).ToList();
var templates =
await _templateRepository.GetTemplatesByTypeAsync(request.SiteId, TemplateType.ContentTemplate);
var(userIsChecked, userCheckedLevel) = await CheckManager.GetUserCheckLevelAsync(_authManager, site, request.ChannelId);
var checkedLevels = CheckManager.GetCheckedLevelOptions(site, userIsChecked, userCheckedLevel, true);
Content content;
if (request.ContentId > 0)
{
content = await _pathManager.DecodeContentAsync(site, channel, request.ContentId);
}
else
{
content = new Content
{
Id = 0,
SiteId = site.Id,
ChannelId = channel.Id,
AddDate = DateTime.Now,
CheckedLevel = site.CheckContentDefaultLevel
};
}
foreach (var style in styles)
{
if (style.InputType == InputType.CheckBox || style.InputType == InputType.SelectMultiple)
{
if (request.ContentId == 0)
{
var value = style.Items != null
? style.Items.Where(x => x.Selected).Select(x => x.Value).ToList()
: new List <string>();
content.Set(style.AttributeName, value);
}
else
{
var value = content.Get(style.AttributeName);
content.Set(style.AttributeName, ListUtils.ToList(value));
}
}
else if (style.InputType == InputType.Radio || style.InputType == InputType.SelectOne)
{
if (request.ContentId == 0)
{
var item = style.Items?.FirstOrDefault(x => x.Selected);
var value = item != null ? item.Value : string.Empty;
content.Set(style.AttributeName, value);
}
else
{
var value = content.Get(style.AttributeName);
content.Set(style.AttributeName, StringUtils.ToString(value));
}
}
}
var siteUrl = await _pathManager.GetSiteUrlAsync(site, true);
var isCensorTextEnabled = await _censorManager.IsTextEnabledAsync();
return(new GetResult
{
Content = content,
Site = site,
SiteUrl = StringUtils.TrimEndSlash(siteUrl),
Channel = channel,
GroupNames = groupNames,
TagNames = tagNames,
Styles = styles,
Templates = templates,
CheckedLevels = checkedLevels,
CheckedLevel = userCheckedLevel,
IsCensorTextEnabled = isCensorTextEnabled
});
}
public async Task RunAsync(string[] args)
{
if (!CliUtils.ParseArgs(_options, args))
{
return;
}
var jobServiceCommandNames = GetJobServiceCommandNames();
var isJobService = false;
var commandName = string.Empty;
var commandArgs = new List <string>();
var commandExtras = new List <string>();
if (args.Length >= 1)
{
var isCommand = true;
foreach (var arg in args)
{
if (isCommand && !StringUtils.StartsWith(arg, "-"))
{
if (isJobService)
{
commandExtras.Add(StringUtils.Trim(arg));
}
else
{
if (!string.IsNullOrEmpty(commandName))
{
commandName += " " + StringUtils.Trim(arg);
}
else
{
commandName = StringUtils.Trim(arg);
}
isJobService = ListUtils.ContainsIgnoreCase(jobServiceCommandNames, commandName);
}
}
else
{
isCommand = false;
commandArgs.Add(StringUtils.Trim(arg));
}
}
}
else
{
isJobService = true;
commandName = "status";
}
CommandName = commandName;
CommandArgs = commandArgs.ToArray();
CommandExtras = commandExtras.ToArray();
if (!isJobService)
{
await RunHelpAsync(CommandName);
}
else if (!string.IsNullOrEmpty(_repeat))
{
await RunRepeatAsync();
}
else
{
await RunExecuteAsync(CommandName, CommandArgs, CommandExtras, null);
}
}
