timebot/timebot/app.py

import argparse
import configparser
import datetime
import logging
import os
import signal
import sys

from timebot.constants import PUNCH_COMMANDS, DateFormats
from timebot.timebot import MobatimeApi, TimeBot, parse_user_time_input

logger = logging.getLogger()
logging.basicConfig(level=logging.INFO)


def run():
    parser = argparse.ArgumentParser()
    parser.add_argument("-v", help="enable debug logging", action="store_true")
    parser.add_argument("-u", help="mobatime login user", default=None)
    parser.add_argument("-p", help="mobatime login user password", default=None)
    parser.add_argument("-c", help="config file", default="timebot.ini")
    parser.add_argument("-a", "--use-system-ca-store", help="use system ca store for ssl connections",
                        action="store_true")
    parser.add_argument("--save-cookies", help="save auth cookies to `./.kekse`", action="store_true", default=False)
    subparsers = parser.add_subparsers(help='sub-command help', dest='subparser_name')

    # subparser command: `status`
    subparsers.add_parser("status", help="show your current tracking status")

    # subparser command: `gui`
    subparsers.add_parser("gui", help="start qt5 gui")

    # subparser command: `list-entries`
    parser_list_entries = subparsers.add_parser("list-entries", help="use this command to list your time entries")
    parser_list_entries.add_argument("--start-date",
                                     help=f"start date filter in format `{DateFormats.SIMPLE_DATETIME.evalue}` "
                                          f"(default: now - 10days; unset for default)")
    parser_list_entries.add_argument("--end-date",
                                     help=f"end date filter in format `{DateFormats.SIMPLE_DATETIME.evalue}` "
                                          f"(default: now; unset for default)")
    parser_list_entries.add_argument("--items", help="max items to request per page", default=20, type=int)

    # subparser command: `punch`
    parser_punch = subparsers.add_parser("punch",
                                         help="use this command to punch in, punch out, or create break entries")
    parser_punch.add_argument("-t",
                              help=f"type of time entry; this can be {', '.join(PUNCH_COMMANDS)}",
                              default="punch_in",
                              choices=PUNCH_COMMANDS)
    parser_punch.add_argument("-s",
                              help=f"timestamp in format `{DateFormats.SIMPLE_DATETIME.evalue}`, "
                                   f"`{DateFormats.SIMPLE_TIME.evalue}` or `now`", default="now")

    # subparser command: `smart-punch`
    parser_smart_punch = subparsers.add_parser("smart-punch",
                                               help="use this command to auto punch in, punch out and create break "
                                                    "entries; this command tries to detect your last action and will "
                                                    "create entries in to following order: "
                                                    "punch_in -> break_start -> break_end -> punch_out")
    parser_smart_punch.add_argument("-s", help=f"timestamp in format `{DateFormats.SIMPLE_DATETIME.evalue}`,"
                                               f" `{DateFormats.SIMPLE_TIME.evalue}` or `now`", default="now")

    args = parser.parse_args()

    if args.v:
        logger.setLevel(logging.DEBUG)

    config = configparser.ConfigParser()
    config.read(args.c)

    if args.use_system_ca_store or config.get(section="general", option="use_system_ca_store", fallback="no") == "yes":
        os.environ["REQUESTS_CA_BUNDLE"] = config["general"]["system_ca_store"] \
            if "system_ca_store" in config["general"] else "/etc/ssl/certs/ca-certificates.crt"

    user = args.u if args.u is not None else config.get(section="general", option="mobatime_user", fallback=None)
    if user is None:
        logger.fatal("could not get username for mobatime...")
        sys.exit(1)

    save_cookies = True if args.save_cookies is True else config.get(section="general", option="save_cookies",
                                                                     fallback="no") == "yes"

    ma = MobatimeApi(baseurl=config["general"]["baseurl"], user=user, password=args.p, ask_for_password=True,
                     save_session=save_cookies)
    tb = TimeBot(mobatime_api=ma)
    if args.subparser_name == "punch":
        if args.s == "now":
            punch_datetime = datetime.datetime.now()
        else:
            punch_datetime = parse_user_time_input(args.s)
        logger.info("running `{}` with date `{}` and time `{}`".format(
            args.t,
            punch_datetime.strftime(DateFormats.SIMPLE_DATE.value),
            punch_datetime.strftime(DateFormats.SIMPLE_TIME.value),
        ))
        getattr(tb, args.t)(punch_datetime)
    elif args.subparser_name == "smart-punch":
        if args.s == "now":
            tb.smart_punch()
        else:
            tb.smart_punch(parse_user_time_input(args.s))
    elif args.subparser_name == "list-entries":
        end_date = None
        if args.end_date:
            end_date = parse_user_time_input(args.end_date)
        start_date = None
        if args.start_date:
            start_date = parse_user_time_input(args.start_date)
        data = tb.mobatime_api.get_entries(entries=args.items, start_date=start_date, end_date=end_date)
        data.reverse()
        for i in data:
            print("Entry: {} - DateTime: {} - Note: {}".format(i["entryName"], i["dateTime"], i["note"]))
    elif args.subparser_name == "status":
        print(tb.status())
    elif args.subparser_name == "gui":
        from PySide6.QtWidgets import QApplication
        from timebot.gui import MainWindow
        signal.signal(signal.SIGINT, lambda *_args: QApplication.quit())
        app = QApplication(sys.argv)
        main_window = MainWindow(timebot=tb, refresh_interval=config.get(section="gui",
                                                                                option="refresh_interval",
                                                                                fallback="1m"))
        main_window.show()
        sys.exit(app.exec())
    else:
        logger.error("Noting done... dunno what you want!")
        sys.exit(1)

    sys.exit(0)


if __name__ == "__main__":
    run()