def create_issue(pecha_id, title, body=None, labels=[]):
# Authenticating bot as an installation
installation_id = get_installation_id(
owner=current_app.config["GITHUBREPO_OWNER"], repo=pecha_id
)
installation_access_token = get_installation_access_token(installation_id)
client = GitHub(token=installation_access_token)
issue = client.create_issue(
current_app.config["GITHUBREPO_OWNER"],
pecha_id,
title,
body=body,
labels=labels,
)
return issue
def submit_issue(title, body, score):
log.debug("Failed test: {test}".format(test=title))
# Create Github issue
gh_username = '******'
gh_password = '******'
log.debug("Logging in as {user}".format(user=gh_username))
github = GitHub(gh_username, gh_password)
log.debug(
"Ratelimit remaining: {rate}".format(rate=github.ratelimit_remaining))
# create_issue(owner, repository, title, body=None, assignee=None, milestone=None, labels=[])
# TRAVIS_REPO_SLUG (owner_name/repo_name)
# https://docs.travis-ci.com/user/environment-variables/
owner, repo = os.environ.get('TRAVIS_REPO_SLUG').split('/')
log.debug("Repo: {owner}/{repo}".format(owner=owner, repo=repo))
found = False
# If there is already an open issue, create a comment instead of a new issue
for issue in github.iter_repo_issues(owner, repo, state='open'):
if issue.title == title:
log.debug(
"Found existing open ticket: {url}".format(url=issue.html_url))
comment = issue.create_comment(body)
log.debug("Created comment: {comment}".format(comment=comment))
found = True
break
if not found:
log.debug("Attempting to create issue...")
resp = github.create_issue(owner, repo, title, body, owner)
log.debug("Created ticket: {resp}".format(resp=resp))
# Post results
log.debug("Attempting to post score ({score})...".format(score=score))
url = "https://tdd-chart.herokuapp.com/score/add?user={owner}/{repo}&score={score}"
resp = get(url.format(owner=owner, repo=repo, score=score))
log.debug("TDD-chart response: {code}".format(code=resp.status_code))
class ServiceGithub(ServicesMgr):
"""
Service Github
"""
def __init__(self, token=None, **kwargs):
super(ServiceGithub, self).__init__(token, **kwargs)
self.scope = ['public_repo']
self.REQ_TOKEN = 'https://github.com/login/oauth/authorize'
self.AUTH_URL = 'https://github.com/login/oauth/authorize'
self.ACC_TOKEN = 'https://github.com/login/oauth/access_token'
self.username = settings.TH_GITHUB_KEY['username']
self.password = settings.TH_GITHUB_KEY['password']
self.consumer_key = settings.TH_GITHUB_KEY['consumer_key']
self.consumer_secret = settings.TH_GITHUB_KEY['consumer_secret']
self.token = token
self.oauth = 'oauth1'
self.service = 'ServiceGithub'
if self.token:
token_key, token_secret = self.token.split('#TH#')
self.gh = GitHub(token=token_key)
else:
self.gh = GitHub(username=self.username, password=self.password)
def gh_footer(self, trigger, issue):
link = 'https://github.com/{0}/{1}/issues/{2}'.format(
trigger.repo, trigger.project, issue.id)
provided_by = _('Provided by')
provided_from = _('from')
footer_from = "<br/><br/>{} <em>{}</em> {} <a href='{}'>{}</a>"
return footer_from.format(provided_by, trigger.trigger.description,
provided_from, link, link)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
trigger_id = kwargs.get('trigger_id')
date_triggered = str(kwargs.get('date_triggered')).replace(' ', 'T')
data = list()
if self.token:
# check if it remains more than 1 access
# then we can create an issue
if self.gh.ratelimit_remaining > 1:
import pypandoc
trigger = Github.objects.get(trigger_id=trigger_id)
issues = self.gh.issues_on(trigger.repo,
trigger.project,
since=date_triggered)
for issue in issues:
content = pypandoc.convert(issue.body, 'md', format='html')
content += self.gh_footer(trigger, issue)
data.append({'title': issue.title, 'content': content})
# digester
self.send_digest_event(trigger_id, issue.title, '')
cache.set('th_github_' + str(trigger_id), data)
else:
# rate limit reach, do nothing right now
logger.warning("Rate limit reached")
update_result(trigger_id,
msg="Rate limit reached",
status=True)
else:
logger.critical("no token provided")
update_result(trigger_id, msg="No token provided", status=True)
return data
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
if self.token:
title = self.set_title(data)
body = self.set_content(data)
# get the details of this trigger
trigger = Github.objects.get(trigger_id=trigger_id)
# check if it remains more than 1 access
# then we can create an issue
limit = self.gh.ratelimit_remaining
if limit > 1:
# repo goes to "owner"
# project goes to "repository"
r = self.gh.create_issue(trigger.repo, trigger.project, title,
body)
else:
# rate limit reach
logger.warn("Rate limit reached")
update_result(trigger_id,
msg="Rate limit reached",
status=True)
# put again in cache the data that could not be
# published in Github yet
cache.set('th_github_' + str(trigger_id), data, version=2)
return True
sentence = str('github {} created').format(r)
logger.debug(sentence)
status = True
else:
sentence = "no token or link provided for " \
"trigger ID {} ".format(trigger_id)
logger.critical(sentence)
update_result(trigger_id, msg=sentence, status=False)
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
:param request: request object
:return: callback url
:rtype: string that contains the url to redirect after auth
"""
auth = self.gh.authorize(self.username, self.password, self.scope, '',
'', self.consumer_key, self.consumer_secret)
request.session['oauth_token'] = auth.token
request.session['oauth_id'] = auth.id
return self.callback_url(request)
def callback(self, request, **kwargs):
"""
Called from the Service when the user accept to activate it
:param request: request object
:return: callback url
:rtype: string , path to the template
"""
access_token = request.session['oauth_token'] + "#TH#"
access_token += str(request.session['oauth_id'])
kwargs = {'access_token': access_token}
return super(ServiceGithub, self).callback(request, **kwargs)
sys.exit(0)
message = cgi.escape(message)
# TODO make xml parser not delete linebreaks
message = message.replace('\\n', '\n')
log.debug("Test failure: {name}, {m}".format(name=name, m=repr(message)))
# Create Github issue
gh_username = '******'
gh_password = '******'
log.debug("Logging in as {user}".format(user=gh_username))
github = GitHub(gh_username, gh_password)
log.debug("Ratelimit remaining: {rate}".format(rate=github.ratelimit_remaining))
# create_issue(owner, repository, title, body=None, assignee=None, milestone=None, labels=[])
# TRAVIS_REPO_SLUG (owner_name/repo_name)
# https://docs.travis-ci.com/user/environment-variables/
owner, repo = os.environ.get('TRAVIS_REPO_SLUG').split('/')
log.debug("Repo: {owner}/{repo}".format(owner=owner, repo=repo))
log.debug("Attempting to create issue...")
resp = github.create_issue(owner, repo, name, message)
log.debug("Created ticket: {resp}".format(resp=resp))
# Post results
log.debug("Attempting to post score...")
url = "https://tdd-chart.herokuapp.com/score/add?user={user}&score={score}"
resp = get(url.format(user=owner, score=score))
log.debug("TDD-chart response: {code}".format(code=resp.status_code))
class ServiceGithub(ServicesMgr):
def __init__(self, token=None):
self.scope = ['public_repo']
self.REQ_TOKEN = 'https://github.com/login/oauth/authorize'
self.AUTH_URL = 'https://github.com/login/oauth/authorize'
self.ACC_TOKEN = 'https://github.com/login/oauth/access_token'
self.username = settings.TH_GITHUB['username']
self.password = settings.TH_GITHUB['password']
self.consumer_key = settings.TH_GITHUB['consumer_key']
self.consumer_secret = settings.TH_GITHUB['consumer_secret']
self.token = token
if self.token:
token_key, token_secret = self.token.split('#TH#')
self.gh = GitHub(token=token_key)
else:
self.gh = GitHub(username=self.username, password=self.password)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
# date_triggered = kwargs['date_triggered']
trigger_id = kwargs['trigger_id']
data = list()
cache.set('th_github_' + str(trigger_id), data)
def process_data(self, **kwargs):
"""
get the data from the cache
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
"""
kw = {'cache_stack': 'th_github', 'trigger_id': str(kwargs['trigger_id'])}
return super(ServiceGithub, self).process_data(**kw)
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
from th_github.models import Github
status = False
if self.token:
title = self.set_title(data)
body = self.set_content(data)
# get the details of this trigger
trigger = Github.objects.get(trigger_id=trigger_id)
# check if it remains more than 1 access
# then we can create an issue
limit = self.gh.ratelimit_remaining
if limit > 1:
# repo goes to "owner"
# project goes to "repository"
r = self.gh.create_issue(trigger.repo,
trigger.project,
title,
body)
else:
# rate limite reach
logger.warn("Rate limit reached")
# put again in cache the data that could not be
# published in Github yet
cache.set('th_github_' + str(trigger_id), data, version=2)
return True
sentance = str('github {} created').format(r)
logger.debug(sentance)
status = True
else:
logger.critical(
"no token or link provided for trigger ID {} ".format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
"""
callback_url = 'http://%s%s' % (
request.get_host(), reverse('github_callback'))
auth = self.gh.authorize(self.username,
self.password,
self.scope,
'',
'',
self.consumer_key,
self.consumer_secret)
request.session['oauth_token'] = auth.token
request.session['oauth_id'] = auth.id
return callback_url
def callback(self, request):
"""
Called from the Service when the user accept to activate it
"""
try:
# finally we save the user auth token
# As we already stored the object ServicesActivated
# from the UserServiceCreateView now we update the same
# object to the database so :
# 1) we get the previous objet
us = UserService.objects.get(
user=request.user,
name=ServicesActivated.objects.get(name='ServiceGithub'))
# 2) Readability API require to use 4 parms consumer_key/secret +
# token_key/secret instead of usually get just the token
# from an access_token request. So we need to add a string
# seperator for later use to slpit on this one
access_token = request.session['oauth_token'] + "#TH#" + str(request.session['oauth_id'])
us.token = access_token
# 3) and save everything
us.save()
except KeyError:
return '/'
return 'github/callback.html'
class ServiceGithub(ServicesMgr):
def __init__(self, token=None, **kwargs):
super(ServiceGithub, self).__init__(token, **kwargs)
self.scope = ['public_repo']
self.REQ_TOKEN = 'https://github.com/login/oauth/authorize'
self.AUTH_URL = 'https://github.com/login/oauth/authorize'
self.ACC_TOKEN = 'https://github.com/login/oauth/access_token'
self.username = settings.TH_GITHUB['username']
self.password = settings.TH_GITHUB['password']
self.consumer_key = settings.TH_GITHUB['consumer_key']
self.consumer_secret = settings.TH_GITHUB['consumer_secret']
self.token = token
self.oauth = 'oauth1'
self.service = 'ServiceGithub'
if self.token:
token_key, token_secret = self.token.split('#TH#')
self.gh = GitHub(token=token_key)
else:
self.gh = GitHub(username=self.username, password=self.password)
def gh_footer(self, trigger, issue):
link = 'https://github.com/{0}/{1}/issues/{2}'.format(
trigger.repo, trigger.project, issue.id)
provided_by = _('Provided by')
provided_from = _('from')
footer_from = "<br/><br/>{} <em>{}</em> {} <a href='{}'>{}</a>"
return footer_from.format(provided_by, trigger.trigger.description,
provided_from, link, link)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
trigger_id = kwargs.get('trigger_id')
date_triggered = str(kwargs.get('date_triggered')).replace(' ', 'T')
data = list()
if self.token:
# check if it remains more than 1 access
# then we can create an issue
if self.gh.ratelimit_remaining > 1:
import pypandoc
trigger = Github.objects.get(trigger_id=trigger_id)
issues = self.gh.issues_on(trigger.repo,
trigger.project,
since=date_triggered)
for issue in issues:
content = pypandoc.convert(issue.body, 'md', format='html')
content += self.gh_footer(trigger, issue)
data.append({'title': issue.title, 'content': content})
cache.set('th_github_' + str(trigger_id), data)
else:
# rate limit reach, do nothing right now
logger.warn("Rate limit reached")
else:
logger.critical("no token provided")
return data
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
if self.token:
title = self.set_title(data)
body = self.set_content(data)
# get the details of this trigger
trigger = Github.objects.get(trigger_id=trigger_id)
# check if it remains more than 1 access
# then we can create an issue
limit = self.gh.ratelimit_remaining
if limit > 1:
# repo goes to "owner"
# project goes to "repository"
r = self.gh.create_issue(trigger.repo,
trigger.project,
title,
body)
else:
# rate limit reach
logger.warn("Rate limit reached")
# put again in cache the data that could not be
# published in Github yet
cache.set('th_github_' + str(trigger_id), data, version=2)
return True
sentence = str('github {} created').format(r)
logger.debug(sentence)
status = True
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
:param request: request object
:return: callback url
:rtype: string that contains the url to redirect after auth
"""
auth = self.gh.authorize(self.username,
self.password,
self.scope,
'',
'',
self.consumer_key,
self.consumer_secret)
request.session['oauth_token'] = auth.token
request.session['oauth_id'] = auth.id
return self.callback_url(request)
def callback(self, request, **kwargs):
"""
Called from the Service when the user accept to activate it
:param request: request object
:return: callback url
:rtype: string , path to the template
"""
access_token = request.session['oauth_token'] + "#TH#"
access_token += str(request.session['oauth_id'])
kwargs = {'access_token': access_token}
return super(ServiceGithub, self).callback(request, **kwargs)
class ServiceGithub(ServicesMgr):
def __init__(self, token=None):
super(ServiceGithub, self).__init__(token)
self.scope = ['public_repo']
self.REQ_TOKEN = 'https://github.com/login/oauth/authorize'
self.AUTH_URL = 'https://github.com/login/oauth/authorize'
self.ACC_TOKEN = 'https://github.com/login/oauth/access_token'
self.username = settings.TH_GITHUB['username']
self.password = settings.TH_GITHUB['password']
self.consumer_key = settings.TH_GITHUB['consumer_key']
self.consumer_secret = settings.TH_GITHUB['consumer_secret']
self.token = token
if self.token:
token_key, token_secret = self.token.split('#TH#')
self.gh = GitHub(token=token_key)
else:
self.gh = GitHub(username=self.username, password=self.password)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
trigger_id = kwargs['trigger_id']
data = list()
cache.set('th_github_' + str(trigger_id), data)
def process_data(self, **kwargs):
"""
get the data from the cache
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
"""
kw = {
'cache_stack': 'th_github',
'trigger_id': str(kwargs['trigger_id'])
}
return super(ServiceGithub, self).process_data(**kw)
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
from th_github.models import Github
if self.token:
title = self.set_title(data)
body = self.set_content(data)
# get the details of this trigger
trigger = Github.objects.get(trigger_id=trigger_id)
# check if it remains more than 1 access
# then we can create an issue
limit = self.gh.ratelimit_remaining
if limit > 1:
# repo goes to "owner"
# project goes to "repository"
r = self.gh.create_issue(trigger.repo, trigger.project, title,
body)
else:
# rate limit reach
logger.warn("Rate limit reached")
# put again in cache the data that could not be
# published in Github yet
cache.set('th_github_' + str(trigger_id), data, version=2)
return True
sentence = str('github {} created').format(r)
logger.debug(sentence)
status = True
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
:param request: request object
:return: callback url
:rtype: string that contains the url to redirect after auth
"""
callback_url = 'http://%s%s' % (request.get_host(),
reverse('github_callback'))
auth = self.gh.authorize(self.username, self.password, self.scope, '',
'', self.consumer_key, self.consumer_secret)
request.session['oauth_token'] = auth.token
request.session['oauth_id'] = auth.id
return callback_url
def callback(self, request, **kwargs):
"""
Called from the Service when the user accept to activate it
:param request: request object
:return: callback url
:rtype: string , path to the template
"""
try:
# finally we save the user auth token
# As we already stored the object ServicesActivated
# from the UserServiceCreateView now we update the same
# object to the database so :
# 1) we get the previous objet
us = UserService.objects.get(
user=request.user,
name=ServicesActivated.objects.get(name='ServiceGithub'))
# 2) Readability API require to use 4 params consumer_key/secret +
# token_key/secret instead of usually get just the token
# from an access_token request. So we need to add a string
# separator for later use to split on this one
access_token = request.session['oauth_token'] + "#TH#"
access_token += str(request.session['oauth_id'])
us.token = access_token
# 3) and save everything
us.save()
except KeyError:
return '/'
return 'github/callback.html'
class ServiceGithub(ServicesMgr):
def __init__(self, token=None, **kwargs):
super(ServiceGithub, self).__init__(token, **kwargs)
self.scope = ['public_repo']
self.REQ_TOKEN = 'https://github.com/login/oauth/authorize'
self.AUTH_URL = 'https://github.com/login/oauth/authorize'
self.ACC_TOKEN = 'https://github.com/login/oauth/access_token'
self.username = settings.TH_GITHUB['username']
self.password = settings.TH_GITHUB['password']
self.consumer_key = settings.TH_GITHUB['consumer_key']
self.consumer_secret = settings.TH_GITHUB['consumer_secret']
self.token = token
self.oauth = 'oauth1'
self.service = 'ServiceGithub'
if self.token:
token_key, token_secret = self.token.split('#TH#')
self.gh = GitHub(token=token_key)
else:
self.gh = GitHub(username=self.username, password=self.password)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
trigger_id = kwargs.get('trigger_id')
data = list()
cache.set('th_github_' + str(trigger_id), data)
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
from th_github.models import Github
if self.token:
title = self.set_title(data)
body = self.set_content(data)
# get the details of this trigger
trigger = Github.objects.get(trigger_id=trigger_id)
# check if it remains more than 1 access
# then we can create an issue
limit = self.gh.ratelimit_remaining
if limit > 1:
# repo goes to "owner"
# project goes to "repository"
r = self.gh.create_issue(trigger.repo,
trigger.project,
title,
body)
else:
# rate limit reach
logger.warn("Rate limit reached")
# put again in cache the data that could not be
# published in Github yet
cache.set('th_github_' + str(trigger_id), data, version=2)
return True
sentence = str('github {} created').format(r)
logger.debug(sentence)
status = True
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
:param request: request object
:return: callback url
:rtype: string that contains the url to redirect after auth
"""
auth = self.gh.authorize(self.username,
self.password,
self.scope,
'',
'',
self.consumer_key,
self.consumer_secret)
request.session['oauth_token'] = auth.token
request.session['oauth_id'] = auth.id
return self.callback_url(request)
def callback(self, request, **kwargs):
"""
Called from the Service when the user accept to activate it
:param request: request object
:return: callback url
:rtype: string , path to the template
"""
access_token = request.session['oauth_token'] + "#TH#"
access_token += str(request.session['oauth_id'])
kwargs = {'access_token': access_token}
return super(ServiceGithub, self).callback(request, **kwargs)
