/// <summary>
/// 保存权限
/// </summary>
/// <param name="roleId"></param>
/// <param name="ids"></param>
public void SavePermissions(long roleId, string ids, LoginUserDto UserCookie)
{
Sqldb.Delete <sys_role_authorize>().Where(s => s.role_id == roleId).ExecuteAffrows();
if (!string.IsNullOrEmpty(ids))
{
var list = new List <sys_role_authorize>();
//var menuIds = ids.Split(',');
var menuIds = ids.ToObject <List <ZtreeSelInt64Dto> >();
var nowTime = DateTime.Now;
foreach (var mid in menuIds)
{
var model = new sys_role_authorize();
model.id = IdHelper.NextId();
model.role_id = roleId;
model.menu_id = mid.id;
model.menu_pid = mid.pId;
model.create_time = nowTime;
model.create_person = UserCookie.LoginName;
list.Add(model);
}
if (list.Any())
{
Sqldb.Insert(list).ExecuteAffrows();
}
}
//移除全部权限
PermissionCache.RemoveAllPermission(roleId);
}
public void Setup()
{
TimeService.SetProvider(new ManualTimeProvider(new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc)));
_permissionApiServiceMock = new Mock <IPermissionApiService>();
_permissionApiServiceMock.Setup(p => p.GetAllOpenProjectsAsync(TestPlant))
.Returns(Task.FromResult <IList <ProCoSysProject> >(new List <ProCoSysProject>
{
new ProCoSysProject {
Name = Project1WithAccess, HasAccess = true
},
new ProCoSysProject {
Name = Project2WithAccess, HasAccess = true
},
new ProCoSysProject {
Name = ProjectWithoutAccess
}
}));
_permissionApiServiceMock.Setup(p => p.GetPermissionsAsync(TestPlant))
.Returns(Task.FromResult <IList <string> >(new List <string> {
Permission1, Permission2
}));
_permissionApiServiceMock.Setup(p => p.GetContentRestrictionsAsync(TestPlant))
.Returns(Task.FromResult <IList <string> >(new List <string> {
Restriction1, Restriction2
}));
var optionsMock = new Mock <IOptionsMonitor <CacheOptions> >();
optionsMock
.Setup(x => x.CurrentValue)
.Returns(new CacheOptions());
_dut = new PermissionCache(new CacheManager(), _permissionApiServiceMock.Object, optionsMock.Object);
}
public async Task <bool> TryBlockLate(DiscordSocketClient client, IUserMessage msg, IGuild guild, IMessageChannel channel, IUser user, string moduleName, string commandName)
{
await Task.Yield();
if (guild == null)
{
return(false);
}
else
{
var resetCommand = commandName == "resetperms";
PermissionCache pc = GetCache(guild.Id);
if (!resetCommand && !pc.Permissions.CheckPermissions(msg, commandName, moduleName, out int index))
{
if (pc.Verbose)
{
try { await channel.SendErrorAsync(_strings.GetText("trigger", guild.Id, "Permissions".ToLowerInvariant(), index + 1, Format.Bold(pc.Permissions[index].GetCommand(_cmd.GetPrefix(guild), (SocketGuild)guild)))).ConfigureAwait(false); } catch { }
}
return(true);
}
if (moduleName == "Permissions")
{
var guildUser = user as IGuildUser;
if (guildUser == null)
{
return(true);
}
var permRole = pc.PermRole;
ulong rid = 0;
if (!(guildUser.GuildPermissions.Administrator &&
(string.IsNullOrWhiteSpace(permRole) ||
!ulong.TryParse(permRole, out rid) ||
!guildUser.RoleIds.Contains(rid))))
{
string returnMsg;
IRole role;
if (string.IsNullOrWhiteSpace(permRole) || (role = guild.GetRole(rid)) == null)
{
returnMsg = $"You need Admin permissions in order to use permission commands.";
}
else
{
returnMsg = $"You need the {Format.Bold(role.Name)} role in order to use permission commands.";
}
if (pc.Verbose)
{
try { await channel.SendErrorAsync(returnMsg).ConfigureAwait(false); } catch { }
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// 获取前台按钮权限
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public List <RoleButtonPermissionDto> GetButtonPermissionList(long roleId)
{
List <RoleButtonPermissionDto> permissionList = PermissionCache.GetFrontOperatesPermission(roleId);
if (permissionList != null)
{
return(permissionList);
}
permissionList = new List <RoleButtonPermissionDto>();
//菜单权限
var menus = Sqldb.Select <sys_menu, sys_role_authorize>()
.InnerJoin((m, r) => m.id == r.menu_id)
.Where((m, r) => r.role_id == roleId && m.role_tag != "#")
.ToList((m, r) => m);
List <string> roleTags = new List <string>();
if (menus.Count > 0)
{
//按钮权限
var buttonRoleTags = Sqldb.Select <sys_operate, sys_role_authorize>()
.InnerJoin((o, r) => o.id == r.menu_id)
.Where((o, r) => r.role_id == roleId)
.ToList((o, r) => o);
foreach (sys_menu menu in menus)
{
//菜单权限标识
roleTags.Add(menu.role_tag.ToLower());
RoleButtonPermissionDto model = new RoleButtonPermissionDto();
model.menuId = CommHelper.GetMenuTabId(menu.menu_url.ToLower());
List <sys_operate> buttons = buttonRoleTags.Where(s => s.menu_id == menu.id).ToList();
foreach (sys_operate button in buttons)
{
model.add(button.role_tag.ToLower());
//操作权限标识
roleTags.Add(button.role_tag.ToLower());
}
permissionList.Add(model);
}
}
//添加缓存
if (permissionList.Count > 0)
{
PermissionCache.AddFrontOperatesPermission(roleId, permissionList);
}
if (roleTags.Count > 0)
{
PermissionCache.AddOperatePermission(roleId, roleTags);
}
return(permissionList);
}
/// <summary>
/// 首页导航菜单全部
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public List <sys_menu> GetNaviMenu(LoginUserDto user)
{
//int total = 0;
List <sys_menu> menus = new List <sys_menu>();
if (user.IsSuper)
{
menus = Sqldb.Queryable <sys_menu>().OrderBy(s => s.menu_sort).ToList();
}
else
{
//获取权限缓存
menus = PermissionCache.GetMenuPermission(user.RoleId);
if (menus != null)
{
return(menus);
}
menus = Sqldb.Select <sys_menu, sys_role_authorize>()
.InnerJoin((m, r) => m.id == r.menu_id)
.Where((m, r) => r.role_id == user.RoleId)
.OrderBy((m, r) => m.menu_sort)
.ToList((m, r) => m);
}
if (menus.Count > 0)
{
List <string> roleTags = new List <string>();
List <sys_menu> tops = menus.Where(s => s.parent_id == 0).ToList();
tops.ForEach(menu =>
{
menu.tab_id = CommHelper.GetMenuTabId(menu.menu_url.ToLower());
var sons = menus.Where(s => s.parent_id == menu.id).ToList();
sons.ForEach(son =>
{
son.tab_id = CommHelper.GetMenuTabId(son.menu_url.ToLower());
var sons2 = menus.Where(s => s.parent_id == son.id).ToList();
sons2.ForEach(s => {
s.tab_id = CommHelper.GetMenuTabId(s.menu_url.ToLower());
});
son.children = sons2;
});
menu.children = sons;
});
if (tops.Count > 0)
{ // 设置权限缓存
PermissionCache.AddMenuPermission(user.RoleId, tops);
}
return(tops);
}
return(menus);
}
public void DefaultPermissionCacheTest()
{
IPermissionCache uut = new PermissionCache();
IPrincipal user = ClaimsPrincipal.Current;
List <string> claims = new List <string>(new string[] { "FirstRole", "ThirdRole" });
uut.SaveRolesForUser(user, claims);
List <string> test = uut.GetRolesForUser(user);
Assert.IsNotNull(test);
Assert.AreEqual(2, test.Count);
Assert.AreEqual("FirstRole", test[0]);
Assert.AreEqual("ThirdRole", test[1]);
}
public void ClearAll_ShouldClearAllPermissionCaches()
{
// Arrange
var cacheManagerMock = new Mock <ICacheManager>();
var dut = new PermissionCache(
cacheManagerMock.Object,
_permissionApiServiceMock.Object,
new Mock <IOptionsMonitor <CacheOptions> >().Object);
// Act
dut.ClearAll(TestPlant, Oid);
// Assert
cacheManagerMock.Verify(c => c.Remove(It.IsAny <string>()), Times.Exactly(3));
}
public void Setup()
{
_permissionApiServiceMock = new Mock <IPermissionApiService>();
_permissionApiServiceMock.Setup(p => p.GetPermissionsAsync(TestPlant))
.Returns(Task.FromResult <IList <string> >(new List <string> {
Permission1, Permission2
}));
var optionsMock = new Mock <IOptionsMonitor <CacheOptions> >();
optionsMock
.Setup(x => x.CurrentValue)
.Returns(new CacheOptions());
_dut = new PermissionCache(new CacheManager(), _permissionApiServiceMock.Object, optionsMock.Object);
}
public void Load_CallOnce_LoadDataFromStore()
{
var sut = new PermissionCache();
var count = 0;
var roles = new List <string> {
"Role1", "Role2"
};
var permission = new ResourcePermissionKey
{
PermissionId = 1,
ResourceId = 2
};
var instance = "0";
sut.Load(() => { count++; return(true); }, roles, permission, instance);
Assert.AreEqual(1, count);
}
private async Task <bool> TryRunCleverbot(IUserMessage usrMsg, SocketGuild guild)
{
if (guild == null)
{
return(false);
}
try
{
Games.ChatterBotSession cbs;
var message = Games.CleverBotCommands.PrepareMessage(usrMsg, out cbs);
if (message == null || cbs == null)
{
return(false);
}
PermissionCache pc = Permissions.GetCache(guild.Id);
int index;
if (
!pc.Permissions.CheckPermissions(usrMsg,
NadekoBot.ModulePrefixes[typeof(Games).Name] + "cleverbot",
typeof(Games).Name,
out index))
{
//todo print in guild actually
var returnMsg =
$"Permission number #{index + 1} **{pc.Permissions[index].GetCommand(guild)}** is preventing this action.";
_log.Info(returnMsg);
return(true);
}
var cleverbotExecuted = await Games.CleverBotCommands.TryAsk(cbs, (ITextChannel)usrMsg.Channel, message).ConfigureAwait(false);
if (cleverbotExecuted)
{
_log.Info($@"CleverBot Executed
Server: {guild.Name} [{guild.Id}]
Channel: {usrMsg.Channel?.Name} [{usrMsg.Channel?.Id}]
UserId: {usrMsg.Author} [{usrMsg.Author.Id}]
Message: {usrMsg.Content}");
return(true);
}
}
catch (Exception ex) { _log.Warn(ex, "Error in cleverbot"); }
return(false);
}
public void Load_CallTwiceWithTheSameDataInTheSameRoleOrder_OnlyOnceCallsStore()
{
var sut = new PermissionCache();
var count = 0;
var roles = new List <string> {
"Role1", "Role2"
};
var permission = new ResourcePermissionKey
{
PermissionId = 1,
ResourceId = 2
};
var instance = "0";
sut.Load(() => { count++; return(true); }, roles, permission, instance);
sut.Load(() => { count++; return(true); }, roles, permission, instance);
Assert.AreEqual(1, count);
}
public void Clear_CallTwiceWithTheSameDataInDifferentRoleOrder_OnlyOnceCallsStore(string clearedRole, int expectedCalls)
{
var sut = new PermissionCache();
var count = 0;
var roles = new List <string> {
"Role1", "Role2"
};
var permission = new ResourcePermissionKey
{
PermissionId = 1,
ResourceId = 2
};
var instance = "0";
sut.Load(() => { count++; return(true); }, roles, permission, instance);
sut.Clear(clearedRole, permission);
sut.Load(() => { count++; return(true); }, roles, permission, instance);
Assert.AreEqual(expectedCalls, count);
}
public async Task ResetPermissions()
{
var channel = (ITextChannel)Context.Channel;
using (var uow = DbHandler.UnitOfWork())
{
var config = uow.GuildConfigs.PermissionsFor(Context.Guild.Id);
config.RootPermission = Permission.GetDefaultRoot();
var toAdd = new PermissionCache()
{
RootPermission = config.RootPermission,
PermRole = config.PermissionRole,
Verbose = config.VerbosePermissions,
};
Cache.AddOrUpdate(channel.Guild.Id,
toAdd, (id, old) => toAdd);
await uow.CompleteAsync();
}
await ReplyConfirmLocalized("perms_reset").ConfigureAwait(false);
}
public async Task <bool> TryBlockLate(DiscordSocketClient client, IUserMessage msg, IGuild guild, IMessageChannel channel, IUser user, string moduleName, string commandName)
{
await Task.Yield();
if (guild == null)
{
return(false);
}
else
{
var resetCommand = commandName == "resetperms";
PermissionCache pc = GetCache(guild.Id);
if (!resetCommand && !pc.Permissions.CheckPermissions(msg, commandName, moduleName, out int index))
{
if (pc.Verbose)
{
try { await channel.SendErrorAsync(_strings.GetText("trigger", guild.Id, "Permissions".ToLowerInvariant(), index + 1, Format.Bold(pc.Permissions[index].GetCommand(_cmd.GetPrefix(guild), (SocketGuild)guild)))).ConfigureAwait(false); } catch { }
}
return(true);
}
if (moduleName == "Permissions")
{
var roles = (user as SocketGuildUser)?.Roles ?? ((IGuildUser)user).RoleIds.Select(x => guild.GetRole(x)).Where(x => x != null);
if (!((IGuildUser)user).GuildPermissions.Administrator &&
!roles.Any(r => r.Name.Trim().ToLowerInvariant() == pc.PermRole.Trim().ToLowerInvariant()))
{
var returnMsg = $"You need the **{pc.PermRole}** role in order to use permission commands.";
if (pc.Verbose)
{
try { await channel.SendErrorAsync(returnMsg).ConfigureAwait(false); } catch { }
}
return(true);
}
}
}
return(false);
}
public async Task ResetPermissions()
{
var channel = (ITextChannel)Context.Channel;
using (var uow = DbHandler.UnitOfWork())
{
var config = uow.GuildConfigs.PermissionsFor(Context.Guild.Id);
config.RootPermission = Permission.GetDefaultRoot();
var toAdd = new PermissionCache()
{
RootPermission = config.RootPermission,
PermRole = config.PermissionRole,
Verbose = config.VerbosePermissions,
};
Permissions.Permissions.Cache.AddOrUpdate(channel.Guild.Id,
toAdd, (id, old) => toAdd);
await uow.CompleteAsync();
}
await channel.SendConfirmAsync($"{Context.Message.Author.Mention} 🆗 **Permissions for this server are reset.**");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
log4net.Config.XmlConfigurator.Configure(new FileInfo(Server.MapPath("~/log4net.config")));
//初始化全局配置缓存信息
SysConfigsCache.Register();
//权限缓存
using (EFDbContext context = new EFDbContext())
{
PermissionCache.time = DateTime.Now;
PermissionCache.ResetPermissionCache(
context.Permissions.ToList(),
context.UserRoles.ToList(),
context.RolePermissions.ToList());
}
}
public async Task <ExecuteCommandResult> ExecuteCommand(CommandContext context, string input, IDependencyMap dependencyMap = null, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception)
{
dependencyMap = dependencyMap ?? DependencyMap.Empty;
var searchResult = _commandService.Search(context, input);
if (!searchResult.IsSuccess)
{
return(new ExecuteCommandResult(null, null, searchResult));
}
var commands = searchResult.Commands;
for (int i = commands.Count - 1; i >= 0; i--)
{
var preconditionResult = await commands[i].CheckPreconditionsAsync(context).ConfigureAwait(false);
if (!preconditionResult.IsSuccess)
{
if (commands.Count == 1)
{
return(new ExecuteCommandResult(null, null, preconditionResult));
}
else
{
continue;
}
}
var parseResult = await commands[i].ParseAsync(context, searchResult, preconditionResult).ConfigureAwait(false);
if (!parseResult.IsSuccess)
{
if (parseResult.Error == CommandError.MultipleMatches)
{
TypeReaderValue[] argList, paramList;
switch (multiMatchHandling)
{
case MultiMatchHandling.Best:
argList = parseResult.ArgValues.Select(x => x.Values.OrderByDescending(y => y.Score).First()).ToArray();
paramList = parseResult.ParamValues.Select(x => x.Values.OrderByDescending(y => y.Score).First()).ToArray();
parseResult = ParseResult.FromSuccess(argList, paramList);
break;
}
}
if (!parseResult.IsSuccess)
{
if (commands.Count == 1)
{
return(new ExecuteCommandResult(null, null, parseResult));
}
else
{
continue;
}
}
}
var cmd = commands[i].Command;
var resetCommand = cmd.Name == "resetperms";
var module = cmd.Module.GetTopLevelModule();
if (context.Guild != null)
{
PermissionCache pc = Permissions.GetCache(context.Guild.Id);
int index;
if (!resetCommand && !pc.Permissions.CheckPermissions(context.Message, cmd.Aliases.First(), module.Name, out index))
{
var returnMsg = $"Permission number #{index + 1} **{pc.Permissions[index].GetCommand((SocketGuild)context.Guild)}** is preventing this action.";
return(new ExecuteCommandResult(cmd, pc, SearchResult.FromError(CommandError.Exception, returnMsg)));
}
if (module.Name == typeof(Permissions).Name)
{
var guildUser = (IGuildUser)context.User;
if (!guildUser.GetRoles().Any(r => r.Name.Trim().ToLowerInvariant() == pc.PermRole.Trim().ToLowerInvariant()) && guildUser.Id != guildUser.Guild.OwnerId)
{
return(new ExecuteCommandResult(cmd, pc, SearchResult.FromError(CommandError.Exception, $"You need the **{pc.PermRole}** role in order to use permission commands.")));
}
}
//int price;
//if (Permissions.CommandCostCommands.CommandCosts.TryGetValue(cmd.Aliases.First().Trim().ToLowerInvariant(), out price) && price > 0)
//{
// var success = await CurrencyHandler.RemoveCurrencyAsync(context.User.Id, $"Running {cmd.Name} command.", price).ConfigureAwait(false);
// if (!success)
// {
// return new ExecuteCommandResult(cmd, pc, SearchResult.FromError(CommandError.Exception, $"Insufficient funds. You need {price}{NadekoBot.BotConfig.CurrencySign} to run this command."));
// }
//}
}
if (cmd.Name != "resetglobalperms" &&
(GlobalPermissionCommands.BlockedCommands.Contains(cmd.Aliases.First().ToLowerInvariant()) ||
GlobalPermissionCommands.BlockedModules.Contains(module.Name.ToLowerInvariant())))
{
return(new ExecuteCommandResult(cmd, null, SearchResult.FromError(CommandError.Exception, $"Command or module is blocked globally by the bot owner.")));
}
// Bot will ignore commands which are ran more often than what specified by
// GlobalCommandsCooldown constant (miliseconds)
if (!UsersOnShortCooldown.Add(context.Message.Author.Id))
{
return(new ExecuteCommandResult(cmd, null, SearchResult.FromError(CommandError.Exception, "You are on a global cooldown.")));
}
if (CmdCdsCommands.HasCooldown(cmd, context.Guild, context.User))
{
return(new ExecuteCommandResult(cmd, null, SearchResult.FromError(CommandError.Exception, "That command is on a cooldown for you.")));
}
return(new ExecuteCommandResult(cmd, null, await commands[i].ExecuteAsync(context, parseResult, dependencyMap)));
}
return(new ExecuteCommandResult(null, null, SearchResult.FromError(CommandError.UnknownCommand, "This input does not match any overload.")));
}
public async Task TryRunCommand(SocketGuild guild, ITextChannel channel, IUserMessage usrMsg)
{
var execTime = Environment.TickCount;
if (guild != null && guild.OwnerId != usrMsg.Author.Id)
{
if (await InviteFiltered(guild, usrMsg).ConfigureAwait(false))
{
return;
}
if (await WordFiltered(guild, usrMsg).ConfigureAwait(false))
{
return;
}
}
if (IsBlacklisted(guild, usrMsg))
{
return;
}
var exec1 = Environment.TickCount - execTime;
var cleverBotRan = await Task.Run(() => TryRunCleverbot(usrMsg, guild)).ConfigureAwait(false);
if (cleverBotRan)
{
return;
}
var exec2 = Environment.TickCount - execTime;
// maybe this message is a custom reaction
// todo log custom reaction executions. return struct with info
var cr = await Task.Run(() => CustomReactions.TryGetCustomReaction(usrMsg)).ConfigureAwait(false);
if (cr != null) //if it was, don't execute the command
{
try
{
if (guild != null)
{
PermissionCache pc = Permissions.GetCache(guild.Id);
int index;
if (
!pc.Permissions.CheckPermissions(usrMsg, cr.Trigger, "ActualCustomReactions",
out index))
{
//todo print in guild actually
var returnMsg =
$"Permission number #{index + 1} **{pc.Permissions[index].GetCommand(guild)}** is preventing this action.";
_log.Info(returnMsg);
return;
}
}
await cr.Send(usrMsg).ConfigureAwait(false);
if (cr.AutoDeleteTrigger)
{
try { await usrMsg.DeleteAsync().ConfigureAwait(false); } catch { }
}
}
catch (Exception ex)
{
_log.Warn("Sending CREmbed failed");
_log.Warn(ex);
}
return;
}
var exec3 = Environment.TickCount - execTime;
string messageContent = usrMsg.Content;
if (guild != null)
{
ConcurrentDictionary <string, string> maps;
if (Modules.Utility.Utility.CommandMapCommands.AliasMaps.TryGetValue(guild.Id, out maps))
{
var keys = maps.Keys
.OrderByDescending(x => x.Length);
var lowerMessageContent = messageContent.ToLowerInvariant();
foreach (var k in keys)
{
string newMessageContent;
if (lowerMessageContent.StartsWith(k + " "))
{
newMessageContent = maps[k] + messageContent.Substring(k.Length, messageContent.Length - k.Length);
}
else if (lowerMessageContent == k)
{
newMessageContent = maps[k];
}
else
{
continue;
}
_log.Info(@"--Mapping Command--
GuildId: {0}
Trigger: {1}
Mapping: {2}", guild.Id, messageContent, newMessageContent);
var oldMessageContent = messageContent;
messageContent = newMessageContent;
try { await usrMsg.Channel.SendConfirmAsync($"{oldMessageContent} => {newMessageContent}").ConfigureAwait(false); } catch { }
break;
}
}
}
// execute the command and measure the time it took
var exec = await Task.Run(() => ExecuteCommand(new CommandContext(_client, usrMsg), messageContent, DependencyMap.Empty, MultiMatchHandling.Best)).ConfigureAwait(false);
execTime = Environment.TickCount - execTime;
if (exec.Result.IsSuccess)
{
await CommandExecuted(usrMsg, exec.CommandInfo).ConfigureAwait(false);
await LogSuccessfulExecution(usrMsg, exec, channel, exec1, exec2, exec3, execTime).ConfigureAwait(false);
}
else if (!exec.Result.IsSuccess && exec.Result.Error != CommandError.UnknownCommand)
{
LogErroredExecution(usrMsg, exec, channel, exec1, exec2, exec3, execTime);
if (guild != null && exec.CommandInfo != null && exec.Result.Error == CommandError.Exception)
{
if (exec.PermissionCache != null && exec.PermissionCache.Verbose)
{
try { await usrMsg.Channel.SendMessageAsync("⚠️ " + exec.Result.ErrorReason).ConfigureAwait(false); } catch { }
}
}
}
else
{
if (usrMsg.Channel is IPrivateChannel)
{
// rofl, gotta do this to prevent dm help message being sent to
// users who are voting on private polls (sending a number in a DM)
int vote;
if (int.TryParse(usrMsg.Content, out vote))
{
return;
}
await usrMsg.Channel.SendMessageAsync(Help.DMHelpString).ConfigureAwait(false);
await SelfCommands.HandleDmForwarding(usrMsg, ownerChannels).ConfigureAwait(false);
}
}
}
public async Task<bool> TryBlockLate(DiscordSocketClient client, ICommandContext ctx, string moduleName,
CommandInfo command)
{
var guild = ctx.Guild;
var msg = ctx.Message;
var user = ctx.User;
var channel = ctx.Channel;
var commandName = command.Name.ToLowerInvariant();
await Task.Yield();
if (guild == null)
{
return false;
}
else
{
var resetCommand = commandName == "resetperms";
PermissionCache pc = GetCacheFor(guild.Id);
if (!resetCommand && !pc.Permissions.CheckPermissions(msg, commandName, moduleName, out int index))
{
if (pc.Verbose)
{
try
{
await channel.SendErrorAsync(_strings.GetText("perm_prevent", guild.Id, index + 1,
Format.Bold(pc.Permissions[index].GetCommand(_cmd.GetPrefix(guild), (SocketGuild) guild))))
.ConfigureAwait(false);
}
catch
{
}
}
return true;
}
if (moduleName == nameof(Permissions))
{
if (!(user is IGuildUser guildUser))
return true;
if (guildUser.GuildPermissions.Administrator)
return false;
var permRole = pc.PermRole;
if (!ulong.TryParse(permRole, out var rid))
rid = 0;
string returnMsg;
IRole role;
if (string.IsNullOrWhiteSpace(permRole) || (role = guild.GetRole(rid)) == null)
{
returnMsg = $"You need Admin permissions in order to use permission commands.";
if (pc.Verbose)
try { await channel.SendErrorAsync(returnMsg).ConfigureAwait(false); } catch { }
return true;
}
else if (!guildUser.RoleIds.Contains(rid))
{
returnMsg = $"You need the {Format.Bold(role.Name)} role in order to use permission commands.";
if (pc.Verbose)
try { await channel.SendErrorAsync(returnMsg).ConfigureAwait(false); } catch { }
return true;
}
return false;
}
}
return false;
}
/// <summary>
/// 获取菜单和操作权限字符串
/// </summary>
/// <param name="roleId"></param>
public bool HasPermission(long roleId, string permissionTags)
{
if (roleId == 0)
{
return(false);
}
string[] permissionTagsArray = permissionTags.ToLower().Split(',');
var permissionList = PermissionCache.GetOperatePermission(roleId);
if (permissionList != null)
{
var tag = permissionList.Where(s => permissionTagsArray.Contains(s)).FirstOrDefault();
if (tag == null)
{
return(false);
}
return(true);
}
//没缓存的化直接取数据
var menus = Sqldb.Select <sys_menu, sys_role_authorize>()
.InnerJoin((m, r) => m.id == r.menu_id)
.Where((m, r) => r.role_id == roleId)
.ToList((m, r) => m.role_tag);
var buttonRoleTags = Sqldb.Select <sys_operate, sys_role_authorize>()
.InnerJoin((o, r) => o.id == r.menu_id)
.Where((o, r) => r.role_id == roleId)
.ToList((o, r) => o.role_tag);
List <string> roleTags = new List <string>();
if (menus.Count > 0)
{
foreach (var menu in menus)
{
if (menu.IsEmpty() || menu == "#")
{
continue;
}
roleTags.Add(menu);
}
}
if (buttonRoleTags.Count > 0)
{
foreach (var btag in buttonRoleTags)
{
if (btag.IsEmpty() || btag == "#")
{
continue;
}
roleTags.Add(btag);
}
}
if (roleTags.Count > 0)
{
PermissionCache.AddOperatePermission(roleId, roleTags);
var tag = roleTags.Where(s => permissionTagsArray.Contains(s)).FirstOrDefault();
if (tag == null)
{
return(false);
}
return(true);
}
return(false);
}
public async Task ResetPermissions(IUserMessage imsg)
{
var channel = (ITextChannel)imsg.Channel;
using (var uow = DbHandler.UnitOfWork())
{
var config = uow.GuildConfigs.PermissionsFor(channel.Guild.Id);
config.RootPermission = Permission.GetDefaultRoot();
var toAdd = new PermissionCache()
{
RootPermission = config.RootPermission,
PermRole = config.PermissionRole,
Verbose = config.VerbosePermissions,
};
Permissions.Permissions.Cache.AddOrUpdate(channel.Guild.Id,
toAdd, (id, old) => toAdd);
await uow.CompleteAsync();
}
await channel.SendMessageAsync($"{imsg.Author.Mention} 🆗 **Permissions for this server are reset.**");
}
public ExecuteCommandResult(CommandInfo commandInfo, PermissionCache cache, IResult result)
{
this.CommandInfo = commandInfo;
this.PermissionCache = cache;
this.Result = result;
}
