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 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 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 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_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 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 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 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 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 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 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 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 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 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 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 __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 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 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 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 _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 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 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))
def client(self):
if not self.verify:
disable_warnings(InsecureRequestWarning)
del os.environ["REQUESTS_CA_BUNDLE"]
return Redmine(self.endpoint,
key=self.apikey,
requests={"verify": self.verify})
def check_issue_status(branch):
refnum = get_ticket_num(branch)
print refnum
if refnum is None:
return False
redmine = Redmine(config.redmine_url, username=config.usr, password = config.passw)
issue = redmine.issue.get(resource_id=refnum)
return issue.status.id in redmine_statuses
def connect(self):
try:
self.redmine_instance = Redmine(self.url,
username=self.username,
password=self.password)
except Exception, e:
print "ERROR >> %s" % str(e)
exit(1)
def __init__(self, url, key=None, admin_key=None, custom_fields_to_id=None, *args, **kwargs):
"""
Custom field definitions can only be retrieved with admin privileges. To use custom fields, you can:
- supply a `custom_fields_to_id` dict that maps custom field names to ids
- provide an API key with admin rights as `key`
- provide an API key with admin rights as `admin_key` in addition to an unprivileged API key as `key`.
The admin API key will only be used to retrieve the list of custom fields.
"""
self.api = Redmine(url, *args, key=key, **kwargs)
if custom_fields_to_id is not None:
self.custom_fields_to_id = custom_fields_to_id
if admin_key is None:
self.admin_api = self.api
else:
self.admin_api = Redmine(url, *args, key=admin_key, **kwargs)
def set_Redmine():
REDMINE_URL = 'http://redmine.meizu.com' #redmine 的地址
REDMINE_KEY = 'fb88cc2ee088296f1cfeac00846cdac197cba867' #这个是自己redmine的账号
redmine = Redmine(REDMINE_URL, key=REDMINE_KEY)
issues = redmine.issue.all(project_id='M1809',
status_id='*',
tracker_id=23)
return issues
def ret_key(name, password, domain):
redmine = Redmine(domain, username=name, password=password).auth()
api = redmine.api_key
return json.dumps({
'api_key': api,
'name': redmine
},
ensure_ascii=False,
default=str)
def print_all_ticket():
try:
redmine = Redmine('url', key='token_key')
issues = redmine.issue.all(sort='category:desc')
for issue in issues:
print('%d:%s' % (issue.id, issue.subject, issue.project_id))
except (ResourceNotFoundError):
print(ResourceNotFoundError)
