ppit/task.py

# import sqlite3
import os
import argparse
import json
import getpass
import datetime
import logging
import sys

import action
from args import get_string_arg

class Task:
    def __init__(self, status = None, priority = None):
        self.name = None
        self.status = status
        self.priority = priority
        self.date = None
        self.time = None

def handle_task(args, last_action, conn):
    logging.info('> handle task')
    logging.debug('args: ' + str(args))

    if not args:
        list_task(last_action.project_id, last_action.task_id, conn)
        sys.exit(0)

    if args[0].isdigit():
        view_task(last_action.task_id, conn)
    elif args[0] == '-c':
        if len(args) == 1:
            print('missing task name')
            sys.exit(1)

        task = Task('open', 'normal')
        task.name = get_string_arg(args[1:], 'task name')
        parse_task_args(task, args[2:])
        create_task(task, last_action.project_id, conn)
    elif args[0] == '-e':
        if len(args) == 1:
            print('nothing to update')
            sys.exit(1)

        task = Task()

        if args[1].isdigit():
            task_id = int(args[1])
            parse_task_args(task, args[2:])
        else:
            task_id = last_action.task_id
            parse_task_args(task, args[1:])
        logging.debug('Task: ({}) {}'.format(task_id, task))

        edit_task(task, task_id, last_action.project_id, conn)
        # TODO To set as active project, us a -a option?
    else:
        print(f'Invalid project option: {args[0]}')

def parse_task_args(task, args):
    if not args:
        return

    i = 0
    while i < len(args):
        logging.debug(args[i])

        if args[i] == '-s':
            i += 1
            task.status = get_string_arg(args[i:i+1], 'task status')
        elif args[i] == '-n':
            i += 1
            task.name = get_string_arg(args[i:i+1], 'task name')
        elif args[i] == '-p':
            i += 1
            task.priority = get_string_arg(args[i:i+1], 'task priority')
        elif args[i] == '-d':
            i += 1
            task.date = get_string_arg(args[i:i+1], 'task date')
        elif args[i] == '-t':
            i += 1
            task.time = get_string_arg(args[i:i+1], 'task time')
        else:
            print(f'Invalid task option: {args[i]}')
            sys.exit(1)
        i += 1


def create_task(task, project_id, conn):
    # TODO Don't create task if no project (nothing selected?) ==> foreign key is not a solution: there is no project ID :)
    logging.info('>> Create task')

    query = """
    INSERT INTO
        task (project_id, username, name, status, priority, date, time, created_at)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?);
    """

    # TODO Date & time
    date = ''
    time = ''

    cursor = conn.cursor()
    cursor.execute(query, (project_id, getpass.getuser(), task.name, task.status,
        task.priority, date, time, datetime.datetime.now(),))

    task_id = cursor.lastrowid

    logging.debug('CREATE ACTION ' + str(project_id) + str(task_id) )

    task_details = [item for item in task.__dict__.items() if item[1] is not None and item[0] is not 'name']
    log_args = ', '.join("%s: %s" % (k, v) for k, v in task_details)

    action_message = '{} ({}, project: {})'.format(task.name, log_args, project_id)

    action.create_action(cursor, project_id=project_id, task_id=task_id, message=action_message)
    print('created task {}: {}'.format(task_id, action_message))

def edit_task(task, task_id, project_id, conn):
    logging.info('>> Edit task')

    update_args = [item for item in task.__dict__.items() if item[1] is not None]

    if not update_args:
        print("nothing to update")
        print("Tips: if you want to set an active task, just do '{} task <task_id>'"
            .format(os.path.basename(sys.argv[0])))
        sys.exit(1)

    logging.debug('Task update args: {}'.format(update_args))

    query = 'UPDATE task SET {} WHERE id = ?'
    query = query.format(', '.join("%s = '%s'" % (k, v) for k, v in update_args))
    logging.debug('update task query: ' + query)

    cursor = conn.cursor()
    logging.debug('Do a task update')
    cursor.execute(query, (task_id,))
    log_args = ', '.join("%s: %s" % (k, v) for k, v in update_args)
    action_message = '{} ({})'.format(task_id, ', '.join("%s: %s" % (k, v) for k, v in update_args))
    # TODO Review action message (at the end)
    print('updated task {}: ({})'.format(task_id, log_args))

    # TODO Retrieve project id ?
    logging.debug('UPDATE TASK - ACTION MESSAGE : ' + action_message)
    action.create_action(cursor, project_id=project_id, task_id=task_id, action=action.TypeAction.UPDATE, message = action_message)

def moving_task(args):
    print('moving')

def delete_task(task_id, conn):
    logging.info('>> Remove task')

    query = """
    DELETE FROM task
    WHERE id = ?;
    """

    cursor = conn.cursor()
    cursor.execute(query, (task_id,))
    if cursor.rowcount != 1:
        logging.error('DELETE FAILED')
    print('deleted task {}: {}'.format(task_id, 'task_name'))

def list_task(active_project_id, active_task_id, conn):
    logging.info('>> No arguments')

    query = """
    SELECT id, username, name, status, created_at,
        (SELECT count(*) FROM task WHERE task.project_id = project.id)
    FROM project;
    """

    query = """
    SELECT id, username, status, priority, name,
        (SELECT count(*) FROM note WHERE note.task_id = task.id)
     FROM task WHERE project_id = ?;
     """ #TODO Date & time

    cursor = conn.cursor()
    cursor.execute(query, (active_project_id,))
    for row in cursor.fetchall():
        task_id, username, status, priority, name, nb_note = row
        print('{:1} {:2d}: ({:8}) | {} | {} | {} ({} notes)'.format('*' if active_task_id == task_id else '', task_id,
            username, status, priority, name, nb_note))
        # TODO Note

        #   2: (budd) |open| |normal|              test (0 notes)
        # * 3: (budd) |open| |normal| Dec 31, 2018 tet  (0 notes)

def view_task(task_id, conn):
    print('TODO View Task')