895 lines
26 KiB
Python
Executable File
895 lines
26 KiB
Python
Executable File
#!/usr/bin/env python3.7
|
|
import os
|
|
import csv
|
|
import logging
|
|
from datetime import datetime
|
|
from itertools import chain
|
|
from pathlib import Path
|
|
import sys
|
|
import tomllib
|
|
|
|
import click
|
|
from clockify_sdk import Clockify
|
|
import requests
|
|
from peewee import fn, JOIN
|
|
from textual.logging import TextualHandler
|
|
|
|
from xdg.BaseDirectory import xdg_config_home
|
|
|
|
|
|
from .db import (
|
|
KimaiTag,
|
|
db,
|
|
HamsterCategory,
|
|
HamsterActivity,
|
|
HamsterFact,
|
|
KimaiCustomer,
|
|
KimaiProject,
|
|
KimaiActivity,
|
|
HamsterActivityKimaiMapping,
|
|
HamsterFactKimaiImport,
|
|
HamsterFactTag,
|
|
ClockifyProject,
|
|
HamsterClockifyMapping,
|
|
HamsterFactClockifyImport
|
|
)
|
|
from .kimaiapi import KimaiAPI, Timesheet
|
|
from .sync import sync
|
|
|
|
CONFIG_FILE = Path(xdg_config_home) / "hamstertools.toml"
|
|
|
|
HAMSTER_DIR = Path.home() / ".local/share/hamster"
|
|
HAMSTER_FILE = HAMSTER_DIR / "hamster.db"
|
|
|
|
db.init(HAMSTER_FILE)
|
|
|
|
|
|
@click.group(context_settings={"auto_envvar_prefix": "HAMSTERTOOL"})
|
|
@click.option("-d", "--debug", is_flag=True)
|
|
@click.option("--config", default=CONFIG_FILE, type=click.Path())
|
|
@click.pass_context
|
|
def cli(ctx, config, debug):
|
|
file_config = {}
|
|
if os.path.exists(config):
|
|
with open(config, "rb") as f:
|
|
file_config = tomllib.load(f)
|
|
if debug:
|
|
logging.basicConfig()
|
|
logging.getLogger().setLevel(logging.DEBUG)
|
|
|
|
peewee_logger = logging.getLogger("peewee")
|
|
peewee_logger.addHandler(TextualHandler())
|
|
peewee_logger.setLevel(logging.DEBUG)
|
|
|
|
requests_log = logging.getLogger("requests.packages.urllib3")
|
|
requests_log.setLevel(logging.DEBUG)
|
|
requests_log.propagate = True
|
|
|
|
ctx.ensure_object(dict)
|
|
ctx.obj['config'] = file_config
|
|
|
|
|
|
@cli.group()
|
|
def categories():
|
|
pass
|
|
|
|
|
|
@categories.command("list")
|
|
@click.option("--search", help="Search string")
|
|
def list_categories(search):
|
|
"""List / search categories"""
|
|
categories = HamsterCategory.select()
|
|
|
|
if search is not None:
|
|
categories = categories.where(HamsterCategory.name.contains(search))
|
|
|
|
for c in categories:
|
|
click.echo(f"@{c.id}: {c.name}")
|
|
|
|
|
|
@categories.command("delete")
|
|
@click.argument("ids", nargs=-1)
|
|
def delete_categories(ids):
|
|
"""Delete categories specified by IDS"""
|
|
click.secho("Deleting:", fg="red")
|
|
|
|
categories = (
|
|
HamsterCategory.select(
|
|
HamsterCategory, fn.Count(HamsterActivity.id).alias("activities_count")
|
|
)
|
|
.join(HamsterActivity, JOIN.LEFT_OUTER)
|
|
.group_by(HamsterCategory)
|
|
.where(HamsterCategory.id.in_(ids))
|
|
)
|
|
|
|
for c in categories:
|
|
click.echo(f"@{c.id}: {c.name} ({c.activities_count} activities)")
|
|
|
|
click.confirm("Do you want to continue?", abort=True)
|
|
|
|
count = HamsterCategory.delete().where(HamsterCategory.id.in_(ids)).execute()
|
|
|
|
click.secho("Deleted {0} categories".format(count), fg="green")
|
|
|
|
|
|
@categories.command("rename")
|
|
@click.argument("id_", metavar="ID")
|
|
@click.argument("name")
|
|
def rename_category(id_, name):
|
|
"""Rename a category"""
|
|
|
|
category = HamsterCategory.get(id=id_)
|
|
|
|
click.echo(f'Renaming @{category.id}: {category.name} to "{name}"')
|
|
|
|
category.name = name
|
|
category.save()
|
|
|
|
|
|
@categories.command("activities")
|
|
@click.argument("ids", nargs=-1)
|
|
def list_category_activities(ids):
|
|
"""Show activities for categories specified by ids"""
|
|
|
|
activities = (
|
|
HamsterActivity.select(HamsterActivity, HamsterCategory.name)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
.where(HamsterCategory.id.in_(ids))
|
|
)
|
|
|
|
for a in activities:
|
|
click.echo(f"@{a.id}: {a.category.name} » {a.name}")
|
|
|
|
|
|
@categories.command("tidy")
|
|
def tidy_categories():
|
|
"""Remove categories with no activities"""
|
|
|
|
subquery = (
|
|
HamsterCategory.select(
|
|
HamsterCategory, fn.COUNT(HamsterActivity.id).alias("activities_count")
|
|
)
|
|
.join(HamsterActivity, JOIN.LEFT_OUTER)
|
|
.group_by(HamsterCategory)
|
|
.alias("subquery")
|
|
)
|
|
|
|
categories = (
|
|
HamsterCategory.select()
|
|
.join(subquery, on=(HamsterCategory.id == subquery.c.id))
|
|
.where(subquery.c.activities_count == 0)
|
|
)
|
|
|
|
click.echo("Found {0} empty categories:".format(categories.count()))
|
|
|
|
for cat in categories:
|
|
click.echo(f"@{cat.id}: {cat.name}")
|
|
|
|
click.confirm("Do you want to continue?", abort=True)
|
|
|
|
[cat.delete_instance() for cat in categories]
|
|
|
|
|
|
@cli.group()
|
|
def activities():
|
|
pass
|
|
|
|
|
|
@activities.command("list")
|
|
@click.option("--search", help="Search string")
|
|
@click.option("--csv/--no-csv", "csv_output", default=False, help="CSV output")
|
|
def list_activities(search, csv_output):
|
|
"""List / search activities"""
|
|
|
|
activities = (
|
|
HamsterActivity.select(HamsterActivity, HamsterCategory)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
.order_by(HamsterCategory.name, HamsterActivity.name)
|
|
)
|
|
|
|
if search is not None:
|
|
activities = activities.where(HamsterActivity.name.contains(search))
|
|
|
|
if csv_output:
|
|
csv_writer = csv.writer(sys.stdout)
|
|
|
|
for a in activities:
|
|
category_name = a.category.name if a.category_id != -1 else ""
|
|
if csv_output:
|
|
csv_writer.writerow([a.category_id, category_name, a.id, a.name])
|
|
else:
|
|
click.echo(f"@{a.category_id}: {category_name} » {a.id}: {a.name}")
|
|
|
|
|
|
@activities.command("delete")
|
|
@click.argument("ids", nargs=-1)
|
|
def delete_activities(ids):
|
|
"""Delete activities specified by IDS"""
|
|
|
|
activities = (
|
|
HamsterActivity.select(
|
|
HamsterActivity,
|
|
HamsterCategory.name,
|
|
fn.Count(HamsterFact.id).alias("facts_count"),
|
|
)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
.switch(HamsterActivity)
|
|
.join(HamsterFact, JOIN.LEFT_OUTER)
|
|
.group_by(HamsterActivity)
|
|
.where(HamsterActivity.id.in_(ids))
|
|
)
|
|
|
|
click.secho("Deleting:", fg="red")
|
|
|
|
for a in activities:
|
|
category_name = a.category.name if a.category_id != -1 else ""
|
|
click.echo(f"@{a.id}: {category_name} » {a.name} ({a.facts_count} facts)")
|
|
|
|
click.confirm("Do you want to continue?", abort=True)
|
|
|
|
[a.delete_instance() for a in activities]
|
|
|
|
click.secho("Deleted {0} activities".format(len(ids)), fg="green")
|
|
|
|
|
|
@activities.command()
|
|
@click.argument("category_id")
|
|
@click.argument("ids", nargs=-1)
|
|
def move(category_id, ids):
|
|
"""Move activities to another category"""
|
|
category = HamsterCategory.get(id=category_id)
|
|
activities = HamsterActivity.select().where(HamsterActivity.id.in_(ids))
|
|
|
|
click.secho(f'Moving to "@{category.id}: {category.name}":', fg="green")
|
|
|
|
for a in activities:
|
|
category_name = a.category.name if a.category_id != -1 else ""
|
|
click.secho(f"@{a.category_id}: {category_name} » @{a.id}: {a.name}", fg="blue")
|
|
|
|
click.confirm("Do you want to continue?", abort=True)
|
|
|
|
for a in activities:
|
|
a.category = category
|
|
a.save()
|
|
|
|
click.secho("Moved {0} activities".format(len(ids)), fg="green")
|
|
|
|
|
|
@activities.command()
|
|
@click.argument("ids", nargs=-1)
|
|
def list_facts(ids):
|
|
"""Show facts for activities"""
|
|
activities = HamsterActivity.select().where(HamsterActivity.id.in_(ids))
|
|
|
|
for a in activities:
|
|
click.secho(f"@{a.id}: {a.name}", fg="green")
|
|
|
|
for f in a.facts:
|
|
click.secho(f"@{f.id}, {f.start_time}", fg="blue")
|
|
|
|
|
|
@activities.command()
|
|
@click.argument("from_id")
|
|
@click.argument("to_id")
|
|
def move_facts(from_id, to_id):
|
|
"""Move facts from one activity to another"""
|
|
from_activity = HamsterActivity.get(id=from_id)
|
|
to_activity = HamsterActivity.get(id=to_id)
|
|
|
|
from_category_name = (
|
|
from_activity.category.name if from_activity.category_id != -1 else ""
|
|
)
|
|
to_category_name = (
|
|
to_activity.category.name if to_activity.category_id != -1 else ""
|
|
)
|
|
|
|
click.secho(
|
|
f'Moving facts from "{from_category_name} » @{from_activity.id}: {from_activity.name}" to "@{to_category_name} » @{to_activity.id}: {to_activity.name}"',
|
|
fg="green",
|
|
)
|
|
|
|
for f in from_activity.facts:
|
|
click.secho(f"@{f.id}, {f.start_time}", fg="blue")
|
|
|
|
click.confirm("Do you want to continue?", abort=True)
|
|
|
|
count = (
|
|
HamsterFact.update(activity_id=to_activity.id)
|
|
.where(HamsterFact.activity == from_activity)
|
|
.execute()
|
|
)
|
|
|
|
click.secho("Moved {0} facts".format(count), fg="green")
|
|
|
|
click.confirm(
|
|
f'Would you like to delete "{from_category_name} » @{from_activity.id}: {from_activity.name}?',
|
|
abort=True,
|
|
)
|
|
|
|
from_activity.delete_instance()
|
|
|
|
|
|
@activities.command()
|
|
def find_duplicates():
|
|
"""Show activities which are not unique in their categories"""
|
|
|
|
non_unique_activities = (
|
|
HamsterActivity.select(
|
|
HamsterActivity,
|
|
HamsterCategory.id,
|
|
fn.COALESCE(HamsterCategory.name, "None").alias("category_name"),
|
|
)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
.group_by(HamsterActivity.category_id, HamsterActivity.name)
|
|
.having(fn.COUNT(HamsterActivity.id) > 1)
|
|
)
|
|
|
|
for activity in non_unique_activities:
|
|
click.secho(
|
|
f"@{activity.category_id}: {activity.category_name} » @{activity.id}: {activity.name}",
|
|
fg="blue",
|
|
)
|
|
|
|
|
|
@cli.group()
|
|
@click.option("--kimai-api-url", envvar="KIMAI_API_URL")
|
|
@click.option("--kimai-username", envvar="KIMAI_USERNAME")
|
|
@click.option("--kimai-api-key", envvar="KIMAI_API_KEY")
|
|
@click.pass_context
|
|
def kimai(ctx, kimai_api_url, kimai_username, kimai_api_key):
|
|
file_config = ctx.obj['config']
|
|
ctx.obj['kimai'] = KimaiAPI(
|
|
kimai_username if kimai_username is not None else file_config.get("kimai_username"),
|
|
kimai_api_key if kimai_api_key is not None else file_config.get("kimai_api_key"),
|
|
kimai_api_url if kimai_api_url is not None else file_config.get("kimai_api_url"),
|
|
)
|
|
pass
|
|
|
|
|
|
def _get_kimai_mapping_file(path, category_search=None):
|
|
try:
|
|
return open(path)
|
|
except FileNotFoundError:
|
|
click.confirm("Mapping file {} not found, create it?:".format(path), abort=True)
|
|
mapping_file = open(path, "w")
|
|
mapping_writer = csv.writer(mapping_file)
|
|
|
|
mapping_writer.writerow(
|
|
[
|
|
"FROM category",
|
|
"FROM activity",
|
|
"TO Customer",
|
|
"TO Project",
|
|
"TO Activity",
|
|
"TO Tag",
|
|
"TO Note",
|
|
]
|
|
)
|
|
|
|
activities = HamsterActivity.select(HamsterActivity, HamsterCategory).join(
|
|
HamsterCategory, JOIN.LEFT_OUTER
|
|
)
|
|
|
|
for a in activities:
|
|
mapping_writer.writerow(
|
|
[a.category.name if a.category_id != -1 else "", a.name]
|
|
)
|
|
|
|
mapping_file.close()
|
|
return open(path)
|
|
|
|
|
|
@kimai.command()
|
|
@click.option(
|
|
"--mapping-path",
|
|
help="Mapping file (default ~/.local/share/hamster/mapping.kimai.csv)",
|
|
multiple=True,
|
|
)
|
|
@click.argument("username")
|
|
@click.option("--just-errors", "just_errors", is_flag=True, help="Only display errors")
|
|
@click.option("--ignore-activities", is_flag=True, help="Ignore missing activities")
|
|
def check(username, api_key, just_errors, ignore_activities, mapping_path=None):
|
|
"""
|
|
Check customer / project / activity data from Kimai
|
|
"""
|
|
|
|
kimai_api_url = "https://kimai.autonomic.zone/api"
|
|
|
|
if len(mapping_path) == 0:
|
|
mapping_path = (HAMSTER_DIR / "mapping.kimai.csv",)
|
|
|
|
mapping_files = []
|
|
for mapping_path_item in mapping_path:
|
|
if not Path(mapping_path_item).exists():
|
|
raise click.UsageError(f"{mapping_path_item} does not exist")
|
|
|
|
mapping_file = _get_kimai_mapping_file(mapping_path_item)
|
|
next(mapping_file)
|
|
mapping_files.append(mapping_file)
|
|
|
|
mapping_reader = csv.reader(chain(*mapping_files))
|
|
|
|
next(mapping_reader)
|
|
|
|
mapping_data = [[row[2], row[3], row[4]] for row in mapping_reader]
|
|
|
|
mapping_file.close()
|
|
|
|
auth_headers = {"X-AUTH-USER": username, "X-AUTH-TOKEN": api_key}
|
|
|
|
customers = requests.get(
|
|
f"{kimai_api_url}/customers?visible=3", headers=auth_headers
|
|
).json()
|
|
projects = requests.get(
|
|
f"{kimai_api_url}/projects?visible=3", headers=auth_headers
|
|
).json()
|
|
activities = requests.get(
|
|
f"{kimai_api_url}/activities?visible=3", headers=auth_headers
|
|
).json()
|
|
|
|
found_customers = []
|
|
found_projects = []
|
|
found_activities = []
|
|
|
|
for row in mapping_data:
|
|
# Check if each mapping still exists in Kimai
|
|
matching_customers = list(filter(lambda x: x["name"] == row[0], customers))
|
|
if row[0] in found_customers:
|
|
just_errors or click.secho(
|
|
"Skipping existing customer '{0}'".format(row[0]), fg="green"
|
|
)
|
|
else:
|
|
if len(matching_customers) > 1:
|
|
click.secho(
|
|
"More than one match for customer '{0}'".format(row[0]), fg="red"
|
|
)
|
|
continue
|
|
elif len(matching_customers) < 1:
|
|
click.secho("Missing customer '{0}'".format(row[0]), fg="yellow")
|
|
continue
|
|
else:
|
|
just_errors or click.secho(
|
|
"Found customer '{0}'".format(row[0]), fg="green"
|
|
)
|
|
found_customers.append(row[0])
|
|
|
|
project_str = ":".join(row[0:2])
|
|
matching_projects = list(
|
|
filter(
|
|
lambda x: x["name"] == row[1]
|
|
and x["customer"] == matching_customers[0]["id"],
|
|
projects,
|
|
)
|
|
)
|
|
|
|
if project_str in found_projects:
|
|
just_errors or click.secho(
|
|
"Skipping existing project '{0}'".format(project_str), fg="green"
|
|
)
|
|
else:
|
|
if len(matching_projects) > 1:
|
|
click.secho(
|
|
"More than one match for project '{0}'".format(project_str),
|
|
fg="red",
|
|
)
|
|
continue
|
|
elif len(matching_projects) < 1:
|
|
click.secho("Missing project '{0}'".format(project_str), fg="yellow")
|
|
continue
|
|
else:
|
|
just_errors or click.secho(
|
|
"Found project '{0}'".format(project_str), fg="green"
|
|
)
|
|
found_projects.append(project_str)
|
|
|
|
if ignore_activities:
|
|
continue
|
|
|
|
activity_str = ":".join(row)
|
|
if activity_str in found_activities:
|
|
just_errors or click.secho(
|
|
"Skipping existing activity '{0}'".format(activity_str), fg="green"
|
|
)
|
|
else:
|
|
matching_activities = list(
|
|
filter(
|
|
lambda x: x["name"] == row[2]
|
|
and x["project"] == matching_projects[0]["id"],
|
|
activities,
|
|
)
|
|
)
|
|
|
|
if len(matching_activities) > 1:
|
|
click.secho(
|
|
"More than one match for activity '{0}'".format(activity_str),
|
|
fg="red",
|
|
)
|
|
elif len(matching_activities) < 1:
|
|
click.secho("Missing activity '{0}'".format(activity_str), fg="yellow")
|
|
else:
|
|
just_errors or click.secho(
|
|
"Found activity '{0}'".format(activity_str), fg="green"
|
|
)
|
|
found_activities.append(activity_str)
|
|
|
|
|
|
@kimai.command("csv")
|
|
@click.option(
|
|
"--mapping-path",
|
|
help="Mapping file (default ~/.local/share/hamster/mapping.kimai.csv)",
|
|
multiple=True,
|
|
)
|
|
@click.option("--output", help="Output file (default kimai.csv)")
|
|
@click.option("--category-search", help="Category search string")
|
|
@click.option("--after", help="Only show time entries after this date")
|
|
@click.option("--show-missing", help="Just report on the missing entries", is_flag=True)
|
|
@click.argument("username")
|
|
def _csv(
|
|
username,
|
|
mapping_path=None,
|
|
output=None,
|
|
category_search=None,
|
|
after=None,
|
|
show_missing=False,
|
|
):
|
|
"""
|
|
Export time tracking data in Kimai format
|
|
"""
|
|
|
|
if mapping_path is None:
|
|
mapping_path = HAMSTER_DIR / "mapping.kimai.csv"
|
|
|
|
if output is None:
|
|
timestamp = datetime.now().strftime("%F")
|
|
output = f"kimai_{timestamp}.csv"
|
|
|
|
if isinstance(mapping_path, tuple):
|
|
mapping_files = []
|
|
for mapping_path_item in mapping_path:
|
|
mapping_file = _get_kimai_mapping_file(mapping_path_item, category_search)
|
|
next(mapping_file)
|
|
mapping_files.append(mapping_file)
|
|
mapping_reader = csv.reader(chain(*mapping_files))
|
|
else:
|
|
mapping_file = _get_kimai_mapping_file(mapping_path, category_search)
|
|
next(mapping_file)
|
|
mapping_reader = csv.reader(mapping_file)
|
|
|
|
mapping = {
|
|
"{0}:{1}".format(row[0], row[1]): [row[2], row[3], row[4], row[5]]
|
|
for row in mapping_reader
|
|
}
|
|
|
|
if isinstance(mapping_path, tuple):
|
|
for mapping_file in mapping_files:
|
|
mapping_file.close()
|
|
else:
|
|
mapping_file.close()
|
|
|
|
output_file = open(output, "w")
|
|
output_writer = csv.writer(output_file)
|
|
|
|
facts = (
|
|
HamsterFact.select(HamsterFact, HamsterActivity, HamsterCategory)
|
|
.join(HamsterActivity)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
)
|
|
|
|
|
|
|
|
if category_search is not None:
|
|
facts = facts.where(HamsterCategory.name.contains(category_search))
|
|
|
|
if after is not None:
|
|
facts = facts.where(HamsterFact.start_time >= after)
|
|
|
|
if not show_missing:
|
|
output_writer.writerow(
|
|
[
|
|
"Date",
|
|
"From",
|
|
"To",
|
|
"Duration",
|
|
"Rate",
|
|
"User",
|
|
"Customer",
|
|
"Project",
|
|
"Activity",
|
|
"Description",
|
|
"Exported",
|
|
"Tags",
|
|
"HourlyRate",
|
|
"FixedRate",
|
|
"InternalRate",
|
|
]
|
|
)
|
|
|
|
for fact in facts:
|
|
k = f"{fact.activity.category.name}:{fact.activity.name}"
|
|
try:
|
|
mapping_ = mapping[k]
|
|
except KeyError:
|
|
if show_missing:
|
|
output_writer.writerow(
|
|
[fact.activity.category.name, fact.activity.name]
|
|
)
|
|
click.secho("Can't find mapping for '{0}', skipping".format(k), fg="yellow")
|
|
continue
|
|
|
|
if show_missing:
|
|
continue
|
|
|
|
if fact.start_time is None or fact.end_time is None:
|
|
click.secho(
|
|
f"Missing duration data '{fact.start_time}-{fact.end_time}', skipping",
|
|
fg="yellow",
|
|
)
|
|
continue
|
|
|
|
if len(mapping_) < 5:
|
|
mapping_.append(None)
|
|
|
|
date_start, date_end = (
|
|
datetime.strptime(fact.start_time.split(".")[0], "%Y-%m-%d %H:%M:%S"),
|
|
datetime.strptime(fact.end_time.split(".")[0], "%Y-%m-%d %H:%M:%S"),
|
|
)
|
|
duration = (date_start - date_end).seconds / 3600
|
|
|
|
output_writer.writerow(
|
|
[
|
|
date_start.strftime("%Y-%m-%d"),
|
|
date_start.strftime("%H:%M"),
|
|
"", # To (time)
|
|
duration,
|
|
"", # Rate
|
|
username,
|
|
mapping_[0],
|
|
mapping_[1],
|
|
mapping_[2],
|
|
fact.description or mapping_[4] or "",
|
|
"0", # Exported
|
|
mapping_[3],
|
|
"", # Hourly rate
|
|
"", # Fixed rate
|
|
]
|
|
)
|
|
|
|
output_file.close()
|
|
|
|
|
|
@kimai.command("import")
|
|
@click.argument("search")
|
|
@click.argument("after")
|
|
@click.argument("before")
|
|
@click.pass_context
|
|
def _import(ctx, search, after, before):
|
|
api = ctx.obj
|
|
|
|
SEARCH = "auto"
|
|
|
|
facts = (
|
|
HamsterFact.select(HamsterFact, HamsterActivity, HamsterCategory)
|
|
.join(HamsterActivity, JOIN.LEFT_OUTER)
|
|
.join(HamsterCategory, JOIN.LEFT_OUTER)
|
|
.switch(HamsterFact)
|
|
.join(HamsterFactTag, JOIN.LEFT_OUTER)
|
|
.where(
|
|
(HamsterFact.start_time > datetime.strptime(after, "%Y-%m-%d"))
|
|
& (HamsterFact.start_time < datetime.strptime(before, "%Y-%m-%d"))
|
|
& HamsterCategory.name.contains(SEARCH)
|
|
)
|
|
)
|
|
|
|
has_errors = False
|
|
|
|
# check data
|
|
for f in facts:
|
|
mappings = f.activity.mappings
|
|
if len(mappings) == 0:
|
|
print(
|
|
f"fact {f.id}: @{f.activity.category.id} {f.activity.category.name} » @{f.activity.id} {f.activity.name} has no mapping"
|
|
)
|
|
has_errors = True
|
|
continue
|
|
if len(mappings) > 1:
|
|
print(
|
|
f"fact {f.id}: activity @{f.activity.id} {f.activity.name} has multiple mappings"
|
|
)
|
|
has_errors = True
|
|
continue
|
|
if (
|
|
mappings[0].kimai_activity.project is None
|
|
and not mappings[0].kimai_project.allow_global_activities
|
|
):
|
|
click.secho(
|
|
f"fact {f.id}: project @{mappings[0].kimai_project.id} {mappings[0].kimai_project.name} does not allow global activity {mappings[0].kimai_activity} ({mappings[0].hamster_activity.name})", fg="red",
|
|
)
|
|
has_errors = True
|
|
continue
|
|
if f.imports.count() > 0:
|
|
click.secho(
|
|
f"fact {f.id}: activity @{f.activity.id} {f.activity.name} was already imported {f.imports.count()} time(s)",
|
|
fg="yellow",
|
|
)
|
|
continue
|
|
|
|
if has_errors:
|
|
sys.exit(1)
|
|
|
|
# upload data
|
|
for f in facts:
|
|
try:
|
|
mapping = f.activity.mappings[0]
|
|
except IndexError:
|
|
print(
|
|
f"no mapping, skipping {f.id} ({f.activity.category.name} » {f.activity.name})"
|
|
)
|
|
continue
|
|
|
|
if f.imports.count() > 0:
|
|
print(
|
|
f"already imported, skipping {f.id} ({f.activity.category.name} » {f.activity.name})"
|
|
)
|
|
continue
|
|
|
|
t = Timesheet(
|
|
api,
|
|
activity=mapping.kimai_activity,
|
|
project=mapping.kimai_project,
|
|
begin=f.start_time,
|
|
end=f.end_time,
|
|
description=f.description
|
|
if f.description != ""
|
|
else mapping.kimai_description,
|
|
tags=",".join([t.tag.name for t in f.tags]) if len(f.tags) > 0 else mapping.kimai_tags
|
|
)
|
|
r = t.upload().json()
|
|
if len(f.tags) > 0 or mapping.kimai_tags:
|
|
print(",".join([t.tag.name for t in f.tags]) if len(f.tags)> 0 else mapping.kimai_tags)
|
|
print(r["tags"])
|
|
if r.get("code", 200) != 200:
|
|
print(r)
|
|
print(f"{f.id} ({f.activity.category.name} » {f.activity.name})")
|
|
|
|
else:
|
|
HamsterFactKimaiImport.create(hamster_fact=f, kimai_id=r["id"]).save()
|
|
print(f'Created Kimai timesheet {r["id"]}')
|
|
|
|
|
|
@kimai.group("db")
|
|
def kimai_db():
|
|
pass
|
|
|
|
|
|
@kimai_db.command()
|
|
def init():
|
|
db.create_tables(
|
|
[
|
|
KimaiCustomer,
|
|
KimaiProject,
|
|
KimaiActivity,
|
|
KimaiTag,
|
|
HamsterActivityKimaiMapping,
|
|
HamsterFactKimaiImport,
|
|
]
|
|
)
|
|
|
|
|
|
@kimai_db.command()
|
|
def reset():
|
|
HamsterActivityKimaiMapping.delete().execute()
|
|
|
|
|
|
@kimai_db.command("sync")
|
|
@click.pass_context
|
|
def kimai_db_sync(ctx):
|
|
sync(
|
|
ctx.obj['kimai']
|
|
)
|
|
|
|
|
|
@kimai_db.command()
|
|
@click.option(
|
|
"-g",
|
|
"--global",
|
|
"global_",
|
|
help="Does this file contain mappings to global activties",
|
|
is_flag=True,
|
|
)
|
|
@click.option("--mapping-path", help="Mapping file")
|
|
def mapping2db(mapping_path=None, global_=False):
|
|
mapping_file = _get_kimai_mapping_file(mapping_path, None)
|
|
next(mapping_file)
|
|
mapping_reader = csv.reader(mapping_file)
|
|
|
|
for row in mapping_reader:
|
|
hamster_category = HamsterCategory.get(name=row[0])
|
|
hamster_activity = HamsterActivity.get(
|
|
name=row[1], category_id=hamster_category.id
|
|
)
|
|
kimai_customer = KimaiCustomer.get(name=row[2])
|
|
kimai_project = KimaiProject.get(name=row[3], customer_id=kimai_customer.id)
|
|
|
|
try:
|
|
kimai_activity = KimaiActivity.get(name=row[4], project_id=kimai_project.id)
|
|
except KimaiActivity.DoesNotExist:
|
|
kimai_activity = KimaiActivity.get(name=row[4], project_id=None)
|
|
|
|
HamsterActivityKimaiMapping.create(
|
|
hamster_activity=hamster_activity,
|
|
kimai_customer=kimai_customer,
|
|
kimai_project=kimai_project,
|
|
kimai_activity=kimai_activity,
|
|
kimai_description=row[6],
|
|
kimai_tags=row[5],
|
|
)
|
|
|
|
|
|
@cli.group()
|
|
@click.option("--api-key", envvar="CLOCKIFY_API_KEY", help="Clockify API key")
|
|
@click.option("--workspace-id", envvar="CLOCKIFY_WORKSPACE_ID", help="Clockify workspace ID")
|
|
@click.pass_context
|
|
def clockify(ctx, api_key, workspace_id):
|
|
file_config = ctx.obj['config']
|
|
ctx.obj['clockify'] = Clockify(
|
|
api_key=api_key if api_key is not None else file_config.get("clockify_api_key"),
|
|
workspace_id=workspace_id if workspace_id is not None else file_config.get("clockify_workspace_id")
|
|
)
|
|
|
|
|
|
@clockify.group("db")
|
|
def clockify_db():
|
|
pass
|
|
|
|
|
|
@clockify_db.command("sync")
|
|
@click.pass_context
|
|
def clockify_db_sync(ctx):
|
|
from .clockify import sync_projects
|
|
count = sync_projects(ctx.obj['clockify'], db)
|
|
click.echo(f"Synced {count} Clockify projects")
|
|
|
|
|
|
@clockify_db.command("init")
|
|
def clockify_db_init():
|
|
db.create_tables(
|
|
[
|
|
ClockifyProject,
|
|
HamsterClockifyMapping,
|
|
HamsterFactClockifyImport,
|
|
]
|
|
)
|
|
|
|
@clockify.command("app")
|
|
@click.pass_context
|
|
def clockify_app(ctx):
|
|
from .app import HamsterToolsAppClockify
|
|
|
|
app = HamsterToolsAppClockify(ctx.obj['clockify'])
|
|
app.run()
|
|
|
|
@kimai.command("app")
|
|
@click.pass_context
|
|
def kimai_app(ctx):
|
|
from .app import HamsterToolsAppKimai
|
|
|
|
app = HamsterToolsAppKimai(ctx.obj['kimai'])
|
|
app.run()
|
|
|
|
|
|
@cli.command()
|
|
def app():
|
|
from .app import HamsterToolsApp
|
|
|
|
app = HamsterToolsApp()
|
|
app.run()
|
|
|
|
|
|
@cli.command()
|
|
def hamster():
|
|
click.echo("🐹")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
cli()
|