protected void checkForRepeatedSlots() {
for (DomainClass domClass : classes.values()) {
DomainEntity superDomClass = domClass.getSuperclass();
if (superDomClass != null) {
for (Slot slot : domClass.getSlotsList()) {
if (superDomClass.findSlot(slot.getName()) != null) {
System.err.printf(
"WARNING: Slot named '%s' in class '%s' already exists in a superclass\n",
slot.getName(), domClass.getName());
}
if (superDomClass.findRoleSlot(slot.getName()) != null) {
System.err.printf(
"WARNING: Slot named '%s' in class '%s' already exists in a superclass as role slot\n",
slot.getName(), domClass.getName());
}
}
for (Role role : domClass.getRoleSlotsList()) {
if (superDomClass.findSlot(role.getName()) != null) {
System.err.printf(
"WARNING: Role slot named '%s' in class '%s' already exists in a superclass as a slot\n",
role.getName(), domClass.getName());
}
if (superDomClass.findRoleSlot(role.getName()) != null) {
System.err.printf(
"WARNING: Role slot named '%s' in class '%s' already exists in a superclass as role slot\n",
role.getName(), domClass.getName());
}
}
}
}
}
private void setTimeoutRole(MessageContext context, String args) {
DiscordApiClient apiClient = context.getApiClient();
if (args.isEmpty()) {
apiClient.sendMessage(
loc.localize("commands.mod.settimeoutrole.response.missing"), context.getChannel());
return;
}
Role role = apiClient.getRole(args, context.getServer());
if (role == NO_ROLE) {
apiClient.sendMessage(
loc.localize("commands.mod.settimeoutrole.response.not_found", args),
context.getChannel());
return;
}
String serverId = context.getServer().getId();
TempServerConfig serverConfig = serverStorage.get(serverId);
if (serverConfig == null) {
serverConfig = new TempServerConfig(serverId);
serverStorage.put(serverId, serverConfig);
}
ServerTimeoutStorage storage = serverConfig.getServerTimeouts();
if (storage == null) {
storage = new ServerTimeoutStorage();
serverConfig.setServerTimeouts(storage);
}
storage.setTimeoutRoleId(role.getId());
apiClient.sendMessage(
loc.localize("commands.mod.settimeoutrole.response", role.getName(), role.getId()),
context.getChannel());
saveServerConfig(serverConfig);
}
public Map<String, String> getRoleIdentifiers() {
Map<String, String> idMap = new Hashtable<String, String>();
for (Role r : getRoles()) {
idMap.put(r.getID(), r.getName());
}
return idMap;
}
public String checkCyclicRoleReference(Role role, String refID) {
String result = null;
List<String> hierarchy = new ArrayList<String>();
hierarchy.add(role.getName());
Role owner = getRole(refID);
String refName = owner.getName(); // name of role attempting to add to
while (owner != null) {
hierarchy.add(owner.getName());
if (owner.equals(role)) {
result = constructCyclicAttributeErrorMessage(hierarchy, "role", refName);
break;
}
owner = owner.getOwnerRole();
}
return result;
}
@Override
public Group getWorkflowRoleGroup(
Context context, Collection collection, String roleName, Group roleGroup)
throws SQLException, IOException, WorkflowException, AuthorizeException {
try {
Role role = WorkflowUtils.getCollectionAndRepositoryRoles(collection).get(roleName);
if (role.getScope() == Role.Scope.COLLECTION || role.getScope() == Role.Scope.REPOSITORY) {
roleGroup = WorkflowUtils.getRoleGroup(context, collection, role);
if (roleGroup == null) {
authorizeService.authorizeAction(context, collection, Constants.WRITE);
roleGroup = groupService.create(context);
if (role.getScope() == Role.Scope.COLLECTION) {
groupService.setName(
roleGroup,
"COLLECTION_" + collection.getID().toString() + "_WORKFLOW_ROLE_" + roleName);
} else {
groupService.setName(roleGroup, role.getName());
}
groupService.update(context, roleGroup);
authorizeService.addPolicy(context, collection, Constants.ADD, roleGroup);
if (role.getScope() == Role.Scope.COLLECTION) {
WorkflowUtils.createCollectionWorkflowRole(context, collection, roleName, roleGroup);
}
}
}
return roleGroup;
} catch (WorkflowConfigurationException e) {
throw new WorkflowException(e);
}
}
public Collection<String> allRoleNames(CruiseConfig cruiseConfig) {
List<String> roles = new ArrayList<String>();
for (Role role : allRoles(cruiseConfig)) {
roles.add(CaseInsensitiveString.str(role.getName()));
}
return roles;
}
public String getRolesAsString() {
StringBuilder sb = new StringBuilder();
for (Role r : roles) {
if (sb.length() > 0) sb.append(", ");
sb.append(r.getName());
}
return sb.toString();
}
// @return a csv listing of the full name of each role
public String getRoleNames() {
StringBuilder csvList = new StringBuilder();
for (Role r : roleMap.values()) {
if (csvList.length() > 0) csvList.append(",");
csvList.append(r.getName());
}
return csvList.toString();
}
private String findRoleUidByName(List<Role> roles, String roleName) {
if (roleName == null || roleName.trim().isEmpty()) {
return null;
}
for (Role role : roles) {
if (roleName.equalsIgnoreCase(role.getName())) {
return role.getId();
}
}
return null;
}
private List<UserModel> allUsersForDisplay() {
Collection<User> users = allUsers();
ArrayList<UserModel> userModels = new ArrayList<UserModel>();
for (User user : users) {
String userName = user.getName();
ArrayList<String> roles = new ArrayList<String>();
for (Role role : goConfigService.rolesForUser(new CaseInsensitiveString(userName))) {
roles.add(CaseInsensitiveString.str(role.getName()));
}
userModels.add(
new UserModel(
user,
roles,
securityService.isUserAdmin(new Username(new CaseInsensitiveString(userName)))));
}
return userModels;
}
public Set<String> usersThatCanOperateOnStage(
CruiseConfig cruiseConfig, PipelineConfig pipelineConfig) {
SortedSet<String> users = new TreeSet<String>();
PipelineConfigs group = cruiseConfig.findGroupOfPipeline(pipelineConfig);
if (group.hasAuthorizationDefined()) {
if (group.hasOperationPermissionDefined()) {
users.addAll(group.getOperateUserNames());
List<String> roles = group.getOperateRoleNames();
for (Role role : cruiseConfig.server().security().getRoles()) {
if (roles.contains(CaseInsensitiveString.str(role.getName()))) {
users.addAll(role.usersOfRole());
}
}
}
} else {
users.addAll(allUsernames());
}
return users;
}
/**
* Create a new package based on an existing template.
*
* @param packageId
* @param aPackage
* @return PackageId
*/
public PackageId createPackageFromTemplate(PackageId packageId, Package aPackage) {
String path =
template
.urlFor(UrlTemplate.TEMPLATE_PATH)
.replace("{packageId}", packageId.getId())
.build();
List<Role> roles = aPackage.getRoles();
aPackage.setRoles(Collections.<Role>emptyList());
String packageJson = Serialization.toJson(aPackage);
PackageId newPackageId = null;
try {
String response = client.post(path, packageJson);
newPackageId = Serialization.fromJson(response, PackageId.class);
} catch (RequestException e) {
throw new EslServerException("Could not create a new package", e);
} catch (Exception e) {
throw new EslException("Could not create a new package", e);
}
Package createdPackage = getApiPackage(newPackageId.getId());
for (Role role : roles) {
String roleUid = findRoleUidByName(createdPackage.getRoles(), role.getName());
if (roleUid == null) {
continue;
}
role.setId(roleUid);
updateRole(newPackageId, role);
}
return newPackageId;
}
public Role getRoleByName(String roleName) {
for (Role r : roleMap.values()) {
if (r.getName().equalsIgnoreCase(roleName)) return r;
}
return null; // no match
}
