def __init__(self):

super().__init__()

self.commands = {

"!ListOrgs": {

"command": "!ListOrgs",

"func": self.list_org_command,

"user_data_required": False,

"help": "Lists the GitHub organizations that are managed.",

"enabled": True

},

"!CreateRepo": {

"command": "!CreateRepo",

"func": self.create_repo_command,

"user_data_required": True,

"help": "Creates a new PRIVATE [default] repository in the specified GitHub organization.",

"enabled": True

},

"!AddCollab": {

"command": "!AddCollab",

"func": self.add_outside_collab_command,

"user_data_required": True,

"help": "Adds an outside collaborator to a specific repository in a specific GitHub organization.",

"permitted_permissions": ["push", "pull"], # To grant admin, add this to the config for

"enabled": True # this command in the config.py.

},

"!RemoveCollab": {

"command": "!RemoveCollab",

"func": self.remove_outside_collab_command,

"user_data_required": True,

"help": "Removes an outside collaborator from a specific repository in a specific GitHub organization.",

"enabled": True # this command in the config.py.

},

"!SetRepoPermissions": {

"command": "!SetRepoPermissions",

"func": self.set_repo_permissions_command,

"user_data_required": True,

"help": "Sets team permissions to a specific repository in a specific GitHub organization.",

"permitted_permissions": ["push", "pull"], # To grant admin, add this to the config for

"enabled": True # this command in the config.py.

},

"!SetDescription": {

"command": "!SetDescription",

"func": self.set_description_command,

"user_data_required": True,

"help": "Adds/Modifies a GitHub repo's description.",

"enabled": True

},

"!SetHomepage": {

"command": "!SetHomepage",

"func": self.set_repo_homepage_command,

"user_data_required": True,

"help": "Adds/Modifies a GitHub repo's homepage URL.",

"enabled": True

},

"!SetDefaultBranch": {

"command": "!SetDefaultBranch",

"func": self.set_default_branch_command,

"user_data_required": True,

"help": "Sets the default branch for a repo.",

"enabled": True # It is HIGHLY recommended you have auth enabled for this!!

},

"!ListPRs": {

"command": "!ListPRs",

"func": self.list_pull_requests_command,

"user_data_required": True,

"help": "List the Pull Requests for a repo.",

"permitted_states": ["open", "closed", "all"],

"enabled": True

},

"!DeleteRepo": {

"command": "!DeleteRepo",

"func": self.delete_repo_command,

"user_data_required": True,

"help": "Delete a GitHub repository.",

"enabled": True # It is HIGHLY recommended you have auth enabled for this!!

},

"!AddUserToTeam": {

"command": "!AddUserToTeam",

"func": self.add_user_to_team_command,

"user_data_required": True,

"help": "Adds a GitHub user to a specific team inside the organization.",

"permitted_roles": ["member", "maintainer"],

"enabled": True

},

"!SetBranchProtection": {

"command": "!SetBranchProtection",

"func": self.set_branch_protection_command,

"user_data_required": True,

"help": "Toggles the branch protection for a repo.",

"enabled": True # It is HIGHLY recommended you have auth enabled for this!!

},

"!ListKeys": {

"command": "!ListKeys",

"func": self.list_deploy_keys_command,

"user_data_required": True,

"help": "List the Deploy Keys for a repo.",

"enabled": True

},

"!AddKey": {

"command": "!AddKey",

"func": self.add_deploy_key_command,

"user_data_required": True,

"help": "Add Deploy Key for a repo.",

"enabled": True

},

"!DeleteKey": {

"command": "!DeleteKey",

"func": self.delete_deploy_key_command,

"user_data_required": True,

"help": "Delete Deploy Key from a repo.",

"enabled": True

},

"!GetKey": {

"command": "!GetKey",

"func": self.get_deploy_key_command,

"user_data_required": True,

"help": "Get Deploy Key Public Key",

"enabled": True

},

"!SetTopics": {

"command": "!SetTopics",

"func": self.set_repo_topics_command,

"user_data_required": True,

"help": "Sets the Topics for a GitHub repo",

"enabled": True

}

}

self.token = None

# For org alias lookup convenience:

self.org_lookup = None

def setup(self, secrets, **kwargs):

self.token = secrets["GITHUB"]

# Create the lookup table:

self.org_lookup = {}

for org in ORGS.items():

# The lookup table is the lowercase real name of the org, plus the aliases, along with

# a tuple containing the full real name of the org, with the org dict details:

self.org_lookup[org[0].lower()] = (org[0], org[1])

for alias in org[1]["aliases"]:

self.org_lookup[alias] = (org[0], org[1])

# Add user-configurable arguments to the command_plugins dictionary:

for cmd, keys in USER_COMMAND_DICT.items():

self.commands[cmd].update(keys)

@staticmethod

def list_org_command(data):

"""

headers = ["Alias", "Organization"]

rows = []

for org in ORGS.items():

rows.append([org[0].lower(), org[0]])

for alias in org[1]["aliases"]:

rows.append([alias, org[0]])

send_info(data["channel"], "```{}```".format(tabulate(rows, headers=headers)), markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def set_description_command(self, data, user_data, org, repo, description):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Modify the description:

if not (self.make_repo_edit(data, user_data, repo, org, description=description)):

return

if description == "":

send_success(data["channel"],

"@{}: The {}/{} repository's description field has been cleared."

.format(user_data["name"], org, repo), markdown=True, thread=data["ts"])

else:

send_success(data["channel"],

"@{}: The {}/{} repository's description has been modified to:\n"

"`{}`.".format(user_data["name"], org, repo, description), markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def set_repo_homepage_command(self, data, user_data, org, repo, homepage):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Modify the homepage:

if not (self.make_repo_edit(data, user_data, repo, org, homepage=homepage)):

return

# Done:

if homepage == "":

send_success(data["channel"],

"@{}: The {}/{} repository's homepage field has been cleared."

.format(user_data["name"], org, repo, homepage), markdown=True, thread=data["ts"])

else:

send_success(data["channel"],

"@{}: The {}/{} repository's homepage has been modified to:\n"

"`{}`.".format(user_data["name"], org, repo, homepage), markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

@github_user_exists("collab")

def add_outside_collab_command(self, data, user_data, collab, org, repos, permission):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grant access:

try:

for r in repos:

self.add_outside_collab_to_repo(collab, r, org, permission)

except ValueError as ve:

send_error(data["channel"],

"@{}: Problem encountered adding the user as an outside collaborator.\n"

"The response code from GitHub was: {}".format(user_data["name"], str(ve)), thread=data["ts"])

return

except Exception as e:

send_error(data["channel"],

"@{}: Problem encountered adding the user as an outside collaborator.\n"

"Here are the details: {}".format(user_data["name"], str(e)), thread=data["ts"])

return

# Done:

send_success(data["channel"],

"@{}: The GitHub user: `{}` has been added as an outside collaborator with `{}` "

"permissions to {} in {}.".format(user_data["name"], collab, permission,

", ".join(repos), org),

markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

@github_user_exists("collab")

def remove_outside_collab_command(self, data, user_data, collab, org, repos):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grant access:

try:

for r in repos:

self.remove_outside_collab_from_repo(collab, r, org)

except ValueError as ve:

send_error(data["channel"],

"@{}: Problem encountered removing the user as an outside collaborator.\n"

"The response code from GitHub was: {}".format(user_data["name"], str(ve)), thread=data["ts"])

return

except Exception as e:

send_error(data["channel"],

"@{}: Problem encountered removing the user as an outside collaborator.\n"

"Here are the details: {}".format(user_data["name"], str(e)), thread=data["ts"])

return

# Done:

send_success(data["channel"],

"@{}: The GitHub user: `{}` has been removed as an outside collaborator "

"from {} in {}.".format(user_data["name"], collab,

", ".join(repos), org),

markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

@team_must_exist()

def set_repo_permissions_command(self, data, user_data, team, org, repo, permission):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grant access:

try:

self.set_repo_permissions(repo, org, team, permission)

except ValueError as ve:

send_error(data["channel"],

"@{}: Problem encountered adding the team.\n"

"The response code from GitHub was: {}".format(user_data["name"], str(ve)), thread=data["ts"])

return

except Exception as e:

send_error(data["channel"],

"@{}: Problem encountered adding the team.\n"

"Here are the details: {}".format(user_data["name"], str(e)), thread=data["ts"])

return

# Done:

send_success(data["channel"],

"@{}: The GitHub team: `{}` has been added to the repo with `{}` "

"permissions to {}/{}.".format(user_data["name"], team, permission,

org, repo),

markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@github_user_exists("user_id")

@team_must_exist()

def add_user_to_team_command(self, data, user_data, user_id, org, team, role):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Do it:

try:

self.invite_user_to_gh_org_team(org, team, user_id, role)

except ValueError as ve:

send_error(data["channel"],

"@{}: Problem encountered adding the user as a team member.\n"

"The response code from GitHub was: {}".format(user_data["name"], str(ve)), thread=data["ts"])

return

except Exception as e:

send_error(data["channel"],

"@{}: Problem encountered adding the user as a team member.\n"

"Here are the details: {}".format(user_data["name"], str(e)), thread=data["ts"])

return

# Done:

send_success(data["channel"],

"@{}: The GitHub user: `{}` has been added as a team member with `{}` "

"permissions to {}/{}.".format(user_data["name"], user_id, role,

org, team),

markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

def create_repo_command(self, data, user_data, org, repo):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Check if the repo already exists:

try:

result = self.check_gh_for_existing_repo(repo, org)

if result:

# Check if the repo was renamed:

if "{}/{}".format(org, repo) == result["full_name"]:

send_error(data["channel"],

"@{}: This repository already exists in {}!".format(user_data["name"], org),

thread=data["ts"])

return

except Exception as e:

send_error(data["channel"],

"@{}: I encountered a problem:\n\n{}".format(user_data["name"], e), thread=data["ts"])

return

# Great!! Create the repository:

try:

visibility = True if not ORGS[org]["public_only"] else False

self.create_new_repo(repo, org, visibility)

except Exception as e:

send_error(data["channel"],

"@{}: I encountered a problem:\n\n{}".format(user_data["name"], e), thread=data["ts"])

return

# Need to wait a bit to ensure that the repo actually exists.

time.sleep(2)

# Grant the proper teams access to the repository:

try:

for perm_dict in ORGS[org]["new_repo_teams"]:

self.set_repo_permissions(repo, org, perm_dict["name"], perm_dict["perm"])

except Exception as e:

send_error(data["channel"],

"@{}: I encountered a problem setting repo permissions for team {team}: \n\n{exc}".format(

user_data["name"], team=perm_dict["name"], exc=e), thread=data["ts"])

return

# All done!

message = "@{}: The new repo: {} has been created in {}.\n".format(user_data["name"], repo, org)

message += "You can access the repo at: https://github.com/{org}/{repo}\n".format(org=org,

repo=repo)

visibility = "PRIVATE" if visibility else "PUBLIC"

message += "The repository is {visibility}.\n" \

"You are free to set up the repo as you like.\n".format(visibility=visibility)

send_success(data["channel"], message, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def delete_repo_command(self, data, user_data, org, repo):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Delete the repository:

try:

self.delete_repo(repo, org)

except Exception as e:

send_error(data["channel"],

"@{}: I encountered a problem:\n\n{}".format(user_data["name"], e), thread=data["ts"])

return

# All done!

message = "@{}: The repo: {} has been deleted from {}.\n".format(user_data["name"], repo, org)

send_success(data["channel"], message, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

@branch_must_exist()

def set_default_branch_command(self, data, user_data, org, repo, branch):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Set the default branch:

if not (self.make_repo_edit(data, user_data, repo, org, default_branch=branch)):

return

# Done:

send_success(data["channel"],

"@{}: The {}/{} repository's default branch has been set to: `{}`."

.format(user_data["name"], org, repo, branch), markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

@branch_must_exist()

def set_branch_protection_command(self, data, user_data, org, repo, branch, toggle):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Change the protection status:

try:

self.set_branch_protection(repo, org, branch, toggle)

except requests.exceptions.RequestException as re:

send_error(data["channel"],

"@{}: Problem encountered setting branch protection.\n"

"The response code from GitHub was: {}".format(user_data["name"], str(re)), thread=data["ts"])

return

# Done:

status = "ENABLED" if toggle else "DISABLED"

send_success(data["channel"],

"@{}: The {}/{} repository's {} branch protection status is now: {}."

.format(user_data["name"], org, repo, branch, status), markdown=True, thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def list_pull_requests_command(self, data, user_data, org, repo, state):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grab all PRs [All states]

pull_requests = self.get_repo_prs(data, user_data, repo, org, state)

if not pull_requests:

if isinstance(pull_requests, list):

send_info(data["channel"],

"@{}: No matching pull requests were found in *{}*.".format(user_data["name"], repo),

thread=data["ts"])

return

headers = ["#PR", "Title", "Opened by", "Assignee", "State"]

rows = []

for pr in pull_requests:

assignee = pr['assignee']['login'] if pr['assignee'] is not None else '-'

rows.append([pr['number'], pr['title'], pr['user']['login'], assignee, pr['state'].title()])

# Done:

send_raw(data["channel"], text="Repository: *{}* \n\n```{}```".format(repo, tabulate(rows, headers=headers,

tablefmt='orgtbl')),

thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def list_deploy_keys_command(self, data, user_data, org, repo):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grab all Deploy Keys

deploy_keys = self.get_repo_deploy_keys(data, user_data, repo, org)

if not (deploy_keys):

if isinstance(deploy_keys, list):

send_info(data["channel"],

"@{}: No deploy keys were found in *{}*.".format(user_data["name"], repo), thread=data["ts"])

return

headers = ["ID#", "Title", "Read-only", "Created"]

rows = []

for key in deploy_keys:

# Set a default readonly state

readonly = 'True'

if not key['read_only']:

readonly = 'False'

rows.append([key['id'], key['title'], readonly, key['created_at']])

# Done:

send_raw(data["channel"], text="Deploy Keys: *{}* \n\n```{}```".format(repo, tabulate(rows, headers=headers,

tablefmt='orgtbl')),

thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def add_deploy_key_command(self, data, user_data, org, repo, title, readonly, pubkey):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Add the Deploy Key

result = self.add_repo_deploy_key(data, user_data, repo, org, title, pubkey, readonly)

# If we have an error due to invalid key, we are returning False from the API response method

if not result:

send_error(data["channel"], "@{}: The deploy key entered was invalid -- or -- it already exists."

.format(user_data["name"], repo), thread=data["ts"])

return

if not result.get('id'):

send_error(data["channel"], "@{}: Adding deploy key failed.".format(user_data["name"], repo),

thread=data["ts"])

return

# Done:

send_raw(data["channel"],

text="Deploy Key *{}* with ID *{}* successfully added to *{}*\n\n".format(result['title'],

result['id'], repo),

thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def delete_deploy_key_command(self, data, user_data, org, repo, id):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grab the Deploy Key (check that it exists)

deploy_key = self.get_repo_deploy_key_by_id(data, user_data, repo, org, id)

if not deploy_key:

if deploy_key is None:

send_error(data["channel"],

"@{}: Deploy Key with ID: `{}` is not present for the {}/{} repo.".format(user_data["name"],

id, org, repo),

markdown=True, thread=data["ts"])

else:

send_error(data["channel"], "@{}: Error Retrieving Deploy Key `{}`.".format(user_data["name"], id),

markdown=True, thread=data["ts"])

return

# Delete the Deploy Key

result = self.delete_repo_deploy_key(data, user_data, repo, org, id)

if not result:

send_info(data["channel"], "@{}: Error deleting deploy key ID *{}*.".format(user_data["name"], id),

markdown=True, thread=data["ts"])

return

# Done:

send_raw(data["channel"], text="Deploy Key ID *{}* successfully deleted from *{}*\n\n".format(id, repo),

thread=data["ts"])

@hubcommander_command(

@auth()

@repo_must_exist()

def get_deploy_key_command(self, data, user_data, org, repo, id):

"""

# Output that we are doing work:

send_info(data["channel"], "@{}: Working, Please wait...".format(user_data["name"]), thread=data["ts"])

# Grab the Deploy Key

deploy_key = self.get_repo_deploy_key_by_id(data, user_data, repo, org, id)

if not deploy_key:

if deploy_key is None:

send_error(data["channel"],

"@{}: Deploy Key with ID: `{}` is not present for the {}/{} repo.".format(user_data["name"],

id, org, repo),

markdown=True, thread=data["ts"])

else:

send_error(data["channel"], "@{}: Error Retrieving Deploy Key `{}`.".format(user_data["name"], id),

markdown=True, thread=data["ts"])

return

# Done:

send_info(data["channel"],

"@{}: Deploy Key ID `{}`: ```{}```".format(user_data["name"], id, deploy_key['key']), markdown=True,

thread=data["ts"])

@hubcommander_command(