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")
