Refactor 'effective-on' to 'target-date'.

1 files changed, 29 insertions, 29 deletions

diff --git a/models/nutrient-target.rkt b/models/nutrient-target.rkt
index 4fd5a10..ccc4f1f 100644
--- a/models/nutrient-target.rkt
+++ b/models/nutrient-target.rkt
@@ -3,14 +3,14 @@
 (provide nutrient-target
          nutrient-target?
          nutrient-target-id
-         (rename-out [nutrient-target-effective-on nutrient-target-date]
+         (rename-out [nutrient-target-target-date nutrient-target-date]
                      [nutrient-target-nutrient-values nutrient-target-values])
          (contract-out
           [create-nutrient-target! (-> string? nutrient-value-hash/c nutrient-target?)]
           [get-nutrient-targets (-> (listof nutrient-target?))]
           [get-nutrient-target
            (->* ()
-                (#:id (or/c #f exact-nonnegative-integer?) #:effective-on (or/c #f string?))
+                (#:id (or/c #f exact-nonnegative-integer?) #:date (or/c #f string?))
                 (or/c nutrient-target? #f))]
           [get-nutrient-target-values (-> nutrient-target-or-id/c nutrient-value-hash/c)]
           [get-nutrient-target-value (-> nutrient-target-or-id/c nutrient? maybe-nutrient-value?)]
@@ -24,11 +24,11 @@
          "../db/conn.rkt"
          "nutrient.rkt")
 
-(struct nutrient-target (id effective-on nutrient-values)
+(struct nutrient-target (id target-date nutrient-values)
   #:transparent
   #:property prop:custom-write
   (λ (v out _)
-    (fprintf out "Target #~a on ~a\n" (nutrient-target-id v) (nutrient-target-effective-on v))
+    (fprintf out "Target #~a on ~a\n" (nutrient-target-id v) (nutrient-target-target-date v))
     (for ([(n v) (in-hash (nutrient-target-nutrient-values v))])
       (fprintf out
                "~a ~a\n"
@@ -46,13 +46,13 @@
 
 ;; CREATE
 
-(define (create-nutrient-target! effective-on nutrient-values)
-  (or (get-nutrient-target #:effective-on effective-on)
+(define (create-nutrient-target! target-date nutrient-values)
+  (or (get-nutrient-target #:date target-date)
       (with-tx
-       (query-exec (current-conn) (insert #:into nutrient_targets #:set [effective_on ,effective-on]))
+       (query-exec (current-conn) (insert #:into nutrient_targets #:set [target_date ,target-date]))
        (define nt-id
          (query-value (current-conn)
-                      (select id #:from nutrient_targets #:where (= effective_on ,effective-on))))
+                      (select id #:from nutrient_targets #:where (= target_date ,target-date))))
        (query-exec (current-conn)
                    (insert #:into nutrient_value_sets #:set [nutrient_target_id ,nt-id]))
        (define nvs-id
@@ -64,7 +64,7 @@
                              #:set [value_set_id ,nvs-id]
                              [nutrient_id ,(nutrient-id n)]
                              [value_ppm ,v])))
-       (get-nutrient-target #:effective-on effective-on))))
+       (get-nutrient-target #:date target-date))))
 
 ;; READ
 
@@ -78,38 +78,38 @@
                              #:on (= n.id nv.nutrient_id))))
 
 (define (grouped-row->nutrient-target row)
-  (match-define (vector nt-id effective-on residuals) row)
-  (nutrient-target nt-id effective-on (residuals->nutrient-value-hash residuals)))
+  (match-define (vector nt-id target-date residuals) row)
+  (nutrient-target nt-id target-date (residuals->nutrient-value-hash residuals)))
 
 (define (get-nutrient-targets)
   (define grouped-rows
     (query-rows (current-conn)
                 (select nt.id
-                        nt.effective_on
+                        nt.target_date
                         n.id
                         n.canonical_name
                         n.french_name
                         n.formula
                         nv.value_ppm
                         #:from (TableExpr:AST ,joined)
-                        #:order-by nt.effective_on
+                        #:order-by nt.target_date
                         #:desc)
                 #:group '#(0 1)))
   (for/list ([row grouped-rows])
     (grouped-row->nutrient-target row)))
 
-(define (get-nutrient-target #:id [nt-id #f] #:effective-on [effective-on #f])
+(define (get-nutrient-target #:id [nt-id #f] #:date [target-date #f])
   (define where
     (cond
-      [(and nt-id effective-on)
-       (scalar-expr-qq (and (= nt.id ,nt-id) (= nt.effective_on ,effective-on)))]
+      [(and nt-id target-date)
+       (scalar-expr-qq (and (= nt.id ,nt-id) (= nt.target_date ,target-date)))]
       [nt-id (scalar-expr-qq (= nt.id ,nt-id))]
-      [effective-on (scalar-expr-qq (= nt.effective_on ,effective-on))]
-      [else (error 'get-nutrient-target "either #:id or #:effective-on must be provided")]))
+      [target-date (scalar-expr-qq (= nt.target_date ,target-date))]
+      [else (error 'get-nutrient-target "either #:id or #:date must be provided")]))
   (define grouped-rows
     (query-rows (current-conn)
                 (select nt.id
-                        nt.effective_on
+                        nt.target_date
                         n.id
                         n.canonical_name
                         n.french_name
@@ -117,7 +117,7 @@
                         nv.value_ppm
                         #:from (TableExpr:AST ,joined)
                         #:where (ScalarExpr:AST ,where)
-                        #:order-by nt.effective_on
+                        #:order-by nt.target_date
                         #:desc)
                 #:group '#(0 1)))
   (match grouped-rows
@@ -149,7 +149,7 @@
                      (select value_ppm
                              #:from (TableExpr:AST ,joined)
                              #:where (= nv.nutrient_id ,(nutrient-id nutrient))
-                             #:order-by nt.effective_on
+                             #:order-by nt.target_date
                              #:desc
                              #:limit 1)))
 
@@ -160,16 +160,16 @@
                         n.canonical_name
                         n.french_name
                         n.formula
-                        nt.effective_on
+                        nt.target_date
                         nv.value_ppm
                         #:from (TableExpr:AST ,joined)
-                        #:order-by nt.effective_on
+                        #:order-by nt.target_date
                         #:desc)
                 #:group '(#(0 1 2 3))))
   (for/hash ([row grouped-rows])
     (match-define (vector n-id n-canonical-name n-french-name n-formula residual-rows) row)
-    ;; residual-rows is a non-empty list of vectors: #(effective_on value_ppm)
-    (match-define (vector _effective-on value-ppm) (first residual-rows))
+    ;; residual-rows is a non-empty list of vectors: #(target_date value_ppm)
+    (match-define (vector _ value-ppm) (first residual-rows))
     (values (nutrient n-id n-canonical-name n-french-name n-formula) value-ppm)))
 
 ;; UPDATE
@@ -203,15 +203,15 @@
        (define phosphorus (get-nutrient #:name "Phosphorus"))
        (create-nutrient-target! target-date (hash nitrogen 12.3 phosphorus 4.5))
        (check-equal? (length (get-nutrient-targets)) 1)
-       (define nt (get-nutrient-target #:effective-on target-date))
+       (define nt (get-nutrient-target #:date target-date))
        (check-true (nutrient-target? nt))
-       (check-equal? (nutrient-target-effective-on nt) target-date))
+       (check-equal? (nutrient-target-target-date nt) target-date))
 
      (test-case "Check all target values"
        (define nitrogen (get-nutrient #:name "Nitrogen"))
        (define phosphorus (get-nutrient #:name "Phosphorus"))
 
-       (define nt (get-nutrient-target #:effective-on target-date))
+       (define nt (get-nutrient-target #:date target-date))
        (check-equal? (get-nutrient-target-value nt nitrogen) 12.3)
        (check-equal? (get-nutrient-target-value nt phosphorus) 4.5)
 
@@ -234,7 +234,7 @@
        (check-equal? (get-latest-nutrient-target-value phosphorus) 8.9))
 
      (test-case "Delete target and cascade to target values"
-       (define nt (get-nutrient-target #:effective-on target-date))
+       (define nt (get-nutrient-target #:date target-date))
        (delete-nutrient-target! nt)
        (check-false (get-nutrient-target #:id (nutrient-target-id nt)))
        (check-equal? (length (get-nutrient-targets))