def __init__(self, tracker):
super().__init__(tracker)
if not self.is_adding_testcase_to_issue_disabled():
self.rpc = redminelib.Redmine(self.tracker.api_url,
username=self.tracker.api_username,
password=self.tracker.api_password)
def submitIssue(self, ticket_type, is_critical, subject, description,
reproduction, add_log):
def wrap(text):
return html.escape(text).replace('\n\n', '</p><p>'). \
replace('\n', '<br/>')
full_desc = '<p>' + wrap(description) + '</p>'
if reproduction:
full_desc += '\n\n<p><b>Reproduction:</b></p>' + \
'<p>' + wrap(reproduction) + '</p>'
if self.traceback:
full_desc += '\n\n<p><b>Traceback:</b></p>\n' + \
'<pre>' + html.escape(self.traceback) + '</pre>'
if add_log and self.log_excerpt:
full_desc += '\n\n<p><b>Log excerpt:</b></p>\n' + \
'<pre>' + html.escape(self.log_excerpt) + '</pre>'
rm = redminelib.Redmine(TRACKER_URL, key=self.apikey)
issue = rm.issue.new()
issue.project_id = PROJECT_ID
issue.subject = subject
trackers = rm.tracker.all()
tracker_id = [t.id for t in trackers if t.name == ticket_type][0]
issue.tracker_id = tracker_id
issue.description = full_desc
if is_critical:
prios = rm.enumeration.filter(resource='issue_priorities')
prio_id = [p.id for p in prios if p.name == 'Urgent'][0]
issue.priority_id = prio_id
if self.instrument != 'none':
issue.custom_fields = [{'id': 1, 'value': self.instrument}]
issue.save()
return issue.id
def connect():
for n, m in [
('environ', lambda:(
os.environ.get('REDMINE_USERNAME').strip(),
os.environ.get('REDMINE_PASSWORD').strip(),
),
),
('keyring', lambda:(
keyring.get_password('redmine', 'username'),
keyring.get_password('redmine', 'password')
),
),
]:
try:
username, password = m()
break
except Exception as e:
print("failed to get credentials", n, e)
print("got credentials for", username)
redmine = redminelib.Redmine(redmine_url,
username=username,
password=password)
return redmine
def _queryDetails(self):
dlg = QDialog(self)
dlg.setWindowTitle('Login details for ticket tracker required')
layout = QGridLayout()
layout.addWidget(
QLabel(
'Please enter details for the ticket tracker. '
'You can contact the instrument control group '
'for help.', dlg))
layout.addWidget(QLabel('Instrument name:', dlg))
instrBox = QLineEdit(self.instrument, dlg)
instrBox.setEnabled(self.instrument != 'none')
layout.addWidget(instrBox)
noinstrBox = QCheckBox('No instrument', dlg)
noinstrBox.setChecked(self.instrument == 'none')
noinstrBox.toggled.connect(lambda c: instrBox.setEnabled(not c))
layout.addWidget(noinstrBox)
layout.addWidget(QLabel('Username:'******'Password:'******'Login successful. Your API key has been stored '
'for further reports.')
settings = CompatSettings('nicos', 'secrets')
settings.beginGroup('Redmine')
if noinstrBox.isChecked():
self.instrument = 'none'
else:
self.instrument = instrBox.text()
self.apikey = apikey
self.username = userBox.text()
settings.setValue('instrument', self.instrument)
settings.setValue('apikey', self.apikey)
settings.setValue('username', self.username)
if not self.instrument or not self.apikey:
return False
self.titleLabel.setText(
'Submit a ticket for instrument "%s" (as user %s)' %
(self.instrument, self.username))
return True
def handle(self, *args, **options):
redmine = redminelib.Redmine(
settings.REDMINE_URL,
key=settings.REDMINE_APIKEY,
requests={
"auth": (
settings.REDMINE_HTACCESS_USER,
settings.REDMINE_HTACCESS_PASSWORD,
)
},
)
last_days = options["last_days"]
# today is excluded
end = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
start = end - timedelta(days=last_days)
# get projects with reports in given last days
affected_projects = (Project.objects.filter(
archived=False,
redmine_project__isnull=False,
tasks__reports__updated__range=[start, end],
).annotate(count_reports=Count("tasks__reports")).filter(
count_reports__gt=0).values("id"))
# calculate total hours
projects = (Project.objects.filter(
id__in=affected_projects).order_by("name").annotate(
total_hours=Sum("tasks__reports__duration")))
for project in projects:
estimated_hours = (project.estimated_time.total_seconds() /
3600 if project.estimated_time else 0.0)
total_hours = project.total_hours.total_seconds() / 3600
try:
issue = redmine.issue.get(project.redmine_project.issue_id)
reports = Report.objects.filter(
task__project=project,
updated__range=[start, end]).order_by("date")
hours = reports.aggregate(hours=Sum("duration"))["hours"]
issue.notes = template.render({
"project": project,
"hours": hours.total_seconds() / 3600,
"last_days": last_days,
"total_hours": total_hours,
"estimated_hours": estimated_hours,
"reports": reports,
})
issue.custom_fields = [{
"id": settings.REDMINE_SPENTHOURS_FIELD,
"value": total_hours
}]
issue.save()
except redminelib.exceptions.BaseRedmineError:
sys.stderr.write("Project {0} has an invalid Redmine "
"issue {1} assigned. Skipping".format(
project.name,
project.redmine_project.issue_id))
def handle(self, *args, **options):
redmine = redminelib.Redmine(settings.REDMINE_URL,
key=settings.REDMINE_APIKEY,
requests={
'auth':
(settings.REDMINE_HTACCESS_USER,
settings.REDMINE_HTACCESS_PASSWORD)
})
last_days = options['last_days']
# today is excluded
end = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
start = end - timedelta(days=last_days)
# get projects with reports in given last days
affected_projects = Project.objects.filter(
archived=False,
redmine_project__isnull=False,
tasks__reports__updated__range=[start, end]).annotate(
count_reports=Count('tasks__reports'), ).filter(
count_reports__gt=0).values('id')
# calculate total hours
projects = Project.objects.filter(id__in=affected_projects).annotate(
total_hours=Sum('tasks__reports__duration'))
for project in projects:
estimated_hours = (project.estimated_time and
project.estimated_time.total_seconds() / 3600)
total_hours = project.total_hours.total_seconds() / 3600
try:
issue = redmine.issue.get(project.redmine_project.issue_id)
reports = Report.objects.filter(
task__project=project,
updated__range=[start, end]).order_by('date')
hours = reports.aggregate(hours=Sum('duration'))['hours']
issue.notes = render_to_string(
'redmine/weekly_report.txt', {
'project': project,
'hours': hours.total_seconds() / 3600,
'last_days': last_days,
'total_hours': total_hours,
'estimated_hours': estimated_hours,
'reports': reports
},
using='text')
issue.custom_fields = [{
'id': settings.REDMINE_SPENTHOURS_FIELD,
'value': total_hours
}]
issue.save()
except redminelib.exceptions.BaseRedmineError:
sys.stderr.write('Project {0} has an invalid Redmine '
'issue {1} assigned. Skipping'.format(
project.name,
project.redmine_project.issue_id))
def __init__(self, config):
self._config = config
self._redmine = redminelib.Redmine(config['url'], key=config['api_key'])
self._last_updated = None
self._update_lock = Lock()
self.open_closed_timeline = {}
self.contributions = {}
self.issues_in_progress = []
self.issues_closed = []
self.issue_states_data = {}
def run(self, context):
sources = self.getarg('src', context)
dst_folder = self.getarg('local_dst', context)
issue_subject = self.getarg('subject', context, parse_yaml=False)
template_path = self.getarg('template', context)
key = self.getarg('api_key', context)
self.log_info(f"Create Redmine issue '{issue_subject}'.")
self.log_debug(f"Template: {template_path}, Source File(s): {sources}")
presentation_list = self.get_presentation_list(sources, dst_folder)
redmine_template = self.get_template(context, template_path)
redmine_template.globals['urlencode'] = urllib.parse.quote
issue_description = redmine_template.render(
presentation_list=presentation_list)
with ChangeDirectory(dst_folder):
with open("./issue_description.txt", 'w') as outfile:
outfile.write(issue_description)
url = 'https://dev.ec-earth.org'
redmine = redminelib.Redmine(url, key=key)
self.log_debug("Connecting to Redmine.")
issue = self.get_issue(redmine, issue_subject)
self.log_debug("Updating the issue description.")
issue.description = ""
for line in issue_description:
issue.description += line
self.log_debug("Uploading attachments.")
issue.uploads = []
for item in presentation_list:
if item['presentation_type'] == 'image':
file_name = os.path.basename(item['path'])
try:
for attachment in issue.attachments or []:
if attachment.filename == file_name:
redmine.attachment.delete(attachment.id)
except redminelib.exceptions.ResourceNotFoundError:
pass
issue.uploads.append({
'filename': file_name,
'path': f"{dst_folder}/{file_name}"
})
self.log_debug("Saving issue.")
issue.save()
#!/usr/bin/env python
import redminelib
# REST API is enabled by default in our container, otherwise go to
# Administration -> Settings -> API to enable it by hand
rpc = redminelib.Redmine(
"http://bugtracker.kiwitcms.org:3000",
username="******",
password="******",
)
# tracker & issue statuses must be configured before hand b/c
# Redmine API doesn't support creating them!
tracker = rpc.tracker.all()[0]
status = rpc.issue_status.all()[0]
# priority must also be configure before hand b/c Redmine doesn't
# expose creation via its API
priority = rpc.enumeration.filter(resource="issue_priorities")[0]
project = rpc.project.create(
name="Integration with Kiwi TCMS",
identifier="kiwitcms",
tracker_ids=[tracker.id],
)
# http://bugtracker.kiwitcms.org:3000/issues/1
issue = rpc.issue.create(
subject="Hello Redmine",
def _rpc_connection(self):
return redminelib.Redmine(self.bug_system.api_url,
username=self.bug_system.api_username,
password=self.bug_system.api_password)
else:
raise Exception(
"Not valid path for ffuf wordlist, if you don't want tou use it just fill it empty in the settings.json file"
)
if settings['WAPPALIZE_KEY'] != '':
WAPPA_KEY = settings['WAPPALIZE_KEY']
# Redmine connection
REDMINE_URL = settings['REDMINE']['url']
REDMINE_USER = settings['REDMINE']['user']
REDMINE_PASSWORD = settings['REDMINE']['password']
try:
if REDMINE_URL != '' and REDMINE_USER != '' and REDMINE_PASSWORD != '':
redmine_client = redminelib.Redmine(str(REDMINE_URL),
username=str(REDMINE_USER),
password=str(REDMINE_PASSWORD),
requests={'verify': False})
redmine_client.project.all()[0]
except requests.exceptions.MissingSchema:
redmine_client = None
raise Exception("Missing schema for redmine")
except redminelib.exceptions.AuthError:
redmine_client = None
raise Exception("Redmine authentication error, check your credentials")
except Exception:
redmine_client = None
raise Exception(
"Somethig went wrong with the redmine, check credencials and url in settings.json configuration file"
)
#Nessus Connection
import os
import redminelib
KEY = os.environ.get('KEY')
r = redminelib.Redmine('https://pedidos.econo.unlp.edu.ar', key=KEY)
r.project()
#!/usr/bin/env python
import redminelib
# REST API is enabled by default in our container, otherwise go to
# Administration -> Settings -> API to enable it by hand
rpc = redminelib.Redmine(
'http://bugtracker.kiwitcms.org:3000',
username='******',
password='******',
)
# tracker & issue statuses must be configured before hand b/c
# Redmine API doesn't support creating them!
tracker = rpc.tracker.all()[0]
status = rpc.issue_status.all()[0]
# priority must also be configure before hand b/c Redmine doesn't
# expose creation via its API
priority = rpc.enumeration.filter(resource='issue_priorities')[0]
project = rpc.project.create(
name='Integration with Kiwi TCMS',
identifier='kiwitcms',
tracker_ids=[tracker.id],
)
# http://bugtracker.kiwitcms.org:3000/issues/1
issue = rpc.issue.create(
subject='Hello Redmine',
def __init__(self, config):
self._config = config
self._redmine = redminelib.Redmine(config['url'], key=config['api_key'])
self._cached_data = Tasks.CachedData(config)
