Merge branch 'master' into feat/capacitor-new

deps/db/src/logseq/db/common/view.cljs

@@ -309,7 +309,7 @@
   [db id]
   (let [entity (d/entity db id)
         ids (set (cons id (ldb/get-block-alias db id)))
-        refs (mapcat (fn [id] (:block/_refs (d/entity db id))) ids)
+        refs (mapcat (fn [id] (:block/_path-refs (d/entity db id))) ids)
         page-filters (get-filters db entity)
         full-ref-blocks (->> refs
                              (remove (fn [block] (common-initial-data/hidden-ref? db block id)))
@@ -317,8 +317,9 @@
         ref-blocks (cond->> full-ref-blocks
                      (seq page-filters)
                      (filter-blocks page-filters))
-        ref-pages-count (->> (mapcat (fn [id] (:block/_path-refs (d/entity db id))) ids)
-                             (remove (fn [block] (common-initial-data/hidden-ref? db block id)))
+        ref-pages-count (->> ref-blocks
+                             (remove (fn [block]
+                                       (common-initial-data/hidden-ref? db block id)))
                              (mapcat (fn [block]
                                        (->>
                                         (cons

deps/graph-parser/script/db_import.cljs

@@ -161,7 +161,9 @@
             (js/process.exit 1))
         init-conn-args (sqlite-cli/->open-db-args db-graph-dir)
         db-name (if (= 1 (count init-conn-args)) (first init-conn-args) (second init-conn-args))
-        db-dir (if (= 1 (count init-conn-args)) (node-path/dirname (first init-conn-args)) (second init-conn-args))
+        db-full-dir (if (= 1 (count init-conn-args))
+                      (node-path/dirname (first init-conn-args))
+                      (apply node-path/join init-conn-args))
         file-graph' (resolve-path file-graph)
         conn (apply outliner-cli/init-conn (conj init-conn-args {:classpath (cp/get-classpath)
                                                                  :import-type :cli/db-import}))
@@ -177,7 +179,7 @@
                         (select-keys options [:files :verbose :continue :debug]))]
     (p/let [{:keys [import-state]}
             (if directory?
-              (import-file-graph-to-db file-graph' db-dir conn options')
+              (import-file-graph-to-db file-graph' db-full-dir conn options')
               (import-files-to-db file-graph' conn options'))]
 
       (when-let [ignored-props (seq @(:ignored-properties import-state))]

deps/outliner/src/logseq/outliner/property.cljs

@@ -42,7 +42,9 @@
                             (and (contains? #{:logseq.property/status :logseq.property/scheduled :logseq.property/deadline} property-id)
                                  (or (empty? (:block/tags block)) (ldb/internal-page? block))
                                  (not (get (d/pull @conn [property-id] (:db/id block)) property-id)))
-                            (assoc :block/tags :logseq.class/Task))]
+                            (assoc :block/tags :logseq.class/Task)
+                            (= :logseq.property/template-applied-to property-id)
+                            (assoc :block/tags :logseq.class/Template))]
       (cond-> []
         multiple-values-empty?
         (conj [:db/retract (:db/id update-block-tx) property-id :logseq.property/empty-placeholder])

src/main/frontend/components/block.cljs

@@ -691,9 +691,13 @@
        :on-mouse-over #(reset! *hover? true)
        :on-mouse-leave #(reset! *hover? false)
        :on-click (fn [e]
-                   (when stop-click-event? (util/stop e)))
+                   (when (and stop-click-event? (not (util/link? (.-target e))))
+                     (util/stop e)))
        :on-pointer-down (fn [^js e]
                           (cond
+                            (util/link? (.-target e))
+                            nil
+
                             (and on-context-menu (= 2 (.-button e)))
                             nil
 
@@ -896,7 +900,8 @@
      (if (boolean? in-popup?)
        (if (and (not (:preview? config))
                 (not in-popup?)
-                (or (not manual?) open?))
+                (or (not manual?) open?)
+                (not (state/editing?)))
          (popup-preview-impl children
                              {:visible? visible? :set-visible! set-visible!
                               :*timer *timer :*timer1 *timer1

src/main/frontend/components/property/value.cljs

@@ -297,12 +297,12 @@
        (if (#{:logseq.property/deadline :logseq.property/scheduled} (:db/ident property))
          [:div "Repeat task"]
          [:div "Repeat " (if (= :date (:logseq.property/type property)) "date" "datetime")])]]
-     [:div.flex.flex-row.gap-2
-      [:div.flex.text-muted-foreground.mr-4
+     [:div.flex.flex-row.gap-2.ls-repeat-task-frequency
+      [:div.flex.text-muted-foreground
        "Every"]
 
       ;; recur frequency
-      [:div.w-6
+      [:div.w-10.mr-2
        (property-value block (db/entity :logseq.property.repeat/recur-frequency) opts)]
 
       ;; recur unit

src/main/frontend/components/property/value.css

@@ -1,10 +1,14 @@
-.property-value-inner:not([data-type="default"]):not([data-type="url"]):not([data-type="number"]) {
+.property-value-inner:not([data-type="default"]):not([data-type="url"]):not([data-type="number"]):not([data-type="date"]):not([data-type="datetime"]) {
   @apply cursor-pointer;
   &:hover, .as-scalar-value-wrap:hover {
     @apply bg-gray-02 rounded transition-[background-color] duration-300;
   }
 }
 
+.property-value-inner[data-type="date"], .property-value-inner[data-type="datetime"] {
+  @apply cursor-pointer;
+}
+
 .ls-property-input {
   @apply min-w-[224px];
 }
@@ -36,3 +40,8 @@
   @apply cursor-text;
   min-height: 20px;
 }
+
+.ls-repeat-task-frequency .property-value-inner {
+  @apply border rounded pl-2;
+  min-width: 3em;
+}

src/main/frontend/worker/commands.cljs

@@ -7,6 +7,7 @@
             [logseq.common.util.date-time :as date-time-util]
             [logseq.db :as ldb]
             [logseq.db.frontend.property :as db-property]
+            [logseq.db.frontend.property.build :as db-property-build]
             [logseq.db.frontend.property.type :as db-property-type]
             [logseq.db.sqlite.util :as sqlite-util]
             [logseq.outliner.pipeline :as outliner-pipeline]))
@@ -107,24 +108,24 @@
 
 (defmulti handle-command (fn [action-id & _others] action-id))
 
-(defn- repeat-until-future-timestamp
+(defn- repeat-timestamp
   [datetime recur-unit frequency period-f keep-week?]
-  (let [now (t/now)]
-    (if (t/after? datetime now)
-      datetime
-      (let [v (period-f (t/interval datetime now))
-            delta (->> (Math/ceil (/ (if (zero? v) 1 v) frequency))
-                       (* frequency)
-                       recur-unit)
-            result (t/plus datetime delta)
-            w1 (t/day-of-week datetime)
-            w2 (t/day-of-week result)]
-        (if (and keep-week? (not= w1 w2))
-          ;; next week
-          (if (> w2 w1)
-            (t/plus result (t/days (- 7 (- w2 w1))))
-            (t/plus result (t/days (- w1 w2))))
-          result)))))
+  (let [now (t/now)
+        v (if (t/after? datetime now)
+            1
+            (period-f (t/interval datetime now)))
+        delta (->> (Math/ceil (/ (if (zero? v) 1 v) frequency))
+                   (* frequency)
+                   recur-unit)
+        result (t/plus datetime delta)
+        w1 (t/day-of-week datetime)
+        w2 (t/day-of-week result)]
+    (if (and keep-week? (not= w1 w2))
+      ;; next week
+      (if (> w2 w1)
+        (t/plus result (t/days (- 7 (- w2 w1))))
+        (t/plus result (t/days (- w1 w2))))
+      result)))
 
 (defn- get-next-time
   [current-value unit frequency]
@@ -142,18 +143,24 @@
       (let [delta (recur-unit frequency)
             next-time (case (:db/ident unit)
                         :logseq.property.repeat/recur-unit.year
-                        (repeat-until-future-timestamp default-timezone-time recur-unit frequency period-f false)
+                        (repeat-timestamp default-timezone-time recur-unit frequency period-f false)
                         :logseq.property.repeat/recur-unit.month
-                        (repeat-until-future-timestamp default-timezone-time recur-unit frequency period-f false)
+                        (repeat-timestamp default-timezone-time recur-unit frequency period-f false)
                         :logseq.property.repeat/recur-unit.week
-                        (repeat-until-future-timestamp default-timezone-time recur-unit frequency period-f true)
-                        (t/plus (t/now) delta))]
+                        (repeat-timestamp default-timezone-time recur-unit frequency period-f true)
+                        (t/plus default-timezone-time delta))]
         (tc/to-long next-time)))))
 
-(defmethod handle-command :reschedule [_ db entity _datoms]
-  (let [property-ident (or (:db/ident (:logseq.property.repeat/temporal-property entity))
-                           :logseq.property/scheduled)
-        frequency (db-property/property-value-content (:logseq.property.repeat/recur-frequency entity))
+(defn- compute-reschedule-property-tx
+  [conn db entity property-ident]
+  (let [frequency (or (db-property/property-value-content (:logseq.property.repeat/recur-frequency entity))
+                      (let [property (d/entity db :logseq.property.repeat/recur-frequency)
+                            default-value-block (db-property-build/build-property-value-block property property 1)
+                            default-value-tx-data [default-value-block
+                                                   {:db/id (:db/id property)
+                                                    :logseq.property/default-value [:block/uuid (:block/uuid default-value-block)]}]]
+                        (d/transact! conn default-value-tx-data)
+                        1))
         unit (:logseq.property.repeat/recur-unit entity)
         property (d/entity db property-ident)
         date? (= :date (:logseq.property/type property))
@@ -175,12 +182,28 @@
            (when value
              [[:db/add (:db/id entity) property-ident value]])))))))
 
-(defmethod handle-command :set-property [_ _db entity _datoms property value]
+(defmethod handle-command :reschedule [_ conn db entity _datoms]
+  (let [property-ident (or (:db/ident (:logseq.property.repeat/temporal-property entity))
+                           :logseq.property/scheduled)
+        other-property-idents (cond
+                                (and (= property-ident :logseq.property/scheduled)
+                                     (:logseq.property/deadline entity))
+                                [:logseq.property/deadline]
+
+                                (and (= property-ident :logseq.property/deadline)
+                                     (:logseq.property/scheduled entity))
+                                [:logseq.property/scheduled]
+
+                                :else
+                                (filter (fn [p] (get entity p)) [:logseq.property/deadline :logseq.property/scheduled]))]
+    (mapcat #(compute-reschedule-property-tx conn db entity %) (distinct (cons property-ident other-property-idents)))))
+
+(defmethod handle-command :set-property [_ _db _conn entity _datoms property value]
   (let [property' (get-property entity property)
         value' (get-value entity property value)]
     [[:db/add (:db/id entity) property' value']]))
 
-(defmethod handle-command :record-property-history [_ db entity datoms]
+(defmethod handle-command :record-property-history [_ _conn db entity datoms]
   (let [changes (keep (fn [d]
                         (let [property (d/entity db (:a d))]
                           (when (and (true? (get property :logseq.property/enable-history?))
@@ -198,7 +221,7 @@
            :logseq.property.history/property (:db/id property)})))
      changes)))
 
-(defmethod handle-command :default [command _db entity datoms]
+(defmethod handle-command :default [command _conn _db entity datoms]
   (throw (ex-info "Unhandled command"
                   {:command command
                    :entity entity
@@ -206,12 +229,12 @@
 
 (defn execute-command
   "Build tx-data"
-  [db entity datoms [_command {:keys [actions]}]]
+  [conn db entity datoms [_command {:keys [actions]}]]
   (mapcat (fn [action]
-            (apply handle-command (first action) db entity datoms (rest action))) actions))
+            (apply handle-command (first action) conn db entity datoms (rest action))) actions))
 
 (defn run-commands
-  [{:keys [tx-data db-after]}]
+  [conn {:keys [tx-data db-after]}]
   (let [db db-after]
     (mapcat (fn [[e datoms]]
               (let [entity (d/entity db e)
@@ -223,6 +246,6 @@
                                         (every? #(satisfy-condition? db entity % datoms) tx-conditions))) @*commands)]
                 (mapcat
                  (fn [command]
-                   (execute-command db entity datoms command))
+                   (execute-command conn db entity datoms command))
                  commands)))
             (group-by :e tx-data))))

src/main/frontend/worker/pipeline.cljs

@@ -55,6 +55,9 @@
   [repo tx-report]
   (let [db (:db-after tx-report)
         journal-id (:db/id (d/entity db :logseq.class/Journal))
+        journal-page (some (fn [d] (when (and (= :block/journal-day (:a d)) (:added d))
+                                     (d/entity db (:e d))))
+                           (:tx-data tx-report))
         journal-template? (some (fn [d] (and (:added d) (= (:a d) :block/tags) (= (:v d) journal-id))) (:tx-data tx-report))
         tx-data (some->> (:tx-data tx-report)
                          (filter (fn [d] (and (= (:a d) :block/tags) (:added d))))
@@ -63,12 +66,11 @@
                                    (let [object (d/entity db e)
                                          template-blocks (->> (mapcat (fn [id]
                                                                         (let [tag (d/entity db id)
-                                                                              journal? (= journal-id id)
                                                                               parents (ldb/get-page-parents tag {:node-class? true})
                                                                               templates (mapcat :logseq.property/_template-applied-to (conj parents tag))]
                                                                           (cond->> templates
-                                                                            journal?
-                                                                            (map (fn [t] (assoc t :journal tag))))))
+                                                                            journal-page
+                                                                            (map (fn [t] (assoc t :journal journal-page))))))
                                                                       (set (map :v datoms)))
                                                               distinct
                                                               (sort-by :block/created-at)
@@ -213,11 +215,11 @@
           (nil? created-by-ent) (cons created-by-block))))))
 
 (defn- compute-extra-tx-data
-  [repo tx-report]
+  [repo conn tx-report]
   (let [{:keys [db-before db-after tx-data tx-meta]} tx-report
         display-blocks-tx-data (add-missing-properties-to-typed-display-blocks db-after tx-data)
         commands-tx (when-not (or (:undo? tx-meta) (:redo? tx-meta) (:rtc-tx? tx-meta))
-                      (commands/run-commands tx-report))
+                      (commands/run-commands conn tx-report))
         insert-templates-tx (insert-tag-templates repo tx-report)
         created-by-tx (add-created-by-ref-hook db-before db-after tx-data tx-meta)]
     (concat display-blocks-tx-data commands-tx insert-templates-tx created-by-tx)))
@@ -226,7 +228,7 @@
   [repo conn {:keys [tx-meta] :as tx-report} context]
   (try
     (let [tx-before-refs (when (sqlite-util/db-based-graph? repo)
-                           (compute-extra-tx-data repo tx-report))
+                           (compute-extra-tx-data repo conn tx-report))
           tx-report* (if (seq tx-before-refs)
                        (let [result (ldb/transact! conn tx-before-refs {:pipeline-replace? true
                                                                         :outliner-op :pre-hook-invoke