def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by user_name on %s. Copyright 2016 organization_name. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-V', '--version', action='version', version=program_version_message) parser.add_argument('--agilefant-host', dest='agilefant_host', default='127.0.0.1', help='Host IP of the Agilefant database (default: 127.0.0.1') parser.add_argument('--agilefant-user', dest='agilefant_user', default='agilefant', help='Agilefant database user (default: agilefant)') parser.add_argument('--afilefant-password', dest='agilefant_password', default='agilefant', help='Agilefant database password for the defined user (default: agilefant)') parser.add_argument('--agilefant-db', dest='agilefant_db', default='agilefant', help='Agilefant database name (default: agilefant)') parser.add_argument('--taiga-host', dest='taiga_host', default='127.0.0.1', help='Host IP or FQDN of the Taiga API server (default: 127.0.0.1)') # Process arguments args = parser.parse_args() cnx = mysql.connector.connect(user=args.agilefant_user, password=args.agilefant_password, host=args.agilefant_host, database=args.agilefant_db) taiga = TaigaAPI(host='http://%s' % args.taiga_host) taiga.auth(username='******',password='******') migrate_products(cnx, taiga=taiga) cnx.close() except KeyboardInterrupt: ### handle keyboard interrupt ### return 0 except Exception as e: if DEBUG or TESTRUN: raise(e) indent = len(program_name) * " " sys.stderr.write(program_name + ": " + repr(e) + "\n") sys.stderr.write(indent + " for help use --help") return 2
def taiga_api(self): us = UserService.objects.get(user=self.user, name='ServiceTaiga') if us.token: api = TaigaAPI(token=us.token, host=us.host) else: api = TaigaAPI(host=us.host) api.auth(us.username, us.password) return api
def create_issue(self, request, group, form_data, **kwargs): url = self.get_option('taiga_url', group.project) username = self.get_option('taiga_username', group.project) password = self.get_option('taiga_password', group.project) project_slug = self.get_option('taiga_project', group.project) labels = self.get_option('taiga_labels', group.project) tg = TaigaAPI(host=url) try: tg.auth(username=username, password=password) except Exception as e: raise forms.ValidationError(_('Error Communicating ' 'with Taiga: %s') % (e,)) projects = tg.projects.list() project = projects.get(slug=project_slug) if project is None: raise forms.ValidationError(_('No project found in Taiga with slug %s') % (project_slug,)) if not project.is_issues_activated: raise forms.ValidationError(_('Project %s has issues disabled.') % (project_slug,)) default_priority = project.default_priority default_issue_status = project.default_issue_status default_issue_type = project.default_issue_type default_severity = project.default_severity if default_priority is None: raise forms.ValidationError(_('Project %s has no default priority. ' 'Set the default priority in Taiga') % (project.name,)) if default_issue_status is None: raise forms.ValidationError(_('Project %s has no default status. ' 'Set the default issue status in Taiga') % (project.name,)) if default_issue_type is None: raise forms.ValidationError(_('Project %s has no default type. ' 'Set the default issue type in Taiga') % (project.name,)) if default_severity is None: raise forms.ValidationError(_('Project %s has no default severity. ' 'Set the default severity in Taiga') % (project.name,)) data = {'subject': form_data['title'], 'priority': default_priority, 'status': default_issue_status, 'issue_type': default_issue_type, 'severity': default_severity, 'description': form_data['description'], 'tags': map(lambda x:x.strip(), labels.split(","))} issue = project.add_issue(**data) return issue.ref
def api(self): if not self._api: api = TaigaAPI(host=self.host) if self.token: api.token = self.token else: if not self.username or not self.password: raise j.exceptions.Runtime("Token or username and password are required") api.auth(self.username, self.password) self._api = api return self._api
def create_issue(self, request, group, form_data, **kwargs): api = self.get_option('taiga_api', group.project) username = self.get_option('taiga_username', group.project) password = self.get_option('taiga_password', group.project) project_slug = self.get_option('taiga_project', group.project) labels = self.get_option('taiga_labels', group.project) tg = TaigaAPI(host=api) try: tg.auth(username=username, password=password) except Exception as e: raise forms.ValidationError( _('Error Communicating ' 'with Taiga: %s') % (e, )) project = tg.projects.get_by_slug(slug=project_slug) if project is None: raise forms.ValidationError( _('No project found in Taiga with slug %s') % (project_slug, )) default_issue_status = project.default_issue_status priority = project.default_priority issue_type = project.default_issue_type severity = project.default_severity if default_issue_status is None: raise forms.ValidationError( _('Project %s has no default status. ' 'Set the default issue status in Taiga') % (project.name, )) if not labels: labels = '' data = { 'subject': form_data['title'], 'status': default_issue_status, 'description': form_data['description'], 'priority': priority, 'issue_type': issue_type, 'severity': severity, 'tags': [label.strip() for label in labels.split(",") if label] } if self.is_issue(group.project): issue = project.add_issue(**data) else: issue = project.add_user_story(**data) return issue.ref
def create_taiga_channels(self, username, password, desc, course_id): api = TaigaAPI() try: api.auth(username=username, password=password) except: return 'invalid auth' group_data = self.get_groupsdata(course_id) for key in group_data: new_project = api.projects.create(key, desc) new_project.is_private = "false" new_project.update() for member in group_data[key]: email = member + '@asu.edu' new_project.add_membership(role=new_project.roles[0].id, username=email, email=email)
class TaigaClient(JSConfigClient): _SCHEMATEXT = """ @url = jumpscale.taiga.clients name** = "" (S) username = "" (S) password_ = "" (S) token_ = "" (S) host = "https://projects.threefold.me" """ def _init(self, **kwargs): self.api = TaigaAPI(host=self.host) if self.token_: self.api.token = self.token_ else: if not self.username or not self.password_: raise RuntimeError("username and password are required") self.api.auth(self.username, self.password_)
def create_issue(self, request, group, form_data, **kwargs): url = self.get_option('taiga_url', group.project) username = self.get_option('taiga_username', group.project) password = self.get_option('taiga_password', group.project) project_slug = self.get_option('taiga_project', group.project) tg = TaigaAPI(host=url) try: tg.auth(username=username, password=password) except Exception as e: raise forms.ValidationError( _('Error Communicating ' 'with Taiga: %s') % (e, )) project = tg.projects.get_by_slug(slug=project_slug) if project is None: raise forms.ValidationError( _('No project found in Taiga with slug %s') % (project_slug, )) default_us_status = project.default_us_status if default_us_status is None: raise forms.ValidationError( _('Project %s has no default status. ' 'Set the default user story status in Taiga') % (project.name, )) data = { 'subject': form_data['title'], 'status': default_us_status, 'description': form_data['description'], 'tags': map(lambda x: x.strip(), labels.split(",")) } us = project.add_user_story(**data) return us.ref
def test_auth_success(self, requests): requests.post.return_value = MockResponse( 200, create_mock_json('tests/resources/auth_user_success.json')) api = TaigaAPI(host='host') api.auth('valid_user', 'valid_password') self.assertEqual(api.token, 'f4k3')
def test_auth_success(self, requests): requests.post.return_value = MockResponse(200, create_mock_json('tests/resources/auth_user_success.json')) api = TaigaAPI(host='host') api.auth('valid_user', 'valid_password') self.assertEqual(api.token, 'f4k3')
from taiga import TaigaAPI import config as c import logging from send import send logging.basicConfig(level=logging.DEBUG) api = TaigaAPI() api.auth(username=c.TAIGA_USER, password=c.TAIGA_PASSWORD) logging.info('Initializing connection and authenticating ...') project = api.projects.get_by_slug(c.PROJECT_SLUG) logging.info('Getting user stories ...') user_stories = api.user_stories.list(project=project.id) user_story_dict = {x.id: x.name for x in project.list_user_story_statuses()} user_story_dict_inv = { x.name: x.id for x in project.list_user_story_statuses() } current_sprints = list(filter(lambda x: not x.closed, project.milestones)) current_sprints = sorted(current_sprints, key=lambda x: x.id) assert len( current_sprints ) >= 2, "There must be at least 2 active sprints to migrate to a new sprint" new_sprint = current_sprints[-1] old_sprint = current_sprints[-2]
#!/usr/bin/env python3 from taiga import TaigaAPI import email.parser import sys import os body = email.parser.Parser().parsestr(sys.stdin.read()) text = body.get_payload() if not body.is_multipart() else body.get_payload(i=0) api = TaigaAPI(host=os.environ.get('TAIGA_HOST', 'http://z.ero.cool/')) api.auth(username=os.environ.get('TAIGA_USER', 'email'), password=os.environ.get('TAIGA_PASS', None)) project = api.projects.get(os.environ.get('TAIGA_PROJECT', '2')) project.add_user_story(body['Subject'], description="""\ From: {fro} Message-Id: {messageid} {text} """.format(fro=body['From'], messageid=body['Message-Id'], text=text))
def manage_issue( module, taiga_host, project_name, issue_subject, issue_priority, issue_status, issue_type, issue_severity, issue_description, issue_attachment, issue_attachment_description, issue_tags, state, check_mode=False, ): """ Method that creates/deletes issues depending whether they exist and the state desired The credentials should be passed via environment variables: - TAIGA_TOKEN - TAIGA_USERNAME and TAIGA_PASSWORD Returns a tuple with these elements: - A boolean representing the success of the operation - A descriptive message - A dict with the issue attributes, in case of issue creation, otherwise empty dict """ changed = False try: token = getenv("TAIGA_TOKEN") if token: api = TaigaAPI(host=taiga_host, token=token) else: api = TaigaAPI(host=taiga_host) username = getenv("TAIGA_USERNAME") password = getenv("TAIGA_PASSWORD") if not any([username, password]): return (False, changed, "Missing credentials", {}) api.auth(username=username, password=password) user_id = api.me().id project_list = filter(lambda x: x.name == project_name, api.projects.list(member=user_id)) if len(project_list) != 1: return (False, changed, "Unable to find project %s" % project_name, {}) project = project_list[0] project_id = project.id priority_list = filter(lambda x: x.name == issue_priority, api.priorities.list(project=project_id)) if len(priority_list) != 1: return ( False, changed, "Unable to find issue priority %s for project %s" % (issue_priority, project_name), {}, ) priority_id = priority_list[0].id status_list = filter(lambda x: x.name == issue_status, api.issue_statuses.list(project=project_id)) if len(status_list) != 1: return (False, changed, "Unable to find issue status %s for project %s" % (issue_status, project_name), {}) status_id = status_list[0].id type_list = filter(lambda x: x.name == issue_type, project.list_issue_types()) if len(type_list) != 1: return (False, changed, "Unable to find issue type %s for project %s" % (issue_type, project_name), {}) type_id = type_list[0].id severity_list = filter(lambda x: x.name == issue_severity, project.list_severities()) if len(severity_list) != 1: return (False, changed, "Unable to find severity %s for project %s" % (issue_severity, project_name), {}) severity_id = severity_list[0].id issue = { "project": project_name, "subject": issue_subject, "priority": issue_priority, "status": issue_status, "type": issue_type, "severity": issue_severity, "description": issue_description, "tags": issue_tags, } # An issue is identified by the project_name, the issue_subject and the issue_type matching_issue_list = filter(lambda x: x.subject == issue_subject and x.type == type_id, project.list_issues()) matching_issue_list_len = len(matching_issue_list) if matching_issue_list_len == 0: # The issue does not exist in the project if state == "present": # This implies a change changed = True if not check_mode: # Create the issue new_issue = project.add_issue( issue_subject, priority_id, status_id, type_id, severity_id, tags=issue_tags, description=issue_description, ) if issue_attachment: new_issue.attach(issue_attachment, description=issue_attachment_description) issue["attachment"] = issue_attachment issue["attachment_description"] = issue_attachment_description return (True, changed, "Issue created", issue) else: # If does not exist, do nothing return (True, changed, "Issue does not exist", {}) elif matching_issue_list_len == 1: # The issue exists in the project if state == "absent": # This implies a change changed = True if not check_mode: # Delete the issue matching_issue_list[0].delete() return (True, changed, "Issue deleted", {}) else: # Do nothing return (True, changed, "Issue already exists", {}) else: # More than 1 matching issue return ( False, changed, "More than one issue with subject %s in project %s" % (issue_subject, project_name), {}, ) except TaigaException: msg = "An exception happened: %s" % sys.exc_info()[1] return (False, changed, msg, {})
def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by user_name on %s. Copyright 2016 organization_name. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-V', '--version', action='version', version=program_version_message) parser.add_argument( '--agilefant-host', dest='agilefant_host', default='127.0.0.1', help='Host IP of the Agilefant database (default: 127.0.0.1') parser.add_argument( '--agilefant-user', dest='agilefant_user', default='agilefant', help='Agilefant database user (default: agilefant)') parser.add_argument( '--afilefant-password', dest='agilefant_password', default='agilefant', help= 'Agilefant database password for the defined user (default: agilefant)' ) parser.add_argument( '--agilefant-db', dest='agilefant_db', default='agilefant', help='Agilefant database name (default: agilefant)') parser.add_argument( '--taiga-host', dest='taiga_host', default='127.0.0.1', help='Host IP or FQDN of the Taiga API server (default: 127.0.0.1)' ) # Process arguments args = parser.parse_args() cnx = mysql.connector.connect(user=args.agilefant_user, password=args.agilefant_password, host=args.agilefant_host, database=args.agilefant_db) taiga = TaigaAPI(host='http://%s' % args.taiga_host) taiga.auth(username='******', password='******') migrate_products(cnx, taiga=taiga) cnx.close() except KeyboardInterrupt: ### handle keyboard interrupt ### return 0 except Exception as e: if DEBUG or TESTRUN: raise (e) indent = len(program_name) * " " sys.stderr.write(program_name + ": " + repr(e) + "\n") sys.stderr.write(indent + " for help use --help") return 2
from taiga import TaigaAPI import argparse parser = argparse.ArgumentParser(description='Create Taiga issue') parser.add_argument('--user', dest='user') parser.add_argument('--passwd', dest='passwd') parser.add_argument('--project', dest='project') parser.add_argument('--storyid', dest='storyid') parser.add_argument('--status', dest='status') args = parser.parse_args() api = TaigaAPI() api.auth(username=args.user, password=args.passwd) proj = api.projects.get_by_slug(args.project) us = proj.list_user_stories().get(ref=int(args.storyid)) us.update(status=proj.list_user_story_statuses().get(name=args.status).id)
from taiga import TaigaAPI from settings import USER, PASS api = TaigaAPI() api.auth( username=USER, password=PASS) me = api.me() #Search for the members of all your projects members = [] projects = api.projects.list(member=me.id) for project in projects: members += project.members #Get the username of the members for user_id in list(set(members)): user = api.users.get(user_id) print "({1}) {0}".format(user.username, user.id)
def init_taiga_api(host, username, password): api = TaigaAPI(host=host) api.auth(username=username, password=password) return api
def test_auth_success(self, requests): requests.post.return_value = MockResponse( 200, create_mock_json("tests/resources/auth_user_success.json")) api = TaigaAPI(host="host") api.auth("valid_user", "valid_password") self.assertEqual(api.token, "f4k3")
# -*- coding: utf-8 -*- from taiga import TaigaAPI from taiga.exceptions import TaigaException api = TaigaAPI(host='http://127.0.0.1:8000') api.auth(username='******', password='******') print(api.me()) new_project = api.projects.create('TEST PROJECT', 'TESTING API') new_project.name = 'TEST PROJECT 3' new_project.update() print(new_project.members) for member in new_project.members: print(member) jan_feb_milestone = new_project.add_milestone('New milestone jan feb', '2015-01-26', '2015-02-26') userstory = new_project.add_user_story('New Story', description='Blablablabla', milestone=jan_feb_milestone.id) userstory.attach('README.md') userstory.add_task('New Task 2', new_project.task_statuses[0].id).attach('README.md')
import datetime, pickle, os from taiga import TaigaAPI from settings import USER, PASS, TEAM, OUTPUT_FOLDER from taiga_reports.snapshot import Snapshot api = TaigaAPI(); api.auth( username=USER, password=PASS) Snapshot(OUTPUT_FOLDER,api,TEAM)
def create_issue(self, request, group, form_data, **kwargs): url = self.get_option('taiga_url', group.project) username = self.get_option('taiga_username', group.project) password = self.get_option('taiga_password', group.project) project_slug = self.get_option('taiga_project', group.project) labels = self.get_option('taiga_labels', group.project) tg = TaigaAPI(host=url) try: tg.auth(username=username, password=password) except Exception as e: raise forms.ValidationError( _('Error Communicating ' 'with Taiga: %s') % (e, )) projects = tg.projects.list() project = projects.get(slug=project_slug) if project is None: raise forms.ValidationError( _('No project found in Taiga with slug %s') % (project_slug, )) if not project.is_issues_activated: raise forms.ValidationError( _('Project %s has issues disabled.') % (project_slug, )) default_priority = project.default_priority default_issue_status = project.default_issue_status default_issue_type = project.default_issue_type default_severity = project.default_severity if default_priority is None: raise forms.ValidationError( _('Project %s has no default priority. ' 'Set the default priority in Taiga') % (project.name, )) if default_issue_status is None: raise forms.ValidationError( _('Project %s has no default status. ' 'Set the default issue status in Taiga') % (project.name, )) if default_issue_type is None: raise forms.ValidationError( _('Project %s has no default type. ' 'Set the default issue type in Taiga') % (project.name, )) if default_severity is None: raise forms.ValidationError( _('Project %s has no default severity. ' 'Set the default severity in Taiga') % (project.name, )) data = { 'subject': form_data['title'], 'priority': default_priority, 'status': default_issue_status, 'issue_type': default_issue_type, 'severity': default_severity, 'description': form_data['description'], 'tags': map(lambda x: x.strip(), labels.split(",")) } issue = project.add_issue(**data) return issue.ref
from __future__ import print_function import tkinter as tk from tkinter import messagebox from flask import Flask, flash, redirect, render_template, request, url_for from taiga import TaigaAPI import pdb import sys import pymysql api = TaigaAPI() api.auth(username='******', password='******') root = tk.Tk() root.withdraw() pdb.set_trace() new_project = api.projects app = Flask(__name__) db = pymysql.connect(host='localhost', database='users', user='******', password='******', autocommit=True) cur = db.cursor() @app.route('/') def index(): return render_template('index.html')
from taiga import TaigaAPI import re import os import time BOT_ID = os.environ.get('BOT_ID') TG_PATTERN = 'tg#' TG_BASE_URL = os.environ.get('taiga_host') TG_USER = os.environ.get('taiga_user') TG_PASSWORD = os.environ.get('taiga_pass') TG_PROJECT = os.environ.get('taiga_project') slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN')) api = TaigaAPI(host=TG_BASE_URL) api.auth(username=TG_USER, password=TG_PASSWORD) def fetch_taiga(message, channel, thread, user): m = set(re.findall('tg#\d*', message.lower())) attachments = [] if m: for match in m: print(match) text_response = "" project = api.projects.get_by_slug(TG_PROJECT) project.name = TG_PROJECT tg_element_id = match.lower().split(TG_PATTERN)[1].strip().lower() taiga_element = project.get_item_by_ref(tg_element_id) if taiga_element is not None:
from taiga import TaigaAPI import pygal API_HOST = "https://api.taiga.io/" if __name__ == "__main__": api = TaigaAPI(host=API_HOST) # Login username = input("Type your username or email:\n> ") password = getpass.getpass("Type your password:\n> ") api.auth(username=username, password=password) me = api.me() # List all my projects projects = api.projects.list(member=me.id) project_list_display = "\n".join( [" {} - {}".format(i, p.name) for i, p in enumerate(projects)] ) index = int(input("Select project: \n{}\n> ".format(project_list_display))) project = projects[index] # Get issues stats data issues_stats = project.issues_stats() # GRAPHS
# -*- coding: utf-8 -*- from taiga import TaigaAPI from taiga.exceptions import TaigaException api = TaigaAPI( host='http://127.0.0.1:8000' ) api.auth( username='******', password='******' ) print (api.me()) new_project = api.projects.create('TEST PROJECT', 'TESTING API') new_project.name = 'TEST PROJECT 3' new_project.update() print (new_project.members) for member in new_project.members: print (member) jan_feb_milestone = new_project.add_milestone( 'New milestone jan feb', '2015-01-26', '2015-02-26' ) userstory = new_project.add_user_story(
def setup_taiga_api(hostname, username, password): api = TaigaAPI(host=hostname) api.auth(username=username, password=password) return api
def manage_issue(module, taiga_host, project_name, issue_subject, issue_priority, issue_status, issue_type, issue_severity, issue_description, issue_attachment, issue_attachment_description, issue_tags, state, check_mode=False): """ Method that creates/deletes issues depending whether they exist and the state desired The credentials should be passed via environment variables: - TAIGA_TOKEN - TAIGA_USERNAME and TAIGA_PASSWORD Returns a tuple with these elements: - A boolean representing the success of the operation - A descriptive message - A dict with the issue attributes, in case of issue creation, otherwise empty dict """ changed = False try: token = getenv('TAIGA_TOKEN') if token: api = TaigaAPI(host=taiga_host, token=token) else: api = TaigaAPI(host=taiga_host) username = getenv('TAIGA_USERNAME') password = getenv('TAIGA_PASSWORD') if not any([username, password]): return (False, changed, "Missing credentials", {}) api.auth(username=username, password=password) user_id = api.me().id project_list = filter(lambda x: x.name == project_name, api.projects.list(member=user_id)) if len(project_list) != 1: return (False, changed, "Unable to find project %s" % project_name, {}) project = project_list[0] project_id = project.id priority_list = filter(lambda x: x.name == issue_priority, api.priorities.list(project=project_id)) if len(priority_list) != 1: return (False, changed, "Unable to find issue priority %s for project %s" % (issue_priority, project_name), {}) priority_id = priority_list[0].id status_list = filter(lambda x: x.name == issue_status, api.issue_statuses.list(project=project_id)) if len(status_list) != 1: return (False, changed, "Unable to find issue status %s for project %s" % (issue_status, project_name), {}) status_id = status_list[0].id type_list = filter(lambda x: x.name == issue_type, project.list_issue_types()) if len(type_list) != 1: return (False, changed, "Unable to find issue type %s for project %s" % (issue_type, project_name), {}) type_id = type_list[0].id severity_list = filter(lambda x: x.name == issue_severity, project.list_severities()) if len(severity_list) != 1: return (False, changed, "Unable to find severity %s for project %s" % (issue_severity, project_name), {}) severity_id = severity_list[0].id issue = { "project": project_name, "subject": issue_subject, "priority": issue_priority, "status": issue_status, "type": issue_type, "severity": issue_severity, "description": issue_description, "tags": issue_tags, } # An issue is identified by the project_name, the issue_subject and the issue_type matching_issue_list = filter( lambda x: x.subject == issue_subject and x.type == type_id, project.list_issues()) matching_issue_list_len = len(matching_issue_list) if matching_issue_list_len == 0: # The issue does not exist in the project if state == "present": # This implies a change changed = True if not check_mode: # Create the issue new_issue = project.add_issue( issue_subject, priority_id, status_id, type_id, severity_id, tags=issue_tags, description=issue_description) if issue_attachment: new_issue.attach( issue_attachment, description=issue_attachment_description) issue["attachment"] = issue_attachment issue[ "attachment_description"] = issue_attachment_description return (True, changed, "Issue created", issue) else: # If does not exist, do nothing return (True, changed, "Issue does not exist", {}) elif matching_issue_list_len == 1: # The issue exists in the project if state == "absent": # This implies a change changed = True if not check_mode: # Delete the issue matching_issue_list[0].delete() return (True, changed, "Issue deleted", {}) else: # Do nothing return (True, changed, "Issue already exists", {}) else: # More than 1 matching issue return (False, changed, "More than one issue with subject %s in project %s" % (issue_subject, project_name), {}) except TaigaException as exc: msg = "An exception happened: %s" % to_native(exc) return (False, changed, msg, {})
def index(request): folder = settings.TAIGA_DATA_FOLDER directories = [os.path.join(folder,o) for o in os.listdir(folder) if os.path.isdir(os.path.join(folder,o))] report = Report(settings.TAIGA_DATA_FOLDER) status_points_filename = os.path.join(settings.MEDIA_ROOT,'status_points_{0}.png'.format(int(time.time())) ) status_count_filename = os.path.join(settings.MEDIA_ROOT,'status_count_{0}.png'.format(int(time.time())) ) tags_points_filename = os.path.join(settings.MEDIA_ROOT,'tags_points_{0}.png'.format(int(time.time())) ) tags_count_filename = os.path.join(settings.MEDIA_ROOT,'tags_count_{0}.png'.format(int(time.time())) ) report.save_status_points_graph( status_points_filename ) report.save_status_counts_graph( status_count_filename ) report.save_tags_points_graph( tags_points_filename ) report.save_tags_counts_graph( tags_count_filename ) closed_status_points_filename = os.path.join(settings.MEDIA_ROOT,'status_points_{0}.png'.format(int(time.time())) ) closed_status_count_filename = os.path.join(settings.MEDIA_ROOT,'status_count_{0}.png'.format(int(time.time())) ) closed_tags_points_filename = os.path.join(settings.MEDIA_ROOT,'tags_points_{0}.png'.format(int(time.time())) ) closed_tags_count_filename = os.path.join(settings.MEDIA_ROOT,'tags_count_{0}.png'.format(int(time.time())) ) report.save_status_points_graph( closed_status_points_filename, closed=True ) report.save_status_counts_graph( closed_status_count_filename, closed=True ) report.save_tags_points_graph( closed_tags_points_filename, closed=True ) report.save_tags_counts_graph( closed_tags_count_filename, closed=True ) api = TaigaAPI() api.auth(username=settings.USER, password=settings.PASS) workload_imgs = [] last_moment = report.last_snapshot for user_id in settings.TEAM: user = api.users.get(user_id) user_report = UserReport(user_id, last_moment) workload_filename = os.path.join(settings.MEDIA_ROOT,'workload_{1}_{0}.png'.format(int(time.time()), user_id) ) user_report.save_workload_4_next_days_graph(workload_filename, settings.TAGS_PRIORITIES) username = (user.full_name if user.full_name!='' else user.username) workload_imgs.append( (username, workload_filename) ) data = { 'status_points_filename': status_points_filename, 'status_count_filename': status_count_filename, 'tags_points_filename': tags_points_filename, 'tags_count_filename': tags_count_filename, 'closed_status_points_filename': closed_status_points_filename, 'closed_status_count_filename': closed_status_count_filename, 'closed_tags_points_filename': closed_tags_points_filename, 'closed_tags_count_filename': closed_tags_count_filename, 'workload_images': workload_imgs, 'not_assigned_stories': last_moment.not_assigned_stories() } template_directory = os.path.dirname(os.path.realpath(__file__)) template_file = os.path.join(template_directory, 'templates', 'index.html') return render_to_response(template_file, data)