Mlv2 describe relative date time range (#34765)

shared/src/metabase/shared/util/internal/time.clj

@@ -66,39 +66,57 @@
 (defn- minus-ms [value]
   (t/minus value (t/millis 1)))
 
+(defn- apply-offset
+  [value offset-n offset-unit]
+  (t/plus
+    value
+    (case offset-unit
+      :minute (t/minutes offset-n)
+      :hour (t/hours offset-n)
+      :day (t/days offset-n)
+      :week (t/weeks offset-n)
+      :month (t/months offset-n)
+      :year (t/years offset-n)
+      (t/minutes 0))))
+
 (defmethod common/to-range :default [value _]
   ;; Fallback: Just return a zero-width at the input time.
   ;; This mimics Moment.js behavior if you `m.startOf("unknown unit")` - it doesn't change anything.
   [value value])
 
-(defmethod common/to-range :minute [value _]
-  (let [start (t/truncate-to value :minutes)]
-    [start (minus-ms (t/plus start (t/minutes 1)))]))
+(defmethod common/to-range :minute [value {:keys [n] :or {n 1}}]
+  (let [start (-> value
+                  (t/truncate-to :minutes))]
+    [start (minus-ms (t/plus start (t/minutes n)))]))
 
-(defmethod common/to-range :hour [value _]
-  (let [start (t/truncate-to value :hours)]
-    [start (minus-ms (t/plus start (t/hours 1)))]))
+(defmethod common/to-range :hour [value {:keys [n] :or {n 1}}]
+  (let [start (-> value
+                  (t/truncate-to :hours))]
+    [start (minus-ms (t/plus start (t/hours n)))]))
 
-(defmethod common/to-range :day [value _]
-  (let [start (t/truncate-to value :days)]
-    [start (minus-ms (t/plus start (t/days 1)))]))
+(defmethod common/to-range :day [value {:keys [n] :or {n 1}}]
+  (let [start (-> value
+                  (t/truncate-to :days))]
+    [start (minus-ms (t/plus start (t/days n)))]))
 
-(defmethod common/to-range :week [value _]
+(defmethod common/to-range :week [value {:keys [n] :or {n 1}}]
   (let [first-day (first-day-of-week)
         start (-> value
                   (t/truncate-to :days)
                   (t/adjust :previous-or-same-day-of-week first-day))]
-    [start (minus-ms (t/plus start (t/weeks 1)))]))
+    [start (minus-ms (t/plus start (t/weeks n)))]))
 
-(defmethod common/to-range :month [value _]
-  (let [value (t/truncate-to value :days)]
-    [(t/adjust value :first-day-of-month)
-     (minus-ms (t/adjust value :first-day-of-next-month))]))
+(defmethod common/to-range :month [value {:keys [n] :or {n 1}}]
+  (let [value (-> value
+                  (t/truncate-to :days)
+                  (t/adjust :first-day-of-month))]
+    [value (minus-ms (t/plus value (t/months n)))]))
 
-(defmethod common/to-range :year [value _]
-  (let [value (t/truncate-to value :days)]
-    [(t/adjust value :first-day-of-year)
-     (minus-ms (t/adjust value :first-day-of-next-year))]))
+(defmethod common/to-range :year [value {:keys [n] :or {n 1}}]
+  (let [value (-> value
+                  (t/truncate-to :days)
+                  (t/adjust :first-day-of-year))]
+    [value (minus-ms (nth (iterate #(t/adjust % :first-day-of-next-year n) value) n))]))
 
 ;;; -------------------------------------------- string->timestamp ---------------------------------------------------
 (defmethod common/string->timestamp :default [value _]
@@ -272,7 +290,7 @@
             hour-matches? (= (t/format "H" lhs) (t/format "H" rhs))
             [lhs-fmt rhs-fmt] (cond
                                 (and year-matches? month-matches? day-matches? hour-matches?)
-                                ["MMM d, yyyy, h:mm" "mm a"]
+                                ["MMM d, yyyy, h:mm a " " h:mm a"]
 
                                 (and year-matches? month-matches? day-matches?)
                                 ["MMM d, yyyy, h:mm a " " h:mm a"]
@@ -302,3 +320,24 @@
 
       :else
       (default-format))))
+
+(defn format-relative-date-range
+  "Given a `n` `unit` time interval and the current date, return a string representing the date-time range.
+   Provide an `offset-n` and `offset-unit` time interval to change the date used relative to the current date.
+   `options` is a map and supports `:include-current` to include the current given unit of time in the range."
+  [n unit offset-n offset-unit {:keys [include-current]}]
+  (let [offset-now (cond-> (now)
+                     (neg? n) (apply-offset n unit)
+                     (and (pos? n) (not include-current)) (apply-offset 1 unit)
+                     (and offset-n offset-unit) (apply-offset offset-n offset-unit))
+        pos-n (cond-> (abs n)
+                include-current inc)
+        date-ranges (map (if (#{:hour :minute} unit)
+                           #(t/format "yyyy-MM-dd'T'HH:mm" (t/local-date-time %))
+                           #(str (t/local-date %)))
+                         (common/to-range offset-now
+                                          {:unit unit
+                                           :n pos-n
+                                           :offset-n offset-n
+                                           :offset-unit offset-unit}))]
+    (apply format-diff date-ranges)))

shared/src/metabase/shared/util/internal/time.cljs

@@ -57,11 +57,20 @@
   {})
 
 ;;; ------------------------------------------------ to-range --------------------------------------------------------
-(defmethod common/to-range :default [^moment/Moment value {:keys [unit]}]
+(defn- apply-offset
+    [^moment/Moment value offset-n offset-unit]
+      (.add
+            (moment value)
+                offset-n
+                    (name offset-unit)))
+
+(defmethod common/to-range :default [^moment/Moment value {:keys [n unit]}]
   (let [^moment/Moment c1 (.clone value)
         ^moment/Moment c2 (.clone value)]
     [(.startOf c1 (name unit))
-     (.endOf   c2 (name unit))]))
+     (cond-> c2
+       (> n 1) (.add (dec n) (name unit))
+       :always ^moment/Moment (.endOf (name unit)))]))
 
 ;; NB: Only the :default for to-range is needed in CLJS, since Moment's startOf and endOf methods are doing the work.
 
@@ -223,10 +232,10 @@
             year-matches? (= (.format lhs "YYYY") (.format rhs "YYYY"))
             month-matches? (= (.format lhs "MMM") (.format rhs "MMM"))
             day-matches? (= (.format lhs "D") (.format rhs "D"))
-            hour-matches? (= (.format lhs "H") (.format rhs "H"))
+            hour-matches? (= (.format lhs "HH") (.format rhs "HH"))
             [lhs-fmt rhs-fmt] (cond
                                 (and year-matches? month-matches? day-matches? hour-matches?)
-                                ["MMM D, YYYY, h:mm" "mm A"]
+                                ["MMM D, YYYY, h:mm A " " h:mm A"]
 
                                 (and year-matches? month-matches? day-matches?)
                                 ["MMM D, YYYY, h:mm A " " h:mm A"]
@@ -256,3 +265,22 @@
 
       :else
       (default-format))))
+
+(defn format-relative-date-range
+  "Given a `n` `unit` time interval and the current date, return a string representing the date-time range.
+   Provide an `offset-n` and `offset-unit` time interval to change the date used relative to the current date.
+   `options` is a map and supports `:include-current` to include the current given unit of time in the range."
+  [n unit offset-n offset-unit {:keys [include-current]}]
+  (let [offset-now (cond-> (now)
+                     (neg? n) (apply-offset n unit)
+                     (and (pos? n) (not include-current)) (apply-offset 1 unit)
+                     (and offset-n offset-unit) (apply-offset offset-n offset-unit))
+        pos-n (cond-> (abs n)
+                include-current inc)
+        date-ranges (map #(.format % (if (#{:hour :minute} unit) "YYYY-MM-DDTHH:mm" "YYYY-MM-DD"))
+                         (common/to-range offset-now
+                                          {:unit unit
+                                           :n pos-n
+                                           :offset-n offset-n
+                                           :offset-unit offset-unit}))]
+    (apply format-diff date-ranges)))

shared/src/metabase/shared/util/time.cljc

@@ -64,3 +64,14 @@
    Drops redundant information."
   [temporal-value-1 temporal-value-2]
   (internal/format-diff temporal-value-1 temporal-value-2))
+
+(defn format-relative-date-range
+  "Given a `n` `unit` time interval and the current date, return a string representing the date-time range.
+   Provide an `offset-n` and `offset-unit` time interval to change the date used relative to the current date.
+   `options` is a map and supports `:include-current` to include the current given unit of time in the range."
+  ([n unit]
+   (format-relative-date-range n unit nil nil nil))
+  ([n unit offset-n offset-unit]
+   (format-relative-date-range n unit offset-n offset-unit nil))
+  ([n unit offset-n offset-unit options]
+   (internal/format-relative-date-range n unit offset-n offset-unit options)))

shared/test/metabase/shared/util/time_test.cljc

@@ -229,8 +229,72 @@
     "Oct 3–5, 2023" "2023-10-03" "2023-10-05"
     "Sep 3 – Oct 5, 2023" "2023-09-03" "2023-10-05"
     "Oct 3, 2023, 10:20 AM – 4:30 PM" "2023-10-03T10:20" "2023-10-03T16:30"
-    "Oct 3, 2023, 10:20–30 AM" "2023-10-03T10:20" "2023-10-03T10:30"
+    "Oct 3, 2023, 10:20 AM – 10:30 AM" "2023-10-03T10:20" "2023-10-03T10:30"
     "Oct 3, 2022, 10:20 AM – Oct 3, 2023, 10:30 AM" "2022-10-03T10:20" "2023-10-03T10:30"
     "Jan 1, 2022 – Dec 31, 2023" "2022-01-01" "2023-12-31"
+    "Aug 1 – Dec 31, 2022" "2022-08-01" "2022-12-31"
     ;; I guess?
     "Oct 5, 2023" "2023-10-05" "2023-10-05"))
+
+(deftest format-relative-date-range
+  (with-redefs [internal/now (fn [] (from test-epoch))]
+    (are [exp n unit include-current] (= exp (shared.ut/format-relative-date-range n unit nil nil {:include-current include-current}))
+      "Jan 1, 2022 – Dec 31, 2023" 1 :year true
+      "Jan 1 – Dec 31, 2023" 1 :year false
+      "Jan 1, 2022 – Dec 31, 2026" 4 :year true
+      "Jan 1, 2023 – Dec 31, 2026" 4 :year false
+
+      "Jan 1, 2021 – Dec 31, 2022" -1 :year true
+      "Jan 1 – Dec 31, 2021" -1 :year false
+      "Jan 1, 2018 – Dec 31, 2022" -4 :year true
+      "Jan 1, 2018 – Dec 31, 2021" -4 :year false
+
+      "Dec 18–24, 2022" 1 :week false
+      "Dec 11–24, 2022" 1 :week true
+      "Dec 18, 2022 – Jan 14, 2023" 4 :week false
+      "Dec 11, 2022 – Jan 14, 2023" 4 :week true
+
+      "Dec 4–10, 2022" -1 :week false
+      "Dec 4–17, 2022" -1 :week true
+      "Nov 13 – Dec 10, 2022" -4 :week false
+      "Nov 13 – Dec 17, 2022" -4 :week true
+
+      "Jan 1–31, 2023" 1 :month false
+      "Dec 1, 2022 – Jan 31, 2023" 1 :month true
+      "Jan 1 – Apr 30, 2023" 4 :month false
+      "Dec 1, 2022 – Apr 30, 2023" 4 :month true
+
+      "Nov 1–30, 2022" -1 :month false
+      "Nov 1 – Dec 31, 2022" -1 :month true
+      "Aug 1 – Nov 30, 2022" -4 :month false
+      "Aug 1 – Dec 31, 2022" -4 :month true
+
+      "Dec 15, 2022" 1 :day false
+      "Dec 14–15, 2022" 1 :day true
+      "Dec 15–18, 2022" 4 :day false
+      "Dec 14–18, 2022" 4 :day true
+
+      "Dec 13, 2022" -1 :day false
+      "Dec 13–14, 2022" -1 :day true
+      "Dec 10–13, 2022" -4 :day false
+      "Dec 10–14, 2022" -4 :day true
+
+      "Dec 14, 2022, 2:00 PM – 2:59 PM" 1 :hour false
+      "Dec 14, 2022, 1:00 PM – 2:59 PM" 1 :hour true
+      "Dec 14, 2022, 2:00 PM – 5:59 PM" 4 :hour false
+      "Dec 14, 2022, 1:00 PM – 5:59 PM" 4 :hour true
+
+      "Dec 14, 2022, 12:00 PM – 12:59 PM" -1 :hour false
+      "Dec 14, 2022, 12:00 PM – 1:59 PM" -1 :hour true
+      "Dec 14, 2022, 9:00 AM – 12:59 PM" -4 :hour false
+      "Dec 14, 2022, 9:00 AM – 1:59 PM" -4 :hour true
+
+      "Dec 14, 2022, 1:19 PM" 1 :minute false
+      "Dec 14, 2022, 1:18 PM – 1:19 PM" 1 :minute true
+      "Dec 14, 2022, 1:19 PM – 1:22 PM" 4 :minute false
+      "Dec 14, 2022, 1:18 PM – 1:22 PM" 4 :minute true
+
+      "Dec 14, 2022, 1:17 PM" -1 :minute false
+      "Dec 14, 2022, 1:17 PM – 1:18 PM" -1 :minute true
+      "Dec 14, 2022, 1:14 PM – 1:17 PM" -4 :minute false
+      "Dec 14, 2022, 1:14 PM – 1:18 PM" -4 :minute true)))

src/metabase/lib/js.cljs

@@ -23,6 +23,7 @@
    [metabase.lib.util :as lib.util]
    [metabase.mbql.js :as mbql.js]
    [metabase.mbql.normalize :as mbql.normalize]
+   [metabase.shared.util.time :as shared.ut]
    [metabase.util :as u]
    [metabase.util.log :as log]))
 
@@ -895,3 +896,15 @@
    Can be passed an integer table id or a legacy `card__<id>` string."
   [a-query table-id]
   (lib.core/with-different-table a-query table-id))
+
+(defn ^:export format-relative-date-range
+  "Given a `n` `unit` time interval and the current date, return a string representing the date-time range.
+   Provide an `offset-n` and `offset-unit` time interval to change the date used relative to the current date.
+   `options` is a map and supports `:include-current` to include the current given unit of time in the range."
+  [n unit offset-n offset-unit options]
+  (shared.ut/format-relative-date-range
+    n
+    (keyword unit)
+    offset-n
+    (some-> offset-unit keyword)
+    (js->clj options :keywordize-keys true)))