about summary refs log tree commit diff
path: root/src/gemma.lisp
blob: a96b722a22997ee2af5c784655ea9dc293d7c964 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
(defpackage gemma
  (:use :cl
        :alexandria
        :hunchentoot
        :local-time
        :cl-json))
(in-package :gemma)

;; TODO: Store an average of how many days it was between task
;; completions. Some of the current numbers are just guesses
;; anyways.

;;
;; Define task management system
;;
(defclass task ()
  (;; (Unique) name of the task
   (name :type symbol
         :initarg :name
         :accessor name-of)

   ;; Maximum completion interval
   (days :type integer
         :initarg :days
         :accessor days-of)

   ;; Optional description
   (description :type string
                :initarg :description
                :accessor description-of)

   ;; Last completion time
   (done-at :type local-time:timestamp
            :accessor last-done-at)))

(defvar *tasks*
  (make-hash-table)
  "List of all tasks registered in this Gemma instance.")

(defmacro deftask (task-name days &optional description)
  `(setf (gethash (quote ,task-name) *tasks*)
         (make-instance (quote task)
                        :name (quote ,task-name)
                        :days ,days
                        :description (or ,description ""))))

(defun get-task (name)
  (gethash name *tasks*))

(defun list-tasks ()
  (alexandria:hash-table-values *tasks*))

(defun days-remaining (task)
  "Returns the number of days remaining before the supplied TASK reaches its
maximum interval."
  (let* ((expires-at (local-time:timestamp+ (last-done-at task)
                                            (days-of task) :day))
         (secs-until-expiry (local-time:timestamp-difference expires-at
                                                             (local-time:now))))
    (round (/ secs-until-expiry 60 60 24))))

(defun sort-tasks (tasks)
  "Sorts TASKS in descending order by number of days remaining."
  (sort (copy-list tasks)
        (lambda (t1 t2) (> (days-remaining t1)
                           (days-remaining t2)))))

(defun complete-task (name &optional at)
  "Mark the task with NAME as completed, either now or AT specified time."
  (setf (last-done-at (get-task name))
        (or at (local-time:now))))

;;
;; Define web API
;;

(defun start-gemma ()
  ;; Set up web server
  (hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242))

  ;; ... and register all handlers.
  (hunchentoot:define-easy-handler
   (get-tasks :uri "/tasks") ()

   (setf (hunchentoot:content-type*) "application/json")
   (setf (hunchentoot:header-out "Access-Control-Allow-Origin") "*")
   (json:encode-json-to-string
    ;; Construct a frontend-friendly representation of the tasks.
    (mapcar
     (lambda (task) `((:name . ,(name-of task))
                      (:description . ,(description-of task))
                      (:remaining . ,(days-remaining task))))
     (sort-tasks (list-tasks))))))

;; (not-so) example tasks

;; Bathroom tasks
(deftask bathroom/wipe-mirror 7)
(deftask bathroom/wipe-counter 7)

;; Bedroom tasks
(deftask bedroom/change-sheets 7)
(deftask bedroom/vacuum 10)

;; Kitchen tasks
(deftask kitchen/normal-trash 3)
(deftask kitchen/green-trash 5)
(deftask kitchen/blue-trash 5)
(deftask kitchen/wipe-counters 3)
(deftask kitchen/vacuum 5 "Kitchen has more crumbs and such!")

;; Entire place
(deftask clean-windows 60)

;; Experimentation / testing stuff

(defun randomise-completion-times ()
  "Set some random completion timestamps for all tasks"
  (mapcar
   (lambda (key) (complete-task key (local-time:timestamp- (local-time:now)
                                                           (random 14)
                                                           :day)))
   (alexandria:hash-table-keys *tasks*)))

;; (randomise-completion-times)