def auth_user(username, password, redmine=__redmine, url=None, verify_ssl_certs=False): user = None try: if url is not None: user = Redmine( url, username=username, password=password, requests={ 'verify': False } if not verify_ssl_certs else {}, ).auth() else: user = Redmine( redmine.url, username=username, password=password, requests={ 'verify': False } if not verify_ssl_certs else {}, ).auth() except AuthError: raise Exception('Invalid login or password provided') return user
def _create_connector(self): if self.apikey: self.redmine = Redmine(self.url, key=self.apikey, requests={'verify': False}) else: self.redmine = Redmine(self.url, username=self.username, password=self.password, requests={'verify': False})
def connect(self): assert self.redmine_url is not None, "Must specify the Redmine URL" assert self.redmine_api_key is not None, "Must specify the API key" try: Redmine(self.redmine_url, key=self.redmine_api_key).auth() self.redmine = Redmine(self.redmine_url, key=self.redmine_api_key) except AuthError: print "Redmine AuthError, API Key is invalid. Time entries will not be sent to Redmine" except Exception, e: print "An error has occured during Redmine connection : %s" % e
def newbug(request, wid=''): if request.method == 'POST': uid = request.session['id'] #开bug前需要先关联key值,key值是redmine用户登录后,点击“我的帐号”,右边面板“API访问键”,点击“显示”,拷贝出来,加到case_redmine_key表中 try: rkey = case.models.redmine_key.objects.get(uid=uid).key except: rs = {} rs['failed'] = True rs['message'] = "请联系李燕为您添加Redmine系统的Key值,才能正常开Bug~~" return HttpResponse(json.dumps(rs)) fb = fileBugForm(request.POST) if fb.is_valid(): env = fb.cleaned_data['env'] description = fb.cleaned_data['description'] today = time.strftime('%Y-%m-%d', time.localtime(time.time())) description = u'使用'+env+u'环境'+today+u'版本:\r'+description fnames = fb.cleaned_data['attachment'] fnames = fnames.split(',') uploads = [] path = os.path.join(settings.MEDIA_ROOT,'bugAttachment/') for item in fnames: if item: filename = item.split(":")[0] fpath = path + item.split(":")[1] uploads.append({'path': fpath, 'filename': filename}) cid = fb.cleaned_data['cid'] ipid = cid if wid else case.models.category.objects.get(id=cid).redmine_proid if not ipid: rs = {} rs['failed'] = True rs['message'] = "请先到产品管理页添加该项目所关联的Redmine项目id~~" return HttpResponse(json.dumps(rs)) redmine = Redmine('http://git.ablesky.com', key=rkey) if '/newbug/' in request.path: issue = redmine.issue.get(wid) if wid else redmine.issue.new() issue.project_id = ipid issue.subject = fb.cleaned_data['subject'] issue.tracker_id = fb.cleaned_data['itype'] issue.description = description issue.status_id = fb.cleaned_data['status'] issue.priority_id = fb.cleaned_data['PRI'] issue.assigned_to_id = fb.cleaned_data['assign_to'] issue.uploads = uploads issue.save() if '/closewi/' in request.path: redmine = Redmine('http://git.ablesky.com', key=rkey) try: issue = redmine.issue.get(wid) except ResourceNotFoundError: return HttpResponse("can't find this wi, please close it by yourself~") issue.status_id = 5 issue.save() return HttpResponse(issue.id)
def checkAuthentication(self, auth): print "#" * 14 + " Check Authentication " + "#" * 14 # Checking Authentication if auth == 1: # case by using Basic Authentication self.redmine = Redmine(self.url, username=self.username, password=self.password) print 'auth: [SUCCESS] Basic Authentication' elif auth == 2: # case by using REST API Key Authentication self.redmine = Redmine(self.url, key=self.key) print 'auth: [SUCCESS] REST API Key Authentication' print "#" * 50
def handle(self, *args, **options): redmine = Redmine() print() self.stdout.write('Score field ...', ending='\r') if redmine.instance_valid() is False: self.stderr.write('Score field not found or invalid:') for m in redmine.validator.score_field_errors: self.stderr.write(f'- {m}') self.exit() field = redmine.score_field if field is None: print(redmine.validator.score_field_errors) self.exit() instance, _ = CustomField.objects.get_or_create( name=field.name, redmine_id=field.id, ) instance.possible_values = field.possible_values instance.save() self.stdout.write('Score field: {}'.format(self.style.SUCCESS('OK'))) print()
def run(self): date = w.ui.calendarWidget.selectedDate().toPyDate() redmine = Redmine('http://help.heliosoft.ru', key='ceb184c8482614bd34a72612861176c9a02732ee') issues_open_me = redmine.issue.filter(status_id='open', assigned_to_id=148) issues_open_all_totay = redmine.issue.filter(project_id='experium', status_id='open', created_on=str(date)) issues_open_all_totay_up = redmine.issue.filter(project_id='experium', status_id='open', updated_on=str(date)) self.message1.emit('ISSUES ASSIGNED TO ME!!!') for t in issues_open_me: self.message1.emit('<a href="http://help.heliosoft.ru/issues/' + str(t.id) + '">' + str(t.id) + '</a> ***' + str(t.status) + '*** ' + str(t).decode('utf8')) self.message1.emit('\n\nEXPERIUM ISSUES CREATED TODAY!!! ' + str(date)) for t in issues_open_all_totay: self.message1.emit('<a href="http://help.heliosoft.ru/issues/' + str(t.id) + '">' + str(t.id) + '</a> ***' + str(t.status) + '*** ' + str(t).decode('utf8')) self.message1.emit('\n\nEXPERIUM ISSUES UPDATE TODAY!!! ' + str(date)) for t in issues_open_all_totay_up: self.message1.emit('<a href="http://help.heliosoft.ru/issues/' + str(t.id) + '">' + str(t.id) + '</a> ***' + str(t.status) + '*** ' + str(t).decode('utf8'))
def ticket_info(user, ticket_id): redmine = Redmine(settings.REDMINE_API_URL, key=settings.REDMINE_KEY, impersonate=user.login) try: issue = redmine.issue.get(ticket_id) except ResourceNotFoundError: return "Ticket no se encuentra" msg = "Ticket {}:\n".format(ticket_id) msg += "- fecha: {}\n".format(issue.created_on) msg += "- proyecto: {}\n".format(issue.project) if issue.status.id != STATUS.CLOSED: msg += "- estado: {} /cierra_{}\n".format(issue.status, ticket_id) else: msg += "- estado: {}\n".format(issue.status) if issue.subject: msg += "- asunto: {}\n".format(issue.subject) if issue.description: msg += "- descripción: {}\n".format(issue.description) msg += "- url: {}issues/{}\n".format(settings.REDMINE_PUBLIC_URL, ticket_id) try: if issue.assigned_to.id == user.id: msg += "- cogido por mi /suelta_{}\n".format(ticket_id) else: msg += "- cogido por: {} /coge_{}\n".format(issue.assigned_to, ticket_id) except ResourceAttrError: msg += "- sin coger /coge_{}\n".format(ticket_id) for ij in issue.journals: try: msg += "- nota {}: {}\n".format(ij.id, ij.notes.strip()) except ResourceAttrError: msg += "- nota {}: (error)\n".format(ij.id) for te in issue.time_entries: msg += "- entrada {}: {} ({:.2f}h)\n".format(te.id, te.comments.strip(), te.hours) return msg.strip()
def main(argv): key = '' vers = '' descrpt = '' try: opts, args = getopt.getopt( argv, "hk:v:d:p:", ["key=", "version=", "description=", "project="]) except getopt.GetoptError: print 'create_version.py -k <key> -v <version> -d <description> -p <project>' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'create_version.py -k <key> -v <version> -d <description> -p <project>' sys.exit(2) elif opt in ("-k", "--key"): key = arg elif opt in ("-v", "--version"): vers = arg elif opt in ("-d", "--description"): descrpt = arg elif opt in ("-p", "--project"): project = arg if key == '': print '<key> cannot be blank' sys.exit(2) if vers == '': print '<version> cannot be blank' sys.exit(2) if project == '': print '<project> cannot be blank' sys.exit(2) creation_date = re.match(r".*(\d{4})(\d{2})(\d{2})\d{4}", vers) redmine = Redmine('https://bugs.freenas.org', key=key) rm_project = redmine.project.get(project) version = redmine.version.new() version.project_id = rm_project.id version.name = vers version.description = descrpt version.status = 'closed' version.sharing = 'none' if creation_date: version.due_date = date(int(creation_date.group(1)), int(creation_date.group(2)), int(creation_date.group(3))) else: version.due_date = date(datetime.now().year, datetime.now().month, datetime.now().day) result = '' try: result = version.save() except exceptions.ValidationError: print "Could not create version" except exceptions.AuthError: print "Error authenticating with server" if result: print "Version %s successfully created" % vers else: print "Error creating version %s" % vers
def ticket_note(user, ticket_id, mensaje): redmine = Redmine(settings.REDMINE_API_URL, key=settings.REDMINE_KEY, impersonate=user.login) try: redmine.issue.update(ticket_id, notes=mensaje) except ResourceNotFoundError: return "Ticket no se encuentra" return "Anotado en el /ticket_{}".format(ticket_id)
def connect_to_redmine(self): self.redmine_conn = Redmine(self.redmine_server, key=self.redmine_api_key) self.redmine_project = self.redmine_conn.project.get( self.project_name_or_identifier) msg('Connected to server [%s] project [%s]' % (self.redmine_server, self.project_name_or_identifier))
def redmine_info(): t_time = datetime.date.today() redmine = Redmine('http://help.heliosoft.ru', key='') issues_open_prov = redmine.issue.filter(project_id='experium', status_id='3', cf_19='me') issues_open_me = redmine.issue.filter(assigned_to_id='me') issues_open_all_totay = redmine.issue.filter(project_id='experium', created_on=str(t_time)) issues_open_all_totay_up = redmine.issue.filter(project_id='experium', updated_on=str(t_time)) text = '' text += u'*НА ПРОВЕРКУ!!!*\n' for t in issues_open_prov: text += ( u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' % (str(t.id), str(t.id), str(t.status), str(t).decode('utf8'))) text += u'*\n\nЗАДАЧИ НА МНЕ!!!*\n' for t in issues_open_me: text += ( u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' % (str(t.id), str(t.id), str(t.status), str(t).decode('utf8'))) text += (u'\n\n*Тикеты, добавленные за %s:*\n' % str(t_time.strftime('%d %b %Y'))) for t in issues_open_all_totay: text += ( u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' % (str(t.id), str(t.id), str(t.status), str(t).decode('utf8'))) text += (u'\n\n*Тикеты, обновленные за %s:*\n' % str(t_time.strftime('%d %b %Y'))) for t in issues_open_all_totay_up: text += ( u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' % (str(t.id), str(t.id), str(t.status), str(t).decode('utf8'))) return text
def main(): parser = argparse.ArgumentParser(usage='', add_help=False) parser.add_argument('--project') parser.add_argument('--redmine-url') parser.add_argument('--redmine-key-file') parser.add_argument('--help', action='store_true', default=False) args = vars(parser.parse_args()) if args['project'] is None or args['redmine_url'] is None or args[ 'redmine_key_file'] is None: exit('Invalid usage') try: redmine_key_file = open(args['redmine_key_file'], 'r') redmine_key = redmine_key_file.read().strip('\r\n') except IOError as e: exit('Error reading Redmine API key file \'%s\': %s' % (args['redmine_key_file'], e.strerror)) redmine = Redmine(args['redmine_url'], key=redmine_key, requests={'verify': False}) add_project(project_name=args['project'], redmine=redmine)
def create_report(): try: redmine = Redmine(redmine_url, key = redmine_api_key) except: return False user = redmine.user.get(user_id) spent_time = user.time_entries user_for_xlsx = user.lastname + ' ' + user.firstname dest_filename = os.path.join("reports", start_date.strftime("%d.%m.%Y") + "-" + datetime.datetime.now().strftime("%d.%m.%Y") + "_report_" + user.login + ".xlsx") for entry in spent_time: delta = (datetime.datetime.now() - entry.created_on).days if delta <= 7: iss_subj = redmine.issue.get(entry.issue.id).subject iss_project = redmine.issue.get(entry.issue.id).project.name task = str(entry.issue.id) + ' ' + iss_subj total_spent_time.append(entry.hours) xlsx_data.append([entry.created_on.strftime("%d-%m-%Y"), user_for_xlsx, 'Tech', iss_project, task, float(entry.hours)]) ws1['A1'] = "Date" ws1['B1'] = "Name" ws1['C1'] = "Department" ws1['D1'] = "Project" ws1['E1'] = "Task" ws1['F1'] = "Hours" ws1['A1'].fill = colorFill ws1['B1'].fill = colorFill ws1['C1'].fill = colorFill ws1['D1'].fill = colorFill ws1['E1'] .fill= colorFill ws1['F1'] .fill= colorFill for row in xlsx_data: ws1.append(row) for col in ws1.columns: max_length = 0 column = col[0].column for cell in col: try: if len(str(cell.value)) > max_length: max_length = len(cell.value) except: pass adjusted_width = (max_length + 2) * 2 ws1.column_dimensions[column].width = adjusted_width for i in range(1,100): try: cell = 'E%s' % i len(ws1[cell].value) except TypeError: cell_F = 'F%s' % i ws1[cell] = 'Total' ws1[cell_F] = float(sum(total_spent_time)) wb.save(filename = dest_filename) return dest_filename
def redmine(): if not request.json: print 'Falta datos en el json: ' + str(request.json) abort(400, 'Falta datos en el json: ' + str(request.json)) api_key = app.iniconfig.get('redmine', 'api_key') url = app.iniconfig.get('redmine', 'url') #"commits": [ # { # "id": "b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327", # "message": "Update Catalan translation to e38cb41.", # "timestamp": "2011-12-12T14:27:31+02:00", # "url": "http://example.com/mike/diaspora/commit/b6568db1bc1dcd7f8b4d5a946b0b91f9dacd7327", # "author": { # "name": "Jordi Mallach", # "email": "*****@*****.**" # } # }, # { # "id": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7", # "message": "fixed readme", # "timestamp": "2012-01-03T23:36:29+02:00", # "url": "http://example.com/mike/diaspora/commit/da1560886d4f094c3e6c9ef40349f7d38b5d27d7", # "author": { # "name": "GitLab dev user", # "email": "gitlabdev@dv6700.(none)" # } # } #], #"total_commits_count": 4 redmine = Redmine(url, key=api_key, requests={'verify': False}) request.json['commits'].reverse() branch = request.json['ref'].split('/')[2] default_branch = request.json['project']['default_branch'] note = '' if branch == default_branch: for commit in request.json['commits']: m = match('.*(rel|issue|fix|fixes)\s*#?(\d+)', commit['message'].replace('\n', ' '), IGNORECASE) if m is not None: accion = m.groups()[0].lower() status = None note = '<pre>author: ' + commit['author']['name'] + ' <'+commit['author']['email']+'>\n' + \ 'msg: '+commit['message'] + '</pre>' + 'commit: "' + commit['id'][:8] + '":' + commit['url'] if accion in ('fix', 'fixes'): status = 3 # fix redmine.issues.update(m.groups()[1], notes=note, status_id=status, done_ratio=100) else: redmine.issues.update(m.groups()[1], notes=note, status_id=status) data = {'msg': 'OK'} resp = jsonify(data) resp.status_code = 200 return resp
def _post_teardown(self): super()._post_teardown() redmine = Redmine(self.REDMINE_HOST, key=self.REDMINE_KEY) redmine.project.all().delete() redmine.issue.all().delete() redmine.user.all()[1:].delete()
def _check_project(project_name, username, password, debug=False): redmine = Redmine(REDMINE_URL, username=username, password=password) try: redmine.project.get(project_name) return True except ResourceNotFoundError: return False
def __init__(self): config = get_config() self.redmine = Redmine(config['redmine']['redmine_url'], username=config['redmine']['username'], password=config['redmine']['password']) self.project = self.redmine.project.get( config['redmine']['project_name'])
def test_moves_all_issues_to_new_status(self): redmine = Redmine(api=RedmineMock(issues_as_dict=get_example_issues())) move_issues(IssueStatus.ON_DEVELOP, IssueStatus.TESTING, redmine) assert "12345" in redmine.api.moved_issues[IssueStatus.TESTING] assert "12346" in redmine.api.moved_issues[IssueStatus.TESTING] assert "12347" in redmine.api.moved_issues[IssueStatus.TESTING]
def edit_issue(): redmine = Redmine(app.base_url, key=app.api_key) data = request.json issue = redmine.issue.edit() issue.project_id = data['project_id'] issue.subject = data['subject'] issue.save() return "OK"
def __init__(self, url, entry, simulation): self.url = url self.entry = entry self.simulation = simulation self.redmine = Redmine(url, key=entry) if simulation: print('RedmineHelper is in simulation mode')
def prepare(self): """ Prepares the listener by checking connectivity to configured Redmine instance. While doing so, grabs the issue statuses, too, used for on_fact_stopped. """ from redmine import Redmine from redmine.exceptions import BaseRedmineError verify_ssl = self.get_from_config('verify_ssl') requests_dict = {} if verify_ssl.lower() in ('y', 'true'): logger.info( "Enabling SSL/TLS certificate verification (default CA path)") requests_dict['verify'] = True elif verify_ssl.lower() in ('n', 'false'): logger.warn("Disabling SSL/TLS certificate verification") requests_dict['verify'] = False elif os.path.isfile(verify_ssl): logger.info( "Enabling SSL/TLS certificate verification (custom CA " "path) '%s'", verify_ssl) requests_dict['verify'] = verify_ssl else: logger.error( "verify_ssl = '%s' is not a valid CA cert path nor a " "valid option. Falling back to enabling SSL/TLS verification " "with default CA path", verify_ssl) requests_dict['verify'] = True # setup the redmine instance self.redmine = Redmine( self.get_from_config('server_url'), key=self.get_from_config('api_key'), version=self.get_from_config('version'), requests=requests_dict, ) # fetch the possible activities for time entries time_entry_activities = self.redmine.enumeration.filter( resource='time_entry_activities') # only now the real http request is made, use this as connectivity check try: logger.info( '### Available Redmine activities for using as tag value:') is_first = True for tea in time_entry_activities: self.__activities[tea.id] = (tea.name, is_first) is_first = False logger.info('### ' + tea.name) except (BaseRedmineError, IOError): logger.exception( 'Unable to communicate with redmine server. See error in the following output:' ) # fetch all available issue statuses and filter the default and in work ones as they are the only relevant statuses here self.__filter_issue_statuses()
def filebug(request): redmine = Redmine('http://git.ablesky.com', key=authKey) web_dev = redmine.Group.get(41) client_dev = redmine.Group.get(67) dev_users = [web_dev.users, client_dev.users] dev_group = {} for item in dev_users: for user in item: dev_group[user.id] = user.name return HttpResponse(json.dumps(dev_group))
def submit_to_redmine(redmine_url, api_key, fnm): with codecs.open(fnm, 'r', 'utf-8') as f: contents = f.read() redmine = Redmine(redmine_url, key=api_key) try: for ted in string_to_time_entries(contents): redmine.time_entry.create(**ted) except SSLError: # Because redmine.elegosoft.com is missing an intermediate # certificate: # https://www.sslshopper.com/ssl-checker.html#hostname=redmine.elegosoft.com redmine = Redmine(redmine_url, key=api_key, requests={'verify': False}) for ted in string_to_time_entries(contents): redmine.time_entry.create(**ted)
def get_redmine(self, sender): redmine = self._cache.get(sender) if redmine is None: redmine = Redmine(self.redmine_url) redmine.default_project_id = self.project_id user = User.get_user_by_jid(sender) if user: redmine.key = user.key self._cache[sender] = redmine return redmine
def get_redmine_connection(key): """ Return the Redmine connection. :param key: The api key to connect with :type key: basestring :return: An instantiated Redmine connection object. """ return Redmine(REDMINE_URL, key=key)
def ticket_close(user, ticket_id): redmine = Redmine(settings.REDMINE_API_URL, key=settings.REDMINE_KEY, impersonate=user.login) try: issue = redmine.issue.get(ticket_id) except ResourceNotFoundError: return "Ticket no se encuentra" if issue.status.id == STATUS.CLOSED: return "El /ticket_{} ya esta cerrado!".format(ticket_id) else: redmine.issue.update(ticket_id, status_id=STATUS.CLOSED) return "Acabas de cerrar el /ticket_{}: {}".format(ticket_id, issue.subject)
def _generic_tickets(user, what, **filter_args): redmine = Redmine(settings.REDMINE_API_URL, key=settings.REDMINE_KEY, impersonate=user.login) textos = [] for issue in redmine.issue.filter(**filter_args): kwargs = dict(id=issue.id, project=issue.project, subject=issue.subject) msg = "/ticket_{id} ({project}) {subject}".format(**kwargs) textos.append(msg) if len(textos) > 0: msg = "Estos son los {}:\n".format(what) + "\n".join(textos) else: msg = "No tiene {}".format(what) return msg
def __init__(self, config, db): # Do checks if not config.get('redmine_apikey') or not config.get('redmine_user') \ or not config.get('redmine_url'): return self.redmine_user_id = config.get('redmine_user') self.redmine_apikey = config.get('redmine_apikey') self.redmine_url = config.get('redmine_url') self.session = db self.redm = Redmine(self.redmine_url, key=self.redmine_apikey)
def __init__(self, url, api_key, simulation): self.url = url self.api_key = api_key self.simulation = simulation if not url: raise Exception( "'redmine' parameter is not provided. Check config.yml") self.redmine = Redmine(url, key=api_key) if simulation: print("RedmineHelper is in simulation mode")