def handler(user_id: str, project: str) -> Response:
""" Handler of TEAM_06_ADD_PROJECT intent,
TEAM_06_ADD_PROJECT intent is activated when user says '[Aa]m (?P<project>.*)'
returns question for task
:return: Response
"""
# Check project_id
clockify_api_key = get_clockify_api_key(user_id)
clockify = get_clockify(clockify_api_key)
clockify_id = clockify['user_id']
workspace_id = clockify['active_workspace_id']
projects = get_projects(clockify_api_key, workspace_id)
# Help the ASR
if project == 'Hecker Tom' or project == 'hekatron' or project == 'Hecker Ton' or project == 'Hecker':
project = 'Hackathon'
# Create new Project
try:
project_id = projects[project]
except KeyError:
add_project(clockify_api_key, workspace_id, project_name=project)
if set_project(user_id, project):
msg = _('ASK_TASK')
else:
msg = _('ASK_PORJECT')
response = ask(msg)
return response
def team_24_project_status_handler() -> Response:
overdue_q = 'project = {project} AND assignee = "{user}" AND duedate < Now() and status in ("In Progress", "To Do")'
jira_account = get_jira_account()
users = get_project_users()
overdue_msg = ""
for user in users:
overdue_q_user = overdue_q.format(project=config.get(
'jira', 'project'),
user=user)
overdue_tasks = get_jira_tasks_with_due_dates(overdue_q_user,
jira_account)
overdue_tasks_count = len(overdue_tasks)
if overdue_tasks_count > 0:
overdue_msg += user + _("ASSIGNED") + " "
for idx, tpl in enumerate(overdue_tasks):
overdue_msg += _("OVERDUE_TASK",
task=tpl[0],
days=(datetime.now() - parse(tpl[1])).days)
overdue_msg += ", " if idx != overdue_tasks_count - 1 else "."
if overdue_msg == "":
overdue_msg = _("NO_OVERDUE_TASKS")
response = Response(overdue_msg)
return response
def team_24_assign_task_handler(username: str, taskname: str) -> Response:
""" TEAM_24_ASSIGN_TASK handler
:param username: str
:param taskname: str
:return:
"""
chosen_user = clarify_user(username)
jira_account = get_jira_account()
tasks, tasks_count_msg = get_all_jira_tasks_with_keys(jira_account)
if tasks_count_msg == _("NONE"):
return Response(_("EMPTY_PROJECT", intent="TEAM_24_NEW_TASK"))
chosen_task = choose_entity_from_tuples(tasks, taskname)
if chosen_task is None or chosen_user is None:
return Response(_("CANNOT_UNDERSTAND", intent="TEAM_24_NEW_TASK"))
assignable_users = jira_account.get_assignable_users_for_issue(chosen_task[0])
user_with_account_id = next(filter(lambda user: user['displayName'] == chosen_user, assignable_users), None)
if user_with_account_id is None:
return Response(_("CANNOT_UNDERSTAND", intent="TEAM_24_NEW_TASK"))
account_id_user = user_with_account_id['accountId']
jira_account.issue_update(chosen_task[0], fields={"assignee": {"accountId": account_id_user}})
response = Response(_("ASSIGN_TASK", intent="TEAM_24_NEW_TASK", username=chosen_user))
return response
def handler() -> Response:
""" A sample handler of AMUSEMENT__JOKE intent,
AMUSEMENT__JOKE intent is activated when user asks to tell him a joke
returns a random joke from Chuck Norris jokes database: http://api.icndb.com/jokes/random
:return: Response
"""
try:
# We request a random joke from icndb with time-out set to 10 seconds
response = requests.get('http://api.icndb.com/jokes/random',
timeout=10)
# We parse the response json or raise exception if unsuccessful
response.raise_for_status()
data = response.json()
# We get the joke from the response data
joke = data['value']['joke'] if data.get('type') == 'success' else None
# We format our response to user or ask for an excuse
if joke:
msg = _('HELLOAPP_JOKE', joke=joke)
else:
msg = _('HELLOAPP_RESPONSE_ERROR')
except requests.exceptions.RequestException as err:
msg = _('HELLOAPP_REQUEST_ERROR', err=err)
# We create a response with either joke or error message
return tell(msg)
def team_24_project_status_handler() -> Response:
urgent_msg = _("NO_URGENT_TASKS")
tasks = get_urgent_tasks()
if len(tasks) > 0:
urgent_msg = _("URGENT_TASKS_INTRO") + format_enumeration(
[_("URGENT_TASK", task=t[0], user=t[1]) for t in tasks]) + "."
response = Response(urgent_msg)
return response
def format_content(content, h, imp, model):
content += _("FROM") + " " + imp.sender.name + " " + _(
"WITH_SUBJECT") + " " + imp.subject + ": "
body = h.handle(imp.body).replace('*', ''). \
replace('|', '').replace('---', '').replace('[', ''). \
replace(']', '').replace('#', '')
body = re.sub(r'\n\s*\n', '\n\n', body)
body = body.replace("\n", " ")
summary = model(body)
content += summary
return content
def handler(user_id: str) -> Response:
""" Handler of TEAM_06_OPEN_TIME_TRACKING intent,
TEAM_06_OPEN_TIME_TRACKING intent is activated when user says 'zeiterfassung stoppen'
welcomes user
:return: Response
"""
user_info = get_user(user_id)
if user_info:
update_user(user_info)
else:
create_user(user_id)
clockify_api_key = get_clockify_api_key(user_id)
if clockify_api_key is None or clockify_api_key == '':
user_token = get_user_token(user_id)
if user_token is None or user_token == '':
user_token = get_random_string(4)
set_user_token(user_id, user_token)
msg = _('WELCOME_NEW_USER')
response = tell(msg)
response.card = Card(
type_="GENERIC_DEFAULT",
title="Time Tracker: Hinterlege deinen Clockify Account",
text="User Token: {token}".format(token=user_token),
action=get_auth_url(token=user_token),
action_text="Klick hier, um einen Account zu hinterlegen.")
else:
clockify = get_clockify(clockify_api_key)
clockify_id = clockify['user_id']
workspace_id = clockify['active_workspace_id']
time_entries = get_time_entries(clockify_api_key=clockify_api_key,
workspace_id=workspace_id,
user_id=clockify_id)
running_timer = check_running_timer(time_entries)
# Get time tracking status
if running_timer:
msg = _('WELCOME_RETURNING_USER')
msg = msg + " " + _('WELCOME_STOP_SELECTION')
else:
msg = _('WELCOME_SELECTION')
response = ask(msg)
return response
def team_24_call_handler() -> Response:
""" TEAM_24_CALL handler
:return:
"""
jira_account = get_jira_account()
tasks, tasks_count_msg = get_backlog(jira_account)
if tasks_count_msg == _("NONE"):
return _("NO_BACKLOG")
msg = _("BACKLOG_INTRO")
msg += format_enumeration(tasks) + "."
response = Response(msg)
return response
def test_make_lazy_translation(self):
from skill_sdk.l10n import _, _n, _a
with open('de.mo') as f:
tr = Translations(f)
tr._catalog['KEY'] = 'VALUE'
tr._catalog[('KEY', 1)] = 'VALUES'
tr._catalog['KEY_PLURAL'] = 'VALUES'
l10n.set_current_locale(None)
self.assertEqual(_('KEY'), 'KEY')
self.assertEqual(_n('KEY', 'KEY_PLURAL', 1), 'KEY')
self.assertEqual(_n('KEY', 'KEY_PLURAL', 2), 'KEY_PLURAL')
self.assertEqual(_a('KEY'), ['KEY'])
l10n.set_current_locale(tr)
self.assertEqual(_('KEY'), 'VALUE')
self.assertEqual(_n('KEY', 'KEY_PLURAL', 2), 'VALUES')
self.assertEqual(_a('KEY'), ['KEY'])
def get_done_tasks():
msg_done_tasks = _("NO_DONE_TASKS")
today = date.today().strftime("%Y-%m-%d")
tomorrow = (date.today() + timedelta(days=1)).strftime("%Y-%m-%d")
done_q = 'project = {project} AND status changed during ({today}, {tomorrow}) to Done'. \
format(project=config.get('jira', 'project'), today=today, tomorrow=tomorrow)
done_tasks, done_tasks_count_msg = get_jira_tasks(done_q)
return done_tasks, done_tasks_count_msg, msg_done_tasks
def team_24_project_status_handler() -> Response:
""" TEAM_24_PROJECT_STATUS handler
:return:
"""
urgent_q = 'project = {project} AND status IN ("To Do") and priority in (Highest)'.\
format(project=config.get('jira', 'project'))
overdue_q = 'project = {project} AND duedate < Now() and status in ("In Progress", "To Do")'.\
format(project=config.get('jira', 'project'))
jira_account = get_jira_account()
todo_tasks, todo_tasks_count_msg = get_jira_tasks(get_board_query("To Do"),
jira_account)
inprogress_tasks, inprogress_tasks_count_msg = get_jira_tasks(
get_board_query("In Progress"), jira_account)
done_tasks, done_tasks_count_msg = get_jira_tasks(get_board_query("Done"),
jira_account)
urgent_tasks, urgent_tasks_count_msg = get_jira_tasks(
urgent_q, jira_account)
overdue_tasks, overdue_tasks_count_msg = get_jira_tasks(
overdue_q, jira_account)
idle_users = get_idle_users(jira_account)
msg = _("SPRINT_STATUS",
project=config.get('jira', 'project'),
todos=todo_tasks_count_msg,
inprogress=inprogress_tasks_count_msg,
done=done_tasks_count_msg)
msg += " " + _("PROJECT_STATUS_INTRO",
project=config.get('jira', 'project'),
urgent_tasks=urgent_tasks_count_msg,
overdue_tasks=overdue_tasks_count_msg)
if len(idle_users) > 0:
verb = _("ARE")
if len(idle_users) == 1:
verb = _("IS")
user_str = format_enumeration(idle_users)
msg_idle = " " + _("IDLE_USERS", users=user_str, verb=verb)
msg += msg_idle
response = Response(msg)
return response
def handler() -> Response:
"""
This handler is the first point of contact when your utterance is actually resolved!
It will make sure to send you funny memes to your phone.
:return: Response
"""
# We get a translated message
msg = _('RANDOM_MEME_AFFIRMATION')
# We create a simple response
response = tell(msg)
response.card = Card(type_="GENERIC_DEFAULT",
title=_("RANDOM_MEME_TITLE"),
sub_title=_("RANDOM_MEME_SUB_TITLE"),
action=get_random_meme_url(),
action_text=_("RANDOM_MEME_ACTION_TEXT"))
return response
def handler(user_id: str) -> Response:
""" Handler of TEAM_06_STOP_TIME_TRACKING intent,
TEAM_06_STOP_TIME_TRACKING intent is activated when user says 'zeiterfassung stoppen'
stops running timer
:return: Response
"""
clockify_api_key = get_clockify_api_key(user_id)
clockify = get_clockify(clockify_api_key)
clockify_id = clockify['user_id']
workspace_id = clockify['active_workspace_id']
time_entries = get_time_entries(clockify_api_key, workspace_id,
clockify_id)
project_ids = get_project_ids(clockify_api_key, workspace_id)
# Get time tracking status
running_timer = check_running_timer(time_entries)
if running_timer:
# Stop time tracking
now = datetime.utcnow()
now_str = now.isoformat()
now_str = now_str.split('.')[0] + ".000Z"
time_entrie = stop_time_entrie(clockify_api_key,
workspace_id,
user_id=clockify_id,
end_datetime=now_str)
project = project_ids[time_entrie['projectId']]
duration = parse_duration(time_entrie['timeInterval']['duration'])
task = time_entrie['description']
set_project(user_id, '')
set_task(user_id, '')
msg = _('STOP_COMFIRMATION',
project=project,
task=task,
duration=duration)
else:
msg = _('STOP_ERROR')
response = tell(msg)
return response
def team_24_schedule_meeting_handler(usernames: str, time: str) -> Response:
""" TEAM_24_SCHEDULE_MEETING handler
:param usernames: str
:param time: str
:return:
"""
response = Response(_("NOT_IMPLEMENTED",
intent="TEAM_24_SCHEDULE_MEETING"))
return response
def handler(user_id: str, task: str) -> Response:
""" Handler of TEAM_06_ADD_TASK intent,
TEAM_06_ADD_TASK intent is activated when user says '(ich möchte|ich werde) (die|den|das)(?P<task>.*)'
returns confirmation start timer
:return: Response
"""
set_task(user_id, task)
# Get project from db
project = get_project(user_id)
clockify_api_key = get_clockify_api_key(user_id)
clockify = get_clockify(clockify_api_key)
clockify_id = clockify['user_id']
workspace_id = clockify['active_workspace_id']
projects = get_projects(clockify_api_key, workspace_id)
project_id = projects[project]
if project is None:
msg = _('ASK_PROJECT')
response = ask(msg)
elif task is None:
msg = _('ASK_TASK')
response = ask(msg)
else:
# Start time tracking
now = datetime.utcnow()
now_str = now.isoformat()
now_str = now_str.split('.')[0] + ".000Z"
add_time_entrie(clockify_api_key,
workspace_id,
project_id,
task,
now_str,
end_datetime=None)
msg = _('START_COMFIRMATION')
response = tell(msg)
return response
def mood_handler():
try:
number = randrange(10)
# TODO: add functionality to create personalized preferences, social/close friends group, to trigger a call.
if number < 3:
# TODO: Maybe add jokes in a database and source from there
# Jokes sourced from "https://github.com/derphilipp/Flachwitze"
response = requests.get(
'https://raw.githubusercontent.com/derphilipp/Flachwitze/master/README.md',
timeout=10)
raw_jokes = response.text.split("##")[1].split("\n")[2:]
jokes = [j[2:] for j in raw_jokes]
msg = _('HAPPINESS_JOKE', joke=jokes[randrange(len(jokes))])
response = tell(msg)
elif number < 6:
# TODO: Add more URL's and if possible learn from user history
video_ids = ["DODLEX4zzLQ", "dQw4w9WgXcQ", "tvMO9TNfdHs"]
msg = _("HAPPINESS_CHECK_PHONE")
response = tell(msg)
response.card = Card(
title=_("HAPPINESS_TITLE"),
subtitle=_("HAPPINESS_SUB_TITLE"),
action=
f"https://www.youtube.com/watch?v={video_ids[randrange(len(video_ids))]}",
actiontext=_("HAPPINESS_ACTION_TEXT"))
else:
msg = _("HAPPINESS_CHECK_PHONE")
response = tell(msg)
response.card = Card(
title=_("HAPPINESS_TITLE"),
subtitle=_("HAPPINESS_SUB_TITLE"),
action=
f"https://soundcloud.com/mariagrazia84/pharrell-williams-happy",
actiontext=_("HAPPINESS_ACTION_TEXT"))
except requests.exceptions.RequestException as err:
msg = _('HAPPINESS_REQUEST_ERROR', err=err)
response = tell(msg)
# We create a response with either joke or error message
return response
def get_idle_users(jira_account):
users = get_project_users()
idle_q = "project = {project} AND assignee = '{user}' AND status IN ('In Progress') ORDER BY issuekey"
idle_users = []
for user in users:
idle_q_user = idle_q.format(project=config.get('jira', 'project'),
user=user)
in_progress_tasks, in_progress_tasks_count_msg = get_jira_tasks(
idle_q_user, jira_account)
if in_progress_tasks_count_msg == _("NONE"):
idle_users.append(user)
return idle_users
def get_jira_tasks(q, account=None):
jira_account = account
if jira_account is None:
jira_account = get_jira_account()
if jira_account is None:
return [], _("NONE")
q_res = jira_account.jql(q)
tasks = [t['fields']['summary'] for t in q_res['issues']]
tasks_count_msg = many_or_none_message(tasks)
return tasks, tasks_count_msg
def team_24_my_day_handler() -> Response:
""" TEAM_24_MY_DAY handler
:return:
"""
meetings, meetings_count_msg = get_meetings()
tasks, tasks_count_msg = get_in_progress_tasks()
msg = _("MY_DAY",
nickname=config.get('jira', 'nickname'),
meetings_count=meetings_count_msg,
tasks_count=tasks_count_msg)
if meetings_count_msg != _("NONE"):
msg += " " + _("MY_MEETINGS_INTRO")
msg += " ".join(
[m[1] + " " + _("AT") + " " + m[0] + "." for m in meetings])
if tasks_count_msg != _("NONE"):
msg += " " + _("MY_TASKS_INTRO")
msg += format_enumeration(tasks)
msg += "."
response = Response(msg)
return response
def team_24_recommend_allocation_handler() -> Response:
""" TEAM_24_RECOMMEND_ALLOCATION handler
:return:
"""
allocation_table = list()
jira_account = get_jira_account()
users = get_project_users_without_pm()
q = "project = {project} AND assignee = '{user}' AND status IN ('To Do', 'In Progress') ORDER BY issuekey"
total = 0
for user in users:
q_user = q.format(project=config.get('jira', 'project'), user=user)
tasks, tasks_count_msg = get_jira_tasks(q_user, jira_account)
allocation_table.append((user, len(tasks)))
total += len(tasks)
tasks, tasks_count_msg = get_backlog(jira_account)
if tasks_count_msg == _("NONE"):
return _("NO_BACKLOG")
summary = allocate_backlog(tasks, allocation_table, total, users)
msg = _("RECOMMENDER_INTRO")
for usr, ts in summary.items():
msg += _("RECOMMENDER_SG",
tasks=format_enumeration(ts)) if len(ts) == 1 else _(
"RECOMMENDER_PL",
tasks=format_enumeration(ts)) + _("TO") + " " + usr + ". "
response = Response(msg)
return response
def handler(user_id: str) -> Response:
""" Handler of TEAM_06_START_TIME_TRACKING intent,
TEAM_06_START_TIME_TRACKING intent is activated when user says 'zeiterfassung starten'
returns question for project
:return: Response
"""
user_info = get_user(user_id)
if user_info:
update_user(user_info)
else:
create_user(user_id)
clockify_api_key = get_clockify_api_key(user_id)
if clockify_api_key is None or clockify_api_key == '':
user_token = get_user_token(user_id)
if user_token is None or user_token == '':
user_token = get_random_string(4)
set_user_token(user_id, user_token)
msg = _('WELCOME_NEW_USER')
response = tell(msg)
response.card = Card(
type_="GENERIC_DEFAULT",
title="Time Tracker: Hinterlege deinen Clockify Account",
text="User Token: {token}".format(token=user_token),
action=get_auth_url(token=user_token),
action_text="Klick hier, um einen Account zu hinterlegen.")
else:
msg = _('ASK_PROJECT')
response = ask(msg)
return response
def handler_memo(text: str):
print(context)
user_id = '2'
if start_round(text):
topic = text.split("thema ")[-1]
cursor = connection.cursor()
if topic == text:
question_id, quiz, answer, _ = cursor.execute(
"select questions.id, quiz, answer, max(user_questions.id) as max_id from questions left join user_questions on questions.id = user_questions.questions_id\
where user_id = ? and step<6 group by questions.id order by max_id limit 1",
[user_id]).fetchone()
else:
question_id, quiz, answer, _ = cursor.execute(
"select questions.id, quiz, answer, max(user_questions.id) as max_id from questions left join user_questions on questions.id = user_questions.questions_id\
where user_id = ? and step<6 and topic = ? group by questions.id order by max_id limit 1",
[user_id, topic]).fetchone()
if quiz is None:
msg = _("NO_MORE_QUIESTION")
return tell(msg)
cursor.execute("insert into user_questions (questions_id) values (?)",
[question_id])
connection.commit()
return ask(quiz)
else:
cursor = connection.cursor()
last_question_id, answer, step = cursor.execute(
"select questions_id, answer, step from user_questions uq\
JOIN questions q on q.id = uq.questions_id where q.user_id = ? order by uq.id desc limit 1",
[user_id]).fetchone()
if similar_answer(answer, text):
step += 1
else:
step = max(1, step - 1)
cursor.execute("update questions set step = ? where id = ?",
[step, last_question_id])
connection.commit()
return tell(_('END_QUESTION_REVIEW'))
def handler(number: int) -> Response:
""" The implementation
:param number:
:return: Response
"""
try:
# We check if value is in range of 1 to 10
assert 1 <= number <= 10
# We get a random number
if number == randint(1, 10):
# ... and congratulate the winner!
msg = _('HELLOAPP_NUMBER_SUCCESS_MESSAGE')
else:
# ... or encourage them to keep trying
msg = _('HELLOAPP_NUMBER_WRONG_MESSAGE')
response = tell(msg)
except (AssertionError, TypeError, ValueError):
msg = _('HELLOAPP_NO_NUMBER_MESSAGE')
# We create a response with NO_NUMBER_MESSAGE and ask to repeat the number
response = ask(msg)
return response
def handler() -> Response:
""" A very basic handler of SMALLTALK__GREETINGS intent,
SMALLTALK__GREETINGS intent is activated when user says 'Hello'
returns translated 'Hello' greeting
:return: Response
"""
# We get a translated message
msg = _('HELLOAPP_HELLO')
# We create a simple response
response = tell(msg)
# We return the response
return response
def handler_card(text: str) -> Response:
print('*******')
print(context)
user_id = '2'
if not has_open_question(user_id):
cursor = connection.cursor()
cursor.execute("insert into questions (user_id) values (?) ",
[user_id])
connection.commit()
msg = _('ASK_YOUR_QUESTION')
return ask(msg)
elif has_open_question_no_quiz(user_id):
cursor = connection.cursor()
question = get_last_quiz(user_id)
cursor.execute("update questions set quiz = ? where id = ?",
[text, question[0]])
connection.commit()
msg = _('INSERT_YOUR_ANSWER')
return ask(msg)
elif has_open_question_no_answer(user_id):
cursor = connection.cursor()
question = get_last_quiz(user_id)
cursor.execute("update questions set answer = ? where id = ?",
[text, question[0]])
connection.commit()
msg = _('WHAT_IS_THE_TOPIC')
return ask(msg)
else:
cursor = connection.cursor()
question = get_last_quiz(user_id)
cursor.execute("update questions set topic = ? where id = ?",
[text, question[0]])
connection.commit()
msg = _('DONE')
return tell(msg)
print("AFTER ALL IFS")
def team_24_new_task_handler(taskname: str) -> Response:
""" TEAM_24_NEW_TASK handler
:param taskname: str
:return:
"""
jira_account = get_jira_account()
my_project = get_current_project(jira_account)
issue_dict = {
'project': {'key': '{project}'.format(project=my_project['key'])},
'issuetype': {'name': 'Story'},
'summary': '{taskname}'.format(taskname=taskname)
}
jira_account.issue_create_or_update(fields=issue_dict)
response = Response(_("NEW_TASK", taskname=taskname))
return response
def team_24_project_status_handler() -> Response:
msg_emails = _("NO_EMAILS")
mailbox = get_mailbox()
query = mailbox.new_query().on_attribute('ReceivedDateTime').greater_equal(
datetime(2020, 12, 5, 0, 0))
titles = format_enumeration([
message.subject + " " + _("FROM") + " " + message.sender.name
for message in mailbox.get_messages(query=query)
])
if titles != "":
msg_emails = _("EMAILS", titles=titles)
msg_important_emails = ""
important_messages = list(
filter(lambda msg: msg.importance.name == 'High',
mailbox.get_messages(query=query)))
if len(important_messages) > 0:
h = HTML2Text()
h.ignore_links = True
model = get_summarizer_model()
content = ""
for imp in important_messages:
content = format_content(content, h, imp, model)
msg_important_emails += _("IMPORTANT_EMAILS", content=content)
done_tasks, done_tasks_count_msg, msg_done_tasks = get_done_tasks()
if done_tasks_count_msg != _("NONE"):
msg_done_tasks = _("DONE_TASKS_INTRO")
msg_done_tasks += format_enumeration(done_tasks)
msg_done_tasks += "."
response = Response(msg_emails + " " + msg_important_emails + " " +
msg_done_tasks)
return response
def dragons(dragon_list: List[str]):
return _('DRAGONS')
def hello():
return _('HELLO')
def team_24_call_handler(username: str) -> Response:
""" TEAM_24_COWORKER_STATUS handler
:param username: str
:return:
"""
user = clarify_user(username)
jira_account = get_jira_account()
todo_tasks, todo_tasks_count_msg = get_jira_tasks(
get_user_board_query("To Do", user), jira_account)
inprogress_tasks, inprogress_tasks_count_msg = get_jira_tasks(
get_user_board_query("In Progress", user), jira_account)
done_tasks, done_tasks_count_msg = get_jira_tasks(
get_user_board_query("Done", user), jira_account)
msg = _("COWORKER_STATUS",
username=username,
todos=todo_tasks_count_msg,
inprogress=inprogress_tasks_count_msg,
done=done_tasks_count_msg)
if inprogress_tasks_count_msg != _("NONE"):
msg += " " + _("COWORKER_INPROGRESS",
username=user,
tasks=format_enumeration(inprogress_tasks))
urgent_q = 'project = {project} AND assignee = "{username}" AND status IN ("To Do") and priority in (Highest)'. \
format(project=config.get('jira', 'project'), username=user)
overdue_q = 'project = {project} AND assignee = "{username}" AND duedate < Now() and status in ("In Progress", ' \
'"To Do")'. \
format(project=config.get('jira', 'project'), username=user)
urgent_tasks, urgent_tasks_count_msg = get_jira_tasks(
urgent_q, jira_account)
if urgent_tasks_count_msg != _("NONE"):
msg += _("COWORKER_URGENT",
username=user,
tasks=format_enumeration(urgent_tasks)) + "."
overdue_tasks = get_jira_tasks_with_due_dates(overdue_q, jira_account)
overdue_tasks_count = len(overdue_tasks)
if overdue_tasks_count > 0:
msg += _("COWORKER_OVERDUE", username=user)
for idx, tpl in enumerate(overdue_tasks):
msg += _("OVERDUE_TASK",
task=tpl[0],
days=(datetime.now() - parse(tpl[1])).days)
msg += ", " if idx != overdue_tasks_count - 1 else "."
no_tasks_q = "project = {project} AND assignee = '{user}' AND status IN ('In Progress', 'To Do') ORDER BY issuekey".format(
project=config.get('jira', 'project'), user=user)
tasks, tasks_count_msg = get_jira_tasks(no_tasks_q, jira_account)
if len(tasks) == 0:
msg += " " + _("COWORKER_EMPTY")
else:
idle_tasks_q = "project = {project} AND assignee = '{user}' AND status IN ('In Progress') ORDER BY " \
"issuekey".format(project=config.get('jira', 'project'), user=user)
idle_tasks, idle_tasks_count_msg = get_jira_tasks(
idle_tasks_q, jira_account)
if len(idle_tasks) == 0:
msg += " " + _("COWORKER_IDLE")
response = Response(msg)
return response
