def spent_on(self, bot, update, user_data, session): tg_message = update.callback_query.message user_data['spent_on'] = dt.datetime.strptime( update.callback_query.data, '%Y-%m-%d').date() user = find_user(session, update.effective_user.id) if user is None or user.redmine_user.empty(): tg_message.reply_text(m.NOT_FOUND_USER) return tg.ConversationHandler.END redmine = Redmine(url=self.config.redmine_host, key=user.redmine_user.key) issues = self.config.redmine_general_issue for issue in redmine.auth().issues: issues[issue.id] = issue.subject user_data['issues'] = issues buttons = [ InlineKeyboardButton(name, callback_data=str(id)) for id, name in issues.items() ] reply_markup = InlineKeyboardMarkup(build_menu(buttons, n_cols=1)) bot.edit_message_text(m.SET_ISSUE.format( self.track_task_to_str(user_data)), chat_id=tg_message.chat.id, message_id=tg_message.message_id, reply_markup=reply_markup) return SET_ISSUE
def auth_redmine(username, password): redmine = Redmine('http://ticket.wise-paas.com', username=username, password=password) try: redmine.auth() return "ok" except Exception as e: return "auth failed: " + str(e)
def sync_data_from_redmine(self): params = self.env['ir.config_parameter'].sudo() if not any([params.get_param('redmine_timesheet.redmine_api_key'), params.get_param('redmine_timesheet.redmine_url')]): raise UserError(_('Please set redmine api credentials')) try: from redminelib import Redmine except ImportError: raise UserError(_('Missing python dependency, check https://python-redmine.com/')) redmine = Redmine(params.get_param('redmine_timesheet.redmine_url'), key=params.get_param('redmine_timesheet.redmine_api_key')) try: redmine.auth() except Exception as e: raise UserError(_(e)) _logger.info('Connect with Redmine') for project in list(redmine.project.all()): proj_obj = self._get_or_create_project(project) _logger.info("Project: {} - been find in odoo ".format(proj_obj.name)) for task in self._get_tasks_from_project(project): task_obj = self._get_or_create_task(task, proj_obj) _logger.info(u"Task: {} - been find in odoo ".format(task_obj.name)) for time_entry in self._get_time_entrys_from_task(task): self._get_or_create_timesheet(task_obj, time_entry, proj_obj)
def set_key(self, bot: Bot, update: Update, session: Session): tg_user = update.message.from_user user = find_user(session, tg_user.id) if user is None: update.message.reply_text(m.NOT_FOUND_USER) return tg.ConversationHandler.END try: redmine = Redmine(url=self.config.redmine_host, key=update.message.text) redmine.auth() except AuthError: update.message.reply_text(m.INVALID_REDMINE_KEY) user.redmine_user.key = '' session.add(user.redmine_user) session.commit() return tg.ConversationHandler.END user.redmine_user.key = update.message.text session.add(user.redmine_user) session.commit() update.message.reply_text(m.DONE_REDMINE_SETTINGS) update.message.reply_text(m.WELCOME_MESSAGES) return tg.ConversationHandler.END
def get_all_time_entry(self, user, spent_on=None): """Get all time entry from redmine for user. :param tracktime.models.User user: :param spent_on: :rtype: list """ redmine = Redmine(url=self.url, key=user.authkey) try: time_entries = list() r_user_id = redmine.auth().id r_time_entries = redmine.time_entry.filter(user_id=r_user_id, spent_on=spent_on) for r_time_entry in r_time_entries: if 'issue' in dir(r_time_entry): time_entry = TimeEntry(id=r_time_entry.id, user=user, issue_id=r_time_entry.issue.id, spent_on=r_time_entry.spent_on, hours=r_time_entry.hours, comments=r_time_entry.comments) time_entries.append(time_entry) return time_entries except AuthError: return list()
def connect(self, user, pswd): self.redmine = Redmine("https://redmine.sparc-npo.ru", username=user, password=pswd, requests={'verify': False}) try: auth = self.redmine.auth() except AuthError: raise Exception('Invalid login or password provided')
def __init__(self, url, token=None, login=None, password=None): if token is None and (login is None or password is None): raise AttributeError self.api = None # type: RedmineLib if token is None: self.api = RedmineLib(url, username=login.encode('utf-8'), password=password.encode('utf-8')) else: self.api = RedmineLib(url, key=token) self.auth = self.__is_auth()
def __init__(self, username, password): self.username = username self.password = password self.__valid_redmine_login = None self.projects_list = None self.all_projects = None self.issues_dict = None self.redmine = Redmine(constants.REDMINE_URL, username=self.username, password=self.password)
def check_authkey(self, authkey): """Check authorization key. :param string authkey: Authorization key to check :return: True if authorization key is correct """ redmine = Redmine(url=self.url, key=authkey) try: redmine.auth() return True except AuthError: return False
def auth_user(username, password, teste=True, verify=True): url = URLHM if teste else URL fiscaliza = Redmine( url, username=username, password=password, requests={"verify": verify} ) try: fiscaliza.auth() return fiscaliza except ConnectionError: console.print( "[bold red] Sem resposta do Servidor. Verifique: Conexão com a Internet | VPN | Fiscaliza fora do ar" )
def __init__(self): # , url, key): self.url = "**" self.key_admin = "*" self.server_admin = Redmine(self.url, key=self.key_admin) self.key_1 = "*" self.server_1 = Redmine(self.url, key=self.key_1) self.key_2 = "*" self.server_2 = Redmine(self.url, key=self.key_2) self.key_3 = "*" self.server_3 = Redmine(self.url, key=self.key_3) self.key_4 = "*" self.server_4 = Redmine(self.url, key=self.key_4) self.key_5 = "*" self.server_5 = Redmine(self.url, key=self.key_5) self.key_6 = "*" self.server_6 = Redmine(self.url, key=self.key_6) self.key_7 = "*" self.server_7 = Redmine(self.url, key=self.key_7) self.key_8 = "*" self.server_8 = Redmine(self.url, key=self.key_8) self.dict_users = { '*': 297, '*': 201, '*': 207, '*': 280, '*': 274, '*': 289, '*': 291, '*': 279, '*': 294 } self.map_Users = { '*': 297, '*': 201, '*': 207, '*': 280, '*': 274, '*': 289, '*': 291, '*': 279, '*': 294 }
def main(): parser, args = parse_args() commands = args.commands if len(commands) < 1: parser.print_help() if API_ACCESS_KEY is None: print('please set REDMINE_API_ACCESS_KEY') sys.exit(1) redmine = Redmine(SERVER_URL, key=API_ACCESS_KEY) if commands[0] == 'projects': if len(commands) < 2 or commands[1] != 'list': # TODO: display help sys.exit(1) projects = fetch_projects(redmine) print('\n'.join(map(str, projects))) elif commands[0] == 'issues': if len(commands) < 2: # TODO: display help sys.exit(1) if commands[1] == 'list': issue = fetch_issues(redmine) print_issues(issue) elif commands[1] == 'view': if len(commands) < 3: sys.exit(1) issue = fetch_issue(redmine, commands[2]) print_issue(issue) else: # TODO: display help sys.exit(1)
def redmine(update, context): # type: (Update, CallbackContext) -> None from redminelib import Redmine redmine_settings = context.user_data.get('redmine', {}) redmine_address = redmine_settings.get('address', None) redmine_auth_key = redmine_settings.get('auth_key', None) if redmine_address and redmine_auth_key: r = Redmine(redmine_address, key=redmine_auth_key) issues = ','.join(context.args).split(',') message = '' for i in issues: try: d = r.issue.get(i) message += '**' + md2_prepare(f'#{i}: {getattr(d, "subject", "-")}') + '**\n' message += md2_prepare(f'[{getattr(d, "status", "-")}]' f' {getattr(d, "assigned_to", "-")}' f' ({format_time(getattr(d, "total_spent_hours", 0))})\n') for t in d.time_entries: message += md2_prepare(f' - {t.spent_on} {format_time(t.hours)} {t.user} \n') message += '\n' except Exception as e: message += md2_prepare(f'#{i}: {e}\n') update.message.reply_text(message, parse_mode=ParseMode.MARKDOWN_V2) else: redmine_auth(update, context)
def __init__(self, url, username, password): self.username = username self.url = url self.password = password self.redmine = Redmine(self.url, username=self.username, password=self.password)
def connect(self, url, username, password): self.username = username self.url = url self.password = password self.redmine = Redmine(self.url, username=self.username, password=self.password)
def main(): args = parse_option() redmine = Redmine(args.redmineurl, key=args.redminekey) if args.list_project: list_project(redmine) return if args.list_tracker: list_tracker(redmine) return # 日本語の時があるのでunicodeにする channel = args.channel.decode('utf8') username = args.username.decode('utf8') projects = args.projects issues = {} if len(projects) == 0: for p in redmine.project.all(): issues.update( get_issues(p, args.days, args.tracker, args.ignore_nodate)) else: for pid in projects: p = redmine.project.get(pid) issues.update( get_issues(p, args.days, args.tracker, args.ignore_nodate)) if len(issues) > 0: post_slack(issues, username, channel)
def _create_ticket(package): redmine = Redmine(get_redmine_url(), key=get_redmine_apikey()) proj = redmine.project.get(get_redmine_project()) logger.info("Creating redmine issue") url = url_for(controller='package', action='read', id=package['name'], qualified=True) issue = redmine.issue.create(project_id=proj.identifier, subject='{} {}'.format( get_redmine_subject_prefix(), package['title']), description='URL: {}'.format(url)) logger.info("Setting redmine url for package") urltemplate = "{}/issues/{}/" if get_redmine_url().endswith('/'): urltemplate = "{}issues/{}/" set_redmine_url(package, urltemplate.format(get_redmine_url(), issue.id)) logger.info("Done")
def done(self, bot, update, user_data, session): if 'track_task_id' not in user_data: return tg.ConversationHandler.END entry_time = db.find_track(session, user_data['track_task_id']) if entry_time.saved is True: return tg.ConversationHandler.END tg_message = update.callback_query.message track_task = entry_time track_task.issue_id = user_data['issue_id'] track_task.spent_on = user_data['spent_on'] track_task.hours = user_data['hours'] track_task.comments = user_data.get('comment', 'Default bot comments') track_task.saved = True redmine = Redmine(url=self.config.redmine_host, key=track_task.user.redmine_user.key) redmine.time_entry.create(issue_id=track_task.issue_id, hours=track_task.hours, spent_on=track_task.spent_on, comments=track_task.comments) session.add(track_task) session.commit() bot.edit_message_text(m.SAVE_ENTRY_TIME.format( self.track_task_to_str(user_data)), chat_id=tg_message.chat.id, message_id=tg_message.message_id) user_data.clear() return tg.ConversationHandler.END
def create(redmine_tag, redmine_priority, ProjectID, issue_Subject, issue_Body): # Define vars Admin_ID = 76 # Define connect to redmine # Defining constants redmine_conf_file = os.path.dirname( os.path.realpath(__file__)) + '/../conf/redmine.conf' # Get redmine server connect credentials for tmp_line in open(redmine_conf_file): if "server" in tmp_line: redmine_server = str(tmp_line.split("=")[1]).rstrip() if "key" in tmp_line: redmine_key = str(tmp_line.split("=")[1]).rstrip() # Connect to redmine server redmine = Redmine(redmine_server, key=redmine_key) # Search already created issue issueExist = redmine.issue.filter(project_id=ProjectID.strip(), subject=issue_Subject) i = 0 while i < 5: try: if not issueExist: print( time.strftime('%Y-%m-%d %H:%M:%S') + ' Create issue: ' + issue_Subject) issue = redmine.issue.create(project_id=ProjectID.strip(), subject=issue_Subject, tracker_id=3, description=issue_Body, status_id=1, tag_list='zabbix, ' + redmine_tag, priority_id=redmine_priority, assigned_to_id=Admin_ID) else: # If issue created, add comment print( time.strftime('%Y-%m-%d %H:%M:%S') + ' Update issue: ' + issue_Subject) issue = redmine.issue.update(issueExist[0].id, notes=issue_Body) # Error processing except Exception as e: print("Can't access to factory, wait 3 minute") print(e) time.sleep(36) i = i + 1 else: i = 10 # Finally send return code if i != 10: return 1 else: return 0
def on_event(self, event, extension): items = [] logger.info(event.get_argument()) logger.info(extension.preferences['redmine_url']) logger.info(extension.preferences['redmine_api_key']) redmine = Redmine(extension.preferences['redmine_url'], version=extension.preferences['redmine_version'], key=extension.preferences['redmine_api_key']) query = str(event.get_argument()) or str() if len(query) != 0: issue = None try: issue = redmine.issue.get(query) except: issue = None if issue == None: issue_list = list(redmine.issue.search(event.get_argument(), limit=15)) for issue in itertools.islice(issue_list, 15): issue_url = build_issue_url(extension.preferences['redmine_url'], issue) items.append(ExtensionResultItem(icon='images/icon.png', name= issue.title, description='', on_enter=OpenUrlAction(issue_url))) else: issue_url = build_issue_url(extension.preferences['redmine_url'], issue) items.append(ExtensionResultItem(icon='images/icon.png', name= '#' + query + ': ' + issue.subject, description='', on_enter=OpenUrlAction(issue_url))) return RenderResultListAction(items)
def issue_time_entries(issue_id, hours, comments): redmine = Redmine(REDMINE_URL, username=USERNAME, password=PASSWORD) time_entry = redmine.time_entry.new() time_entry.issue_id = issue_id time_entry.hours = hours time_entry.comments = comments time_entry.save()
def auth_redmine_api(self): try: redmine = Redmine(config.REDMINE_URL, key=config.REDMINE_KEY) print("Auth complete\n") return redmine except: sys.exit('Auth redmine failed!')
def commit_create_bug(wechat_user, user_state): if bug_creation_map[user_state['state']].commit: user_state['uploads'] = generate_uploads(user_state) print user_state existed_user = User.query.get(wechat_user) if existed_user is not None: existed_key = Tokens.query.filter_by( user_id=existed_user.redmine_id, action='api').first() redmine_key = existed_key.value else: delete_state(wechat_user) return False, u'没能找到你的注册信息呦,请先注册后重新create bug啦~' config = ConfigParser.RawConfigParser() config.read('{}{}'.format(REDMINE_ROOT, '/config.ini')) redmine = Redmine(url=config.get('redmine', 'url'), key=redmine_key, version=config.get('redmine', 'version')) new_issue = redmine.issue.create(**user_state) if new_issue is not None: delete_state(wechat_user) return True, u'您已成功提交了bug哟' else: return False, u'人家没有能够成功创建bug呢' else: return False, u'当前状态不可以commit bug\n{}'.format( bug_creation_map[user_state['state']].usage_func())
def populate_issue_data(identifier): tickets = [] redmine = Redmine('http://example.redmine.com/', key='your-redmine-api-key') issues = redmine.issue.filter(project_id=identifier, status_id='*') for issue in issues: ticket = {} if hasattr(issue, 'category'): ticket['category'] = issue.category.name ticket['id'] = issue.id ticket['status'] = issue.status.name ticket['subject'] = issue.subject ticket['tracker'] = issue.tracker.name ticket['priority'] = issue.priority.name if hasattr(issue, 'assigned_to'): ticket['assigned_to'] = issue.assigned_to.name ticket['project'] = issue.project.name cd = str(issue.created_on) cd = cd.replace(' ', 'T') ticket['created_on'] = cd if issue.custom_fields.get(22).value != '': ticket['cause'] = issue.custom_fields.get(22).value if issue.custom_fields.get(23).value != '': ticket['factor'] = issue.custom_fields.get(23).value if issue.custom_fields.get( 9) is not None and issue.custom_fields.get(9).value != '': ticket['reproducibility'] = issue.custom_fields.get(9).value tickets.append(ticket) return tickets
def get_ticket_information(): """Redmineのチケット情報とチケットと結びついているSlackチャンネルを取得 """ redmine = Redmine(REDMINE_URL, key=REDMINE_API_KEY) # すべてのチケットを取得 issues = redmine.issue.filter(status_id='open', sort='due_date') projects_past_due_date = defaultdict(list) projects_close_to_due_date = defaultdict(list) today = date.today() close_to_today = today + timedelta(LIMIT) s = Session() all_proj_channels = s.query(ProjectChannel).all() for issue in issues: # due_date属性とdue_dateがnoneの場合は除外 if not getattr(issue, 'due_date', None): continue proj_id = issue.project.id # 全てのプロジェクトチャンネルを獲得 channels = get_proj_channels(proj_id, all_proj_channels) if not channels: # slack channelが設定されていないissueは無視する continue elif issue.due_date < today: # 辞書のkeyと値の例proj_id: ['- 2017-03-31 23872: サーバーセキュリティーの基準を作ろう(@takanory)',] projects_past_due_date[proj_id].append(issue) # issueの期限が1週間以内の場合 elif issue.due_date < close_to_today: projects_close_to_due_date[proj_id].append(issue) # 各プロジェクトのチケット通知をSlackチャンネルに送る。 send_ticket_info_to_channels(projects_past_due_date, all_proj_channels, True) send_ticket_info_to_channels(projects_close_to_due_date, all_proj_channels, False)
def __init__(self, rurl, rid, rpw, ruid, logger): self.redmine = Redmine(rurl, username=rid, password=rpw) self.userid = ruid self.issues = self.redmine.issue.all( sort='priority:desc,due_date:desc') self.count = len(self.issues) self.logger = logger
def alarm(context: CallbackContext) -> None: user_data = context.job.context.user_data api = user_data["api"] chat_id = user_data["chat_id"] issues_new = [] issues_old = [] if "issues_old" in user_data: issues_old = user_data["issues_old"] redmine = Redmine(redmine_url, key=api) issues = redmine.issue.filter(status_id="open", assigned_to_id="me") for issue in issues: issues_new.append(issue.id) if issue.id not in issues_old: txt = "Номер задачи: <a href='{0}/issues/{1}'>{1}</a>\nТема задачи: {2}\nНазначена: {3}\nТрекер: {4}\nСтатус: {5}\nПриоритет: {6}".format( redmine_url, issue.id, issue.subject, issue.assigned_to, issue.tracker, issue.status, issue.priority) context.bot.send_message(chat_id, text=txt, parse_mode=ParseMode.HTML, disable_web_page_preview=True) issues_old = issues_new.copy() user_data["issues_old"] = issues_old
def run(): #Load credentials from local file '.gitlabCredentials' file = open('.redmineCredentials', 'r') credentials = loads(file.read()) address = credentials['address'] username = credentials['username'] password = credentials['password'] try: redmine = Redmine(address, username=username, password=password) #issues = redmine.issue.filter(status_id='*', sort='id') #ids = [ int(id) for id in issues ] #for id in ids: # print(str(id)) firstIssue = redmine.issue.get(1) #for prop in firstIssue: # print(str(prop)) print('"' + str(firstIssue.project) + '"[id=' + str(firstIssue.project.id) + ']=>"' + firstIssue.subject.encode('utf-8') + '"[id=' + str(firstIssue.id) + "]") except: print('Could not connect to "' + address + '"!') print('-' * 60) traceback.print_exc(file=sys.stderr) return -1 reachId = credentials['reachId'] try: reachIssue = redmine.issue.get(reachId) print("Ticket exists!") try: goalIssue = redmine.issue.get(reachId + 1) print("Too late...") except: print("Creating new issue...") try: goalIssue = redmine.issue.create( project_id=credentials['newIssue']['projectId'], subject=credentials['newIssue']['subject'], tracker_id=credentials['newIssue']['trackerId'], description=credentials['newIssue']['description'], status_id=credentials['newIssue']['statusId'], priority_id=credentials['newIssue']['priorityId'], assigned_to_id=credentials['newIssue']['assignedToId']) print("OK!") except: print("Could not create new ticket!!") print('-' * 60) traceback.print_exc(file=sys.stderr) return -3 except ResourceNotFoundError: print('Reach ticket does not yet exist. Doing nothing...') except: print("Unknown error occured!") print('-' * 60) traceback.print_exc(file=sys.stderr) return -2 return 0
def redmine_setup(api_key): """ :param api_key: API key available from your Redmine user account settings. Stored in setup.py. :return: instantiated Redmine API object """ redmine_url = 'https://redmine.biodiversity.agr.gc.ca/' redmine = Redmine(redmine_url, key=api_key, requests={'verify': False}) return redmine
def login(self, url, user, passwd): try: self.redmine = Redmine(url, username=user, password=passwd) log.info('logged in with {} on {}'.format(user, url)) except Exception as e: log.error( 'fail to log redmine, please check url/username/password. detail: {}' .format(e))