makes POS page much less likely to break everything

iol_ion/src/iol_ion/query.clj

@@ -19,8 +19,11 @@
   (localize (time/now)))
 
 
-(defn recent-date []
+(defn recent-date
-  (coerce/to-date (time/minus (local-now) (time/days 90))))
+  ([]
+   (recent-date 90))
+  ([n]
+   (coerce/to-date (time/minus (local-now) (time/days n)))))
 
 (def excel-formatter (f/with-zone (f/formatter "MM/dd/yyyy") (time/time-zone-for-id "America/Los_Angeles")))
 (defn excel-date [d]

src/clj/auto_ap/backup.clj

@@ -4,6 +4,7 @@
 
 ;; You can also press C-u C-j to evaluate the expression and pretty-print its result.
 
+(comment 
   (ns auto-ap.backup
     (:require [datomic.api :as d]
               [manifold.deferred :as de]
@@ -526,3 +527,4 @@
               :service "export-backup")
       (Thread/sleep 5000)
       (throw e))))
+)

src/clj/auto_ap/datomic.clj

@@ -853,3 +853,21 @@
                    :status "WARN")
            (transact-with-backoff tx (inc attempt)))
          (throw e))))))
+
+(defn visible-clients [id]
+  (cond
+    (= (:user/role id) "none")
+    #{}
+
+    (= (:user/role id) "admin")
+    (->> (dc/q '[:find (pull ?e [:db/id :client/code])
+                 :in $
+                 :where [?e :client/code]]
+               (dc/db conn))
+         (map first)
+         (map :db/id)
+         (into #{}))
+
+    (#{"manager" "user" "power-user"} (:user/role id))
+    (into #{}
+          (map :db/id (:user/clients id [])))))

src/clj/auto_ap/datomic/sales_orders.clj

@@ -4,11 +4,14 @@
     :refer [add-sorter-fields-2
             apply-pagination
             apply-sort-3
+            pull-id
             merge-query
             pull-many
+            visible-clients
             conn]]
    [auto-ap.graphql.utils :refer [limited-clients]]
    [clj-time.coerce :as c]
+   [clj-time.core :as time]
    [clojure.set :as set]
    [clojure.tools.logging :as log]
    [datomic.client.api :as dc]
@@ -30,95 +33,36 @@
                     {:sales-order/client [:client/name :db/id :client/code]
                      :sales-order/charges [* {:charge/processor [:db/ident]} {:expected-deposit/_charges [:db/id]}]}])
 
-#_(defn client-index-search [db attr client-ids [start end]]
-  (for [c client-ids
-        d
-        (dc/q '[:find ?e
-                :in $ ?start ?end
-                :where [?e :sales-order/client+date ?g]
-                [(>= ?g ?start)]
-                [(<= ?g ?end)]]
-              db [c start] [c end])
-
-        #_(dc/index-range db {:attrid attr
-                              :start  [c start]
-                              :end    [c end]})]
-    (first d)))
-
-#_(comment 
-  (do 
-    (println "starting")
-    (doseq [n (partition-all 500 (dc/q '[:find ?s ?d
-                                          :where [?s :sales-order/date ?d]]
-                                        (dc/db conn)))]
-      (print ".")
-      (dc/transact conn {:tx-data (map (fn [[n d]] {:db/id n :sales-order/date d}) n)}))
-    (println "done"))
-
-
-  (time (count (client-index-search (dc/db conn)
-                                    :sales-order/client+date
-                                    [3575611821801781]
-                                    [#inst "2021-05-21T18:06:02.000-00:00"
-                                     #inst "2022-09-25T18:06:02.000-00:00"]
-                                    )))
-
-  (time (count (dc/q '[:find ?e
-                       :in $ ?client ?start ?end
-                       :where [?e :sales-order/client ?client]
-                       [?e :sales-order/date ?date]
-                       [(>= ?date ?start)]
-                       [(<= ?date ?end)]]
-                     (dc/db conn)
-                      3575611821801781
-
-                      #inst "2021-05-21T18:06:02.000-00:00"
-                      #inst "2022-09-25T18:06:02.000-00:00"
-                      )))
-
-  (time (do (count (dc/q '[:find  ?e,
-                           :in    $ [[?s1 ?e1]]
-                           :where
-                           #_[(untuple ?period) [?s1 ?e1]]
-                           [(q '[:find ?e
-                                 :in $ ?s1 ?e1
-                                 :where [?e :sales-order/client+date ?g]
-                                 [(>= ?g ?s1)]
-                                 [(<= ?g ?e1)]]
-                               $ ?s1 ?e1) [?e ...]]
-                           ]
-                         (dc/db conn) [[[3575611821801781 #inst "2022-08-21T18:06:02.000-00:00" ] [3575611821801781 #inst "2022-09-25T18:06:02.000-00:00"]]
-                                       [[3575611821801766 #inst "2022-08-21T18:06:02.000-00:00" ] [3575611821801766 #inst "2022-09-25T18:06:02.000-00:00"]]]))  
-              (println "done"))) 
-
-  (dc/index-range (dc/db conn) {:attrid :sales-order/date+client3
-                                :start  [#inst "2022-08-25T18:06:02.000-00:00" ]
-                                :end    [#inst "2022-08-25T20:06:02.000-00:00" ]}) 
-  (dc/pull (dc/db conn) '[*] :sales-order/date+client3)
-  (dc/pull (dc/db conn) '[*] 5040161313201309) 
-
-  #_(time (do (dc/q {:query '{:find  [(count ?x)],
-                              :in    [$ ?client-id],
-                              :where [[?e :sales-order/date+client3 ?x]]},
-                     :args  [(dc/db conn) 3575611821801781]}) 
-              (println "done")))
-
-  #_(datomic.dev-local.async/return-1)
-
-  (clojure.core.async/<!! (dca/transact conn {:tx-data [{:db/ident       :sales-order/client+date
-                                                           :db/valueType   :db.type/tuple
-                                                           :db/tupleAttrs  [:sales-order/client :sales-order/date]
-                                                           :db/cardinality :db.cardinality/one}]
-                                                :timeout 600000}))
-
-
-  )
-
 (defn raw-graphql-ids [db args]
-  (let [query (cond-> {:query {:find []
+  (let [visible-clients  (visible-clients (:id args))
-                               :in ['$]
+        selected-clients (->> (cond
+                                (:client-id args)
+                                (set/intersection #{(:client-id args)}
+                                                  visible-clients)
+
+
+                                (:client-code args)
+                                (set/intersection #{(pull-id db [:client/code (:client-code args)])}
+                                                  visible-clients)
+
+                                :else
+                                visible-clients)
+                              (take 3)
+                              set)
+        _ (mu/log ::selected-clients
+                  :selected-clients selected-clients)
+        query (cond-> {:query {:find []
+                               :in ['$ '[?c ...]]
                                :where []}
-                       :args [db]}
+                       :args [db selected-clients]}
+
+
+                true
+                (merge-query {:query {:in    ['?start-date '?end-date]
+                                      :where '[[(iol-ion.query/sales-orders-in-range $ ?c ?start-date ?end-date) [?e ...]]]}
+                              :args  [(or (some->  (:start (:date-range args)) c/to-date) (iol-ion.query/recent-date 5))
+                                      (or (some-> (:end (:date-range args)) c/to-date )
+                                          (c/to-date (time/now)))]})
                 (:sort args) (add-sorter-fields-2 {"client"   ['[?e :sales-order/client ?c]
                                                                '[?c :client/name ?sort-client]]
                                                    "location" ['[?e :sales-order/location ?sort-location]]
@@ -128,34 +72,6 @@
                                                    "tax"      ['[?e :sales-order/tax ?sort-tax]]
                                                    "tip"      ['[?e :sales-order/tip ?sort-tip]]}
                                                   args)
-
-                (:start (:date-range args))
-                (merge-query {:query {:in    '[?start-date]
-                                      :where ['[?e :sales-order/date ?date]
-                                              '[(>= ?date ?start-date)]]}
-                              :args  [(c/to-date (:start (:date-range args)))]})
-
-                (:end (:date-range args))
-                (merge-query {:query {:in    '[?end-date]
-                                      :where ['[?e :sales-order/date ?date]
-                                              '[(<= ?date ?end-date)]]}
-                              :args  [(c/to-date (:end (:date-range args)))]})
-
-                (limited-clients (:id args))
-                (merge-query {:query {:in ['[?xx ...]]
-                                      :where ['[?e :sales-order/client ?xx]]}
-                              :args [(set (map :db/id (limited-clients (:id args))))]})
-
-                (:client-id args)
-                (merge-query {:query {:in ['?client-id]
-                                      :where ['[?e :sales-order/client ?client-id]]}
-                              :args [(:client-id args)]})
-                (:client-code args)
-                (merge-query {:query {:in ['?client-code]
-                                      :where ['[?e :sales-order/client ?client-id]
-                                              '[?client-id :client/code ?client-code]]}
-                              :args [(:client-code args)]})
-                
                 (:category args)
                 (merge-query {:query {:in    ['?category]
                                       :where ['[?e :sales-order/line-items ?li]
@@ -196,7 +112,6 @@
                 (merge-query {:query {:find  ['?date '?e]
                                       :where ['[?e :sales-order/date ?date]]}}))]
 
-    (println query)
     (mu/log ::query-stats
             :stats (:query-stats (dc/q (assoc query :query-stats true)))
             :q (str query))

src/clj/auto_ap/graphql/utils.clj

@@ -98,6 +98,8 @@
     (#{"manager" "user" "power-user"} (:user/role id))
     (:user/clients id [])))
 
+
+
 (defn result->page [results result-count key args]
   {key (map ->graphql results)
    :total result-count

src/clj/auto_ap/pdf/ledger.clj

@@ -363,13 +363,13 @@
                    :input-stream (io/make-input-stream pdf-data {})
                    :metadata {:content-length (count pdf-data)
                               :content-type   "application/pdf"})
-    @(d/transact conn
+    (dc/transact conn
-                 [{:report/name    name
+                 {:tx-data [{:report/name    name
                              :report/client  (:client_ids args)
                              :report/key     key
                              :report/url     url
                              :report/creator (:user user)
-                   :report/created (java.util.Date.)}])
+                             :report/created (java.util.Date.)}]})
     {:report/name name
      :report/url  url }))