private String editRolePermission(Operation op, Permission permission, IRole role) {
IGuild parent = role.getGuild();
DiscordGuild g =
cacheService.findGuildById(parent.getID()).orElseGet(() -> new DiscordGuild(parent));
DiscordRole edit = null;
for (DiscordRole r : g.getRoles()) {
if (r.getId().equals(role.getID())) {
edit = r;
break;
}
}
if (edit == null) {
edit = new DiscordRole(role);
g.getRoles().add(edit);
}
if (edit.getName() == null) {
edit.setName(role.getName());
}
changePermission(op, permission, edit);
g = cacheService.saveGuild(g);
log.info("Saving new guild/role permission settings: {}", g);
permissionService.evict();
return String.format(
"Modified role %s: %s permission %s",
edit.getName(), op.name().toLowerCase(), permission.getName());
}
public void mergeFrom(AccessSection section) {
for (Permission src : section.getPermissions()) {
Permission dst = getPermission(src.getName());
if (dst != null) {
dst.mergeFrom(src);
} else {
permissions.add(src);
}
}
}
private String editUserPermission(Operation op, Permission permission, IUser user) {
DiscordUser u = cacheService.findUserById(user.getID()).orElseGet(() -> new DiscordUser(user));
changePermission(op, permission, u);
u = cacheService.saveUser(u);
log.info("Saving new user permission settings: {}", u);
permissionService.evict();
return String.format(
"Modified user %s: %s permission %s",
u.getName(), op.name().toLowerCase(), permission.getName());
}
public void setPermissions(List<Permission> list) {
Set<String> names = new HashSet<>();
for (Permission p : list) {
if (!names.add(p.getName().toLowerCase())) {
throw new IllegalArgumentException();
}
}
permissions = list;
}
public void testGetSetting() {
Setting setting = m_permission.getSetting();
assertEquals(m_permission.getName(), setting.getName());
assertTrue(setting.getType() instanceof BooleanSetting);
Permission permission = new Permission();
permission.setDefaultValue(true);
assertEquals("ENABLE", permission.getSetting().getDefaultValue());
assertTrue(permission.getSetting().getName().startsWith("perm"));
}
private String editGuildPermission(Operation op, Permission permission, IGuild guild) {
DiscordGuild g =
cacheService.findGuildById(guild.getID()).orElseGet(() -> new DiscordGuild(guild));
changePermission(op, permission, g);
g = cacheService.saveGuild(g);
log.info("Saving new guild permission settings: {}", g);
permissionService.evict();
return String.format(
"Modified server %s: %s permission %s",
g.getName(), op.name().toLowerCase(), permission.getName());
}
public Set<String> getPermissionNames() {
if (this.permissionNames == null || this.stale) {
this.permissionNames = new HashSet<String>(this.permissions.size());
for (Permission perm : this.permissions) {
this.permissionNames.add(perm.getName());
}
this.permissionNames = Collections.unmodifiableSet(this.permissionNames);
this.stale = false;
}
return this.permissionNames;
}
public Permission getPermission(String name, boolean create) {
for (Permission p : getPermissions()) {
if (p.getName().equalsIgnoreCase(name)) {
return p;
}
}
if (create) {
Permission p = new Permission(name);
permissions.add(p);
return p;
}
return null;
}
/**
* Aggiorna un permesso nel db.
*
* @param permission Oggetto Permission rappresentante il permesso da aggionare.
*/
public void updatePermission(Permission permission) {
Connection conn = null;
PreparedStatement stat = null;
try {
conn = this.getConnection();
conn.setAutoCommit(false);
stat = conn.prepareStatement(UPDATE_PERMISSIONS);
stat.setString(1, permission.getDescription());
stat.setString(2, permission.getName());
stat.executeUpdate();
conn.commit();
} catch (Throwable t) {
this.executeRollback(conn);
_logger.error("Error while updating a permission", t);
throw new RuntimeException("Error while updating a permission", t);
// processDaoException(t, "Error while updating a permission", "updatePermission");
} finally {
closeDaoResources(null, stat, conn);
}
}
private String editChannelPermission(Operation op, Permission permission, IChannel channel) {
if (channel.isPrivate()) {
throw new IllegalArgumentException("No private channels allowed!");
}
DiscordGuild g =
cacheService
.findGuildById(channel.getGuild().getID())
.orElseGet(() -> new DiscordGuild(channel.getGuild()));
g = cacheService.saveGuild(g);
DiscordChannel ch =
cacheService.findChannelById(channel.getID()).orElseGet(() -> new DiscordChannel(channel));
ch.setGuild(g);
g.getChannels().add(ch);
changePermission(op, permission, ch);
ch = cacheService.saveChannel(ch);
cacheService.saveGuild(g);
log.info("Saving new permission data: {}", g);
permissionService.evict();
return String.format(
"Modified channel %s: %s permission %s",
ch.getName(), op.name().toLowerCase(), permission.getName());
}
/**
* Carica la mappa (indicizzata in base al nome) dei permessi di autorizzazione presenti nel db.
*
* @return La mappa dei permessi di autorizzazione.
*/
public Map<String, Permission> loadPermissions() {
Connection conn = null;
Statement stat = null;
ResultSet res = null;
Map<String, Permission> permissions = new HashMap<String, Permission>();
Permission permission = null;
try {
conn = this.getConnection();
stat = conn.createStatement();
res = stat.executeQuery(ALL_PERMISSIONS);
while (res.next()) {
permission = this.createPermissionFromRecord(res);
permissions.put(permission.getName(), permission);
}
} catch (Throwable t) {
_logger.error("Error loading permissions", t);
throw new RuntimeException("Error loading permissions", t);
// processDaoException(t, "Error loading permissions", "loadPermissions");
} finally {
closeDaoResources(res, stat, conn);
}
return permissions;
}
/**
* Cancella un permesso di autorizzazione dal db.
*
* @param permission Oggetto Permission rappresentante il permesso da eliminare.
*/
public void deletePermission(Permission permission) {
this.deletePermission(permission.getName());
}
/**
* Compute the URL to which to send the user to request the extended permission.
*
* @param apiKey your application's API key.
* @param permission the permission you want the grant URL for.
* @return a String that specifies the URL to direct users to in order to grant this permission to
* the application.
*/
public static String authorizationUrl(String apiKey, Permission permission) {
return authorizationUrl(apiKey, permission.getName());
}
public void remove(Permission permission) {
if (permission != null) {
removePermission(permission.getName());
}
}
