def get_slack_token(cls, team_id, user_id=None):
database = Database()
database.initialize()
try:
slack_token_object = cls.get_token_from_database(team_id=team_id,
user_id=user_id)
except TypeError:
print(
"Visit http://178.128.234.3:5000/eight_ball/begin_auth to authorize this app"
)
raise ValueError("Slack authorization failed")
if slack_token_object.token_expiry_time is None:
print(
"Visit http://178.128.234.3:5000/eight_ball/begin_auth to authorize this app"
)
raise ValueError("Slack authorization failed")
elif int(slack_token_object.token_expiry_time) < int(time.time()):
hook = cls.get_token_from_database(team_id=team_id,
user_id=user_id)
auth_response = hook.slack_token_request(hook.auth_code)
try:
hook.update_token(auth_response)
except TypeError:
hook.add_token(auth_response)
return SlackClient(str(auth_response['access_token']))
else:
return SlackClient(str(slack_token_object.access_token))
def find_entry(cls, text):
database = Database()
database.initialize()
entry = database.find_one("samples", {"text": text})
if entry is not None:
return cls(**entry)
else:
return None
def remove_fact(fact_text):
database = Database()
database.initialize()
if database.find_one("facts", {"fact_text": fact_text}) is None:
raise LookupError('Fact was not found in the database')
else:
database.remove("facts", {"fact_text": fact_text})
print("Fact was successfully removed")
def remove_distributor(email_address=None, slack_ids=None):
database = Database()
database.initialize()
if database.find_one("distributors", {"email_address": email_address,
"slack_ids": slack_ids}):
database.remove("distributors", {"email_address": email_address,
"slack_ids": slack_ids})
return True
def get_distributors(cls, type):
database = Database()
database.initialize()
distributors = database.find("distributors", {"type": type})
return [cls(**distributor) for distributor in distributors]
#Distributor.add_distributor(type="slack", slack_channel_id="C0JS385LP")
#Distributor.add_distributor(type="email", email_address="*****@*****.**")
def log_staging_deploy(msg):
pattern = re.compile("finished deploying branch.* version.* to staging")
if pattern.findall(msg):
version = msg.split("branch")[1].split("version")[0].strip()
database = Database()
database.initialize()
database.insert(collection="version_record",
data={
"version": version,
"time": int(time.time())
})
def get_release_notes(version):
database = Database()
database.initialize()
jira_settings = database.find_one("jira_settings", query={})
auth_jira = JIRA(basic_auth=(jira_settings['email'], jira_settings['password']),
server=jira_settings['server'])
release_notes = "{} has been deployed to production! Release notes:\n".format(version)
issues = auth_jira.search_issues("""fixVersion in ("{}")""".format(version))
for issue in issues:
release_notes = release_notes + str(issue) + " - " + auth_jira.issue(issue).fields.summary + "\n"
return release_notes
def add_fact(fact_type, fact_text):
if not any([(fact_type == "puppy_fact"),
(fact_type == "cat_fact"),
(fact_type == "horse_fact")]):
print("fact_type must be one of the following: puppy_fact, cat_fact, horse_fact")
else:
database = Database()
database.initialize()
fact = Facts(fact_type = fact_type, fact_text = fact_text)
database.insert("facts", fact.json())
print("Fact successfully added")
def add_token(self, auth_response):
database = Database()
database.initialize()
self.access_token = auth_response['bot']['bot_access_token']
self.user_id = auth_response['user_id']
self.team_id = auth_response['team_id']
numbers = re.compile('\d+(?:\.\d+)?')
max_age = int(
numbers.findall(
auth_response['headers']['Strict-Transport-Security'])[0])
self.token_expiry_time = int(time.time()) + max_age
database.insert(collection="slack_tokens", data=self.json())
def get_latest_release():
database = Database()
database.initialize()
entries = database.find(collection="version_record",
query={})
saved_entries = list()
times = list()
for i in entries:
times.append(i['time'])
saved_entries.append(i)
max_time = max(times)
for i in saved_entries:
if i['time'] == max_time:
version = i['version']
return version
def migrate_facts():
dirpath = os.path.dirname(__file__)
fact_files = {'horse_fact': 'facts/horse_facts.txt',
'cat_fact': 'facts/cat_facts.txt',
'puppy_fact': 'facts/puppy_facts.txt'}
database = Database()
database.initialize()
for k, v in fact_files.items():
lines = open(os.path.join(dirpath, v)).read().splitlines()
for line in lines:
if line == "":
continue
else:
fact = Facts(fact_type=k, fact_text=line)
database.insert("facts", fact.json())
def get_token_from_database(cls, team_id, user_id=None):
database = Database()
database.initialize()
if user_id is not None:
credentials = database.find_one("slack_tokens",
query=({
"team_id": team_id,
"user_id": user_id
}))
else:
credentials = database.find_one("slack_tokens",
query=({
"team_id": team_id
}))
return cls(**credentials)
def add_distributor(type, email_address=None, slack_ids=None):
if "type" == "email":
if email_address is not None:
return "Please pass an email address"
if "type" == "slack":
if email_address is not None:
return "Please pass an slack_channel_id"
elif all([(type != "slack"), (type != "email")]):
return "Valid 'type's are 'slack' and 'email'"
else:
distributor = Distributor(type=type,
email_address=email_address,
slack_ids=slack_ids)
database = Database()
database.initialize()
database.insert("distributors", distributor.json())
def get_email_credentials(cls, returnless=False):
database = Database()
database.initialize()
emailer_credential_object = database.find_one("emailer_credentials",
({}))
if emailer_credential_object is None:
email_address = input(
"Please enter the gmail account address you would like to use to send emails:"
)
email_password = input("Please enter your gmail password:"******"Login failed. Please enter your GMAIL address:")
email_password = input("Please enter your GMAIL password:"******"emailer_credentials",
({
"email_address": email_address,
"email_password": email_password
}))
else:
email_address = emailer_credential_object['email_address']
email_password = emailer_credential_object['email_password']
if returnless is False:
return email_address, email_password
def add_entry(data):
database = Database()
database.initialize()
database.insert("logging", data)
def get_entries(cls):
database = Database()
database.initialize()
entries = database.find("samples", ({}))
return [cls(**entry) for entry in entries]
def remove_entry(self):
database = Database()
database.initialize()
database.remove("samples", self.json())
def get_keyword_from_database():
database = Database()
database.initialize()
result = database.find_one("giphy_keyword", query=({}))
return result['giphy_keyword']
def get_app_credentials():
database = Database()
database.initialize()
result = database.find_one("slack_credentials", query=({}))
return result
def onboard_user(self):
database = Database()
database.initialize()
database.insert("users", self.json())
print("User successfully added")
def add_entry(self):
database = Database()
database.initialize()
database.insert("message_log", self.json())
def remove_user(self):
database = Database()
database.initialize()
database.remove("users", {"_id": self._id})
print("User successfully removed")
def update_user(self, update):
database = Database()
database.initialize()
database.update("users", {"_id": self._id}, update)
print("User successfully updated")
def get_one_user(cls, query=({})):
database = Database()
database.initialize()
user = database.find_one("users", query)
return cls(**user)
def get_users(cls, query=({})):
database = Database()
database.initialize()
users = database.find("users", query)
return [cls(**user) for user in users]
def get_facts(cls, query=({})):
database = Database()
database.initialize()
facts = database.find("facts", query)
return [cls(**fact) for fact in facts]
def add_entry(self):
database = Database()
database.initialize()
database.insert("samples", self.json())
def get_entry_by_ts(cls, ts):
database = Database()
database.initialize()
result = database.find_one("message_log", {"trigger_ts": ts})
if result is not None:
return cls(**result)
def add_to_send_count(self):
database = Database()
database.initialize()
self.send_count += 1
database.update("users", {"_id": self._id}, self.json())
def get_token_from_database():
database = Database()
database.initialize()
result = database.find_one("giphy_tokens", query=({}))
return result['giphy_token']
