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)