├── timetagger ├── app │ ├── __init__.py │ ├── sandbox.md │ ├── timetagger_manifest.json │ ├── _template.html │ ├── demo.md │ ├── index.md │ ├── sw.js │ ├── tools.py │ └── app.scss ├── pages │ ├── __init__.py │ ├── logout.md │ ├── index.md │ ├── login.md │ └── account.md ├── common │ ├── __init__.py │ ├── Ubuntu-C.ttf │ ├── Ubuntu-R.ttf │ ├── clearly-602.ogg │ ├── wind-up-1-534.ogg │ ├── Ubuntu_latin.woff2 │ ├── eventually-590.ogg │ ├── fa-solid-900.woff2 │ ├── UbuntuCondensed_latin.woff2 │ ├── SpaceMono-Regular-webfont.woff │ ├── sha1.html │ ├── _template.html │ ├── cred.html │ └── _style_embed.scss ├── images │ ├── __init__.py │ ├── paper0.jpg │ ├── paper1.jpg │ ├── paper2.jpg │ ├── paper3.jpg │ ├── favicon.ico │ ├── timetagger_sf.ico │ ├── timetagger128_sf.png │ ├── timetagger16_sf.png │ ├── timetagger192_bd.png │ ├── timetagger192_sd.png │ ├── timetagger192_sf.png │ ├── timetagger192_sl.png │ ├── timetagger192_sm.png │ ├── timetagger192_tg.png │ ├── timetagger256_sf.png │ ├── timetagger32_sf.png │ ├── timetagger48_sf.png │ ├── timetagger512_bd.png │ ├── timetagger512_sf.png │ ├── timetagger512_sm.png │ ├── timetagger64_sf.png │ ├── timetagger192_sf_dot.png │ ├── _names.txt │ ├── timetagger_sd.svg │ ├── timetagger_sl.svg │ ├── _update_icons.py │ ├── _update_paper.py │ ├── timetagger_wd.svg │ └── timetagger_wl.svg ├── server │ ├── __init__.py │ ├── _utils.py │ └── _assets.py ├── __init__.py ├── _config.py └── __main__.py ├── .github ├── pull_request_template.md ├── FUNDING.yml └── workflows │ ├── ci.yml │ └── dockerimage.yml ├── docs ├── docs_requirements.txt ├── mkdocs.yml └── docs │ ├── libapi.md │ ├── index.md │ └── webapi.md ├── MANIFEST.in ├── tests ├── import_samples │ ├── timechimp_sample.txt │ └── yast_sample.csv ├── _common.py ├── test_client_stores.py ├── test_both.py ├── test_server_utils.py ├── test_config.py ├── test_server_assetserver.py ├── test_client_dt.py ├── test_server_mainhandler.py ├── test_client_utils.py └── test_client_recordstore.py ├── requirements.txt ├── .readthedocs.yaml ├── deploy ├── image.Dockerfile ├── repo.Dockerfile ├── docker-compose.yml ├── docker-compose.nonroot.yml ├── repo.rpi.Dockerfile ├── repo.nonroot.Dockerfile └── pip.Dockerfile ├── setup.py ├── .gitignore ├── CLA.md ├── tasks.py └── README.md /timetagger/app/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /timetagger/pages/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /timetagger/common/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /timetagger/images/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/docs_requirements.txt: -------------------------------------------------------------------------------- 1 | mkdocs 2 | mkautodoc 3 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include LICENSE README.md requirements.txt 2 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | custom: ["https://timetagger.app", "https://almarklein.org/donate.html"] 2 | -------------------------------------------------------------------------------- /timetagger/images/paper0.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/paper0.jpg -------------------------------------------------------------------------------- /timetagger/images/paper1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/paper1.jpg -------------------------------------------------------------------------------- /timetagger/images/paper2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/paper2.jpg -------------------------------------------------------------------------------- /timetagger/images/paper3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/paper3.jpg -------------------------------------------------------------------------------- /timetagger/common/Ubuntu-C.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/Ubuntu-C.ttf -------------------------------------------------------------------------------- /timetagger/common/Ubuntu-R.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/Ubuntu-R.ttf -------------------------------------------------------------------------------- /timetagger/images/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/favicon.ico -------------------------------------------------------------------------------- /timetagger/common/clearly-602.ogg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/clearly-602.ogg -------------------------------------------------------------------------------- /timetagger/common/wind-up-1-534.ogg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/wind-up-1-534.ogg -------------------------------------------------------------------------------- /timetagger/images/timetagger_sf.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger_sf.ico -------------------------------------------------------------------------------- /timetagger/common/Ubuntu_latin.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/Ubuntu_latin.woff2 -------------------------------------------------------------------------------- /timetagger/common/eventually-590.ogg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/eventually-590.ogg -------------------------------------------------------------------------------- /timetagger/common/fa-solid-900.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/fa-solid-900.woff2 -------------------------------------------------------------------------------- /timetagger/images/timetagger128_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger128_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger16_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger16_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_bd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_bd.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_sd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_sd.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_sl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_sl.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_sm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_sm.png -------------------------------------------------------------------------------- /timetagger/images/timetagger192_tg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_tg.png -------------------------------------------------------------------------------- /timetagger/images/timetagger256_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger256_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger32_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger32_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger48_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger48_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger512_bd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger512_bd.png -------------------------------------------------------------------------------- /timetagger/images/timetagger512_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger512_sf.png -------------------------------------------------------------------------------- /timetagger/images/timetagger512_sm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger512_sm.png -------------------------------------------------------------------------------- /timetagger/images/timetagger64_sf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger64_sf.png -------------------------------------------------------------------------------- /tests/import_samples/timechimp_sample.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/tests/import_samples/timechimp_sample.txt -------------------------------------------------------------------------------- /timetagger/images/timetagger192_sf_dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/images/timetagger192_sf_dot.png -------------------------------------------------------------------------------- /timetagger/common/UbuntuCondensed_latin.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/UbuntuCondensed_latin.woff2 -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | uvicorn 2 | asgineer>=0.8.0 3 | itemdb>=1.1.1 4 | pscript>=0.7.6 5 | pyjwt 6 | jinja2 7 | markdown 8 | bcrypt 9 | iptools 10 | -------------------------------------------------------------------------------- /timetagger/common/SpaceMono-Regular-webfont.woff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/almarklein/timetagger/HEAD/timetagger/common/SpaceMono-Regular-webfont.woff -------------------------------------------------------------------------------- /timetagger/common/sha1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /tests/_common.py: -------------------------------------------------------------------------------- 1 | def run_tests(scope): 2 | """Run all test functions in the given scope.""" 3 | for func in list(scope.values()): 4 | if callable(func) and func.__name__.startswith("test_"): 5 | print(f"Running {func.__name__} ...") 6 | func() 7 | print("Done") 8 | -------------------------------------------------------------------------------- /.readthedocs.yaml: -------------------------------------------------------------------------------- 1 | version: 2 2 | 3 | formats: all 4 | 5 | build: 6 | os: ubuntu-22.04 7 | tools: 8 | python: "3.11" 9 | 10 | mkdocs: 11 | configuration: docs/mkdocs.yml 12 | 13 | python: 14 | install: 15 | - requirements: requirements.txt 16 | - requirements: docs/docs_requirements.txt 17 | -------------------------------------------------------------------------------- /timetagger/pages/logout.md: -------------------------------------------------------------------------------- 1 | # Logout 2 | 3 | 4 | 5 | 16 | 17 | Logging out ... 18 | -------------------------------------------------------------------------------- /timetagger/server/__init__.py: -------------------------------------------------------------------------------- 1 | # flake8: noqa 2 | 3 | from ._utils import user2filename, filename2user 4 | from ._apiserver import ( 5 | authenticate, 6 | AuthException, 7 | api_handler_triage, 8 | get_webtoken_unsafe, 9 | ) 10 | from ._assets import ( 11 | md2html, 12 | create_assets_from_dir, 13 | enable_service_worker, 14 | IMAGE_EXTS, 15 | FONT_EXTS, 16 | ) 17 | -------------------------------------------------------------------------------- /deploy/image.Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile that is simply based on the published Docker image. 2 | # 3 | # Some MyPaas args (ignore if you don't use MyPaas): 4 | # 5 | # mypaas.service = timetagger.test1 6 | # mypaas.url = https://test1.timetagger.app 7 | # mypaas.volume = /root/_timetagger:/root/_timetagger 8 | # mypaas.maxmem = 256m 9 | # mypaas.env = TIMETAGGER_CREDENTIALS 10 | 11 | FROM ghcr.io/almarklein/timetagger 12 | -------------------------------------------------------------------------------- /docs/mkdocs.yml: -------------------------------------------------------------------------------- 1 | site_name: TimeTagger 2 | site_description: Tag your time, get the insight. 3 | theme: readthedocs 4 | 5 | repo_name: almarklein/timetagger 6 | repo_url: https://github.com/almarklein/timetagger 7 | edit_uri: "" 8 | 9 | nav: 10 | - Home: index.md 11 | - Library API: libapi.md 12 | - Web API: webapi.md 13 | 14 | markdown_extensions: 15 | - admonition 16 | - codehilite 17 | - mkautodoc 18 | -------------------------------------------------------------------------------- /timetagger/__init__.py: -------------------------------------------------------------------------------- 1 | """ 2 | Timetagger - Tag your time, get the insight. 3 | """ 4 | 5 | __version__ = "25.12.1" 6 | 7 | version_info = tuple(map(int, __version__.split("."))) 8 | 9 | 10 | from ._config import config # noqa 11 | from . import server # noqa - server logic 12 | from . import common # noqa - common assets 13 | from . import images # noqa - image assets 14 | from . import app # noqa - app assets 15 | from . import pages # noqa - pages 16 | -------------------------------------------------------------------------------- /timetagger/images/_names.txt: -------------------------------------------------------------------------------- 1 | * PNG's have their size in the name. 2 | * The suffix has 2 chars: 3 | * type: 4 | * "s" for small, square 5 | * "w" for word, wide 6 | * "b" for below, big 7 | * "t" for text-only 8 | * coloring: 9 | * "d" for dark (to be used on a light bg) 10 | * "l" for light (to be used on a dark bg) 11 | * "g" for gray 12 | * "f" for filled (dark on a light circle) 13 | * "m" for maskable (dark on a white square) 14 | -------------------------------------------------------------------------------- /timetagger/app/sandbox.md: -------------------------------------------------------------------------------- 1 | % TimeTagger - Sandbox 2 | % An empty app, not connected to the server, to try things out. 3 | 4 | 17 | 18 | This page needs a working (HTML5) canvas. 19 | -------------------------------------------------------------------------------- /deploy/repo.Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile to build an image from the repo. 2 | # Note that the build context must be the root of the repo. 3 | # Used by CI to build the image that is pushed to ghcr. 4 | 5 | FROM python:3.13-slim-bookworm 6 | 7 | WORKDIR /root 8 | COPY . . 9 | 10 | # Install dependencies (including optional ones that make uvicorn faster) 11 | # Upgrade pip to the lastest version 12 | RUN pip --no-cache-dir install pip --upgrade && \ 13 | # Install optional depedencies that make uvicorn faster 14 | pip --no-cache-dir install uvicorn uvloop httptools && \ 15 | # Install timetagger depedencies defined via setup.py 16 | pip install --no-cache-dir --no-warn-script-location -e . 17 | 18 | CMD ["python", "-m", "timetagger"] 19 | -------------------------------------------------------------------------------- /timetagger/common/_template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {{ title }} 6 | 7 | 8 | 9 | 10 | 11 | 14 | 15 | 16 | 17 | 18 |
19 |
20 |
21 | Home | Account | App | Demo | Sandbox 22 |
23 | {{ main }} 24 |
25 |
26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /deploy/docker-compose.yml: -------------------------------------------------------------------------------- 1 | # Example docker-compose file for TimeTagger that uses the published 2 | # Docker image in the default root variant. 3 | # Shows all options settable via the environment. 4 | # 5 | # !! Make sure to apply your own credentials !! 6 | # !! You can use e.g. https://timetagger.app/cred to generate them !! 7 | # !! In docker-compose characters '$' should be escaped as '$$' !! 8 | # !! If you use a .env file, use single quotes instead of escaping !! 9 | 10 | services: 11 | timetagger: 12 | image: ghcr.io/almarklein/timetagger 13 | ports: 14 | - "80:80" 15 | volumes: 16 | - ./_timetagger:/root/_timetagger 17 | environment: 18 | - TIMETAGGER_BIND=0.0.0.0:80 19 | - TIMETAGGER_DATADIR=/root/_timetagger 20 | - TIMETAGGER_LOG_LEVEL=info 21 | - TIMETAGGER_CREDENTIALS=test:$$2a$$08$$0CD1NFiIbancwWsu3se1v.RNR/b7YeZd71yg3cZ/3whGlyU6Iny5i # test:test 22 | -------------------------------------------------------------------------------- /deploy/docker-compose.nonroot.yml: -------------------------------------------------------------------------------- 1 | # Example docker-compose file for TimeTagger that uses the published 2 | # Docker image in the nonroot variant. 3 | # Shows all options settable via the environment. 4 | # 5 | # !! Make sure to apply your own credentials !! 6 | # !! You can use e.g. https://timetagger.app/cred to generate them !! 7 | # !! In docker-compose characters '$' should be escaped as '$$' !! 8 | # !! If you use a .env file, use single quotes instead of escaping !! 9 | 10 | services: 11 | timetagger: 12 | image: ghcr.io/almarklein/timetagger:latest-nonroot 13 | ports: 14 | - "80:80" 15 | volumes: 16 | - ./_timetagger:/opt/_timetagger 17 | environment: 18 | - TIMETAGGER_BIND=0.0.0.0:80 19 | - TIMETAGGER_DATADIR=/opt/_timetagger 20 | - TIMETAGGER_LOG_LEVEL=info 21 | - TIMETAGGER_CREDENTIALS=test:$$2a$$08$$0CD1NFiIbancwWsu3se1v.RNR/b7YeZd71yg3cZ/3whGlyU6Iny5i # test:test 22 | -------------------------------------------------------------------------------- /docs/docs/libapi.md: -------------------------------------------------------------------------------- 1 | # TimeTagger library reference 2 | 3 | 4 | ## Configuration 5 | 6 | ::: timetagger.config 7 | :docstring: 8 | 9 | 10 | ## Utils 11 | 12 | ::: timetagger.server.user2filename 13 | :docstring: 14 | 15 | ::: timetagger.server.filename2user 16 | :docstring: 17 | 18 | 19 | ## For the API server 20 | 21 | ::: timetagger.server.authenticate 22 | :docstring: 23 | 24 | 25 | ::: timetagger.server.AuthException 26 | :docstring: 27 | 28 | 29 | ::: timetagger.server.api_handler_triage 30 | :docstring: 31 | 32 | 33 | ::: timetagger.server.get_webtoken_unsafe 34 | :docstring: 35 | 36 | 37 | ## For the assets server 38 | 39 | ::: timetagger.server.md2html 40 | :docstring: 41 | 42 | ::: timetagger.server.create_assets_from_dir 43 | :docstring: 44 | 45 | ::: timetagger.server.enable_service_worker 46 | :docstring: 47 | 48 | ::: timetagger.server.IMAGE_EXTS 49 | 50 | ::: timetagger.server.FONT_EXTS 51 | 52 | -------------------------------------------------------------------------------- /deploy/repo.rpi.Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile to build an image from the repo, suited for the Raspberry-pi 2 | # Note that the build context must be the root of the repo. 3 | 4 | FROM python:3.10-slim-bullseye 5 | 6 | ARG DEBIAN_FRONTEND=noninteractive 7 | ARG CRYPTOGRAPHY_DONT_BUILD_RUST=1 8 | 9 | # Install dependencies (including optional ones that make uvicorn faster) 10 | RUN apt-get update && \ 11 | apt-get -qq install build-essential libssl-dev libffi-dev gcc && \ 12 | pip --no-cache-dir install pip --upgrade && \ 13 | pip --no-cache-dir install -U "bcrypt<4.0.0" && \ 14 | pip --no-cache-dir install \ 15 | uvicorn uvloop httptools \ 16 | fastuaparser itemdb>=1.1.1 asgineer requests \ 17 | jinja2 markdown pscript \ 18 | pyjwt cryptography==3.4.6 19 | 20 | WORKDIR /root 21 | COPY . . 22 | 23 | RUN pip install -e . 24 | # Example docker-compose file for TimeTagger that uses the published 25 | 26 | CMD ["python", "-m", "timetagger"] 27 | -------------------------------------------------------------------------------- /timetagger/images/timetagger_sd.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /timetagger/images/timetagger_sl.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /timetagger/images/_update_icons.py: -------------------------------------------------------------------------------- 1 | # import imageio 2 | import webruntime 3 | 4 | 5 | sizes = 16, 32, 48, 64, 128, 256 6 | 7 | icon = webruntime.util.icon.Icon() 8 | for size in sizes: 9 | fname = f"timetagger{size}_sf.png" 10 | icon.read(fname) 11 | # imb = imageio.imread(fname) 12 | # imw = 255 - imb # make white the inverse 13 | # imw[:, :, 3] = imb[:, :, 3] # Transfer original alpha channel 14 | # imageio.imsave(f"timetagger{size}w.png", imw) 15 | 16 | icon.write(f"timetagger_sf.ico") 17 | icon.write(f"favicon.ico") 18 | 19 | # %% 20 | 21 | im1, shape = webruntime.util.png.read_png(open("timetagger192.png", "rb")) 22 | im2, shape = webruntime.util.png.read_png(open("timetagger192w.png", "rb")) 23 | 24 | # soften alpha 25 | for i in range(3, len(im1), 4): 26 | im1[i] = int(im1[i] * 0.1 + 0.4999) 27 | im2[i] = int(im2[i] * 0.1 + 0.4999) 28 | 29 | with open("timetagger192soft.png", "wb") as f: 30 | webruntime.util.png.write_png(im1, shape, f) 31 | with open("timetagger192wsoft.png", "wb") as f: 32 | webruntime.util.png.write_png(im2, shape, f) 33 | -------------------------------------------------------------------------------- /deploy/repo.nonroot.Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile to build an image from the repo. 2 | # Note that the build context must be the root of the repo. 3 | # Used by CI to build the image that is pushed to ghcr. 4 | # Unpriviliged version that installs and runs as UID 1000. 5 | 6 | FROM python:3.13-slim-bookworm 7 | 8 | # Create unpriviliged user and group, including directory structure 9 | RUN groupadd -g 1000 timetagger && \ 10 | useradd -r -u 1000 -m -g timetagger timetagger && \ 11 | mkdir /opt/timetagger && \ 12 | chown timetagger:timetagger /opt/timetagger 13 | 14 | # Switch to unpriviliged user 15 | USER 1000 16 | 17 | WORKDIR /opt/timetagger 18 | COPY . /opt/timetagger 19 | 20 | # Install dependencies (including optional ones that make uvicorn faster) 21 | # Upgrade pip to the lastest version 22 | RUN pip --no-cache-dir install pip --upgrade && \ 23 | # Install optional depedencies that make uvicorn faster 24 | pip --no-cache-dir install uvicorn uvloop httptools && \ 25 | # Install timetagger depedencies defined via setup.py 26 | pip install --no-cache-dir --no-warn-script-location -e . 27 | 28 | CMD ["python", "-m", "timetagger"] 29 | -------------------------------------------------------------------------------- /tests/test_client_stores.py: -------------------------------------------------------------------------------- 1 | """ 2 | Test other stores. 3 | """ 4 | 5 | import datetime 6 | 7 | from _common import run_tests 8 | from timetagger.app import stores 9 | 10 | 11 | class Stub: 12 | def addEventListener(self, *args): 13 | pass 14 | 15 | def setTimeout(self, *args): 16 | pass 17 | 18 | def clearTimeout(self, *args): 19 | pass 20 | 21 | 22 | stores.window = Stub() 23 | stores.window.document = Stub() 24 | 25 | 26 | def test_demo_record_store(): 27 | ds = stores.DemoDataStore() 28 | 29 | # There are now records for only one year 30 | # Note that this test fails early januari :P 31 | if datetime.date.today().month > 1: 32 | assert len(ds.records.get_records(0, 1e15)) > 25 33 | assert len(ds.records.get_records(0, 1e15)) < 2000 34 | 35 | # Build other years 36 | for year in ds._years: 37 | ds._create_one_year_of_data(year) 38 | 39 | # Now we have the full demo. The demo generates the records async 40 | assert len(ds.records.get_records(0, 1e15)) > 2000 41 | 42 | stats = ds.records.get_stats(0, 1e15) 43 | assert len(stats.keys()) > 1 44 | print(stats) 45 | 46 | 47 | if __name__ == "__main__": 48 | run_tests(globals()) 49 | -------------------------------------------------------------------------------- /timetagger/app/timetagger_manifest.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "TimeTagger App", 3 | "short_name": "TimeTagger", 4 | "description": "Tag your time, get the insight. An open source time tracker for individuals.", 5 | "categories": ["productivity"], 6 | "lang": "en-US", 7 | "start_url": "./", 8 | "scope": "./", 9 | "display": "standalone", 10 | "theme_color": "#F4F4F4", 11 | "background_color": "#E6E7E5", 12 | "icons": [ 13 | { 14 | "src": "timetagger192_sf.png", 15 | "sizes": "192x192", 16 | "type": "image/png", 17 | "purpose": "any" 18 | }, 19 | { 20 | "src": "timetagger512_sf.png", 21 | "sizes": "512x512", 22 | "type": "image/png", 23 | "purpose": "any" 24 | }, 25 | { 26 | "src": "timetagger192_sm.png", 27 | "sizes": "192x192", 28 | "type": "image/png", 29 | "purpose": "maskable" 30 | }, 31 | { 32 | "src": "timetagger512_sm.png", 33 | "sizes": "512x512", 34 | "type": "image/png", 35 | "purpose": "maskable" 36 | } 37 | ], 38 | "screenshots": [ 39 | ] 40 | } 41 | -------------------------------------------------------------------------------- /tests/test_both.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | from _common import run_tests 4 | 5 | import timetagger 6 | 7 | 8 | server_fname = os.path.dirname(timetagger.server.__file__) 9 | client_fname = os.path.dirname(timetagger.app.__file__) 10 | 11 | 12 | def get_common_lines_from_module(filename): 13 | t_begin = "# ----- COMMON PART" 14 | t_end = "# ----- END COMMON PART" 15 | if not isinstance(filename, str): 16 | filename = filename.__file__ 17 | code = open(filename, "rb").read().decode() 18 | lines = code.split(t_begin)[1].split(t_end)[0].splitlines() 19 | lines.pop(0) 20 | lines = [line.rstrip() for line in lines if line.rstrip()] 21 | return lines 22 | 23 | 24 | def test_matching_specs_and_reqs(): 25 | """Ensure that both server and client use the same spec to 26 | validate items and to ensure the same required fields. 27 | """ 28 | server_lines = get_common_lines_from_module(server_fname + "/_apiserver.py") 29 | client_lines = get_common_lines_from_module(client_fname + "/stores.py") 30 | 31 | assert len(server_lines) >= 4 32 | assert len(server_lines) == len(client_lines) 33 | for line1, line2 in zip(server_lines, client_lines): 34 | print("* " + line1 + "\n " + line2) 35 | assert line1 == line2 36 | 37 | assert server_lines == client_lines 38 | 39 | 40 | if __name__ == "__main__": 41 | run_tests(globals()) 42 | -------------------------------------------------------------------------------- /deploy/pip.Dockerfile: -------------------------------------------------------------------------------- 1 | # Dockerfile to build/run TimeTagger in a container, by installing 2 | # timegagger using pip (from PyPi or GitHub) at build time. 3 | # 4 | # Below are the MyPaas parameters that I use for deploying test builds. 5 | # You can ignore/remove these if you do not use MyPaas. You're probably 6 | # more interested in the docker-compose.yml :) 7 | # 8 | # mypaas.service = timetagger.test1 9 | # mypaas.url = https://test1.timetagger.app 10 | # mypaas.volume = /root/_timetagger:/root/_timetagger 11 | # mypaas.maxmem = 256m 12 | # mypaas.env = TIMETAGGER_CREDENTIALS 13 | 14 | FROM python:3.13-slim-bookworm 15 | 16 | # Install dependencies (including optional ones that make uvicorn faster) 17 | RUN pip --no-cache-dir install pip --upgrade && pip --no-cache-dir install \ 18 | uvicorn uvloop httptools \ 19 | fastuaparser itemdb>=1.1.1 asgineer requests \ 20 | jinja2 markdown pscript \ 21 | pyjwt cryptography 22 | 23 | # This causes the cache to skip, so that we get the latest TimeTagger version. 24 | # If this occasionally does not work (e.g. ramdom.org is out), simply comment. 25 | ADD "https://www.random.org/cgi-bin/randbyte?nbytes=10&format=h" skipcache 26 | 27 | # Install the latest release, or the bleeding edge from GitHub 28 | RUN pip install -U timetagger 29 | # RUN pip install -U https://github.com/almarklein/timetagger/archive/main.zip 30 | 31 | WORKDIR /root 32 | 33 | CMD ["python", "-m", "timetagger"] 34 | -------------------------------------------------------------------------------- /timetagger/pages/index.md: -------------------------------------------------------------------------------- 1 | % TimeTagger - Tag your time, get the insight 2 | % An open source time tracker that feels lightweight and has powerful reporting. 3 | 4 |
5 | 6 | 7 |

Tag your time,
get the insight.

8 | 9 | 26 | 27 |
28 | 29 | \uf04b  Demo 30 | 31 | \uf04b  App 32 |
33 | 34 | ---- 35 | 36 | This is the stub index page for TimeTagger, 37 | an open source time-tracker that feels lightweight and has powerful reporting. 38 | 39 | Links: 40 | 41 | * [Main website](https://timetagger.app) 42 | * [Source code on Github](https://github.com/almarklein/timetagger) 43 | * [Docs on RTD](https://timetagger.readthedocs.io) 44 | * [CLI tool](https://github.com/almarklein/timetagger_cli) 45 | -------------------------------------------------------------------------------- /tests/import_samples/yast_sample.csv: -------------------------------------------------------------------------------- 1 | Project,Type,Date,Start,End,Duration H:M,Duration M,Billable,Income,Person,username,Comment,Tags,Project path, 2 | Company A,Hours,09.01.2019,11:07,12:45,1:38,98,No,0,Almar Klein,ak,,,paid, 3 | Company A,Hours,10.01.2019,11:04,11:09,0:06,5.56,No,0,Almar Klein,ak,,,paid, 4 | Company A,Hours,15.01.2019,13:41,14:04,0:23,23.43,No,0,Almar Klein,ak,,,paid, 5 | Company A,Hours,15.01.2019,14:11,15:01,0:49,49.46,No,0,Almar Klein,ak,,,paid, 6 | Company A,Hours,18.01.2019,9:53,9:54,0:02,1.71,No,0,Almar Klein,ak,,,paid, 7 | Company A,Hours,18.01.2019,14:35,16:20,1:45,105.38,No,0,Almar Klein,ak,,,paid, 8 | Company A,Hours,06.02.2019,8:52,9:04,0:12,12.43,No,0,Almar Klein,ak,,,paid, 9 | Company A,Hours,11.02.2019,10:38,10:49,0:11,10.78,No,0,Almar Klein,ak,,,paid, 10 | Company A,Hours,14.02.2019,15:02,15:07,0:06,5.5,No,0,Almar Klein,ak,,,paid, 11 | Company A,Hours,19.02.2019,22:29,22:35,0:05,5.06,No,0,Almar Klein,ak,,,paid, 12 | Company A,Hours,28.02.2019,23:45,23:55,0:11,10.65,No,0,Almar Klein,ak,,,paid, 13 | Company A,Hours,03.03.2019,10:05,10:12,0:07,6.66,No,0,Almar Klein,ak,"arg ... 14 | this was hard",,paid, 15 | S workshop,Hours,22.10.2018,19:06,21:26,2:19,139.25,No,0,Almar Klein,ak,,,paid,training 16 | S workshop,Hours,02.11.2018,10:45,11:03,0:18,17.89,No,0,Almar Klein,ak,,,paid,training 17 | S workshop,Hours,04.11.2018,21:02,22:30,1:28,87.58,No,0,Almar Klein,ak,,,paid,training 18 | Company B,Hours,18.12.2018,10:59,11:02,0:02,2.4,No,0,Almar Klein,ak,,,paid, 19 | U workshop / college,Hours,24.01.2019,10:38,11:14,0:35,35.36,No,0,Almar Klein,ak,,,paid,training 20 | U workshop / college,Hours,24.01.2019,15:36,16:20,0:45,44.75,No,0,Almar Klein,ak,,,paid,training 21 | U workshop / college,Hours,25.01.2019,10:50,12:50,2:00,120,No,0,Almar Klein,ak,,,paid,training 22 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | import re 2 | 3 | from setuptools import find_packages, setup 4 | 5 | 6 | with open("timetagger/__init__.py") as fh: 7 | VERSION = re.search(r"__version__ = \"(.*?)\"", fh.read()).group(1) 8 | 9 | 10 | with open("requirements.txt") as fh: 11 | runtime_deps = [x.strip() for x in fh.read().splitlines() if x.strip()] 12 | 13 | 14 | short_description = ( 15 | "Tag your time, get the insight - an open source time tracker for individuals" 16 | ) 17 | long_description = """ 18 | # Timetagger 19 | 20 | An open source time tracker with a focus on a simple and interactive user experience. 21 | 22 | * Website: https://timetagger.app 23 | * Github: https://github.com/almarklein/timetagger 24 | 25 |
26 | 27 | """ 28 | 29 | setup( 30 | name="timetagger", 31 | version=VERSION, 32 | packages=find_packages(exclude=["tests", "tests.*", "examples", "examples.*"]), 33 | package_data={ 34 | f"timetagger.{x}": ["*"] for x in ["common", "images", "app", "pages"] 35 | }, 36 | scripts=["contrib/multiuser_tweaks/timetagger_multiuser_tweaks.py"], 37 | python_requires=">=3.6.0", 38 | install_requires=runtime_deps, 39 | license="GPL-3.0", 40 | description=short_description, 41 | long_description=long_description, 42 | long_description_content_type="text/markdown", 43 | author="Almar Klein", 44 | author_email="almar.klein@gmail.com", 45 | url="https://github.com/almarklein/timetagger", 46 | classifiers=[ 47 | "Development Status :: 5 - Production/Stable", 48 | "Intended Audience :: Developers", 49 | "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", 50 | "Operating System :: MacOS :: MacOS X", 51 | "Operating System :: Microsoft :: Windows", 52 | "Operating System :: POSIX", 53 | "Programming Language :: Python", 54 | "Programming Language :: Python :: 3 :: Only", 55 | "Programming Language :: Python :: 3.9", 56 | "Programming Language :: Python :: 3.10", 57 | "Programming Language :: Python :: 3.11", 58 | "Programming Language :: Python :: 3.12", 59 | "Programming Language :: Python :: 3.13", 60 | ], 61 | ) 62 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | workflow_dispatch: 5 | push: 6 | branches: [ main ] 7 | pull_request: 8 | branches: [ main ] 9 | 10 | 11 | jobs: 12 | 13 | lint: 14 | name: linting 15 | runs-on: ubuntu-latest 16 | steps: 17 | - uses: actions/checkout@v5 18 | - name: Set up Python 19 | uses: actions/setup-python@v6 20 | with: 21 | python-version: 3.13 22 | - name: Install dependencies 23 | shell: bash 24 | run: | 25 | python -m pip install --upgrade pip 26 | pip install black flake8 invoke 27 | - name: Lint 28 | shell: bash 29 | run: | 30 | invoke checkformat 31 | invoke lint 32 | 33 | tests: 34 | name: ${{ matrix.name }} 35 | runs-on: ${{ matrix.os }} 36 | strategy: 37 | matrix: 38 | include: 39 | - name: Linux py39 40 | os: ubuntu-latest 41 | pyversion: '3.9' 42 | - name: Linux py310 43 | os: ubuntu-latest 44 | pyversion: '3.10' 45 | - name: Linux py311 46 | os: ubuntu-latest 47 | pyversion: '3.11' 48 | - name: Linux py312 49 | os: ubuntu-latest 50 | pyversion: '3.12' 51 | - name: Linux py313 52 | os: ubuntu-latest 53 | pyversion: '3.13' 54 | - name: Linux pypy3 55 | os: ubuntu-latest 56 | pyversion: 'pypy3.9' 57 | - name: Windows py313 58 | os: windows-latest 59 | pyversion: '3.13' 60 | - name: MacOS py313 61 | os: macos-latest 62 | pyversion: '3.13' 63 | steps: 64 | - uses: actions/checkout@v5 65 | - name: Set up Python ${{ matrix.pyversion }} 66 | uses: actions/setup-python@v6 67 | with: 68 | python-version: ${{ matrix.pyversion }} 69 | - name: Install dependencies 70 | shell: bash 71 | run: | 72 | python -m pip install --upgrade pip 73 | pip install -U -r requirements.txt 74 | pip install pytest requests setuptools . 75 | rm -rf ./timetagger ./build ./egg-info 76 | - name: Test with pytest 77 | shell: bash 78 | run: | 79 | python -c "import sys; print(sys.version, '\n', sys.prefix)"; 80 | pytest -v . 81 | -------------------------------------------------------------------------------- /docs/docs/index.md: -------------------------------------------------------------------------------- 1 | # Welcome to the TimeTagger docs 2 | 3 | [TimeTagger](https://timetagger.app) is an open source time tracker 4 | with a focus on a simple and interactive user experience. 5 | 6 | These docs are intended for developers who want to either 7 | communicate with the server via the [web API](webapi.md), or 8 | run their own server using the [library](libapi.md). 9 | 10 | 11 | ## Using the public web API 12 | 13 | The [web API](webapi.md) provides a way to communicate with the TimeTagger server 14 | (either the one at timetagger.app, or one you host yourself). It allows you 15 | to query, create, and update time-records outside of the web interface. 16 | Any changes you make will be visible in the web client almost directly (the client syncs every 10s). 17 | 18 | This makes it possible to create alternative clients, like the [TimeTagger CLI](https://github.com/almarklein/timetagger_cli), 19 | or to automate the tracking of certain processes by writing a script. 20 | 21 | 22 | ## Run your own server 23 | 24 | TimeTagger provides an example/default script to run the TimeTagger app locally 25 | in [`__main__.py`](https://github.com/almarklein/timetagger/blob/main/timetagger/__main__.py). 26 | You can also integrate TimeTagger into a larger web application, or extend 27 | it in your own ways using the [library](libapi.md). 28 | One prerequisite is that the web-server framework is 29 | async. Examples can be [Asgineer](https://github.com/almarklein/asgineer), 30 | [Responder](https://github.com/taoufik07/responder), 31 | [Starlette](https://github.com/encode/starlette), and 32 | [Quart](https://pgjones.gitlab.io/quart/). 33 | 34 | 35 | You can do whatever you want when you run things locally. When you host it 36 | on the web, you should take care of authentication, and make sure that you 37 | comply to the TimeTagger license (GPLv3). 38 | 39 | Note that when you run your own server, you probably want to make sure that it's 40 | always on. See [this article](https://tderflinger.com/en/using-systemd-to-start-a-python-application-with-virtualenv) 41 | for autostarting TimeTagger on Linux systems. The TimeTagger client has a local 42 | cache and stays working even when the server is off. In this case the 43 | sync indicator icon in the top left will show an exclamation mark. 44 | 45 | Also check [this article](https://timetagger.app/articles/selfhost/) about self-hosting TimeTagger. 46 | 47 | If you're interested in including TimeTagger into a larger product, 48 | contact [me](https://almarklein.org) for information about an OEM license. 49 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | docs/site/ 6 | 7 | # C extensions 8 | *.so 9 | 10 | # Distribution / packaging 11 | .Python 12 | build/ 13 | develop-eggs/ 14 | dist/ 15 | downloads/ 16 | eggs/ 17 | .eggs/ 18 | lib/ 19 | lib64/ 20 | parts/ 21 | sdist/ 22 | var/ 23 | wheels/ 24 | pip-wheel-metadata/ 25 | share/python-wheels/ 26 | *.egg-info/ 27 | .installed.cfg 28 | *.egg 29 | MANIFEST 30 | 31 | # PyInstaller 32 | # Usually these files are written by a python script from a template 33 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 34 | *.manifest 35 | *.spec 36 | 37 | # Installer logs 38 | pip-log.txt 39 | pip-delete-this-directory.txt 40 | 41 | # Unit test / coverage reports 42 | htmlcov/ 43 | .tox/ 44 | .nox/ 45 | .coverage 46 | .coverage.* 47 | .cache 48 | nosetests.xml 49 | coverage.xml 50 | *.cover 51 | *.py,cover 52 | .hypothesis/ 53 | .pytest_cache/ 54 | 55 | # Translations 56 | *.mo 57 | *.pot 58 | 59 | # Django stuff: 60 | *.log 61 | local_settings.py 62 | db.sqlite3 63 | db.sqlite3-journal 64 | 65 | # Flask stuff: 66 | instance/ 67 | .webassets-cache 68 | 69 | # Scrapy stuff: 70 | .scrapy 71 | 72 | # Sphinx documentation 73 | docs/_build/ 74 | 75 | # PyBuilder 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | .python-version 87 | 88 | # pipenv 89 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 90 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 91 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 92 | # install all needed dependencies. 93 | #Pipfile.lock 94 | 95 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 96 | __pypackages__/ 97 | 98 | # Celery stuff 99 | celerybeat-schedule 100 | celerybeat.pid 101 | 102 | # SageMath parsed files 103 | *.sage.py 104 | 105 | # Environments 106 | .env 107 | .venv 108 | env/ 109 | venv/ 110 | ENV/ 111 | env.bak/ 112 | venv.bak/ 113 | 114 | # Spyder project settings 115 | .spyderproject 116 | .spyproject 117 | 118 | # Rope project settings 119 | .ropeproject 120 | 121 | # mkdocs documentation 122 | /site 123 | 124 | # mypy 125 | .mypy_cache/ 126 | .dmypy.json 127 | dmypy.json 128 | 129 | # Pyre type checker 130 | .pyre/ 131 | 132 | # docker datadir 133 | _timetagger/ 134 | -------------------------------------------------------------------------------- /timetagger/app/_template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {{ title }} 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 46 | 47 | 48 | 49 | 50 | 51 |
52 |
53 | {{ main }} 54 | 55 | 56 | tt 57 | tt 58 | tt 59 | 60 | 61 | 62 | TimeTagger logo 63 | TimeTagger logo 64 | TimeTagger logo 65 |
66 |
67 | 68 | 69 | 70 | -------------------------------------------------------------------------------- /tests/test_server_utils.py: -------------------------------------------------------------------------------- 1 | import os 2 | import time 3 | 4 | from _common import run_tests 5 | from timetagger.server import _utils as utils 6 | 7 | from pytest import raises 8 | 9 | 10 | def test_user2filename_and_filename2user(): 11 | fnamechars = "".join(utils.ok_chars) + "=~." 12 | 13 | examples = [ 14 | "foo@bar.com", 15 | "a.typical.name@someprovider.com", 16 | "does not have to be email", 17 | "john.do+spam$%^@somedo.main.co.uk", 18 | "with~~tilde.too@do.main", 19 | "unicode€éö ?@grr.com", 20 | ] 21 | 22 | for username in examples: 23 | filename = utils.user2filename(username) 24 | fname = os.path.basename(filename) 25 | print(fname) 26 | 27 | assert fname.endswith(".db") 28 | assert fname.count("~") == 1 29 | assert fname.count(".") == 1 30 | 31 | assert all(c in fnamechars for c in fname) 32 | 33 | assert fname != filename 34 | assert utils.filename2user(fname) == username 35 | assert utils.filename2user(filename) == username 36 | 37 | 38 | def test_jwt_stuff(): 39 | exp = time.time() + 100 40 | 41 | # The secret key must be a long enough string 42 | k = utils._load_jwt_key() 43 | assert isinstance(k, str) and len(k) > 10 44 | 45 | # Payload needs username, expires, seed. 46 | with raises(ValueError): 47 | token = utils.create_jwt({}) 48 | with raises(ValueError): 49 | token = utils.create_jwt({"expires": exp, "seed": "x"}) 50 | with raises(ValueError): 51 | token = utils.create_jwt({"username": "foo", "seed": "x"}) 52 | with raises(ValueError): 53 | token = utils.create_jwt({"username": "foo", "expires": exp}) 54 | 55 | # Get a JWT 56 | payload = {"username": "foo", "expires": exp, "seed": "x"} 57 | token = utils.create_jwt(payload) 58 | assert isinstance(token, str) and token.count(".") == 2 59 | 60 | # Decode it 61 | assert utils.decode_jwt(token) == payload 62 | 63 | # We can always decode the unsafe way 64 | assert utils.decode_jwt_nocheck(token) == payload 65 | 66 | # Cannot decode bullshit 67 | with raises(Exception): 68 | utils.decode_jwt("not.a.token") 69 | 70 | 71 | def test_scss_stuff(): 72 | text = """ 73 | $foo: #fff; 74 | $bar: 1px solid $foo; 75 | p { 76 | border: $bar; 77 | color: $spam; 78 | } 79 | """ 80 | 81 | css = """ 82 | p { 83 | border: 1px solid #fff; 84 | color: red; 85 | } 86 | """ 87 | 88 | vars = utils.get_scss_vars(text) 89 | assert vars == {"$foo": "#fff", "$bar": "1px solid $foo"} 90 | assert utils.compile_scss_to_css(text, spam="red") == css 91 | 92 | with raises(ValueError): 93 | utils.compile_scss_to_css(text) 94 | 95 | 96 | if __name__ == "__main__": 97 | run_tests(globals()) 98 | -------------------------------------------------------------------------------- /timetagger/app/demo.md: -------------------------------------------------------------------------------- 1 | % TimeTagger - Demo 2 | % A live demo using simulated data. 3 | 4 | 70 | 71 | This page needs a working (HTML5) canvas. 72 | -------------------------------------------------------------------------------- /timetagger/pages/login.md: -------------------------------------------------------------------------------- 1 | # Login 2 | 3 | 4 | 5 | 68 | 69 |
70 |
71 |
72 | 73 |
74 |
75 | 76 | 77 |

78 | -------------------------------------------------------------------------------- /timetagger/images/_update_paper.py: -------------------------------------------------------------------------------- 1 | """ 2 | Script to generate a pattern from an image. 3 | """ 4 | 5 | import numpy as np 6 | import imageio 7 | 8 | # Parameters 9 | ori = 10, 10 10 | size1 = 1200 11 | padding = 50 12 | size2 = size1 + 1 * padding 13 | clim = 220, 255 14 | 15 | # Take a square sample 16 | im = imageio.imread("paper0.jpg") 17 | rgba = np.zeros((size2, size2, 4)).astype(np.float32) 18 | rgba[:, :, :3] = im[ori[0] : ori[0] + size2, ori[1] : ori[1] + size2][:, :, :3] 19 | assert rgba.shape == (size2, size2, 4) 20 | 21 | # apply clim 22 | rgb = rgba[:, :, :3] 23 | rgb[rgb < clim[0]] = clim[0] 24 | rgb[rgb > clim[1]] = clim[1] 25 | 26 | 27 | def generate(fname, opacity, base_clr): 28 | square = rgba.copy() 29 | 30 | # Apply linear degrading opacity at the edges 31 | for x in range(size2): 32 | for y in range(size2): 33 | fx = 1 34 | if x < padding: 35 | fx = x / padding 36 | elif x > size2 - padding: 37 | fx = (size2 - x) / padding 38 | fy = 1 39 | if y < padding: 40 | fy = y / padding 41 | elif y > size2 - padding: 42 | fy = (size2 - y) / padding 43 | square[y, x, 3] = opacity * fx * fy 44 | 45 | # Cut out quadrants 46 | # q1 q2 47 | # q4 q3 48 | h1 = size2 // 2 49 | h2 = size2 // 2 50 | q1 = square[:h2, :h2] 51 | q2 = square[h1:, :h2] 52 | q3 = square[h1:, h1:] 53 | q4 = square[:h2, h1:] 54 | 55 | # Prepare result 56 | result = np.zeros((size1, size1, 4)).astype(np.float32) 57 | result[:, :, :3] = base_clr * (1 - opacity) 58 | result[:, :, 3] = 1 - opacity 59 | 60 | # Blend quadrants in their oposite position 61 | h3 = size1 // 2 - padding // 2 62 | h4 = size1 // 2 + padding // 2 63 | blend(result, q1, slice(h3, size1), slice(h3, size1)) 64 | blend(result, q2, slice(h3, size1), slice(0, h4)) 65 | blend(result, q3, slice(0, h4), slice(0, h4)) 66 | blend(result, q4, slice(0, h4), slice(h3, size1)) 67 | 68 | # Write result 69 | assert result[:, :, 3].min() > 0.99 and result[:, :, 3].max() <= 1.001 70 | result[result < 0] = 0 71 | result[result > 255] = 255 72 | imageio.imwrite(fname, result.astype(np.uint8)[:, :, :3]) 73 | 74 | # Show avg value 75 | rgb = [result[:, :, i].mean() for i in range(3)] 76 | print(f"mean rgb({rgb[0]:0.1f}, {rgb[1]:0.1f}, {rgb[2]:0.1f})") 77 | 78 | 79 | def blend(result, q, xslice, yslice): 80 | for i in range(3): 81 | result[yslice, xslice, i] += q[:, :, i] * q[:, :, 3] 82 | result[yslice, xslice, 3] += q[:, :, 3] 83 | 84 | 85 | # -- paper 1 -> #E6E7E5 -> rgb(230, 231, 229) 86 | generate("paper1.jpg", 0.5, 220) 87 | 88 | # -- paper 2 -> #F4F4F4 -> rgb(244, 244, 244) 89 | # generate("paper4.jpg", 0.6, 255) 90 | generate("paper2.jpg", 0.5, 250) 91 | 92 | 93 | generate("paper3.jpg", 0.2, 0) 94 | -------------------------------------------------------------------------------- /CLA.md: -------------------------------------------------------------------------------- 1 | # TimeTagger Contributor License Agreement 2 | 3 | ## Purpose of this agreement 4 | 5 | I love open source! But to protect a 3d party from commercially exploiting TimeTagger, it is licensed under the GPL-3.0. This license (among other things) requires any larger work that uses TimeTagger to be released under the same license. 6 | 7 | Copyright counts stronger than a license. Therefore, as the copyright owner, I can use the same code for https://timetagger.app, which also includes proprietary code, or sublicense the code, if I want. However, if *you* make a contribution to TimeTagger, you are the copyright owner of that contribution. Subsequently, I would not be allowed to use your contribution in ways other than GPL-3.0 dictates, which means I would not be able to run https://timetagger.app. 8 | 9 | This agreement fixes that. With it, you grant me (Almar Klein) the right to use your contribution for any purpose, just like you can use your contribution in any way you like. To be clear, this agreement does not constrain your rights to use your contribution in any way. 10 | 11 | 12 | ## The legal part 13 | 14 | 1. "You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. 15 | 16 | 2. "Contribution" shall mean any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the TimeTagger project repository (https://github.com/almarklein/timetagger). 17 | 18 | 3. Grant of Copyright License. Subject to the terms and conditions of this Agreement, You hereby grant to the owner of the TimeTagger repository (Almar Klein), worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works. 19 | 20 | 4. You represent that each of Your Contributions is Your original creation. You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions. 21 | 22 | 5. You are *not* expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON- INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. 23 | -------------------------------------------------------------------------------- /.github/workflows/dockerimage.yml: -------------------------------------------------------------------------------- 1 | 2 | name: "Build and push release docker image" 3 | 4 | on: 5 | workflow_dispatch: 6 | push: 7 | tags: 8 | - "v*" 9 | 10 | permissions: 11 | contents: read 12 | packages: write 13 | 14 | jobs: 15 | 16 | # Build default priviliged container image version 17 | docker-root: 18 | runs-on: ubuntu-latest 19 | steps: 20 | - name: Check out the repo 21 | uses: actions/checkout@v3 22 | 23 | - name: Set up QEMU 24 | uses: docker/setup-qemu-action@v2 25 | 26 | - name: Set up Docker Buildx 27 | uses: docker/setup-buildx-action@v2 28 | 29 | - name: Log in to GitHub container registry 30 | uses: docker/login-action@v2 31 | with: 32 | registry: ghcr.io 33 | username: ${{ github.actor }} 34 | password: ${{ secrets.GITHUB_TOKEN }} 35 | 36 | - name: Extract metadata (tags, labels) for Docker 37 | id: meta 38 | uses: docker/metadata-action@v4 39 | with: 40 | images: ghcr.io/${{ github.repository }} 41 | tags: type=ref,event=tag 42 | 43 | - name: Build and push Docker image 44 | uses: docker/build-push-action@v4 45 | with: 46 | context: . 47 | platforms: linux/amd64,linux/arm64 48 | file: deploy/repo.Dockerfile 49 | push: true 50 | tags: ${{ steps.meta.outputs.tags }} 51 | labels: ${{ steps.meta.outputs.labels }} 52 | 53 | # Build non-root container image variant 54 | docker-nonroot: 55 | runs-on: ubuntu-latest 56 | steps: 57 | - name: Check out the repo 58 | uses: actions/checkout@v3 59 | 60 | - name: Set up QEMU 61 | uses: docker/setup-qemu-action@v2 62 | 63 | - name: Set up Docker Buildx 64 | uses: docker/setup-buildx-action@v2 65 | 66 | - name: Log in to GitHub container registry 67 | uses: docker/login-action@v2 68 | with: 69 | registry: ghcr.io 70 | username: ${{ github.actor }} 71 | password: ${{ secrets.GITHUB_TOKEN }} 72 | 73 | - name: Extract metadata (tags, labels) for Docker 74 | id: meta-nonroot 75 | uses: docker/metadata-action@v4 76 | with: 77 | images: ghcr.io/${{ github.repository }} 78 | # no "latest" tag for non-root variant 79 | flavor: latest=false 80 | tags: | 81 | type=ref,event=tag,suffix=-nonroot 82 | # set latest-nonroot tag for default branch 83 | type=raw,value=latest-nonroot 84 | 85 | - name: Build and push Docker image 86 | uses: docker/build-push-action@v4 87 | with: 88 | context: . 89 | platforms: linux/amd64,linux/arm64 90 | file: deploy/repo.nonroot.Dockerfile 91 | push: true 92 | tags: ${{ steps.meta-nonroot.outputs.tags }} 93 | labels: ${{ steps.meta-nonroot.outputs.labels }} 94 | -------------------------------------------------------------------------------- /tests/test_config.py: -------------------------------------------------------------------------------- 1 | from _common import run_tests 2 | from pytest import raises 3 | 4 | from timetagger import config 5 | from timetagger._config import set_config 6 | 7 | 8 | def test_config(): 9 | # Defaults 10 | default_bind = "127.0.0.1:8080" 11 | set_config([], {}) 12 | assert config.bind == default_bind 13 | assert config.datadir == "~/_timetagger" 14 | 15 | # argv 16 | set_config(["--bind=localhost:8080"], {}) 17 | assert config.bind == "localhost:8080" 18 | set_config(["foobar.py", "--bind=localhost:8081", "-v", "--spam=eggs"], {}) 19 | assert config.bind == "localhost:8081" 20 | set_config(["foobar.py", "--bind", "localhost:8082", "-v", "--spam", "eggs"], {}) 21 | assert config.bind == "localhost:8082" 22 | 23 | # argv fails 24 | set_config(["bind=localhost:8080"], {}) 25 | assert config.bind == default_bind 26 | set_config(["-bind=localhost:8080"], {}) 27 | assert config.bind == default_bind 28 | with raises(RuntimeError): 29 | set_config(["foobar.py", "--bind"], {}) 30 | 31 | # env 32 | set_config([], {"TIMETAGGER_BIND": "localhost:8081"}) 33 | assert config.bind == "localhost:8081" 34 | 35 | # env fails 36 | set_config([], {"BIND": "localhost:8080"}) 37 | assert config.bind == default_bind 38 | set_config([], {"timetagger_bind": "localhost:8080"}) 39 | assert config.bind == default_bind 40 | 41 | # Test integer conv - disabled because all our config values are str 42 | # set_config([], {}) 43 | # assert config.test == 3 44 | # set_config(["--test=42"], {}) 45 | # assert config.test == 42 46 | # set_config([], {"TIMETAGGER_TEST": "7"}) 47 | # assert config.test == 7 48 | # with raises(RuntimeError): 49 | # set_config(["--test=notanumber"], {}) 50 | # with raises(RuntimeError): 51 | # set_config([], {"TIMETAGGER_TEST": "notanumber"}) 52 | 53 | # Test path_prefix configuration 54 | set_config([], {}) 55 | assert config.path_prefix == "/timetagger/" 56 | set_config(["--path_prefix=/custom/"], {}) 57 | assert config.path_prefix == "/custom/" 58 | set_config(["--path_prefix=custom"], {}) 59 | assert config.path_prefix == "/custom/" 60 | set_config(["--path_prefix=/custom"], {}) 61 | assert config.path_prefix == "/custom/" 62 | set_config(["--path_prefix=custom/path"], {}) 63 | assert config.path_prefix == "/custom/path/" 64 | set_config(["--path_prefix=/"], {}) 65 | assert config.path_prefix == "/" 66 | set_config([], {"TIMETAGGER_PATH_PREFIX": "/api/"}) 67 | assert config.path_prefix == "/api/" 68 | set_config([], {"TIMETAGGER_PATH_PREFIX": "api"}) 69 | assert config.path_prefix == "/api/" 70 | 71 | # Test app_redirect configuration 72 | set_config([], {}) 73 | assert config.app_redirect is False 74 | set_config(["--app_redirect=true"], {}) 75 | assert config.app_redirect is True 76 | set_config(["--app_redirect=1"], {}) 77 | assert config.app_redirect is True 78 | set_config(["--app_redirect=yes"], {}) 79 | assert config.app_redirect is True 80 | set_config(["--app_redirect=false"], {}) 81 | assert config.app_redirect is False 82 | set_config(["--app_redirect=0"], {}) 83 | assert config.app_redirect is False 84 | set_config(["--app_redirect=no"], {}) 85 | assert config.app_redirect is False 86 | set_config([], {"TIMETAGGER_APP_REDIRECT": "true"}) 87 | assert config.app_redirect is True 88 | set_config([], {"TIMETAGGER_APP_REDIRECT": "false"}) 89 | assert config.app_redirect is False 90 | 91 | # Reset to normal (using sys.argv and os.environ) 92 | set_config() 93 | 94 | 95 | if __name__ == "__main__": 96 | run_tests(globals()) 97 | -------------------------------------------------------------------------------- /timetagger/app/index.md: -------------------------------------------------------------------------------- 1 | % TimeTagger - App 2 | % The TimeTagger application. 3 | 4 | 83 | 84 | This page needs a working (HTML5) canvas. 85 | -------------------------------------------------------------------------------- /timetagger/app/sw.js: -------------------------------------------------------------------------------- 1 | // Service worker for the TimeTagger app. The primary purpose of this SW is to make the 2 | // app usable offline, which is also a prerequisite for a PWA. Many approaches are 3 | // possible, with each have their implications, making this quite hard to do well. 4 | // 5 | // I've now opted for a simple cache-first approach, where the server will set the 6 | // currentCacheName to a hash of the assets so that the SW is automatically renewed 7 | // when a change is made. Some advantages: 8 | // * This SW script is quite simple. 9 | // * The app Just Works offline. 10 | // * A new SW means a new version, we can use that to notify the user to refresh. 11 | // 12 | // A note of warning: when doing rolling deploys, the server may produce a mix of old and 13 | // new assets. In the event that the SW installs at that moment, the app may be left in a weird 14 | // state, and the user won't be able to fix it by refreshing the page. 15 | // So don't do rolling deploys when using this SW. 16 | // 17 | // Another approach I considered is network-first, which tries to behave like a normal 18 | // website, but falls back to the cache when the fetch fails. This seems a "simple" behavior, 19 | // but becomes rather complicated to implement, since you want to move in and out of offline-mode, 20 | // and cancel running fetches when entering offline-mode. It also makes loading the app slow 21 | // when being offline. 22 | 23 | // The cache name. The server should replace this name with a new name, which must have 24 | // the "timetagger" prefix, and which should include a stable hash of the assets. 25 | var currentCacheName = 'timetagger_cache'; 26 | 27 | // The assets to cache upon installation. By default nothing is cached, making this SW a no-op. 28 | // The server should replace this with a list of assets (sorted, for consistency). 29 | var assets = []; 30 | 31 | // Register the callbacks 32 | self.addEventListener('install', event => { self.skipWaiting(); event.waitUntil(on_install(event)); }); 33 | self.addEventListener('activate', event => { event.waitUntil(on_activate(event)); }); 34 | self.addEventListener('fetch', on_fetch); 35 | 36 | async function on_install(event) { 37 | console.log('[SW] Installling new app ' + currentCacheName); 38 | let cache = await caches.open(currentCacheName); 39 | await cache.addAll(assets.map(asset => "./" + asset)); 40 | } 41 | 42 | async function on_activate(event) { 43 | let cacheNames = await caches.keys(); 44 | for (let cacheName of cacheNames) { 45 | if (cacheName.startsWith("timetagger") && cacheName != currentCacheName) { 46 | await caches.delete(cacheName); 47 | } 48 | } 49 | await clients.claim(); 50 | } 51 | 52 | function on_fetch(event) { 53 | var requestURL = new URL(event.request.url); 54 | if ( 55 | (requestURL.origin == location.origin) && 56 | (requestURL.pathname.indexOf('/api/') < 0) && 57 | (assets.length > 0) 58 | ) { 59 | event.respondWith(cache_or_network(event)); 60 | } // else do a normal fetch 61 | 62 | } 63 | 64 | async function cache_or_network(event) { 65 | let cache = await caches.open(currentCacheName); 66 | let response = await cache.match(event.request); 67 | if (!response) { 68 | response = await fetch(event.request); 69 | } 70 | return response; 71 | } 72 | 73 | 74 | // Notifications 75 | 76 | self.addEventListener('notificationclick', on_notificationclick); 77 | 78 | function on_notificationclick(event) { 79 | event.notification.close(); 80 | 81 | var promise = new Promise(function(resolve) { 82 | setTimeout(resolve, 1); 83 | }).then(function() { 84 | event.waitUntil(clients.matchAll({ 85 | type: "window" 86 | }).then(function(clientList) { 87 | for (var i = 0; i < clientList.length; i++) { 88 | var client = clientList[i]; 89 | console.log('[SW] proxying notificationclick ' + event.action); 90 | client.postMessage({type: "notificationclick", action: event.action}); 91 | if (event.action !== 'close') { 92 | return client.focus(); 93 | } 94 | } 95 | })); 96 | }); 97 | event.waitUntil(promise); 98 | } 99 | -------------------------------------------------------------------------------- /tests/test_server_assetserver.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import subprocess 3 | from importlib import resources 4 | 5 | from timetagger.server import create_assets_from_dir 6 | import asgineer 7 | 8 | from asgineer.testutils import MockTestServer 9 | from _common import run_tests 10 | 11 | 12 | # Create asset handler 13 | assets = {} 14 | assets.update(create_assets_from_dir(resources.files("timetagger.app"))) 15 | assets.update(create_assets_from_dir(resources.files("timetagger.common"))) 16 | assets.update(create_assets_from_dir(resources.files("timetagger.images"))) 17 | asset_handler = asgineer.utils.make_asset_handler(assets, max_age=0) 18 | 19 | 20 | def test_assets(): 21 | with MockTestServer(asset_handler) as p: 22 | # Get root 23 | r = p.get("") 24 | assert r.status == 200 25 | body = r.body.decode() 26 | assert body.startswith("") 27 | assert r.headers["content-type"] == "text/html" 28 | assert r.headers["etag"] 29 | assert r.headers["cache-control"] 30 | 31 | # Get root, but compressed 32 | r = p.get("", headers={"accept-encoding": "gzip"}) 33 | assert r.status == 200 34 | assert len(r.body) < len(body.encode()) 35 | assert r.headers["content-type"] == "text/html" 36 | assert r.headers["etag"] 37 | assert r.headers["cache-control"] 38 | 39 | # Get known page 40 | r = p.get("demo") 41 | assert r.status == 200 42 | assert r.body.decode().startswith("") 43 | assert r.headers["content-type"] == "text/html" 44 | assert r.headers["etag"] 45 | assert r.headers["cache-control"] 46 | # Test caching with etag 47 | r = p.get("demo", headers={"if-none-match": r.headers["etag"]}) 48 | assert r.status == 304 49 | assert not r.body 50 | 51 | # Test known file asset 52 | r = p.get("timetagger192_sl.png") 53 | assert r.status == 200 54 | assert r.headers["content-type"] == "image/png" 55 | assert r.headers["etag"] 56 | assert r.headers["cache-control"] 57 | # Test caching with etag 58 | r = p.get("timetagger192_sl.png", headers={"if-none-match": r.headers["etag"]}) 59 | assert r.status == 304 60 | assert not r.body 61 | 62 | # Get a wrong page 63 | for page in ( 64 | "foobarspam", 65 | "index", 66 | "index.html", 67 | "foobarspam.html", 68 | "foobarspam.png", 69 | ): 70 | r = p.get(page) 71 | assert r.status == 404 72 | assert "not found" in r.body.decode() 73 | # assert "404" in r.body.decode() 74 | 75 | 76 | hash_checker_code = """ 77 | from importlib import resources 78 | from timetagger.server import create_assets_from_dir, enable_service_worker 79 | assets = {} 80 | assets.update(create_assets_from_dir(resources.files("timetagger.app"))) 81 | assets.update(create_assets_from_dir(resources.files("timetagger.common"))) 82 | assets.update(create_assets_from_dir(resources.files("timetagger.images"))) 83 | enable_service_worker(assets) 84 | cachename = assets["sw.js"].split("currentCacheName =")[1].split("\n")[0] 85 | print(cachename) 86 | """ 87 | 88 | 89 | def test_consistent_hash_for_sw(): 90 | # It's important that the hash is consistent so let's validate this 91 | 92 | oneliner1 = ";".join(hash_checker_code.strip().splitlines()) 93 | different_code = hash_checker_code.replace("{}", """{"foo": "bar"}""") 94 | oneliner2 = ";".join(different_code.strip().splitlines()) 95 | 96 | x1 = subprocess.check_output([sys.executable, "-c", oneliner1]) 97 | x2 = subprocess.check_output([sys.executable, "-c", oneliner1]) 98 | x3 = subprocess.check_output([sys.executable, "-c", oneliner2]) 99 | 100 | x1 = x1.decode().strip().strip(" ';") 101 | x2 = x2.decode().strip().strip(" ';") 102 | x3 = x3.decode().strip().strip(" ';") 103 | 104 | assert len(x1) > 20 105 | assert len(x2) > 20 106 | assert len(x3) > 20 107 | assert x1.startswith("timetagger") 108 | assert x2.startswith("timetagger") 109 | assert x3.startswith("timetagger") 110 | 111 | assert x1 == x2 112 | assert x1 != x3 113 | 114 | 115 | if __name__ == "__main__": 116 | run_tests(globals()) 117 | -------------------------------------------------------------------------------- /timetagger/common/cred.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | Generate credentials 9 | 10 | 42 | 43 | 44 | 45 | 46 | 84 | 85 | 86 | 87 | 88 | 89 |
90 | 91 |

Generate credentials

92 | 93 |

Generate a credentials-string with BCrypt hashing. This 94 | page only generates the hash. It does not communicate with 95 | a server or log you in somewhere. You can check the source if you want. 96 |

97 | 98 |
99 |
100 | 101 |

The raw credentials:

102 |
username:hash
103 |

Dollar signs escaped with backslash, for Unix shell:

104 |
username:hash
105 |

Double dollar signs, for docker-compose script:

106 |
username:hash
107 |
108 | 109 | 110 | 111 | 112 | -------------------------------------------------------------------------------- /tests/test_client_dt.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | 3 | import pscript 4 | from pscript import py2js, evaljs as _evaljs 5 | 6 | from _common import run_tests 7 | from timetagger.app import dt 8 | from timetagger.app.dt import to_time_int, time2str 9 | 10 | 11 | def evaljs(code, final=None): 12 | if final: 13 | code += "\n\nconsole.log(" + final + ");" 14 | return _evaljs(code, print_result=False) 15 | 16 | 17 | try: 18 | subprocess.check_output([pscript.functions.get_node_exe(), "-v"]) 19 | HAS_NODE = True 20 | except Exception: # pragma: no cover 21 | HAS_NODE = False 22 | 23 | 24 | def test_to_time_int(): 25 | t1 = to_time_int("2018-04-24 13:18:00") 26 | t2 = to_time_int("2018-04-24 13:18:00Z") 27 | t3 = to_time_int("2018-04-24 13:18:00+0200") 28 | 29 | for t in (t1, t2, t2): 30 | assert isinstance(t, int) 31 | 32 | # Tests that don't work always/anywhere :/ 33 | # assert t1 != t2 # This can be invalid in the winter in the UK 34 | # assert t1 == t3 # This is only valid in e.g. summer in Amsterdam 35 | 36 | # Verify that T does not matter 37 | assert to_time_int("2018-04-24 13:18:00") == to_time_int("2018-04-24T13:18:00") 38 | assert to_time_int("2018-04-24 13:18:00Z") == to_time_int("2018-04-24T13:18:00Z") 39 | assert to_time_int("2018-04-24 13:18:00+0200") == to_time_int( 40 | "2018-04-24T13:18:00+0200" 41 | ) 42 | 43 | if not HAS_NODE: 44 | print("skipping tests that use node") 45 | return 46 | 47 | # Verify that JS and Python produce the same results 48 | js = py2js(open(dt.__file__, "rb").read().decode(), docstrings=False) 49 | js1 = evaljs(js, "to_time_int('2018-04-24 13:18:00')") 50 | js2 = evaljs(js, "to_time_int('2018-04-24 13:18:00Z')") 51 | js3 = evaljs(js, "to_time_int('2018-04-24 13:18:00+0200')") 52 | assert js1 == str(t1) 53 | assert js2 == str(t2) 54 | assert js3 == str(t3) 55 | 56 | # Again with T 57 | js1 = evaljs(js, "to_time_int('2018-04-24T13:18:00')") 58 | js2 = evaljs(js, "to_time_int('2018-04-24T13:18:00Z')") 59 | js3 = evaljs(js, "to_time_int('2018-04-24T13:18:00+0200')") 60 | assert js1 == str(t1) 61 | assert js2 == str(t2) 62 | assert js3 == str(t3) 63 | 64 | 65 | def test_time2str(): 66 | t1 = to_time_int("2018-04-24 13:18:00") 67 | t2 = to_time_int("2018-04-24 13:18:00Z") 68 | t3 = to_time_int("2018-04-24 13:18:00+0200") 69 | 70 | for t in (t1, t2, t2): 71 | assert isinstance(t, int) 72 | 73 | # Get outputs 74 | assert time2str(t1) == time2str(t1, None) 75 | s1 = time2str(t1, None) 76 | s2 = time2str(t2, 0) 77 | s3 = time2str(t3, 2) 78 | 79 | # Verify first. Exact output depends on timezone and summertime policy 80 | assert s1.startswith(("2018-04-24T13:18:00", "2018-04-24T12:48:00")) 81 | # Verify output in Python 82 | assert s2 == "2018-04-24T13:18:00Z" 83 | assert s3 == "2018-04-24T13:18:00+0200" 84 | 85 | if not HAS_NODE: 86 | print("skipping tests that use node") 87 | return 88 | 89 | # Verify that JS and Python produce the same results 90 | js = py2js(open(dt.__file__, "rb").read().decode(), docstrings=False) 91 | js1 = evaljs(js, f"time2str({t1})") 92 | js2 = evaljs(js, f"time2str({t2}, 0)") 93 | js3 = evaljs(js, f"time2str({t3}, 2)") 94 | assert js1 == s1 95 | assert js2 == s2 96 | assert js3 == s3 97 | 98 | 99 | def test_duration_string(): 100 | js = py2js(open(dt.__file__, "rb").read().decode(), docstrings=False) 101 | js += "\n\nwindow = {};" 102 | 103 | js1 = evaljs(js, f"duration_string(5, false)") 104 | js2 = evaljs(js, f"duration_string(5, true)") 105 | js3 = evaljs(js, f"duration_string(65, false)") 106 | js4 = evaljs(js, f"duration_string(65, true)") 107 | js5 = evaljs(js, f"duration_string(7265, false)") 108 | js6 = evaljs(js, f"duration_string(7265, true)") 109 | js7 = evaljs(js, f"duration_string(42, false)") 110 | js8 = evaljs(js, f"duration_string(42, true)") 111 | 112 | assert js1 == "5s" 113 | assert js2 == "0m05s" 114 | assert js3 == "1m" 115 | assert js4 == "1m05s" 116 | assert js5 == "2h01m" 117 | assert js6 == "2h01m05s" 118 | assert js7 == "42s" 119 | assert js8 == "0m42s" 120 | 121 | js1 = evaljs(js, f"duration_string_colon(5, false)") 122 | js2 = evaljs(js, f"duration_string_colon(5, true)") 123 | js3 = evaljs(js, f"duration_string_colon(65, false)") 124 | js4 = evaljs(js, f"duration_string_colon(65, true)") 125 | js5 = evaljs(js, f"duration_string_colon(7265, false)") 126 | js6 = evaljs(js, f"duration_string_colon(7265, true)") 127 | 128 | assert js1 == "0:00" 129 | assert js2 == "0:00:05" 130 | assert js3 == "0:01" 131 | assert js4 == "0:01:05" 132 | assert js5 == "2:01" 133 | assert js6 == "2:01:05" 134 | 135 | 136 | if __name__ == "__main__": 137 | run_tests(globals()) 138 | -------------------------------------------------------------------------------- /timetagger/_config.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | 4 | 5 | def to_bool(value): 6 | """Converts a string to a bool""" 7 | stringValue = str(value).lower() 8 | if stringValue in ["true", "yes", "on", "1"]: 9 | return True 10 | return False 11 | 12 | 13 | def to_path_prefix(value): 14 | """Ensures that a path prefix starts and ends with '/'""" 15 | path_prefix = str(value).strip() 16 | if not path_prefix.startswith("/"): 17 | path_prefix = "/" + path_prefix 18 | if not path_prefix.endswith("/") and path_prefix != "/": 19 | path_prefix = path_prefix + "/" 20 | return path_prefix 21 | 22 | 23 | class Config: 24 | """Object that holds config values. 25 | 26 | * `bind (str)`: the address and port to bind on. Default "127.0.0.1:8080". 27 | * `datadir (str)`: the directory to store data. Default "~/_timetagger". 28 | The user db's are stored in `datadir/users`. 29 | * `log_level (str)`: the log level for timetagger and asgineer 30 | (not the asgi server). Default "info". 31 | * `credentials (str)`: login credentials for one or more users, in the 32 | form "user1:hash1,user2:hash2" where each hash is a salted hash (BCrypt) 33 | of the password. Used in the default startup script ``__main__.py``. 34 | You can generate credentials with https://timetagger.app/cred. 35 | * `proxy_auth_enabled (bool)`: enables authentication from a reverse proxy 36 | (for example Authelia). Default "False". 37 | * `proxy_auth_trusted (str)`: list of trusted reverse proxy IPs with or without CIDR, in the 38 | form "127.0.0.1,10.0.0.1,10.99.0.0/24,192.168/16". Default "127.0.0.1". 39 | * `proxy_auth_header (str)`: name of the proxy header which contains the 40 | username of the logged in user. Default "X-Remote-User". 41 | * `path_prefix (str)`: the path prefix where timetagger is served. Default "/timetagger/". 42 | * `app_redirect (bool)`: whether to redirect the root path "/" directly to the timetagger app, 43 | instead of the promotional landing page. Default "False". 44 | 45 | The values can be configured using CLI arguments and environment variables. 46 | For CLI arguments, the following formats are supported: 47 | ``` 48 | python -m timetagger --datadir=~/timedata 49 | python -m timetagger --datadir ~/timedata 50 | ``` 51 | 52 | For environment variable, the key is uppercase and prefixed: 53 | ``` 54 | TIMETAGGER_DATADIR=~/timedata 55 | ``` 56 | """ 57 | 58 | _ITEMS = [ 59 | ("bind", str, "127.0.0.1:8080"), 60 | ("datadir", str, "~/_timetagger"), 61 | ("log_level", str, "info"), 62 | ("credentials", str, ""), 63 | ("proxy_auth_enabled", to_bool, False), 64 | ("proxy_auth_trusted", str, "127.0.0.1"), 65 | ("proxy_auth_header", str, "X-Remote-User"), 66 | ("path_prefix", to_path_prefix, "/timetagger/"), 67 | ("app_redirect", to_bool, False), 68 | ] 69 | __slots__ = [name for name, _, _ in _ITEMS] 70 | 71 | 72 | config = Config() 73 | 74 | 75 | def set_config(argv=None, env=None): 76 | """Set config values. By default argv is sys.argv and env is os.environ.""" 77 | if argv is None: 78 | argv = sys.argv 79 | if env is None: 80 | env = os.environ 81 | 82 | _reset_config_to_defaults() 83 | _update_config_from_argv(argv) 84 | _update_config_from_env(env) 85 | 86 | 87 | def _reset_config_to_defaults(): 88 | for name, _, default in Config._ITEMS: 89 | setattr(config, name, default) 90 | 91 | 92 | def _update_config_from_argv(argv): 93 | for i in range(len(argv)): 94 | arg = argv[i] 95 | for config_attr, conv, _ in Config._ITEMS: 96 | for name in (config_attr, config_attr.replace("_", "-")): 97 | if arg.startswith(f"--{name}="): 98 | _, _, raw_value = arg.partition("=") 99 | elif arg == f"--{name}": 100 | if i + 1 < len(argv): 101 | raw_value = argv[i + 1] 102 | else: 103 | raise RuntimeError(f"Value for {arg} not given") 104 | else: 105 | continue 106 | try: 107 | setattr(config, config_attr, conv(raw_value)) 108 | except Exception as err: 109 | raise RuntimeError(f"Could not set config.{config_attr}: {err}") 110 | break 111 | 112 | 113 | def _update_config_from_env(env): 114 | for name, conv, _ in Config._ITEMS: 115 | env_name = f"TIMETAGGER_{name.upper()}" 116 | raw_value = env.get(env_name, None) 117 | if raw_value: 118 | try: 119 | setattr(config, name, conv(raw_value)) 120 | except Exception as err: 121 | raise RuntimeError(f"Could not set config.{name}: {err}") 122 | 123 | 124 | # Init config 125 | set_config() 126 | -------------------------------------------------------------------------------- /timetagger/pages/account.md: -------------------------------------------------------------------------------- 1 | % TimeTagger - Account 2 | % User account 3 | 4 | # Account 5 | 6 | 7 | 8 | 9 | 10 | 95 | 96 | 103 | 104 |
105 | 106 | 107 | 108 | ## Authentication status 109 | 110 |
Getting auth status ...
111 | 112 | 113 | 114 | 115 | 116 |
117 | web-token details 118 |

119 | Authentication occurs using a web-token that is obtained when logging in. 120 | The token is valid for 14 days, and is refreshed when you use the application. 121 | It is recommended to log out on devices that you do not own. In case you forget, 122 | or when a device is lost/stolen, the token seed can be reset, causing all other sessions to log out. 123 |

124 |
125 |
126 | 127 | ## API token 128 | 129 |
Getting API token ...
130 | 131 | 132 | 133 | 134 |
135 | api-token details 136 |

137 | The API token enables access to the server for 3d party applications (e.g. the CLI tool). API tokens do not expire. 138 | Reset the token to revoke access for all applications using the current API token. 139 |

140 |
141 |
142 | 143 | 144 | -------------------------------------------------------------------------------- /timetagger/server/_utils.py: -------------------------------------------------------------------------------- 1 | """ 2 | Misc utils. 3 | """ 4 | 5 | import os 6 | import json 7 | import logging 8 | import secrets 9 | from base64 import urlsafe_b64encode, urlsafe_b64decode 10 | 11 | import jwt 12 | 13 | from .. import config 14 | 15 | 16 | # Init directory paths 17 | ROOT_TT_DIR = os.path.expanduser(config.datadir) 18 | ROOT_USER_DIR = os.path.join(ROOT_TT_DIR, "users") 19 | if not os.path.isdir(ROOT_USER_DIR): 20 | os.makedirs(ROOT_USER_DIR) 21 | 22 | # Init logger 23 | logger = logging.getLogger("asgineer") 24 | logger.setLevel(config.log_level.upper()) 25 | 26 | 27 | # %% Username stuff 28 | 29 | ok_chars = frozenset("-_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") 30 | 31 | 32 | def user2filename(username): 33 | """Convert a username (e.g. email address) to the corresponding absolute filename.""" 34 | # The rules for characters in email addresses are quite complex, 35 | # but can at least contain !#$%&'*+-/=?^_`{|}~. Therefore we 36 | # agressively create a clean representation (for recognizability) 37 | # and a base64 encoded string (so that we can reverse this process). 38 | 39 | clean = "".join((c if c in ok_chars else "-") for c in username) 40 | encoded = urlsafe_b64encode(username.encode()).decode() 41 | fname = clean + "~" + encoded + ".db" 42 | 43 | return os.path.join(ROOT_USER_DIR, fname) 44 | 45 | 46 | def filename2user(filename): 47 | """Convert a (relative or absolute) filename to the corresponding username.""" 48 | fname = os.path.basename(filename) 49 | encoded = fname.split("~")[-1].split(".")[0] 50 | return urlsafe_b64decode(encoded.encode()).decode() 51 | 52 | 53 | # %% JWT 54 | 55 | 56 | def _load_jwt_key(): 57 | """Load the secret JWT key from file. If it does not exist, we 58 | simply create a new one. This means that by removing this key file 59 | and restarting the server, all issued tokens before that time will 60 | become invalid. 61 | """ 62 | filename = os.path.join(ROOT_TT_DIR, "jwt.key") 63 | secret = "" 64 | if os.path.isfile(filename): 65 | with open(filename, "rb") as f: 66 | secret = f.read().decode().strip() 67 | if not secret: 68 | secret = secrets.token_urlsafe(32) 69 | with open(filename, "wb") as f: 70 | f.write(secret.encode()) 71 | return secret 72 | 73 | 74 | JWT_KEY = _load_jwt_key() 75 | 76 | 77 | def create_jwt(payload): 78 | """Create a new JWT with the given payload.""" 79 | for key in ("username", "expires", "seed"): 80 | if key not in payload: 81 | raise ValueError(f"JWT must have a {key} field.") 82 | result = jwt.encode(payload, JWT_KEY, algorithm="HS256") 83 | if isinstance(result, bytes): 84 | return result.decode() 85 | return result 86 | 87 | 88 | def decode_jwt(token): 89 | """Decode a JWT, validating it with our key. Returns the payload as a dict.""" 90 | return jwt.decode(token, JWT_KEY, algorithms=["HS256"]) 91 | 92 | 93 | def decode_jwt_nocheck(token): 94 | """Get the payload (as a dict) from a JWT token without performing 95 | any validating. 96 | """ 97 | payload_b64 = token.split(".")[1] 98 | missing_padding = len(payload_b64) % 4 99 | if missing_padding: 100 | payload_b64 += "=" * missing_padding 101 | payload_s = urlsafe_b64decode(payload_b64.encode()).decode() 102 | return json.loads(payload_s) 103 | 104 | 105 | # %% Very basic SCSS parser 106 | 107 | 108 | def get_scss_vars(text): 109 | """Get scss variables from a source file. These can then be supplied 110 | to compile_scss_to_css() when parsing other scss files. 111 | """ 112 | vars = {} 113 | for line in text.splitlines(): 114 | if line.lstrip().startswith("$") and ":" in line and line.endswith(";"): 115 | name, _, val = line.partition(":") 116 | name, val = name.strip(), val.strip().strip(";").strip() 117 | vars[name] = val 118 | return vars 119 | 120 | 121 | def compile_scss_to_css(text, **extra_vars): 122 | """Very basic scss compiler that can only replace $variables. But 123 | that's enough for now. Yes, I know pyScss, but it produces loads 124 | of warnings which I find annoying. 125 | """ 126 | # Get complete vars 127 | vars = {} 128 | for key, val in extra_vars.items(): 129 | if not key.startswith("$"): 130 | key = "$" + key 131 | vars[key] = val 132 | vars.update(get_scss_vars(text)) 133 | # Pre-process 134 | lines = text.splitlines() 135 | lines2remove = [] 136 | for i in range(len(lines)): 137 | line = lines[i] 138 | if line.lstrip().startswith("$") and ":" in line: 139 | lines2remove.append(i) 140 | lines[i] = "" 141 | text = "\n".join(lines) 142 | # Sort keys by length to avoid replacing partial keys 143 | var_keys = list(vars.keys()) 144 | var_keys.sort(key=lambda x: len(x), reverse=True) 145 | # Replace in vars themselves 146 | for key in var_keys: 147 | val = vars[key] 148 | for k, v in vars.items(): 149 | if key in v: 150 | vars[k] = v.replace(key, val) 151 | # Replace in text 152 | for key in var_keys: 153 | val = vars[key] 154 | text = text.replace(key, val) 155 | # Post-check 156 | lines = text.splitlines() 157 | for i in range(len(lines)): 158 | line = lines[i] 159 | if "$" in line: 160 | raise ValueError(f"Found unreplaced SCSS variable on line {i + 1}:\n{line}") 161 | for i in reversed(lines2remove): 162 | lines.pop(i) 163 | return "\n".join(lines) 164 | -------------------------------------------------------------------------------- /tasks.py: -------------------------------------------------------------------------------- 1 | """Invoke tasks for timetagger""" 2 | 3 | import os 4 | import sys 5 | import shutil 6 | import importlib 7 | import subprocess 8 | 9 | from invoke import task 10 | 11 | # ---------- Per project config ---------- 12 | 13 | NAME = "timetagger" 14 | LIBNAME = NAME.replace("-", "_") 15 | 16 | # ---------------------------------------- 17 | 18 | ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) 19 | if not os.path.isdir(os.path.join(ROOT_DIR, LIBNAME)): 20 | sys.exit("package NAME seems to be incorrect.") 21 | 22 | 23 | @task 24 | def tests(ctx, cover=False): 25 | """Perform unit tests. Use --cover to open a webbrowser to show coverage.""" 26 | import pytest # noqa 27 | 28 | test_path = "tests" 29 | res = pytest.main( 30 | ["-v", f"--cov={LIBNAME}", "--cov-report=term", "--cov-report=html", test_path] 31 | ) 32 | if res: 33 | sys.exit(res) 34 | if cover: 35 | import webbrowser 36 | 37 | webbrowser.open(os.path.join(ROOT_DIR, "htmlcov", "index.html")) 38 | 39 | 40 | @task 41 | def lint(ctx): 42 | """Validate the code style (e.g. undefined names)""" 43 | try: 44 | importlib.import_module("flake8") 45 | except ImportError: 46 | sys.exit("You need to ``pip install flake8`` to lint") 47 | 48 | # We use flake8 with minimal settings 49 | # http://pep8.readthedocs.io/en/latest/intro.html#error-codes 50 | cmd = [ 51 | sys.executable, 52 | "-m", 53 | "flake8", 54 | ROOT_DIR, 55 | "--max-line-length=999", 56 | "--extend-ignore=N,E731,E203,F541,D,B", 57 | "--exclude=build,dist,*.egg-info", 58 | ] 59 | ret_code = subprocess.call(cmd, cwd=ROOT_DIR) 60 | if ret_code == 0: 61 | print("No style errors found") 62 | else: 63 | sys.exit(ret_code) 64 | 65 | 66 | @task 67 | def checkformat(ctx): 68 | """Check whether the code adheres to the style rules. Use autoformat to fix.""" 69 | black_wrapper(False) 70 | 71 | 72 | @task 73 | def format(ctx): 74 | """Automatically format the code (using black).""" 75 | black_wrapper(True) 76 | 77 | 78 | def black_wrapper(writeback): 79 | """Helper function to invoke black programatically.""" 80 | 81 | check = [] if writeback else ["--check"] 82 | exclude = "|".join(["cangivefilenameshere"]) 83 | sys.argv[1:] = check + ["--exclude", exclude, ROOT_DIR] 84 | 85 | import black 86 | 87 | black.main() 88 | 89 | 90 | @task 91 | def clean(ctx): 92 | """Clean the repo of temp files etc.""" 93 | # Walk over all files and delete based on name 94 | for root, dirs, files in os.walk(ROOT_DIR): 95 | for dname in dirs: 96 | if dname in ( 97 | "__pycache__", 98 | ".cache", 99 | ".hypothesis", 100 | "_build", 101 | ".mypy_cache", 102 | ): 103 | shutil.rmtree(os.path.join(root, dname)) 104 | print("Removing", dname) 105 | for fname in files: 106 | if fname.endswith((".pyc", ".pyo")) or fname in (".coverage"): 107 | os.remove(os.path.join(root, fname)) 108 | print("Removing", fname) 109 | # Delete specific files and directories 110 | for fname in [ 111 | "docs/site", 112 | "htmlcov", 113 | ".pytest_cache", 114 | "dist", 115 | "build", 116 | LIBNAME + ".egg-info", 117 | ]: 118 | filename = os.path.join(ROOT_DIR, fname) 119 | if os.path.isfile(filename): 120 | os.remove(filename) 121 | print("Removing", filename) 122 | elif os.path.isdir(filename): 123 | shutil.rmtree(filename) 124 | print("Removing", filename) 125 | 126 | 127 | @task 128 | def bumpversion(ctx, version): 129 | """Bump the version. If no version is specified, show the current version.""" 130 | version = version.lstrip("v") 131 | # Check that we're not missing any libraries 132 | for x in ("setuptools", "twine"): 133 | try: 134 | importlib.import_module(x) 135 | except ImportError: 136 | sys.exit(f"You need to ``pip install {x}`` to do a version bump") 137 | # Check that there are no outstanding changes 138 | lines = ( 139 | subprocess.check_output(["git", "status", "--porcelain"]).decode().splitlines() 140 | ) 141 | lines = [line for line in lines if not line.startswith("?? ")] 142 | if lines: 143 | print("Cannot bump version because there are outstanding changes:") 144 | print("\n".join(lines)) 145 | return 146 | # Get the version definition 147 | filename = os.path.join(ROOT_DIR, LIBNAME, "__init__.py") 148 | with open(filename, "rb") as f: 149 | lines = f.read().decode().splitlines() 150 | for line_index, line in enumerate(lines): 151 | if line.startswith("__version__ = "): 152 | break 153 | else: 154 | raise ValueError("Could not find version definition") 155 | # Only show the version? 156 | if not version.strip("x-"): 157 | print(lines[line_index]) 158 | return 159 | # Apply change 160 | lines[line_index] = lines[line_index].split("=")[0] + f'= "{version}"' 161 | with open(filename, "wb") as f: 162 | f.write(("\n".join(lines).strip() + "\n").encode()) 163 | # Ask confirmation 164 | subprocess.run(["git", "diff"]) 165 | while True: 166 | x = input("Is this diff correct? [Y/N]: ") 167 | if x.lower() == "y": 168 | break 169 | elif x.lower() == "n": 170 | print("Cancelling (git checkout)") 171 | subprocess.run(["git", "checkout", filename]) 172 | return 173 | # Git 174 | print("Git commit and tag") 175 | subprocess.run(["git", "add", filename]) 176 | subprocess.run(["git", "commit", "-m", f"Bump version to {version}"]) 177 | subprocess.run(["git", "tag", f"v{version}"]) 178 | print(f"git push origin main v{version}") 179 | subprocess.run(["git", "push", "origin", "main", f"v{version}"]) 180 | # Pypi 181 | input("\nHit enter to upload to pypi: ") 182 | dist_dir = os.path.join(ROOT_DIR, "dist") 183 | if os.path.isdir(dist_dir): 184 | shutil.rmtree(dist_dir) 185 | subprocess.run([sys.executable, "setup.py", "sdist", "bdist_wheel"]) 186 | subprocess.run([sys.executable, "-m", "twine", "upload", dist_dir + "/*"]) 187 | # Bye bye 188 | print("Success!") 189 | print("Don't forget to write release notes!") 190 | -------------------------------------------------------------------------------- /timetagger/images/timetagger_wd.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 26 | 29 | 31 | 32 | 34 | 42 | 51 | 60 | 68 | 72 | 73 | 74 | 75 | -------------------------------------------------------------------------------- /timetagger/images/timetagger_wl.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 26 | 29 | 31 | 32 | 34 | 42 | 51 | 60 | 68 | 72 | 73 | 74 | 75 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![CI](https://github.com/almarklein/timetagger/workflows/CI/badge.svg)](https://github.com/almarklein/timetagger/actions) 2 | [![Documentation Status](https://readthedocs.org/projects/timetagger/badge/?version=latest)](https://timetagger.readthedocs.io/en/latest/?badge=latest) 3 | [![PyPI version](https://badge.fury.io/py/timetagger.svg)](https://badge.fury.io/py/timetagger) 4 | 5 | # TimeTagger 6 | 7 | *Tag your time, get the insight* - an open source time-tracker with an 8 | interactive user experience and powerful reporting. 9 | 10 | * Website: https://timetagger.app 11 | * Demo: https://timetagger.app/demo 12 | * Docs: https://timetagger.readthedocs.io 13 | * CLI tool: https://github.com/almarklein/timetagger_cli 14 | * [TimeTagger_VSCodeExtension](https://github.com/Yamakaze-chan/TimeTagger_VSCodeExtension) (3d party) 15 | 16 | 17 | ## Introduction 18 | 19 | TimeTagger is a web-based time-tracking solution that can run locally 20 | or on a server. It's aimed at individuals and freelancers, and has the 21 | following features: 22 | 23 | * Intuitive UI based around an interactive timeline. 24 | * Lightweight feel by use of tags rather than projects. 25 | * Reporting in PDF and CSV. 26 | * Set daily/weekly/monthly targets. 27 | * Integrated Pomodoro method (experimental). 28 | * Responsive: works well on small and large screens. 29 | * Sync between devices. 30 | 31 | 32 | ## Under the hood 33 | 34 | The server runs on async Python using 35 | [uvicorn](https://github.com/encode/uvicorn) and 36 | [asgineer](https://github.com/almarklein/asgineer) - which is fun and bloody fast. 37 | It uses SQLite via [itemdb](https://github.com/almarklein/itemdb) to 38 | store the data, making it easy to deploy. 39 | 40 | The client is a mix of HTML, CSS, Markdown, and ... Python! 41 | [PScript](https://github.com/flexxui/pscript) is used to compile the 42 | Python to JavaScript. This may be a bit idiosyncratic, but it's fun! 43 | Maybe I'll someday implement it in something that compiles down to Wasm :) 44 | 45 | 46 | ## Install and run 47 | 48 | TimeTagger is implemented as a Python library that requires Python 3.6 or higher. The dependencies are listed in `requirements.txt` - these are installed automatically when you install TimeTagger with Pip. 49 | 50 | ``` 51 | # Install 52 | pip install -U timetagger 53 | 54 | # Run 55 | python -m timetagger 56 | ``` 57 | 58 | If the server runs on your local machine, you can use single-user mode out-of-the-box. 59 | 60 | 61 | ## Self-hosting your time tracker 62 | 63 | Docker images are provided via the [Github container registry](https://github.com/almarklein/timetagger/pkgs/container/timetagger), 64 | so you can use e.g. Docker-compose to easily host your own server. 65 | 66 | There are two variants, one that runs the server as root inside the container and a nonroot variant 67 | that runs as user 1000: 68 | - [docker-compose.yml](https://github.com/almarklein/timetagger/blob/main/deploy/docker-compose.yml) 69 | - [docker-compose.nonroot.yml](https://github.com/almarklein/timetagger/blob/main/deploy/docker-compose.nonroot.yml) 70 | 71 | See [this article](https://timetagger.app/articles/selfhost2/) for more information about self hosting. 72 | 73 | ### Authentication using credentials 74 | 75 | If you want multiple users, or if the server is not on localhost, you 76 | may want to provide the server with user credentials using an 77 | environment variable or a command line arg (see the 78 | [docs on config](https://timetagger.readthedocs.io/en/latest/libapi/)). 79 | 80 | ``` 81 | # Using command-line args 82 | python -m timetagger --credentials=test:$2a$08$0CD1NFiIbancwWsu3se1v.RNR/b7YeZd71yg3cZ/3whGlyU6Iny5i 83 | 84 | # Using environment variables 85 | export TIMETAGGER_CREDENTIALS='test:$2a$08$0CD1NFiIbancwWsu3se1v.RNR/b7YeZd71yg3cZ/3whGlyU6Iny5i' 86 | python -m timetagger 87 | ``` 88 | 89 | The credentials take the form ":", where the hash is a 90 | (salted) BCrypt hash of the password. You can generate credentials using 91 | e.g. https://timetagger.app/cred. 92 | 93 | 94 | ### Authentication using a reverse proxy 95 | 96 | If you have a reverse proxy which already authenticates users (e.g. [Authelia](https://www.authelia.com)) and provides the username through a HTTP header, you can tell TimeTagger to use this information. To configure it there are three environment variables and command line arguments (see the 97 | [docs on config](https://timetagger.readthedocs.io/en/latest/libapi/)). 98 | 99 | ``` 100 | # Using command-line args 101 | python -m timetagger --proxy_auth_enabled=True --proxy_auth_trusted=127.0.0.1 --proxy_auth_header=X-Remote-User 102 | 103 | # Using environment variables 104 | export TIMETAGGER_PROXY_AUTH_ENABLED=True TIMETAGGER_PROXY_AUTH_TRUSTED=127.0.0.1 TIMETAGGER_PROXY_AUTH_HEADER=X-Remote-User 105 | python -m timetagger 106 | ``` 107 | 108 | 109 | ## Show your support 110 | 111 | If you're self-hosting TimeTagger and want to support the project, you can: 112 | 113 | * Write something about TimeTagger in a blog post or social media (and link to `https://timetagger.app`). This helps search engines find it better. 114 | * Contribute improvements via Github. 115 | * For financial support you can take a subscription or donate (see the donation links on the side). 116 | 117 | 118 | ## Using the hosted version 119 | 120 | You can also make use of https://timetagger.app so you don't have to worry about 121 | maintaining a server, backups, and all that. An account is just €3 per month. 122 | With that you'd also sponsor this project and open source in general. 123 | 124 | 125 | ## Copyright and license 126 | 127 | As usual, copyright applies to whomever made a particular contribution in this repository, 128 | which can be inspected via e.g. git blame. The owner of the copyright (i.e. the author) 129 | is free to use their code in any way. 130 | 131 | This code is also subject to the GPL-3.0 License, to protect it from being used 132 | commercially by other parties. 133 | 134 | Contributors must agree to the 135 | [Contributor License Agreement](https://github.com/almarklein/timetagger/blob/main/CLA.md) 136 | to grant me (Almar) the right to use their contributions at e.g. the TimeTagger.app service. 137 | By making a contribution to this project, you agree to this CLA. 138 | 139 | 140 | ## Developers 141 | 142 | Clone the repo and install in development mode: 143 | 144 | ```sh 145 | git clone https://github.com/almarklein/timetagger.git 146 | cd timetagger 147 | pip install -e . 148 | ``` 149 | 150 | Install additional developer dependencies: 151 | 152 | ``` 153 | pip install invoke black flake8 pytest pytest-cov requests 154 | ``` 155 | 156 | Then these commands can be used during development: 157 | 158 | * `invoke -l` to see available invoke tasks 159 | * `invoke clean` to remove temporary files 160 | * `invoke format` to autoformat the code (using black) 161 | * `invoke lint` to detect linting errors (using flake8) 162 | * `invoke tests` to run tests (using pytest) 163 | -------------------------------------------------------------------------------- /timetagger/server/_assets.py: -------------------------------------------------------------------------------- 1 | """ 2 | The asset server. All assets are loaded on startup and served from 3 | memory, thus allowing blazing fast serving. 4 | """ 5 | 6 | import os 7 | import re 8 | import hashlib 9 | import logging 10 | from importlib import resources 11 | 12 | import jinja2 13 | import pscript 14 | import markdown 15 | 16 | from . import _utils as utils 17 | from .. import __version__ 18 | 19 | 20 | versionstring = "v" + __version__ 21 | 22 | 23 | logger = logging.getLogger("asgineer") 24 | 25 | IMAGE_EXTS = ".png", ".jpg", ".gif", ".ico", ".mp4", ".svg" 26 | FONT_EXTS = ".ttf", ".otf", ".woff", ".woff2" 27 | AUDIO_EXTS = ".wav", ".mp3", ".ogg" 28 | 29 | re_fas = re.compile(r"\>(\\uf[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])\<") 30 | 31 | default_template = ( 32 | open(resources.files("timetagger.common") / "_template.html", "rb").read().decode() 33 | ) 34 | 35 | 36 | def _get_base_style(): 37 | fname = resources.files("timetagger.common") / "_style_embed.scss" 38 | with open(fname, "rb") as f: 39 | text = f.read().decode() 40 | return utils.get_scss_vars(text), utils.compile_scss_to_css(text) 41 | 42 | 43 | style_vars, style_embed = _get_base_style() 44 | 45 | 46 | def compile_scss(text): 47 | return utils.compile_scss_to_css(text, **style_vars) 48 | 49 | 50 | def md2html(text, template): 51 | title = description = "" 52 | if text.startswith("%"): 53 | title, text = text.split("\n", 1) 54 | title = title.strip("% \t\r\n") 55 | if text.startswith("%"): 56 | description, text = text.split("\n", 1) 57 | description = description.strip("% \t\r\n") 58 | title = title or "TimeTagger" 59 | description = description or title 60 | assert '"' not in description 61 | # Convert font-awesome codepoints to Unicode chars 62 | for match in reversed(list(re_fas.finditer(text))): 63 | text = ( 64 | text[: match.start(1)] 65 | + eval("'" + match.group(1) + "'") 66 | + text[match.end(1) :] 67 | ) 68 | # Some per-line tweaks (turn some headers into anchors, e.g. in support page) 69 | lines = text.splitlines() 70 | for i, line in enumerate(lines): 71 | if line.startswith(("## ", "### ")) and "|" in line: 72 | pre, header = line.split(" ", 1) 73 | linkname, header = header.split("|", 1) 74 | pre, linkname, line = pre.strip(), linkname.strip(), header.strip() 75 | line = f"{header}" 76 | line = f"{line}" 77 | lines[i] = line 78 | text = "\n".join(lines) 79 | # Turn md into html and store 80 | main = markdown.markdown(text, extensions=["fenced_code"]) 81 | 82 | if isinstance(template, str): 83 | template = jinja2.Template(template) 84 | return template.render( 85 | title=title, 86 | description=description, 87 | main=main, 88 | embedded_script="", 89 | embedded_style=style_embed, 90 | versionstring=versionstring, 91 | ) 92 | 93 | 94 | def create_assets_from_dir(dirname, template=None): 95 | """Get a dictionary of assets from a directory.""" 96 | 97 | assets = {} 98 | 99 | thtml = default_template 100 | if template is not None: 101 | thtml = template 102 | elif os.path.isfile(os.path.join(dirname, "_template.html")): 103 | thtml = open(os.path.join(dirname, "_template.html"), "rb").read().decode() 104 | template = jinja2.Template(thtml) 105 | 106 | for fname in sorted(os.listdir(dirname)): 107 | if fname.startswith("_"): 108 | continue 109 | elif fname.endswith(".md"): 110 | # Turn markdown into HTML 111 | text = open(os.path.join(dirname, fname), "rb").read().decode() 112 | html = md2html(text, template) 113 | name, ext = os.path.splitext(fname) 114 | assets["" if name == "index" else name] = html 115 | elif fname.endswith((".scss", ".sass")): 116 | # An scss/sass file, a preprocessor of css 117 | text = open(os.path.join(dirname, fname), "rb").read().decode() 118 | assets[fname[:-5] + ".css"] = compile_scss(text) 119 | elif fname.endswith(".html"): 120 | # Raw HTML 121 | text = open(os.path.join(dirname, fname), "rb").read().decode() 122 | assets[fname[:-5]] = text 123 | elif fname.endswith(".py"): 124 | # Turn Python into JS 125 | name, ext = os.path.splitext(fname) 126 | filename = os.path.join(dirname, fname) 127 | # Compile 128 | pycode = open(filename, "rb").read().decode() 129 | parser = pscript.Parser(pycode, filename) 130 | jscode = "/* Do not edit, autogenerated by pscript */\n\n" + parser.dump() 131 | # Wrap in module 132 | exports = [ 133 | name for name in parser.vars.get_defined() if not name.startswith("_") 134 | ] 135 | exports.sort() # important to produce reproducable assets 136 | jscode = pscript.create_js_module(name, jscode, [], exports, "simple") 137 | assets[fname[:-2] + "js"] = jscode.encode() 138 | logger.info(f"Compiled pscript from {fname}") 139 | elif fname.endswith((".txt", ".js", ".css", ".json")): 140 | # Text assets 141 | assets[fname] = open(os.path.join(dirname, fname), "rb").read().decode() 142 | elif fname.endswith(IMAGE_EXTS + FONT_EXTS + AUDIO_EXTS): 143 | # Binary assets 144 | assets[fname] = open(os.path.join(dirname, fname), "rb").read() 145 | else: 146 | continue # Skip unknown extensions 147 | 148 | logger.info(f"Collected {len(assets)} assets from {dirname}") 149 | return assets 150 | 151 | 152 | def enable_service_worker(assets): 153 | """Enable the service worker 'sw.js', by giving it a cacheName 154 | based on a hash from all the assets. 155 | """ 156 | assert "sw.js" in assets, "Expected sw.js in assets" 157 | sw = assets.pop("sw.js") 158 | 159 | # Generate hash based on content. Use sha1, just like Git does. 160 | hash = hashlib.sha1() 161 | for key in sorted(assets.keys()): 162 | content = assets[key] 163 | content = content.encode() if isinstance(content, str) else content 164 | hash.update(content) 165 | 166 | # Generate cache name. The name must start with "timetagger" so 167 | # that old caches are cleared correctly. We include the version 168 | # string for clarity. The hash is the most important part. It 169 | # ensures that the SW is considered new whenever any of the assets 170 | # change. It also means that two containers serving the same assets 171 | # use the same hash. 172 | hash_str = hash.hexdigest()[:12] # 6 bytes should be more than enough 173 | cachename = f"timetagger_{versionstring}_{hash_str}" 174 | 175 | # Produce list of assets. If we don't replace this, we get the default SW 176 | # behavior, which is not doing any caching, essentially being a no-op. 177 | asset_list = list(sorted(assets.keys())) 178 | 179 | # Update the code 180 | replacements = { 181 | "timetagger_cache": cachename, 182 | "assets = [];": f"assets = {asset_list};", 183 | } 184 | for needle, replacement in replacements.items(): 185 | assert needle in sw, f"Expected {needle} in sw.js" 186 | sw = sw.replace(needle, replacement, 1) 187 | assets["sw.js"] = sw 188 | -------------------------------------------------------------------------------- /timetagger/common/_style_embed.scss: -------------------------------------------------------------------------------- 1 | $prim1_clr: #0F2C3E; 2 | $prim2_clr: #A4B0B8; 3 | $prim3_clr: #849098; 4 | $sec1_clr: #E6E7E5; 5 | $sec2_clr: #F4F4F4; 6 | $acc_clr: #DEAA22; 7 | $notification: #ff4444; 8 | 9 | $bg1: #E6E7E5; 10 | $bg2: #F4F4F4; 11 | $bg3: #333333; 12 | 13 | $normalfont: "Ubuntu", Verdana, sans-serif; 14 | $narrowfont: "Ubuntu Condensed", Verdana, sans-serif; 15 | $monofont: Consolas, "DejaVu Sans Mono", Monaco, "Courier New", Courier, monospace; 16 | 17 | 18 | /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */ 19 | html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none} 20 | 21 | /**************** Fonts ****************/ 22 | 23 | /* latin */ 24 | @font-face { 25 | font-family: 'Ubuntu'; 26 | font-style: normal; 27 | font-weight: 400; 28 | /*font-display: swap; does not work well with canvas? */ 29 | src: url(Ubuntu_latin.woff2) format('woff2'); 30 | unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; 31 | } 32 | 33 | /* latin */ 34 | @font-face { 35 | font-family: 'Ubuntu Condensed'; 36 | font-style: normal; 37 | font-weight: 400; 38 | /*font-display: swap;*/ 39 | src: url(UbuntuCondensed_latin.woff2) format('woff2'); 40 | unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; 41 | } 42 | 43 | @font-face { 44 | font-family: 'Space Mono'; 45 | src: url(SpaceMono-Regular-webfont.woff) format('woff'); 46 | font-weight: normal; 47 | font-style: normal; 48 | } 49 | 50 | /* FontAwesome 5 Free, only the solid version */ 51 | @font-face { 52 | font-family: 'FontAwesome'; 53 | font-style: normal; 54 | font-weight: 900; 55 | /*font-display: swap; 'block' cause falling back makes no sense - but works bad with canvas? */ 56 | src: url(fa-solid-900.woff2) format('woff2'); 57 | } 58 | 59 | .fas { 60 | font-family: 'FontAwesome'; 61 | font-weight: 900; 62 | font-style: normal; 63 | /* attempt to improve on OS X 64 | font-smooth: auto; 65 | -webkit-font-smoothing: antialiased; 66 | text-rendering: optimizeLegibility; 67 | */ 68 | } 69 | 70 | /**************** Main layout ****************/ 71 | 72 | html { 73 | height: 100%; 74 | } 75 | 76 | body { 77 | height: 100%; 78 | margin: 0; 79 | padding: 0; 80 | box-sizing: border-box; 81 | overflow-x: hidden; 82 | } 83 | 84 | main, header, footer { 85 | position: static; 86 | box-sizing: border-box; 87 | width: 100%; 88 | border: 0; 89 | margin: 0; 90 | } 91 | main .content, header .content, footer .content { 92 | position: static; 93 | box-sizing: border-box; 94 | width: 100%; 95 | border: 0; 96 | margin: 0; 97 | } 98 | 99 | main .content { 100 | position: absolute; 101 | top: 0px; bottom: 0; left: 0; right: 0; 102 | padding: 1em; margin: 0; /* override centering for static position */ 103 | } 104 | @media screen and (min-width: 1000px) { 105 | main .content { /* width-auto */ 106 | left: calc(25% - 250px); right: calc(25% - 250px); width: calc(500px + 50%); 107 | } 108 | main .content.width-1000 { 109 | left: calc(50% - 500px); right: calc(50% - 500px); width: 1000px; 110 | } 111 | main .content.width-full, 112 | main .content.width-1500 { 113 | left: 0; right: 0; width: 100vw; 114 | } 115 | } 116 | @media screen and (min-width: 1500px) { 117 | main .content.width-1500 { 118 | left: calc(50% - 750px); right: calc(50% - 750px); width: 1500px; 119 | } 120 | } 121 | 122 | 123 | /**************** Base styling ****************/ 124 | 125 | body { 126 | background: $bg2; 127 | color: $prim1_clr; 128 | font-family: $normalfont; 129 | font-weight: normal; 130 | font-size: 110%; 131 | } 132 | 133 | .acc_color { color: $acc_clr; } 134 | .normalfont { font-family: $normalfont; } 135 | .narrowfont { font-family: $narrowfont; } 136 | 137 | code, .monospace, .monofont { font-family: $monofont; } 138 | 139 | code { 140 | font-size: 90%; 141 | color: #444; 142 | background: $sec2_clr; 143 | padding: 1px 5px; 144 | white-space: nowrap; 145 | border: solid 1px #e1e4e5; 146 | } 147 | pre > code { 148 | font-size: 80%; 149 | display: block; 150 | white-space: pre; 151 | padding: 1em; 152 | line-height: 140%; 153 | } 154 | 155 | p { 156 | line-height: 140%; 157 | } 158 | 159 | /**************** Links ****************/ 160 | 161 | a:link, a:visited, a:active { 162 | color: inherit; 163 | text-decoration: none; 164 | border-bottom: 1px solid $acc_clr; 165 | } 166 | p a:link, p a:visited, p a:active, li a:link, li a:visited, li a:active { 167 | text-decoration: none; 168 | } 169 | a:hover, p a:hover { 170 | color: inherit; 171 | text-decoration: none; 172 | border-bottom: 2px solid $acc_clr; 173 | } 174 | 175 | header a, footer a, a.link-icon { 176 | border: none !important; /* disable for specific cases */ 177 | } 178 | 179 | /**************** Headers ****************/ 180 | 181 | h1, h2, h3, h4 { 182 | color: $prim3_clr; 183 | } 184 | h1 { 185 | color: $prim1_clr; 186 | } 187 | h1 { font-size: 220%; } 188 | h2 { font-size: 150%; } 189 | h3 { font-size: 120%; } 190 | h2 > a:link, h2 > a:visited, h2 > a:active, h3 > a:link, h3 > a:visited, h3 > a:active { 191 | color: inherit; 192 | } 193 | h2 > a:hover, h3 > a:hover { 194 | text-decoration: none; 195 | } 196 | h2 { 197 | font-family: $monofont; 198 | } 199 | 200 | hr { 201 | height: 1px; 202 | background: #ccc; 203 | border: none; 204 | } 205 | 206 | /**************** Buttons appear in the app, and e.g. /account ****************/ 207 | 208 | button, a.button { 209 | display: inline-block; 210 | background: #eee; 211 | color: $prim1_clr; 212 | padding: 0.3em 0.4em; 213 | border-radius: 4px; 214 | border: 1px solid #bbb; 215 | transition: background 0.2s; 216 | } 217 | button:hover, a.button:hover { 218 | text-decoration: none; 219 | background: #f5f5f5; 220 | } 221 | button:disabled, button:disabled:hover { 222 | background: #ddd; 223 | color: #888; 224 | } 225 | button.whitebutton { 226 | border: none; 227 | color: $prim1_clr; 228 | background: #fff; 229 | padding: 0.5em 0.6em; 230 | margin: 4px; 231 | box-shadow: 0px 1px 2px rgba(0, 0, 0, 0.4); 232 | transition: box-shadow 0.1s; 233 | } 234 | button.whitebutton:hover { box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.4); } 235 | button.whitebutton:disabled { color: #aaa; } 236 | button.whitebutton:disabled:hover { background: #fff; box-shadow: 0px 1px 2px rgba(0, 0, 0, 0.4); } 237 | -------------------------------------------------------------------------------- /docs/docs/webapi.md: -------------------------------------------------------------------------------- 1 | # TimeTagger public web API 2 | 3 | 4 | 5 | ## Introduction 6 | 7 | ### API base URL 8 | 9 | If you run your own instance of TimeTagger, you determine the API endpoint. By default the startup script has it at: 10 | 11 | ``` 12 | http://localhost/timetagger/api/v2/ 13 | ``` 14 | 15 | The API endpoint for the service by [https://timetagger.app](https://timetagger.app) is at: 16 | 17 | ``` 18 | https://timetagger.app/api/v2/ 19 | ``` 20 | 21 | ### Authentication 22 | 23 | All endpoints in this API need to be authenticated via the `authtoken` field in the request header. This token can be either a web-token (used by the web client), or an api-token (used by 3d party services). A web-token is valid for 14 days, but can be refreshed. An api-token does not expire. Both kinds of tokens can be revoked via the web client. When the authentication of a request fails, a 401 response is given. 24 | 25 | ### Responses 26 | 27 | The server responds with http status code 200 if the request is sound. In this case, the body of the response is always a JSON encoded object. 28 | 29 | Otherwise, an appropriate error code is returned, and the body is simply a string with the meaning of that error code and a more specific explanation, e.g. 401 for authentication fails, 404 for invalid API paths, 400 for faulty arguments, etc. 30 | 31 | Responses with error code 500 are server errors and should probably be considered a bug. 32 | 33 | ### Timestamps 34 | 35 | All times and timestamps in this document are Unix timestamps (floating point numbers representing the number of seconds since the epoch) unless specified otherwise. 36 | 37 | 38 | 39 | ## The endpoints 40 | 41 | ### GET records 42 | 43 | See below for a description of record objects. To get records, the following request can be made: 44 | 45 | ``` 46 | GET ./records?timerange=-&running=&hidden=&tag= 47 | ``` 48 | 49 | The timestamps are compared to the record's start and end times (`t1` and `t2`). A record 50 | is included if its partially in the range. If the two timestamps in the range are equal, 51 | it will query all records that include that timestamp. If the range is reversed (`timstamp1 > timestamp2`), 52 | it will query only records that fully occupy that range. Running records are considered 53 | to have their end-time in the infinite future. 54 | 55 | Optional query parameters: 56 | 57 | * `running`: Filter records by their running state. If unset, all records matching the time range are returned. 58 | - Set to [`true` | `yes` | `on` | `1`] to return only running records 59 | - Set to [`false` | `no` | `off` | `0`] to return only stopped records 60 | * `hidden`: Filter records by their hidden state (hidden records are considered deleted in the UI and CLI; see [Deleting records](#deleting-records)). If unset, all records matching the time range are returned. 61 | - Set to [`true` | `yes` | `on` | `1`] to return only hidden records 62 | - Set to [`false` | `no` | `off` | `0`] to return only non-hidden records 63 | * `tag`: Filter records by tags in their description. If unset, all records matching the time range are returned. 64 | - Provide one or more comma-separated tags (e.g. `tag=work`, or `tag=work,urgent`) 65 | - Omit the leading `#` character, or alternatively URL-encode it properly as `%23` 66 | - Only records containing **all** specified tags in their description will be returned 67 | 68 | The fields in the JSON response: 69 | 70 | * `records`: A list of record objects that are (partially) within the range given by the two timestamps. 71 | 72 | ### PUT records 73 | 74 | See below for a description of record objects. To edit records, or submit new records, send a request with a body consisting of a JSON-encoded list of record objects: 75 | 76 | ``` 77 | PUT ./records 78 | ``` 79 | 80 | The fields in the JSON response: 81 | 82 | * `accepted`: The keys of the accepted records. 83 | * `failed`: The keys of the rejected records. 84 | * `errors`: The error messages corresponding to the items in `fail`, plus possibly additional error messages. 85 | 86 | ### GET settings 87 | 88 | See below for a description of settings objects. To get all settings, perform the following request: 89 | 90 | ``` 91 | GET ./settings 92 | ``` 93 | 94 | The fields in the JSON response: 95 | 96 | * `settings`: a list of settings objects. 97 | 98 | ### PUT settings 99 | 100 | Settings can be updated by doing a request with a body consisting of a JSON-encoded list of settings objects. 101 | 102 | ``` 103 | PUT ./settings 104 | ``` 105 | 106 | The fields in the JSON response: 107 | 108 | * `accepted`: The keys of the accepted settings. 109 | * `failed`: The keys of the rejected settings. 110 | * `errors`: The error messages corresponding to the items in `fail`, plus possibly additional error messages. 111 | 112 | ### GET updates 113 | 114 | Clients can cache the records and settings locally and efficiently get updates. Such clients have access to all the data, while also being up-to-date. The web client uses this approach (it never uses `GET records`). 115 | 116 | ``` 117 | GET ./updates?since= 118 | ``` 119 | 120 | The fields in the JSON response: 121 | 122 | * `server_time`: a timestamp indicating the time of the server when the update was sampled. The client should use this value in the `since` field of 123 | the next update request. 124 | 125 | * `reset`: either 0 or 1, indicating whether the client should purge its local cache. This will rarely be 1, but it can happen, e.g. in the event that a database is reset from backup. 126 | * `records`: a list of record objects that have changed since. Can be empty. 127 | * `settings`: a list of settings objects that have changed since. Can be empty. 128 | 129 | ### GET version 130 | 131 | To get the server version, perform the following request: 132 | 133 | ``` 134 | GET ./version 135 | ``` 136 | 137 | The fields in the JSON response: 138 | 139 | * `version`: a string indicating the TimeTagger server version. 140 | 141 | This endpoint can be used to check the server version for compatibility or debugging purposes. 142 | 143 | ### Other endpoints 144 | 145 | If you look at the [source code](https://github.com/almarklein/timetagger/blob/main/timetagger/server/_apiserver.py), you'll see a few other endpoints, e.g. to refresh the web-token and obtain the api-token. These two endpoints are only available with a web-token (not with an api-token). 146 | 147 | Further, the API at [https://timetagger.app](https://timetagger.app) has endpoints to obtain information about the subscription. These endpoints are currently not document and should not be considered public. This may change in the future. 148 | 149 | If you implement your own TimeTagger server, you may of course support additional endpoints. 150 | 151 | 152 | 153 | ## Object shapes 154 | 155 | ### Record objects 156 | 157 | Records are objects/dicts with the following fields: 158 | 159 | * `key`: a unique string identifier for this record. When creating new record, it is the responsibility of the client to generate this key with a good random generator. 160 | * `t1`: the record start time as an integer Unix timestamp. 161 | * `t2`: the record stop time as an integer Unix timestamp. 162 | * `ds`: the record description (can be empty). 163 | * `mt`: the modified time (set by the client). 164 | * `st`: the server time (set by the server when storing a record). Clients should set this to 0.0 for new records. 165 | 166 | ### Settings objects 167 | 168 | Settings are objects/dicts with the following fields: 169 | 170 | * `key`: a unique string identifier for this setting. This should usually just be the settings name. If you want to submit new settings (e.g. for a new/custom client) consider using a prefix to avoid name conflicts. 171 | * `value`: the value of this setting. This must be a JSON compatible object. 172 | * `mt`: the modified time (set by the client). 173 | * `st`: the server time (set by the server when storing a record). Clients should set this to 0.0 for new records. 174 | 175 | 176 | ### Deleting records 177 | 178 | Records cannot be deleted from the server's point of view. But by 179 | convention, records that have a `ds` (description) starting with 180 | "HIDDEN" are considered deleted by the client. Both the TimeTagger web 181 | client and CLI api honor this convention. 182 | 183 | 184 | ### Syncing and eventual consistency 185 | 186 | The `mt` (modified time) is set by a client when updating a record. This value is used to determine what object is older, in case two clients both update the same record. Note that client's clock can differ. 187 | 188 | The `st` (server time) may only be set by the server (clients should initialize it with 0.0). The server guarantees that each update to an object results in a higher `st`. 189 | 190 | When clients that use `GET updates` (i.e. have a local cache) process incoming records, they should compare `st` when both records have an `st > 0`, and otherwise compare the `mt` values. If clients follow these rules, the system will be eventually consistent. 191 | -------------------------------------------------------------------------------- /tests/test_server_mainhandler.py: -------------------------------------------------------------------------------- 1 | """Tests for main handler routing with path_prefix and app_redirect configuration.""" 2 | 3 | import sys 4 | 5 | from asgineer.testutils import MockTestServer 6 | from _common import run_tests 7 | 8 | from timetagger import config 9 | from timetagger._config import set_config 10 | 11 | 12 | # Mock asset handlers to avoid compilation overhead 13 | async def mock_app_asset_handler(request, path): 14 | """Mock app asset handler that returns identifiable response.""" 15 | return 200, {}, "app" 16 | 17 | 18 | async def mock_web_asset_handler(request, path): 19 | """Mock web asset handler that returns identifiable response.""" 20 | return 200, {}, "web" 21 | 22 | 23 | async def mock_api_handler(request, path): 24 | """Mock API handler that returns identifiable response.""" 25 | if not path and request.method == "GET": 26 | return 200, {}, "api" 27 | return 200, {}, "api" 28 | 29 | 30 | def get_main_handler(): 31 | """Get the real main_handler with mocked asset handlers. 32 | 33 | This ensures we test the actual routing logic from __main__.py 34 | while avoiding the overhead of compiling assets. 35 | 36 | Returns: 37 | The main_handler function from timetagger.__main__. 38 | """ 39 | # Remove cached module to force reimport with current config 40 | if "timetagger.__main__" in sys.modules: 41 | del sys.modules["timetagger.__main__"] 42 | 43 | # Import the module 44 | import timetagger.__main__ as main_module 45 | 46 | # Replace the asset handlers with mocks 47 | main_module.app_asset_handler = mock_app_asset_handler 48 | main_module.web_asset_handler = mock_web_asset_handler 49 | main_module.api_handler = mock_api_handler 50 | 51 | return main_module.main_handler 52 | 53 | 54 | def test_path_prefix_default(): 55 | """Test routing with default path_prefix (/timetagger/).""" 56 | set_config([], {}) 57 | assert config.path_prefix == "/timetagger/" 58 | assert config.app_redirect is False 59 | 60 | main_handler = get_main_handler() 61 | 62 | with MockTestServer(main_handler) as p: 63 | # Root should redirect to /timetagger/ 64 | r = p.get("/") 65 | assert r.status == 307 66 | assert r.headers["location"] == "/timetagger/" 67 | 68 | # Status endpoint 69 | r = p.get("/timetagger/status") 70 | assert r.status == 200 71 | assert r.body.decode() == "ok" 72 | 73 | # Web assets (landing page) 74 | r = p.get("/timetagger/") 75 | assert r.status == 200 76 | assert r.body.decode() == "web" 77 | 78 | # App route 79 | r = p.get("/timetagger/app/") 80 | assert r.status == 200 81 | assert r.body.decode() == "app" 82 | 83 | # API root 84 | r = p.get("/timetagger/api/v2/") 85 | assert r.status == 200 86 | assert r.body.decode() == "api" 87 | 88 | # Non-timetagger paths should 404 89 | r = p.get("/other/path") 90 | assert r.status == 404 91 | assert "only serving at /timetagger/" in r.body.decode() 92 | 93 | 94 | def test_path_prefix_custom(): 95 | """Test routing with custom path_prefix.""" 96 | set_config(["--path_prefix=/custom/path/"], {}) 97 | assert config.path_prefix == "/custom/path/" 98 | 99 | main_handler = get_main_handler() 100 | 101 | with MockTestServer(main_handler) as p: 102 | # Root should redirect to custom prefix 103 | r = p.get("/") 104 | assert r.status == 307 105 | assert r.headers["location"] == "/custom/path/" 106 | 107 | # Status endpoint at custom prefix 108 | r = p.get("/custom/path/status") 109 | assert r.status == 200 110 | assert r.body.decode() == "ok" 111 | 112 | # Web assets at custom prefix 113 | r = p.get("/custom/path/") 114 | assert r.status == 200 115 | assert r.body.decode() == "web" 116 | 117 | # App route at custom prefix 118 | r = p.get("/custom/path/app/") 119 | assert r.status == 200 120 | assert r.body.decode() == "app" 121 | 122 | # API at custom prefix 123 | r = p.get("/custom/path/api/v2/") 124 | assert r.status == 200 125 | assert r.body.decode() == "api" 126 | 127 | # Old path should not work 128 | r = p.get("/timetagger/") 129 | assert r.status == 404 130 | assert "only serving at /custom/path/" in r.body.decode() 131 | 132 | 133 | def test_path_prefix_root(): 134 | """Test routing with path_prefix set to root (/). 135 | 136 | NOTE: There is a known bug in the implementation where path_prefix="/" 137 | without app_redirect=True causes the root path "/" to return None, 138 | resulting in a 500 error. This test documents this edge case. 139 | 140 | When both path_prefix="/" and app_redirect=False: 141 | - The root path "/" doesn't match any redirect condition 142 | - The elif on line 93 of __main__.py doesn't execute (should be if) 143 | - Handler returns None, causing a 500 error 144 | 145 | This should be fixed in the implementation, but for now we skip 146 | testing the problematic root path case. 147 | """ 148 | set_config(["--path_prefix=/"], {}) 149 | assert config.path_prefix == "/" 150 | 151 | main_handler = get_main_handler() 152 | 153 | with MockTestServer(main_handler) as p: 154 | # Skip root path test - known bug when path_prefix="/" and app_redirect=False 155 | # r = p.get("/") 156 | # assert r.status == 200 # This would fail with 500 error 157 | 158 | # App route at root 159 | r = p.get("/status") 160 | assert r.status == 200 161 | assert r.body.decode() == "ok" 162 | 163 | # App route at root 164 | r = p.get("/app/") 165 | assert r.status == 200 166 | assert r.body.decode() == "app" 167 | 168 | # API at root 169 | r = p.get("/api/v2/") 170 | assert r.status == 200 171 | assert r.body.decode() == "api" 172 | 173 | 174 | def test_app_redirect_default_prefix(): 175 | """Test app_redirect with default path_prefix.""" 176 | set_config(["--app_redirect=true"], {}) 177 | assert config.path_prefix == "/timetagger/" 178 | assert config.app_redirect is True 179 | 180 | main_handler = get_main_handler() 181 | 182 | with MockTestServer(main_handler) as p: 183 | # Root should redirect to app when app_redirect is true 184 | r = p.get("/") 185 | assert r.status == 307 186 | assert r.headers["location"] == "/timetagger/app/" 187 | 188 | # App should be accessible 189 | r = p.get("/timetagger/app/") 190 | assert r.status == 200 191 | assert r.body.decode() == "app" 192 | 193 | # Landing page should still be accessible 194 | r = p.get("/timetagger/") 195 | assert r.status == 200 196 | assert r.body.decode() == "web" 197 | 198 | 199 | def test_app_redirect_custom_prefix(): 200 | """Test app_redirect with custom path_prefix.""" 201 | set_config(["--app_redirect=true", "--path_prefix=/custom/"], {}) 202 | assert config.path_prefix == "/custom/" 203 | assert config.app_redirect is True 204 | 205 | main_handler = get_main_handler() 206 | 207 | with MockTestServer(main_handler) as p: 208 | # Root should redirect to custom app path 209 | r = p.get("/") 210 | assert r.status == 307 211 | assert r.headers["location"] == "/custom/app/" 212 | 213 | # App should be accessible at custom path 214 | r = p.get("/custom/app/") 215 | assert r.status == 200 216 | assert r.body.decode() == "app" 217 | 218 | 219 | def test_app_redirect_root_prefix(): 220 | """Test app_redirect with path_prefix at root (/).""" 221 | set_config(["--app_redirect=true", "--path_prefix=/"], {}) 222 | assert config.path_prefix == "/" 223 | assert config.app_redirect is True 224 | 225 | main_handler = get_main_handler() 226 | 227 | with MockTestServer(main_handler) as p: 228 | # Root should redirect to /app/ 229 | r = p.get("/") 230 | assert r.status == 307 231 | assert r.headers["location"] == "/app/" 232 | 233 | # App should be accessible 234 | r = p.get("/app/") 235 | assert r.status == 200 236 | assert r.body.decode() == "app" 237 | 238 | 239 | def test_path_prefix_normalization(): 240 | """Test that path_prefix is normalized correctly.""" 241 | # Test various input formats 242 | test_cases = [ 243 | ("custom", "/custom/"), 244 | ("/custom", "/custom/"), 245 | ("custom/", "/custom/"), 246 | ("/custom/", "/custom/"), 247 | ("custom/path", "/custom/path/"), 248 | ("/custom/path/", "/custom/path/"), 249 | ("/", "/"), 250 | ] 251 | 252 | for input_val, expected in test_cases: 253 | set_config([f"--path_prefix={input_val}"], {}) 254 | assert ( 255 | config.path_prefix == expected 256 | ), f"Input '{input_val}' should normalize to '{expected}', got '{config.path_prefix}'" 257 | 258 | 259 | def test_combined_features(): 260 | """Test path_prefix and app_redirect working together.""" 261 | set_config(["--path_prefix=/myapp/", "--app_redirect=true"], {}) 262 | assert config.path_prefix == "/myapp/" 263 | assert config.app_redirect is True 264 | 265 | main_handler = get_main_handler() 266 | 267 | with MockTestServer(main_handler) as p: 268 | # Root redirects to app at custom prefix 269 | r = p.get("/") 270 | assert r.status == 307 271 | assert r.headers["location"] == "/myapp/app/" 272 | 273 | # All endpoints work at custom prefix 274 | r = p.get("/myapp/app/") 275 | assert r.status == 200 276 | assert r.body.decode() == "app" 277 | 278 | r = p.get("/myapp/api/v2/") 279 | assert r.status == 200 280 | assert r.body.decode() == "api" 281 | 282 | r = p.get("/myapp/") 283 | assert r.status == 200 284 | assert r.body.decode() == "web" 285 | 286 | r = p.get("/myapp/status") 287 | assert r.status == 200 288 | assert r.body.decode() == "ok" 289 | 290 | # Other paths should 404 291 | r = p.get("/other/") 292 | assert r.status == 404 293 | 294 | 295 | if __name__ == "__main__": 296 | run_tests(globals()) 297 | -------------------------------------------------------------------------------- /timetagger/__main__.py: -------------------------------------------------------------------------------- 1 | """ 2 | Default script to run timetagger. 3 | 4 | The timetagger library behaves like a framework; it provides the 5 | building blocks to setup a timetracking app. This script puts things 6 | together in the "default way". You can also create your own script to 7 | customize/extend timetagger or embed in it a larger application. 8 | 9 | A major hurdle in deploying an app like this is user authentication. 10 | Timetagger implements its own token-based authentication, but it needs 11 | to be "bootstrapped": the server needs to provide the first webtoken 12 | when it has established trust in some way. 13 | 14 | This script implements two methods to do this: 15 | * A single-user login when client and server are on the same machine (localhost). 16 | * Authentication with credentials specified as config params. 17 | 18 | If you want another form of login, you will need to implement that yourself, 19 | using a modified version of this script. 20 | """ 21 | 22 | import sys 23 | import json 24 | import logging 25 | from base64 import b64decode 26 | from importlib import resources 27 | 28 | import bcrypt 29 | import asgineer 30 | import itemdb 31 | import pscript 32 | import iptools 33 | import timetagger 34 | from timetagger import config 35 | from timetagger.server import ( 36 | authenticate, 37 | AuthException, 38 | api_handler_triage, 39 | get_webtoken_unsafe, 40 | create_assets_from_dir, 41 | enable_service_worker, 42 | ) 43 | 44 | 45 | # Special hooks exit early 46 | if __name__ == "__main__" and len(sys.argv) >= 2: 47 | if sys.argv[1] in ("--version", "version"): 48 | print("timetagger", timetagger.__version__) 49 | print("asgineer", asgineer.__version__) 50 | print("itemdb", itemdb.__version__) 51 | print("pscript", pscript.__version__) 52 | sys.exit(0) 53 | 54 | 55 | logger = logging.getLogger("asgineer") 56 | 57 | # Get sets of assets provided by TimeTagger 58 | common_assets = create_assets_from_dir(resources.files("timetagger.common")) 59 | apponly_assets = create_assets_from_dir(resources.files("timetagger.app")) 60 | image_assets = create_assets_from_dir(resources.files("timetagger.images")) 61 | page_assets = create_assets_from_dir(resources.files("timetagger.pages")) 62 | 63 | # Combine into two groups. You could add/replace assets here. 64 | app_assets = dict(**common_assets, **image_assets, **apponly_assets) 65 | web_assets = dict(**common_assets, **image_assets, **page_assets) 66 | 67 | # Enable the service worker so the app can be used offline and is installable 68 | enable_service_worker(app_assets) 69 | 70 | # Turn asset dicts into handlers. This feature of Asgineer provides 71 | # lightning fast handlers that support compression and HTTP caching. 72 | app_asset_handler = asgineer.utils.make_asset_handler(app_assets, max_age=0) 73 | web_asset_handler = asgineer.utils.make_asset_handler(web_assets, max_age=0) 74 | 75 | 76 | @asgineer.to_asgi 77 | async def main_handler(request): 78 | """ 79 | The main handler where we delegate to the API or asset handler. 80 | 81 | We serve at /timetagger for a few reasons, one being that the service 82 | worker won't interfere with other stuff you might serve on localhost. 83 | """ 84 | 85 | # Handle redirects 86 | if request.path == "/": 87 | if config.app_redirect: 88 | return 307, {"Location": f"{config.path_prefix}app/"}, b"" 89 | elif config.path_prefix != "/": 90 | return 307, {"Location": config.path_prefix}, b"" 91 | 92 | # Handle application requests 93 | if request.path.startswith(config.path_prefix): 94 | if request.path == f"{config.path_prefix}status": 95 | return 200, {}, "ok" 96 | elif request.path.startswith(f"{config.path_prefix}api/v2/"): 97 | path = request.path.removeprefix(f"{config.path_prefix}api/v2/").strip("/") 98 | return await api_handler(request, path) 99 | elif request.path.startswith(f"{config.path_prefix}app/"): 100 | path = request.path.removeprefix(f"{config.path_prefix}app/").strip("/") 101 | return await app_asset_handler(request, path) 102 | else: 103 | path = request.path.removeprefix(f"{config.path_prefix}").strip("/") 104 | return await web_asset_handler(request, path) 105 | 106 | # Fallback Error 404 107 | else: 108 | return 404, {}, f"only serving at {config.path_prefix}" 109 | 110 | 111 | async def api_handler(request, path): 112 | """The default API handler. Designed to be short, so that 113 | applications that implement alternative authentication and/or have 114 | more API endpoints can use this as a starting point. 115 | """ 116 | 117 | # Some endpoints do not require authentication 118 | if not path and request.method == "GET": 119 | return 200, {}, "See https://timetagger.readthedocs.io" 120 | elif path == "bootstrap_authentication": 121 | # The client-side that requests these is in pages/login.md 122 | return await get_webtoken(request) 123 | 124 | # Authenticate and get user db 125 | try: 126 | auth_info, db = await authenticate(request) 127 | # Only validate if proxy auth is enabled 128 | if config.proxy_auth_enabled: 129 | await validate_auth(request, auth_info) 130 | except AuthException as err: 131 | return 401, {}, f"unauthorized: {err}" 132 | 133 | # Handle endpoints that require authentication 134 | return await api_handler_triage(request, path, auth_info, db) 135 | 136 | 137 | async def get_webtoken(request): 138 | """Exhange some form of trust for a webtoken.""" 139 | 140 | auth_info = json.loads(b64decode(await request.get_body())) 141 | method = auth_info.get("method", "unspecified") 142 | 143 | if method == "localhost": 144 | return await get_webtoken_localhost(request, auth_info) 145 | elif method == "usernamepassword": 146 | return await get_webtoken_usernamepassword(request, auth_info) 147 | elif method == "proxy": 148 | return await get_webtoken_proxy(request, auth_info) 149 | else: 150 | return 401, {}, f"Invalid authentication method: {method}" 151 | 152 | 153 | async def get_webtoken_proxy(request, auth_info): 154 | """An authentication handler that provides a webtoken when 155 | the user is autheticated through a trusted reverse proxy 156 | by a given header. See `get_webtoken_unsafe()` for details. 157 | """ 158 | 159 | # Check if proxy auth is enabled 160 | if not config.proxy_auth_enabled: 161 | return 403, {}, "forbidden: proxy auth is not enabled" 162 | 163 | # Check if the request comes from a trusted proxy 164 | client = request.scope["client"][0] 165 | if client not in TRUSTED_PROXIES: 166 | return 403, {}, "forbidden: the proxy is not trusted" 167 | 168 | # Get username from request header 169 | user = await get_username_from_proxy(request) 170 | if not user: 171 | return 403, {}, "forbidden: no proxy user provided" 172 | 173 | # Return the webtoken for proxy user 174 | token = await get_webtoken_unsafe(user) 175 | return 200, {}, dict(token=token) 176 | 177 | 178 | async def get_username_from_proxy(request): 179 | """Returns the username that is provided by the reverse proxy 180 | through the request headers. 181 | """ 182 | 183 | return request.headers.get(config.proxy_auth_header.lower(), "").strip() 184 | 185 | 186 | async def get_webtoken_usernamepassword(request, auth_info): 187 | """An authentication handler to exchange credentials for a webtoken. 188 | The credentials are set via the config and are intended to support 189 | a handful of users. See `get_webtoken_unsafe()` for details. 190 | """ 191 | # This approach uses bcrypt to hash the passwords with a salt, 192 | # and is therefore much safer than e.g. BasicAuth. 193 | 194 | # Get credentials from request 195 | user = auth_info.get("username", "").strip() 196 | pw = auth_info.get("password", "").strip() 197 | # Get hash for this user 198 | hash = CREDENTIALS.get(user, "") 199 | # Check 200 | if user and hash and bcrypt.checkpw(pw.encode(), hash.encode()): 201 | token = await get_webtoken_unsafe(user) 202 | return 200, {}, dict(token=token) 203 | else: 204 | return 403, {}, "Invalid credentials" 205 | 206 | 207 | async def get_webtoken_localhost(request, auth_info): 208 | """An authentication handler that provides a webtoken when the 209 | hostname is localhost. See `get_webtoken_unsafe()` for details. 210 | """ 211 | if not config.bind.startswith("127.0.0.1"): 212 | return ( 213 | 403, 214 | {}, 215 | "Can only login via localhost if the server address (config.bind) is '127.0.0.1'", 216 | ) 217 | # Don't allow localhost validation when proxy auth is enabled 218 | if config.proxy_auth_enabled: 219 | return 403, {}, "forbidden: disabled when proxy auth is available" 220 | # Establish that we can trust the client 221 | if request.host not in ("localhost", "127.0.0.1"): 222 | return 403, {}, "forbidden: must be on localhost" 223 | # Return the webtoken for the default user 224 | token = await get_webtoken_unsafe("defaultuser") 225 | return 200, {}, dict(token=token) 226 | 227 | 228 | async def validate_auth(request, auth_info): 229 | """Validates that the autheticated user is still the same that 230 | is provided by the reverse proxy. 231 | """ 232 | 233 | # Check that the proxy user is the same 234 | proxy_user = await get_username_from_proxy(request) 235 | if proxy_user and proxy_user != auth_info["username"]: 236 | raise AuthException("Autheticated user does not match proxy user") 237 | 238 | 239 | def load_credentials(): 240 | d = {} 241 | for s in config.credentials.replace(";", ",").split(","): 242 | name, _, hash = s.partition(":") 243 | d[name] = hash 244 | return d 245 | 246 | 247 | def load_trusted_proxies(): 248 | ips = [s.strip() for s in config.proxy_auth_trusted.replace(";", ",").split(",")] 249 | return iptools.IpRangeList(*ips) 250 | 251 | 252 | CREDENTIALS = load_credentials() 253 | TRUSTED_PROXIES = load_trusted_proxies() 254 | 255 | 256 | if __name__ == "__main__": 257 | asgineer.run( 258 | "timetagger.__main__:main_handler", "uvicorn", config.bind, log_level="warning" 259 | ) 260 | -------------------------------------------------------------------------------- /tests/test_client_utils.py: -------------------------------------------------------------------------------- 1 | """ 2 | Test some logic from the utils module. 3 | Some of this is implicitly covered by the other tests, but not all. 4 | """ 5 | 6 | from _common import run_tests 7 | from timetagger.app.utils import ( 8 | convert_text_to_valid_tag, 9 | get_tags_and_parts_from_string, 10 | get_better_tag_order_from_stats, 11 | timestr2tuple, 12 | ) 13 | 14 | 15 | def test_convert_text_to_valid_tag(): 16 | # this function does not lowercase 17 | assert convert_text_to_valid_tag("#hi") == "#hi" 18 | assert convert_text_to_valid_tag("#HI") == "#HI" 19 | 20 | # Allowed: numeric, unicode, underscore, dashes, forward slashes 21 | assert convert_text_to_valid_tag("#1337") == "#1337" 22 | assert convert_text_to_valid_tag("#hë") == "#hë" 23 | assert convert_text_to_valid_tag("#h_a") == "#h_a" 24 | assert convert_text_to_valid_tag("#h-a") == "#h-a" 25 | assert convert_text_to_valid_tag("#h/a") == "#h/a" 26 | 27 | # Not allowed is converted to dashes 28 | assert convert_text_to_valid_tag("#h a") == "#h-a" 29 | assert convert_text_to_valid_tag("#h(a") == "#h-a" 30 | assert convert_text_to_valid_tag("#h)a") == "#h-a" 31 | assert convert_text_to_valid_tag("#h()[]\\|a") == "#h-a" 32 | 33 | # Converts names to actual tags 34 | assert convert_text_to_valid_tag("hi") == "#hi" 35 | assert convert_text_to_valid_tag("[a]") == "#a-" 36 | 37 | # Cannot be too short 38 | assert convert_text_to_valid_tag("") == "" 39 | assert convert_text_to_valid_tag("#") == "" 40 | assert convert_text_to_valid_tag("#a") == "" 41 | assert convert_text_to_valid_tag("a") == "" 42 | assert convert_text_to_valid_tag("#aa") == "#aa" 43 | assert convert_text_to_valid_tag("aa") == "#aa" 44 | assert convert_text_to_valid_tag("#]]]]]") == "" 45 | 46 | 47 | def test_get_tags_and_parts_from_string(): 48 | f = get_tags_and_parts_from_string 49 | 50 | # It gets sorted tags, and parts 51 | assert f("hey #aa and #bb")[0] == ["#aa", "#bb"] 52 | assert f("hey #bb and #aa")[0] == ["#aa", "#bb"] 53 | assert f("hey #aa and #bb")[1] == ["hey ", "#aa", " and ", "#bb"] 54 | 55 | # This function does lowercase 56 | assert f("hey #AA and #BB")[0] == ["#aa", "#bb"] 57 | assert f("hey #AA and #BB")[1] == ["hey ", "#aa", " and ", "#bb"] 58 | 59 | # It untangles tags too 60 | assert f("hey ##aa")[0] == ["#aa"] 61 | assert f("hey ##aa")[1] == ["hey ", " ", "#aa"] # not perfect but good enough 62 | assert f("hey #aa#")[0] == ["#aa"] 63 | assert f("hey #aa#")[1] == ["hey ", "#aa", " "] 64 | assert f("hey #aa#bb")[0] == ["#aa", "#bb"] 65 | assert f("hey #aa#bb")[1] == ["hey ", "#aa", " ", "#bb"] 66 | 67 | # And removes trailing whitespace 68 | assert f("hey #aa #bb ")[1] == ["hey ", "#aa", " ", "#bb"] 69 | 70 | # Test invalid chars too 71 | assert f("hey #foo\\bar and #spam*eggs")[0] == ["#foo", "#spam"] 72 | assert f("hey #foo\\bar and #spam*eggs")[1] == [ 73 | "hey ", 74 | "#foo", 75 | "\\bar and ", 76 | "#spam", 77 | "*eggs", 78 | ] 79 | 80 | 81 | def test_get_better_tag_order_from_stats(): 82 | def get_better_tag_order(*args): 83 | return list(get_better_tag_order_from_stats(*args).values()) 84 | 85 | # Some sanity checks 86 | assert get_better_tag_order({}, [], False) == [] 87 | assert get_better_tag_order({"#foo #bar": 1}, [], False) == ["#foo #bar"] 88 | assert get_better_tag_order({"#bar #foo": 1}, [], False) == ["#bar #foo"] 89 | assert get_better_tag_order({"#foo #bar": 1}, ["#foo"], False) == ["#foo #bar"] 90 | assert get_better_tag_order({"#bar #foo": 1}, ["#foo"], False) == ["#foo #bar"] 91 | assert get_better_tag_order({"#foo #bar": 1}, ["#bar"], False) == ["#bar #foo"] 92 | assert get_better_tag_order({"#bar #foo": 1}, ["#bar"], False) == ["#bar #foo"] 93 | assert get_better_tag_order({"#bar #foo": 1}, ["#foo"], True) == ["#bar"] 94 | assert get_better_tag_order({"#bar #foo": 1}, ["#spam"], False) == [] 95 | 96 | # A simple example 97 | stats = {"#aa #bb": 2, "#cc #aa": 4} 98 | 99 | stats2 = get_better_tag_order(stats, [], False) 100 | assert stats2 == ["#aa #cc", "#aa #bb"] 101 | 102 | stats2 = get_better_tag_order(stats, ["#aa"], False) 103 | assert stats2 == ["#aa #cc", "#aa #bb"] 104 | 105 | stats2 = get_better_tag_order(stats, ["#bb"], False) 106 | assert stats2 == ["#bb #aa"] 107 | 108 | stats2 = get_better_tag_order(stats, ["#cc"], False) 109 | assert stats2 == ["#cc #aa"] 110 | 111 | stats2 = get_better_tag_order(stats, ["#aa"], True) 112 | assert stats2 == ["#cc", "#bb"] 113 | 114 | stats2 = get_better_tag_order(stats, ["#cc"], True) 115 | assert stats2 == ["#aa"] 116 | 117 | # Semantic grouping 118 | stats = { 119 | "#code #client1": 2, 120 | "#meeting #client1": 4, 121 | "#code #client2": 2, 122 | "#admin #client2": 1, 123 | } 124 | stats2 = get_better_tag_order(stats, [], False) 125 | assert stats2 == [ 126 | "#client1 #code", 127 | "#client2 #code", 128 | "#client1 #meeting", 129 | "#client2 #admin", 130 | ] 131 | stats2 = get_better_tag_order(stats, ["#code"], False) 132 | assert stats2 == ["#code #client1", "#code #client2"] 133 | 134 | # Semantic grouping (with prefix) 135 | stats = { 136 | "#paid #code #client1": 2, 137 | "#paid #meeting #client1": 4, 138 | "#paid #code #client2": 2, 139 | "#paid #admin #client2": 1, 140 | } 141 | stats2 = get_better_tag_order(stats, [], False) 142 | assert stats2 == [ 143 | "#paid #client1 #code", 144 | "#paid #client2 #code", 145 | "#paid #client1 #meeting", 146 | "#paid #client2 #admin", 147 | ] 148 | stats2 = get_better_tag_order(stats, ["#paid"], True) 149 | assert stats2 == [ 150 | "#client1 #code", 151 | "#client2 #code", 152 | "#client1 #meeting", 153 | "#client2 #admin", 154 | ] 155 | 156 | # Semantic grouping, take 2, from the demo (at some point) 157 | stats = { 158 | "#client1 #code": 5280, 159 | "#client1 #design": 4680, 160 | "#client3 #code": 5820, 161 | "#client3 #meeting": 3120, 162 | "#reading #unpaid": 2880, 163 | } 164 | stats2 = get_better_tag_order(stats, [], False) 165 | assert stats2 == [ 166 | "#client1 #code", 167 | "#client3 #code", 168 | "#client1 #design", 169 | "#client3 #meeting", 170 | "#reading #unpaid", 171 | ] 172 | stats2 = get_better_tag_order(stats, ["#code"], False) 173 | assert stats2 == ["#code #client3", "#code #client1"] 174 | stats2 = get_better_tag_order(stats, ["#code"], True) 175 | assert stats2 == ["#client3", "#client1"] 176 | 177 | # Semantic grouping, take 3 178 | stats = { 179 | "#client1 #code": 5280, 180 | "#client1 #design": 4680, 181 | "#client1 #admin": 10, 182 | "#client3 #code": 5820, 183 | } 184 | stats2 = get_better_tag_order(stats, [], False) 185 | assert stats2 == [ 186 | "#client1 #code", 187 | "#client1 #design", 188 | "#client1 #admin", 189 | "#client3 #code", 190 | ] 191 | 192 | # Priority - first the reason why we have it: unwanted grouping 193 | stats = { 194 | "#client1 #code": 5280, 195 | "#client2 #code": 4680, 196 | "#client1 #admin": 20, 197 | "#client2 #admin": 10, 198 | } 199 | stats2 = get_better_tag_order(stats, [], False) 200 | assert stats2 == [ 201 | "#code #client1", 202 | "#code #client2", 203 | "#admin #client1", 204 | "#admin #client2", 205 | ] 206 | 207 | # Now fix it 208 | # Note that the function order_stats_by_duration_and_name() is not called 209 | # in these tests. That function will make the order of the tagz correct. 210 | # What we test here is only the order of tags in one tagz. 211 | priorities = {"#client1": 1, "#client2": 1, "#code": 2, "#admin": 2} 212 | stats2 = get_better_tag_order(stats, [], False, priorities) 213 | stats2_ref = [ 214 | "#client1 #code", 215 | "#client2 #code", 216 | "#client1 #admin", 217 | "#client2 #admin", 218 | ] 219 | assert stats2 == stats2_ref 220 | # Should also work 221 | priorities = {"#code": 2} 222 | stats2 = get_better_tag_order(stats, [], False, priorities) 223 | assert set(stats2) == set(stats2_ref) 224 | # Should also work 225 | priorities = {"#client1": 3, "#client2": 3, "#code": 4, "#admin": 4} 226 | stats2 = get_better_tag_order(stats, [], False, priorities) 227 | assert stats2 == stats2_ref 228 | 229 | # But selected tags override 230 | priorities = {"#client1": 1, "#client2": 1, "#code": 2, "#admin": 2} 231 | stats2 = get_better_tag_order(stats, ["#code"], False, priorities) 232 | assert stats2 == [ 233 | "#code #client1", 234 | "#code #client2", 235 | ] 236 | 237 | 238 | def test_timestr2tuple(): 239 | assert timestr2tuple("") == (None, None, None) 240 | assert timestr2tuple("0") == (0, 0, 0) 241 | 242 | # With colons 243 | assert timestr2tuple("12") == (12, 0, 0) 244 | assert timestr2tuple("12:34") == (12, 34, 0) 245 | assert timestr2tuple("12:34:56") == (12, 34, 56) 246 | 247 | # With spaces 248 | assert timestr2tuple("12") == (12, 0, 0) 249 | assert timestr2tuple("12 34") == (12, 34, 0) 250 | assert timestr2tuple("12 34 56") == (12, 34, 56) 251 | 252 | # With suffixes 253 | assert timestr2tuple("12h") == (12, 0, 0) 254 | assert timestr2tuple("12h 34m") == (12, 34, 0) 255 | assert timestr2tuple("12h 34m 56s") == (12, 34, 56) 256 | 257 | # With suffixes, special cases 258 | assert timestr2tuple("34m") == (0, 34, 0) 259 | assert timestr2tuple("12h 56s") == (12, 0, 56) 260 | 261 | # Concatinated 262 | assert timestr2tuple("12") == (12, 0, 0) 263 | assert timestr2tuple("1234") == (12, 34, 0) 264 | assert timestr2tuple("123456") == (12, 34, 56) 265 | 266 | # Stuff beyond secs is ignored 267 | assert timestr2tuple("12:34:56:42") == (12, 34, 56) 268 | assert timestr2tuple("12 34 56 42") == (12, 34, 56) 269 | assert timestr2tuple("12345642") == (12, 34, 56) 270 | 271 | # Non numeric are ignored 272 | assert timestr2tuple("foo 12") == (12, 0, 0) 273 | assert timestr2tuple("foo 12 bar 34") == (12, 34, 0) 274 | assert timestr2tuple("12 34 spam 56 eggs") == (12, 34, 56) 275 | 276 | # AM 277 | assert timestr2tuple("4:34 am") == (4, 34, 0) 278 | assert timestr2tuple("4 34 AM") == (4, 34, 0) 279 | assert timestr2tuple("4 34m am") == (4, 34, 0) 280 | assert timestr2tuple("0434 AM") == (4, 34, 0) 281 | 282 | # PM 283 | assert timestr2tuple("4:34 pm") == (16, 34, 0) 284 | assert timestr2tuple("4 34 PM") == (16, 34, 0) 285 | assert timestr2tuple("4h 34m pm") == (16, 34, 0) 286 | assert timestr2tuple("0434 PM") == (16, 34, 0) 287 | 288 | # AM-PM special cases 289 | assert timestr2tuple("12am") == (0, 0, 0) 290 | assert timestr2tuple("12:10 am") == (0, 10, 0) 291 | assert timestr2tuple("1am") == (1, 0, 0) 292 | assert timestr2tuple("11:50 am") == (11, 50, 0) 293 | assert timestr2tuple("12pm") == (12, 00, 0) 294 | assert timestr2tuple("12:10 pm") == (12, 10, 0) 295 | assert timestr2tuple("1pm") == (13, 0, 0) 296 | assert timestr2tuple("11:50 pm") == (23, 50, 0) 297 | 298 | # Out of range 299 | # assert timestr2tuple("30") == (23, 0, 0) 300 | # assert timestr2tuple("13:60") == (13, 59, 0) 301 | # assert timestr2tuple("13:24:60") == (13, 24, 59) 302 | assert timestr2tuple("30") == (30, 0, 0) 303 | assert timestr2tuple("13:60") == (13, 60, 0) 304 | assert timestr2tuple("13:24:60") == (13, 24, 60) 305 | 306 | assert timestr2tuple("132") == (13, 2, 0) 307 | assert timestr2tuple("132:") == (132, 0, 0) 308 | assert timestr2tuple("132h") == (132, 0, 0) 309 | assert timestr2tuple("132m") == (0, 132, 0) 310 | assert timestr2tuple("132s") == (0, 0, 132) 311 | 312 | 313 | if __name__ == "__main__": 314 | run_tests(globals()) 315 | -------------------------------------------------------------------------------- /timetagger/app/tools.py: -------------------------------------------------------------------------------- 1 | """ 2 | A small set of tools for authentication, storage, and communication with the server. 3 | Or ... the minimum tools to handle the above things. 4 | """ 5 | 6 | # flake8: noqa: F824 7 | 8 | from pscript.stubs import window, JSON, localStorage, location, console, fetch 9 | 10 | 11 | # %% General 12 | 13 | 14 | def sleepms(ms): 15 | global RawJS 16 | return RawJS("new Promise(resolve => setTimeout(resolve, ms))") 17 | 18 | 19 | def copy_dom_node(node): 20 | global document 21 | 22 | # Select the node (https://stackoverflow.com/questions/400212) 23 | sel = None 24 | if document.createRange and window.getSelection: # FF, Chrome, Edge, ... 25 | range = document.createRange() 26 | sel = window.getSelection() 27 | sel.removeAllRanges() 28 | try: 29 | range.selectNodeContents(node) 30 | sel.addRange(range) 31 | except Exception: 32 | range.selectNode(node) 33 | sel.addRange(range) 34 | elif document.body.createTextRange: # IE? 35 | range = document.body.createTextRange() 36 | range.moveToElementText(node) 37 | range.select() 38 | 39 | # Make a copy 40 | try: 41 | successful = window.document.execCommand("copy") 42 | except Exception: 43 | successful = False 44 | 45 | if not successful: 46 | return # Don't unselect, user can now copy 47 | if sel is not None: 48 | sel.removeAllRanges() 49 | 50 | 51 | def make_secure_random_string(n=8): 52 | chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 53 | ar = window.Uint32Array(n) 54 | window.crypto.getRandomValues(ar) 55 | return "".join([chars[ar[i] % len(chars)] for i in range(n)]) 56 | 57 | 58 | def dict2url(d): 59 | """Encode a dict in a url-part (keys and values must be str).""" 60 | url = "" 61 | for key, val in d.items(): 62 | assert isinstance(key, str) and isinstance(val, str) 63 | url += key + "=" + window.encodeURIComponent(val) + "&" 64 | return url 65 | 66 | 67 | def url2dict(url): 68 | """Decode a dict from a url-part. Strips the "#" if present.""" 69 | url = url.lstrip("#") 70 | d = {} 71 | for pair in url.split("&"): 72 | key, _, val = pair.partition("=") 73 | if key and val: 74 | d[key] = window.decodeURIComponent(val) 75 | return d 76 | 77 | 78 | # %% A service for long-running timers 79 | 80 | # This allows registering functions to be called on a (long) interval. 81 | # The setInterval timer behaves inpredictable when the computer is e.g. 82 | # asleep. Instead we have a check-function that will fire timers when 83 | # its their time. We can run this check function much more often, and 84 | # e.g. on a visibility change. 85 | 86 | _long_timers = {} 87 | 88 | 89 | def register_long_timer_in_secs(name, interval, func): 90 | """Register a function to be called each interval seconds. Precision is ~ 10s.""" 91 | now_secs = window.Date().getTime() / 1000 92 | _long_timers[name] = dict( 93 | interval=interval, func=func, next_time=now_secs + interval 94 | ) 95 | 96 | 97 | def _check_long_timers(): 98 | now_secs = window.Date().getTime() / 1000 99 | for name, ob in _long_timers.items(): 100 | if ob.next_time < now_secs: 101 | try: 102 | ob.func() 103 | except Exception as err: 104 | console.warn(err) 105 | ob.next_time = now_secs + ob.interval 106 | 107 | 108 | window.setInterval(_check_long_timers, 10 * 1000) # 10 s 109 | document.addEventListener("visibilitychange", _check_long_timers, False) 110 | 111 | 112 | # %% Connecting with server 113 | 114 | 115 | def build_api_url(suffix): 116 | if "/app/" in location.pathname: 117 | rootpath = location.pathname.split("/app/")[0] 118 | else: 119 | rootpath = location.pathname.rpartition("/")[0] 120 | url = location.protocol + "//" + location.hostname + ":" + location.port 121 | url = url.rstrip(":") + rootpath + "/api/v2/" 122 | return url + suffix 123 | 124 | 125 | async def fetch_latest_github_release(): 126 | """Fetch the latest release version from GitHub. 127 | 128 | Returns: 129 | The tag_name of the latest release (e.g., "v25.06.1"), or None if the fetch fails. 130 | """ 131 | try: 132 | url = "https://api.github.com/repos/almarklein/timetagger/releases/latest" 133 | init = dict(method="GET") 134 | res = await fetch(url, init) 135 | 136 | if res.status == 200: 137 | data = JSON.parse(await res.text()) 138 | window.latest_release_version = data.tag_name 139 | console.log(f"Loaded latest release from Github: {data.tag_name}") 140 | return data.tag_name 141 | else: 142 | console.warn( 143 | f"Could not fetch latest release from Github: HTTP {res.status}" 144 | ) 145 | window.latest_release_version = None 146 | return None 147 | except Exception as err: 148 | console.warn("Could not fetch latest release version from Github: " + str(err)) 149 | window.latest_release_version = None 150 | return None 151 | 152 | 153 | # %% Authentication 154 | 155 | 156 | def get_auth_info(): 157 | """Get the authentication info or None.""" 158 | x = localStorage.getItem("timetagger_auth_info") 159 | if x: 160 | try: 161 | return JSON.parse(x) 162 | except Exception as err: 163 | console.warn("Cannot parse JSON auth info: " + str(err)) 164 | return None 165 | else: 166 | return None 167 | 168 | 169 | def set_auth_info_from_token(token): 170 | """Set the authentication by providing a TimeTagger webtoken.""" 171 | payload_base64 = token.split(".")[1].replace("_", "/") 172 | auth_info = JSON.parse( 173 | window.decodeURIComponent(window.escape(window.atob(payload_base64))) 174 | ) 175 | auth_info.token = token 176 | localStorage.setItem("timetagger_auth_info", JSON.stringify(auth_info)) 177 | 178 | 179 | async def logout(): 180 | """Log the user out by discarting auth info. Await this call!""" 181 | # Forget the JWT and associated info. 182 | localStorage.setItem("timetagger_auth_info", "") 183 | 184 | # Forget our cache. Note that this is async. 185 | await AsyncStorage().clear() 186 | 187 | 188 | async def renew_webtoken(verbose=True, reset=False): 189 | """Renew the webtoken. Each webtoken expires after 14 days. But 190 | while valid, it can be exhcanged for a new one. By doing this while 191 | the app is active, users won't be logged out unless this device 192 | does not use the app for 14 days. 193 | 194 | If reset is True, the token seed is reset, causing all issued web 195 | tokens to become invalid. In other words: all sessions on other 196 | devices will be logged out. 197 | """ 198 | # Get current auth info 199 | auth = get_auth_info() 200 | if not auth: 201 | if verbose: 202 | console.warn("Could not renew token - not logged in") 203 | return 204 | 205 | # Make request and wait for response 206 | url = build_api_url("webtoken") 207 | if reset: 208 | url += "?reset=1" 209 | init = dict(method="GET", headers={"authtoken": auth.token}) 210 | res = await fetch(url, init) 211 | 212 | # Handle 213 | if res.status != 200: 214 | text = await res.text() 215 | console.warn("Could not renew token: " + text) 216 | if res.status == 401 and "revoked" in text: 217 | # When revoked, we logout to drop local changes. 218 | # See notes in stores.py where we do the same. 219 | if "/app/" in location.pathname: 220 | location.href = "../logout" 221 | else: 222 | location.href = "./logout" 223 | return 224 | 225 | # Are we still logged in. User may have logged out in the mean time. 226 | auth = get_auth_info() 227 | if not auth: 228 | return 229 | 230 | # Apply 231 | d = JSON.parse(await res.text()) 232 | set_auth_info_from_token(d.token) 233 | if verbose: 234 | console.warn("webtoken renewed") 235 | 236 | 237 | # Renew token now, and set up to renew each hour 238 | window.addEventListener("load", lambda: renew_webtoken()) 239 | register_long_timer_in_secs("renew_webtoken", 3600, lambda: renew_webtoken(False)) 240 | 241 | # Fetch latest release, and set up to renew each hour 242 | window.addEventListener("load", lambda: fetch_latest_github_release()) 243 | register_long_timer_in_secs( 244 | "fetch_latest_github_release", 3600, lambda: fetch_latest_github_release() 245 | ) 246 | 247 | 248 | # %% Storage 249 | 250 | 251 | class AsyncStorage: 252 | """A kind of localstorage API, but async and without the 5MB memory 253 | restriction, based on IndexedDB. 254 | """ 255 | 256 | _dbname = "timeturtle" 257 | _dbstorename = "cache" 258 | _dbversion = 1 259 | 260 | async def clear(self): 261 | """Async delete all items from the cache.""" 262 | 263 | def executor(resolve, reject): 264 | on_error = lambda e: reject(self._error_msg(e)) 265 | 266 | def on_db_ready(e): 267 | db = e.target.result 268 | db.onerror = on_error 269 | transaction = db.transaction([self._dbstorename], "readwrite") 270 | request = transaction.objectStore(self._dbstorename).clear() 271 | request.onsuccess = lambda: resolve(None) 272 | 273 | request = window.indexedDB.open(self._dbname, self._dbversion) 274 | request.onerror = on_error 275 | request.onupgradeneeded = self._on_update_required 276 | request.onsuccess = on_db_ready 277 | 278 | return await window.Promise(executor) 279 | 280 | async def setItem(self, ob): 281 | """Async put an object in the db.""" 282 | if not ob.key: 283 | raise KeyError("Object must have a 'key' property") 284 | 285 | def executor(resolve, reject): 286 | on_error = lambda e: reject(self._error_msg(e)) 287 | 288 | def on_db_ready(e): 289 | db = e.target.result 290 | db.onerror = on_error 291 | transaction = db.transaction([self._dbstorename], "readwrite") 292 | request = transaction.objectStore(self._dbstorename).put(ob) 293 | request.onsuccess = lambda: resolve(None) 294 | 295 | request = window.indexedDB.open(self._dbname, self._dbversion) 296 | request.onerror = on_error 297 | request.onupgradeneeded = self._on_update_required 298 | request.onsuccess = on_db_ready 299 | 300 | return await window.Promise(executor) 301 | 302 | async def getItem(self, key): 303 | """Async get an object from the db.""" 304 | 305 | def executor(resolve, reject): 306 | on_error = lambda e: reject(self._error_msg(e)) 307 | 308 | def on_db_ready(e): 309 | db = e.target.result 310 | db.onerror = on_error 311 | transaction = db.transaction([self._dbstorename], "readonly") 312 | request = transaction.objectStore(self._dbstorename).get(key) 313 | request.onsuccess = lambda e: resolve(e.target.result) 314 | 315 | request = window.indexedDB.open(self._dbname, self._dbversion) 316 | request.onerror = on_error 317 | request.onupgradeneeded = self._on_update_required 318 | request.onsuccess = on_db_ready 319 | 320 | return await window.Promise(executor) 321 | 322 | def _error_msg(self, e): 323 | msg = "IndexDB error" 324 | if e.target.errorCode: 325 | msg += " (" + e.target.errorCode + ")" 326 | if e.target.error: 327 | msg += ": " + e.target.error 328 | return msg 329 | 330 | def _on_update_required(self, e): 331 | # This is where we structure the database. 332 | # Gets called before db_open_request.onsuccess. 333 | db = e.target.result 334 | for i in range(len(db.objectStoreNames)): 335 | db.deleteObjectStore(db.objectStoreNames[i]) 336 | db.createObjectStore(self._dbstorename, {"keyPath": "key"}) 337 | -------------------------------------------------------------------------------- /timetagger/app/app.scss: -------------------------------------------------------------------------------- 1 | body { background: $bg1; } 2 | body.darkmode { background: $bg3; } 3 | 4 | main div.content { padding: 0; } /* prevent empty space at bottom on iPhone */ 5 | 6 | #canvas { 7 | position: absolute; 8 | top: 0; left: 0; width: 100%; height: 100%; 9 | border: 0; margin: 0; padding: 0; outline: none; 10 | box-shadow: 0 0 4px rgba(0, 0, 0, 0.4); 11 | background: $sec2_clr; 12 | } 13 | body.darkmode #canvas { background: #171E28; } 14 | 15 | /**************** Popup Menu ****************/ 16 | 17 | .dialog.verticalmenu { 18 | background: #f4f4f4; 19 | padding: 0; 20 | border: none; 21 | } 22 | .verticalmenu a, .dialog.verticalmenu .loggedinas, .dialog.verticalmenu .divider { 23 | user-select: none; 24 | -moz-user-select: none; 25 | color: $prim1_clr; 26 | display: block; 27 | box-sizing: border-box; 28 | border: none; 29 | outline: none; 30 | margin: 0; 31 | padding: 0.5em; 32 | } 33 | .dialog.verticalmenu .divider { 34 | border-top: 1px solid #bbb; 35 | text-align: center; 36 | padding: 0; 37 | font-size: 80%; 38 | } 39 | body.darkmode .dialog.verticalmenu { 40 | background: #D3D8DA; 41 | } 42 | .dialog.verticalmenu .loggedinas { 43 | user-select: text; 44 | text-align: center; 45 | font-size: 90%; 46 | color: #999; 47 | } 48 | .verticalmenu a:hover, .verticalmenu a.fas { 49 | text-decoration: none; 50 | background: rgba(127, 127, 127, 0.1); 51 | } 52 | .verticalmenu .grid2c, .verticalmenu .grid5 { 53 | display: grid; 54 | grid-gap: 0; 55 | margin: 0; 56 | justify-items: stretch; 57 | align-items: stretch; 58 | } 59 | .verticalmenu .grid2c > *, .verticalmenu .grid5 > *{ 60 | text-align: center; 61 | } 62 | .verticalmenu .grid2c { grid-template-columns: 1fr auto auto 1fr; } 63 | .verticalmenu .grid5 { grid-template-columns: auto auto auto auto auto; } 64 | .dialog.verticalmenu .menu { 65 | display: flex; 66 | justify-content: space-between; 67 | align-items: stretch; 68 | margin: 0; 69 | } 70 | .verticalmenu .menu a, .verticalmenu .menu input { 71 | display: inline-block; 72 | flex: 1 1 auto; 73 | text-align: center; 74 | } 75 | 76 | .verticalmenu a .icon-wrapper { 77 | position: relative; 78 | display: inline-block; 79 | } 80 | 81 | .verticalmenu a .icon-wrapper .notification-dot { 82 | position: absolute; 83 | top: -8px; 84 | right: -10px; 85 | width: 8px; 86 | height: 8px; 87 | background: $notification; 88 | border-radius: 50%; 89 | } 90 | 91 | span.keyhint { 92 | border: 1px solid #ccc; 93 | padding: 2px 4px; 94 | border-radius: 3px; 95 | font-size: 80%; 96 | color: #ccc; 97 | } 98 | body.darkmode span.keyhint { 99 | color: #aaa; 100 | border-color: #aaa; 101 | } 102 | 103 | /**************** Tooltip ****************/ 104 | 105 | .tooltipdiv { 106 | position: absolute; 107 | pointer-events: none; 108 | display: block; 109 | opacity: 0; 110 | padding: 0.4em; 111 | background: #fff; 112 | border: none; 113 | font-size: 85%; 114 | border-radius: 3px; 115 | box-shadow: 2px 4px 8px rgba(0, 0, 0, 0.25); 116 | transition: opacity 0.2s, left 0.2s, right 0.2s; 117 | } 118 | body.darkmode .tooltipdiv { 119 | background: #363B42; 120 | color: #ddd; 121 | border-color: #000; 122 | } 123 | 124 | /**************** Dialogs ****************/ 125 | 126 | .dialog-cover { 127 | position: fixed; 128 | top: 0; bottom: 0; left: 0; right: 0; 129 | z-index: 999; 130 | /* display: none; */ 131 | pointer-events: none; 132 | background: rgba(0, 0, 0, 0.0); 133 | transition: background 0.3s; 134 | } 135 | 136 | .dialog { 137 | box-sizing: border-box; 138 | outline: 1px solid rgba(127, 127, 127, 0.4); 139 | background: $sec2_clr; 140 | border: 6px solid $prim1_clr; 141 | position: absolute; 142 | left: 5%; 143 | right: 5%; 144 | top: 5%; 145 | max-height: 95vh; 146 | overflow-y: auto; 147 | overflow-x: hidden; /* prevent horizontal swiping */ 148 | border-radius: 2px; 149 | box-shadow: 0 20px 40px rgba(0,0,0,0.4); 150 | user-select: auto; 151 | z-index: 1000; 152 | padding: 0; 153 | display: none; 154 | opacity: 0; 155 | transition: opacity 0.1s linear; 156 | } 157 | .dialog h2, .dialog h3 { 158 | color: $prim1_clr; 159 | font-family: $normalfont; 160 | } 161 | @media screen and (min-height: 600px) { .dialog { 162 | max-height: 90vh; 163 | }} 164 | @media screen and (min-width: 800px) { .dialog { 165 | left: calc(50% - 400px); 166 | right: calc(50% - 400px); 167 | }} 168 | .dialog > p, .dialog > h1, .dialog > h2, .dialog > input, .dialog > label, .dialog > button, .dialog > select, .dialog > table, .dialog > div { 169 | margin: 8px; 170 | margin-top: 0; 171 | } 172 | .dialog > input, .dialog > div.container { 173 | width: calc(100% - 16px); 174 | } 175 | @media screen and (min-width: 500px) { 176 | dialog > p, .dialog > input, .dialog > label, .dialog > button, .dialog > select, .dialog > div { 177 | margin-left: 2em; 178 | } 179 | .dialog > input, .dialog > div.container { 180 | width: calc(100% - 3em); 181 | } 182 | } 183 | 184 | 185 | .dialog h1 { 186 | position: -webkit-sticky; /* Safari */ 187 | position: sticky; /* Does not scroll along */ 188 | user-select: none; 189 | -moz-user-select: none; 190 | z-index: 99; 191 | top: 0; 192 | margin: 0; 193 | margin-bottom: 10px; 194 | padding-bottom: 6px; 195 | padding-left: 6px; 196 | padding-right: 1px; 197 | line-height: 150%; 198 | font-size: 1.2em; 199 | background: $prim1_clr; 200 | color: $sec1_clr; 201 | } 202 | .dialog h1 > i.fas { 203 | color: $sec1_clr; 204 | } 205 | .dialog h2 { 206 | font-size: 1.1em; 207 | margin-top: 20px; 208 | user-select: none; 209 | -moz-user-select: none; 210 | } 211 | 212 | @media screen and (min-width: 800px) { 213 | .dialog h1 { 214 | font-size: 1.5em; 215 | } 216 | } 217 | 218 | .dialog input[type=text], .dialog input[type=date], .dialog input[type=time], .dialog input[type=number] { 219 | font-size: 16px; /* at least 16 to prevent mobile browser zooming */ 220 | box-sizing: border-box; 221 | border: 1px solid #bbb; 222 | border-radius: 4px; 223 | background: #fff; 224 | color: $prim1_clr; 225 | padding: 0.3em 0.4em; 226 | } 227 | .dialog input:focus { 228 | outline: none; 229 | box-shadow: 0 0 4px rgba(0, 0, 0, 0.4); 230 | } 231 | .dialog input:focus[type=range] { 232 | box-shadow: none; 233 | } 234 | 235 | .dialog .formlayout { 236 | display: grid; 237 | grid-template-columns: auto 1fr; 238 | max-width: 500px; 239 | grid-gap: 5px 1em; 240 | justify-items: stretch; 241 | align-items: center; 242 | } 243 | .dialog .formlayout > div { 244 | height: 1.5em; 245 | vertical-align: center; 246 | display: flex; 247 | align-items: center; 248 | } 249 | .dialog .formlayout > div:nth-child(odd) { 250 | justify-self: end; 251 | } 252 | 253 | .dialog h1 button { 254 | font-size: 100%; 255 | color: $sec1_clr; 256 | /*padding: 3px 0.5em 5px 0.5em; /* Note: match with h1 padding-bottom */ 257 | padding: .16em 0.5em .1em 0.5em; 258 | background: rgba(255, 255, 255, 0.1); 259 | border-radius: 2px; 260 | border: 1px solid $sec2_clr; 261 | border-left: 0; 262 | float: right; 263 | min-width: 2.5em; 264 | } 265 | .dialog h1 button:last-child { 266 | border-left: 1px solid #eee; 267 | } 268 | .dialog h1 button:hover { 269 | background: rgba(255, 255, 255, 0.2); 270 | } 271 | .dialog h1 button:disabled { 272 | color: #777; 273 | background: none; 274 | } 275 | 276 | body.darkmode .dialog { 277 | background: #D3D8DA; 278 | border-color: $prim1_clr 279 | } 280 | body.darkmode .dialog h1 { 281 | background: $prim1_clr; 282 | border-color: $prim1_clr 283 | } 284 | 285 | .dialog button.actionbutton { 286 | margin-left: 0.3em; 287 | font-size: 80%; 288 | padding: 0.5em 0.6em; 289 | background: #fff; 290 | border: none; 291 | box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.4); 292 | transition: box-shadow 0.1s; 293 | } 294 | .dialog button.actionbutton:hover { box-shadow: 0px 2px 5px rgba(0, 0, 0, 0.4); } 295 | .dialog button.actionbutton.submit { background: $acc_clr; } 296 | .dialog button.actionbutton.submit:disabled { color: #aaa; } 297 | body.darkmode .dialog button.actionbutton { background: #eee; } 298 | body.darkmode .dialog button.actionbutton.submit { background: $acc_clr; } 299 | @media screen and (min-width: 600px) { 300 | .dialog button.actionbutton { margin-left: 1em; font-size: 100%; } 301 | .dialog button.actionbutton.submit { min-width: 7em; } 302 | } 303 | body.is_read_only button.actionbutton { 304 | color: #aaa; 305 | box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.2); 306 | pointer-events: none; /* Prevent clicks */ 307 | } 308 | body.is_read_only button.actionbutton:hover { box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.2); } 309 | 310 | .dialog .tag-suggestions-autocomp { 311 | position: absolute; 312 | border: 1px solid #bbb; 313 | border-radius: 4px; 314 | background: #fff; 315 | color: $prim1_clr; 316 | border-top: none; 317 | z-index: 99; 318 | top: 100%; 319 | left: 3px; 320 | width: calc(100% - 6px); 321 | max-width: 400px; 322 | max-height: 180px; 323 | overflow-y: auto; 324 | box-shadow: 0 2px 2px rgba(0, 0, 0, 0.4); 325 | } 326 | 327 | .dialog .tag-suggestions-autocomp > div { 328 | font-size: 85%; 329 | padding: 4px; 330 | cursor: pointer; 331 | background-color: #fff; 332 | border-bottom: 1px solid #d4d4d4; 333 | white-space: nowrap; 334 | overflow-x: hidden; 335 | } 336 | .dialog .tag-suggestions-autocomp > div.meta { 337 | cursor: default; 338 | font-size: 70%; 339 | } 340 | .dialog .tag-suggestions-autocomp > div > span.meta { 341 | font-size: 70%; 342 | color: #bbb; 343 | margin-left: 1em; 344 | } 345 | .dialog .tag-suggestions-autocomp .tag-suggestion.active, .dialog .tag-suggestions-autocomp > .tag-suggestion:hover { 346 | background-color: #f5f5ff; 347 | } 348 | 349 | /* --- dialog table --- */ 350 | 351 | .dialog table { 352 | border-collapse: collapse; 353 | min-width: calc(100% - 16px); 354 | font-size: 85%; 355 | } 356 | .dialog table td, .dialog table th { 357 | text-align: left; 358 | padding: 0.4em 0.4em; 359 | white-space: nowrap; 360 | /*border-bottom: 1px solid #777;*/ 361 | } 362 | .dialog table td:first-child, .dialog table th:first-child { 363 | text-align: right; 364 | } 365 | .dialog table th { 366 | background: rgb(220,220,220); 367 | color: #000; 368 | font-weight: normal; 369 | border-bottom: 1px solid #aaa; 370 | } 371 | .dialog table.darkheaders th { 372 | color: #000; 373 | font-weight: bold; 374 | border: none; 375 | } 376 | .dialog table th:nth-child(2) { 377 | max-width: 0; /* Make contribution not count, but overflow: colspan without colspan */ 378 | } 379 | .dialog table th:last-child { 380 | width: 100%; 381 | } 382 | 383 | .dialog table th.pad1::before { content: '\00A0\00A0\00A0'; } 384 | .dialog table th.pad2::before { content: '\00A0\00A0\00A0\00A0\00A0\00A0'; } 385 | .dialog table th.pad3::before { content: '\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0'; } 386 | .dialog table th.pad4::before { content: '\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0\00A0'; } 387 | 388 | .dialog table td.t1 { 389 | padding-right: 0; 390 | } 391 | .dialog table td.t2 { 392 | padding-left: 0.2em; 393 | } 394 | .dialog table td.t1::after { 395 | content: ' -'; 396 | } 397 | 398 | .dialog table tr { 399 | background-color: rgb(250,250,250); 400 | } 401 | .dialog table tr:nth-child(even) { 402 | background-color: rgb(240,240,240); 403 | } 404 | .dialog table tr.blank_row { 405 | background-color: initial; 406 | height: 1.5em; 407 | } 408 | @media screen and (min-width: 800px) { .dialog table { 409 | font-size: 100%; 410 | }} 411 | 412 | body.darkmode .dialog table th { 413 | background-color: rgb(140,145,149); 414 | } 415 | body.darkmode .dialog table tr { 416 | background-color: rgb(170,175,179); 417 | } 418 | body.darkmode .dialog table tr:nth-child(even) { 419 | background-color: rgb(160,165,169); 420 | } 421 | body.darkmode .dialog table tr.blank_row { 422 | background-color: initial; 423 | } 424 | -------------------------------------------------------------------------------- /tests/test_client_recordstore.py: -------------------------------------------------------------------------------- 1 | from _common import run_tests 2 | from timetagger.app.stores import RecordStore, make_hidden 3 | 4 | 5 | class DataStoreStub: 6 | def _put(self, kind, *items): 7 | assert kind == "records" 8 | 9 | 10 | def test_record_store1(): 11 | datastore = DataStoreStub() 12 | rs = RecordStore(datastore) 13 | 14 | # Nothing in there 15 | assert len(rs._heap) == 1 and len(rs._heap[0].keys()) == 0 16 | 17 | # We can get stats 18 | assert len(rs.get_records(0, 1e15)) == 0 19 | assert len(rs.get_stats(0, 1e15).keys()) == 0 20 | 21 | rs.put(rs.create("2018-04-23 15:00:00", "2018-04-23 16:00:00", "#p1")) 22 | rs.put(rs.create("2018-04-23 17:00:00", "2018-04-23 17:30:00", "#p1")) 23 | 24 | # Two nearby entries, which we picked to be inside a single bin (bins are about 1.5 day wide) 25 | assert len(rs._heap[-1].keys()) == 1 26 | assert len(rs._heap) in (1, 2) # Exact value depends on timezone 27 | assert len(rs.get_records(0, 1e15)) == 2 28 | assert rs.get_stats(0, 1e15) == {"#p1": 90 * 60} 29 | 30 | # Add very early records 31 | rs.put(rs.create("2014-01-12 14:00:00", "2014-01-12 17:30:00", "#p2")) 32 | 33 | # Now need a steep heap 34 | assert len(rs._heap[-1].keys()) == 1 35 | assert len(rs._heap) == 12 36 | assert len(rs.get_records(0, 1e15)) == 3 37 | assert rs.get_stats(0, 1e15) == {"#p1": 90 * 60, "#p2": 210 * 60} 38 | 39 | # Sample 2014 and 2018 seperately 40 | assert len(rs.get_records("2014-01-01 00:00:00", "2015-01-01 00:00:00")) == 1 41 | assert len(rs.get_records("2018-01-01 00:00:00", "2019-01-01 00:00:00")) == 2 42 | assert rs.get_stats("2014-01-01 00:00:00", "2015-01-01 00:00:00") == { 43 | "#p2": 210 * 60 44 | } 45 | assert rs.get_stats("2018-01-01 00:00:00", "2019-01-01 00:00:00") == { 46 | "#p1": 90 * 60 47 | } 48 | 49 | # Now move the record from 2014 to 2018 50 | key = list(rs.get_records("2014-01-01 00:00:00", "2015-01-01 00:00:00").values())[ 51 | 0 52 | ].key 53 | record = rs.create("2018-04-22 14:00:00", "2018-04-22 17:30:00", "#p2") 54 | record.key = key 55 | rs.put(record) 56 | 57 | assert len(rs._heap[-1].keys()) == 1 58 | assert len(rs._heap) in (1, 2) 59 | assert len(rs.get_records(0, 1e15)) == 3 60 | 61 | assert rs.get_stats("2014-01-01 00:00:00", "2015-01-01 00:00:00") == {} 62 | assert rs.get_stats("2018-01-01 00:00:00", "2019-01-01 00:00:00") == { 63 | "#p1": 90 * 60, 64 | "#p2": 210 * 60, 65 | } 66 | 67 | # Now remove all records 68 | for record in rs.get_records(0, 1e15).values(): 69 | rs.put(record.clone(ds="HIDDEN")) 70 | 71 | # Verify that records are gone from the heap 72 | assert len(rs._heap) == 1 73 | assert len(rs._heap[0].keys()) == 0 74 | assert len(rs._heap0_bin2record_keys.keys()) == 0 75 | # But not from the pool of records 76 | assert len(rs._items.keys()) == 3 77 | 78 | 79 | def test_record_store_untagged(): 80 | datastore = DataStoreStub() 81 | rs = RecordStore(datastore) 82 | 83 | # Nothing in there 84 | assert len(rs._heap) == 1 and len(rs._heap[0].keys()) == 0 85 | 86 | # We can get stats 87 | assert len(rs.get_records(0, 1e15)) == 0 88 | assert len(rs.get_stats(0, 1e15).keys()) == 0 89 | 90 | rs.put(rs.create("2018-04-23 15:00:00", "2018-04-23 16:00:00", "")) 91 | rs.put(rs.create("2018-04-23 17:00:00", "2018-04-23 17:30:00", "foo")) 92 | 93 | assert rs.get_stats(0, 1e15) == {"#untagged": 90 * 60} 94 | 95 | rs.put(rs.create("2018-04-24 17:00:00", "2018-04-24 17:30:00", "#foo")) 96 | 97 | assert rs.get_stats(0, 1e15) == {"#untagged": 90 * 60, "#foo": 30 * 60} 98 | 99 | 100 | def test_record_spanning_multiple_bins(): 101 | datastore = DataStoreStub() 102 | rs = RecordStore(datastore) 103 | 104 | # Make a record of 5 days, which, with 1.5 day bins should span at least 3 bins 105 | r1 = rs.create("2018-04-20 00:00:00", "2018-04-25 00:00:00", "#p3") 106 | rs.put(r1) 107 | 108 | assert len(rs._heap[-1].keys()) == 1 109 | assert len(rs._heap) == 3 110 | assert len(rs._heap[0]) == 4 111 | assert len(rs.get_records(0, 1e15)) == 1 112 | assert rs.get_stats(0, 1e15) == {"#p3": 5 * 24 * 60 * 60} 113 | 114 | # Another record, that has overlap 115 | r2 = rs.create("2018-04-23 00:00:00", "2018-04-28 00:00:00", "#p4") 116 | rs.put(r2) 117 | 118 | assert len(rs._heap[-1].keys()) == 1 119 | assert len(rs._heap) == 6 120 | assert len(rs._heap[0]) == 6 121 | assert len(rs.get_records(0, 1e15)) == 2 122 | assert rs.get_stats(0, 1e15) == {"#p3": 5 * 24 * 60 * 60, "#p4": 5 * 24 * 60 * 60} 123 | 124 | # Change project of the latter to the same as the first 125 | r2_ = rs.create("2018-04-23 00:00:00", "2018-04-28 00:00:00", "#p3") 126 | r2_.key = r2.key 127 | rs.put(r2_) 128 | 129 | assert rs.get_stats(0, 1e15) == {"#p3": 2 * 5 * 24 * 60 * 60} 130 | 131 | # Add a tiny record somewhere in there too (10 seconds) 132 | r3 = rs.create("2018-04-24 00:00:00", "2018-04-24 00:00:10", "#p3") 133 | rs.put(r3) 134 | 135 | assert rs.get_stats(0, 1e15) == {"#p3": 2 * 5 * 24 * 60 * 60 + 10} 136 | 137 | # Test doing queries within records 138 | assert len(rs.get_records("2018-04-22 00:00:00", "2018-04-23 00:00:00").keys()) == 1 139 | assert rs.get_stats("2018-04-22 00:00:00", "2018-04-23 00:00:00") == { 140 | "#p3": 24 * 60 * 60 141 | } 142 | assert len(rs.get_records("2018-04-23 00:00:00", "2018-04-24 00:00:00").keys()) == 2 143 | assert rs.get_stats("2018-04-23 00:00:00", "2018-04-24 00:00:00") == { 144 | "#p3": 2 * 24 * 60 * 60 145 | } 146 | assert len(rs.get_records("2018-04-23 00:00:00", "2018-04-24 00:00:01").keys()) == 3 147 | assert rs.get_stats("2018-04-23 00:00:00", "2018-04-24 00:00:01") == { 148 | "#p3": 2 * 24 * 60 * 60 + 3 149 | } 150 | assert rs.get_stats("2018-01-01 00:00:00", "2018-12-01 00:00:00") == { 151 | "#p3": 5 * 24 * 60 * 60 + 5 * 24 * 60 * 60 + 10 152 | } 153 | 154 | # Add records some time after 155 | r4 = rs.create("2018-05-02 08:00:00", "2018-05-02 10:00:00", "#p5") 156 | rs.put(r4) 157 | 158 | # Test some more queries 159 | assert len(rs.get_records("2018-01-01 00:00:00", "2018-12-31 00:00:00").keys()) == 4 160 | assert rs.get_stats("2018-01-01 00:00:00", "2018-12-01 00:00:00") == { 161 | "#p3": 5 * 24 * 60 * 60 + 5 * 24 * 60 * 60 + 10, 162 | "#p5": 2 * 60 * 60, 163 | } 164 | assert rs.get_stats("2018-05-01 00:00:00", "2018-05-02 00:00:00") == {} 165 | 166 | # Cleanup 167 | for record in rs.get_records(0, 1e15).values(): 168 | rs.put(record.clone(ds="HIDDEN")) 169 | 170 | # Verify that all is gone 171 | assert len(rs._heap) == 1 172 | assert len(rs._heap[0].keys()) == 0 173 | assert len(rs._heap0_bin2record_keys.keys()) == 0 174 | # assert len(rs._items.keys()) == 0 175 | 176 | 177 | def test_record_mutations(): 178 | datastore = DataStoreStub() 179 | rs = RecordStore(datastore) 180 | 181 | # First pretend local mutations, rt == 0 182 | 183 | # Note that in these tests, we must set the mt of the records already 184 | # present in the store, because put() sets the mt. 185 | 186 | # Create a record 187 | r1 = rs.create("2018-04-20 10:00:00", "2018-04-20 11:00:00", "#p11") 188 | assert r1.mt > 0 189 | assert r1.st == 0 190 | rs.put(r1) 191 | assert rs.get_stats(0, 1e15) == {"#p11": 3600} 192 | 193 | # Now mutate it with older record - wont work 194 | r2 = r1.clone(ds="#p12") 195 | rs._items[r1.key].mt = r2.mt + 1 196 | rs.put(r2) 197 | assert rs.get_stats(0, 1e15) == {"#p11": 3600} 198 | 199 | # Now mutate it with same mt record - will work, since server time is zero. 200 | r2 = r1.clone(ds="#p12") 201 | rs._items[r1.key].mt = r2.mt 202 | rs.put(r2) 203 | assert rs.get_stats(0, 1e15) == {"#p12": 3600} 204 | 205 | # Now mutate it with newer mt record - will work 206 | r2 = r1.clone(mt=r1.mt + 1, ds="#p13") 207 | rs._items[r1.key].mt = r2.mt - 1 208 | rs.put(r2) 209 | assert rs.get_stats(0, 1e15) == {"#p13": 3600} 210 | 211 | # Now pretend mutations from the server. We can now set mt on the item. 212 | 213 | # Now mutate with older record - wont work 214 | r3 = r2.clone(rt=100, mt=r2.mt - 1, ds="#p14") 215 | assert r2.mt > r3.mt 216 | rs._put_received(r3) 217 | assert rs.get_stats(0, 1e15) == {"#p13": 3600} 218 | 219 | # Now mutate it with same mt record - will work, since server time is larger 220 | r3 = r2.clone(rt=100, mt=r2.mt, ds="#p14") 221 | assert r2.mt == r3.mt 222 | rs._put_received(r3) 223 | assert rs.get_stats(0, 1e15) == {"#p14": 3600} 224 | 225 | # Now mutate it with newer mt record - will work (even if rt is same) 226 | r3 = r2.clone(rt=100, mt=r2.mt + 2, ds="#p21") 227 | assert r2.mt < r3.mt 228 | rs._put_received(r3) 229 | assert rs.get_stats(0, 1e15) == {"#p21": 3600} 230 | 231 | # Now mutate it with newer mt record - will work (even if rt is less) 232 | r3 = r2.clone(rt=0, mt=r2.mt + 3, ds="#p22") 233 | assert r2.mt < r3.mt 234 | rs._put_received(r3) 235 | assert rs.get_stats(0, 1e15) == {"#p22": 3600} 236 | 237 | # Now drop it 238 | rs._drop(r3.key) 239 | assert rs.get_stats(0, 1e15) == {} 240 | 241 | 242 | def test_invalid_records(): 243 | datastore = DataStoreStub() 244 | rs = RecordStore(datastore) 245 | 246 | assert len(rs._items.keys()) == 0 247 | 248 | # Put one record in 249 | r = rs.create("2018-04-20 10:00:00", "2018-04-20 10:00:01", "#p1") 250 | rs.put(r) 251 | assert len(rs._items.keys()) == 1 252 | 253 | # Try putting more in - but all are missing a required field 254 | for key in ("key", "t1", "t2"): 255 | r = rs.create("2018-04-20 10:00:00", "2018-04-20 10:00:01", "#p1") 256 | r.pop(key) 257 | rs.put(r) 258 | assert len(rs._items.keys()) == 1 259 | 260 | # Try putting more in - but all have an invalid type in a field 261 | for key, val in dict(t1="x", t2="x").items(): 262 | r = rs.create("2018-04-20 10:00:00", "2018-04-20 10:00:01", "#p1") 263 | r[key] = val 264 | rs.put(r) 265 | assert len(rs._items.keys()) == 1 266 | 267 | 268 | def test_record_running(): 269 | datastore = DataStoreStub() 270 | rs1 = RecordStore(datastore) 271 | 272 | # Add a one second record 273 | r1 = rs1.create("2018-04-20 10:00:00", "2018-04-20 10:00:01", "#p11") 274 | rs1.put(r1) 275 | 276 | assert rs1.get_stats(0, 1e15) == {"#p11": 1} 277 | assert len(rs1.get_records(0, 1e15)) == 1 278 | 279 | datastore = DataStoreStub() 280 | rs2 = RecordStore(datastore) 281 | 282 | # Add a zero-second record, i.e. a running record 283 | r2 = rs2.create("2018-04-20 10:00:00", "2018-04-20 10:00:00", "#p11") 284 | rs2.put(r2) 285 | 286 | # The stats will indicate it as running until *now* 287 | assert rs2.get_running_records() == [r2] 288 | assert rs2.get_stats(0, 1e15)["#p11"] > 17756100 289 | assert len(rs2.get_records(0, 1e15)) == 1 290 | 291 | # Stop the record 292 | r2.t2 = r2.t1 + 10 293 | rs2.put(r2) 294 | 295 | assert rs2.get_running_records() == [] 296 | assert rs2.get_stats(0, 1e15)["#p11"] == 10 297 | assert len(rs2.get_records(0, 1e15)) == 1 298 | 299 | 300 | def test_deleting_records(): 301 | datastore = DataStoreStub() 302 | rs = RecordStore(datastore) 303 | 304 | assert len(rs._items.keys()) == 0 305 | 306 | # Put one record in 307 | r = rs.create("2021-01-28 10:00:00", "2021-01-28 11:00:00", "#p1") 308 | rs.put(r) 309 | assert len(rs._items.keys()) == 1 310 | assert len(rs.get_records(0, 1e15)) == 1 311 | 312 | # Mark deleted 313 | make_hidden(r) 314 | assert r.ds == "HIDDEN #p1" 315 | make_hidden(r) 316 | assert r.ds == "HIDDEN #p1" 317 | 318 | # Update it 319 | rs.put(r) 320 | assert len(rs._items.keys()) == 1 321 | assert len(rs.get_records(0, 1e15)) == 0 322 | 323 | # And again (emulating coming back from the server, guards against issue #48) 324 | rs.put(r) 325 | assert len(rs._items.keys()) == 1 326 | assert len(rs.get_records(0, 1e15)) == 0 327 | 328 | # Revive it 329 | r.ds = "#p1" 330 | rs.put(r) 331 | assert len(rs._items.keys()) == 1 332 | assert len(rs.get_records(0, 1e15)) == 1 333 | 334 | # Put another record in 335 | r2 = rs.create("2021-01-28 11:00:00", "2021-01-28 12:00:00", "#p1") 336 | rs.put(r2) 337 | assert len(rs._items.keys()) == 2 338 | assert len(rs.get_records(0, 1e15)) == 2 339 | assert len(rs.get_stats(0, 1e15)) == 1 # because same project 340 | 341 | # Delete the record again, and push 342 | make_hidden(r) 343 | rs.put(r) 344 | assert len(rs._items.keys()) == 2 345 | assert len(rs.get_records(0, 1e15)) == 1 346 | assert len(rs.get_stats(0, 1e15)) == 1 347 | 348 | # Again (guards against issue #48) 349 | rs.put(r) 350 | assert len(rs._items.keys()) == 2 351 | assert len(rs.get_records(0, 1e15)) == 1 352 | assert len(rs.get_stats(0, 1e15)) == 1 353 | 354 | 355 | if __name__ == "__main__": 356 | run_tests(globals()) 357 | --------------------------------------------------------------------------------