everything is audited.

src/clj/auto_ap/graphql/clients.clj

@@ -1,17 +1,17 @@
 (ns auto-ap.graphql.clients
-  (:require [auto-ap.datomic.clients :as d-clients]
-            [datomic.api :as d]
-            [auto-ap.datomic :refer [uri remove-nils]]
+  (:require [auto-ap.datomic :refer [audit-transact conn remove-nils]]
+            [auto-ap.datomic.clients :as d-clients]
             [auto-ap.graphql.utils :refer [->graphql assert-admin can-see-client?]]
+            [clj-time.coerce :as coerce]
             [clojure.string :as str]
             [clojure.tools.logging :as log]
-            [clj-time.coerce :as coerce])) 
+            [datomic.api :as d]))
 
 (defn assert-client-code-is-unique [code]
   (when (seq (d/query {:query {:find '[?id]
                                :in ['$ '?code]
                                :where ['[?id :client/code ?code]]}
-                       :args [(d/db (d/connect uri)) code]}))
+                       :args [(d/db conn) code]}))
     (throw (ex-info "Client is not unique" {:validation-error (str "Client code '" code "' is not unique.")}))))
 
 (defn edit-client [context {:keys [edit_client new_bank_accounts] :as args} value]
@@ -22,10 +22,10 @@
   (let [client (when (:id edit_client) (d-clients/get-by-id (:id edit_client)))
         id (or (:db/id client) "new-client")
         _ (when client
-            @(d/transact (d/connect uri)
-                         (into 
-                          (mapv (fn [lm] [:db/retractEntity (:db/id lm)]) (:client/location-matches client))
-                          (mapv (fn [m] [:db/retract (:db/id client) :client/matches m]) (:client/matches client)))))
+            (audit-transact (into 
+                             (mapv (fn [lm] [:db/retractEntity (:db/id lm)]) (:client/location-matches client))
+                             (mapv (fn [m] [:db/retract (:db/id client) :client/matches m]) (:client/matches client)))
+                            (:id context)))
         transactions [(remove-nils {:db/id id
                                     :client/code (if (str/blank? (:client/code client))
                                                    (:code edit_client)
@@ -80,7 +80,7 @@
                                                                         )
                                                                       (:forecasted_transactions edit_client))]]
         _ (log/info "upserting client" transactions)
-        result @(d/transact (d/connect uri) transactions)]
+        result (audit-transact transactions (:id context))]
     (-> result :tempids (get id) (or id) d-clients/get-by-id
         (update :client/location-matches
                 (fn [lms]

src/clj/auto_ap/graphql/ledger.clj

@@ -1,19 +1,19 @@
 (ns auto-ap.graphql.ledger
-  (:require [auto-ap.datomic :refer [uri remove-nils]]
+  (:require [auto-ap.datomic :refer [audit-transact-batch remove-nils uri]]
+            [auto-ap.datomic.accounts :as a]
+            [auto-ap.datomic.clients :as d-clients]
             [auto-ap.datomic.ledger :as l]
             [auto-ap.datomic.vendors :as d-vendors]
-            [auto-ap.datomic.accounts :as a]
-            [auto-ap.utils :refer [by dollars=]]
-            [auto-ap.time :refer [parse iso-date]]
-            [auto-ap.graphql.utils :refer [->graphql <-graphql limited-clients assert-admin result->page assert-can-see-client]]
-            [clj-time.coerce :as coerce]
-            [clojure.string :as str]
-            [clj-time.core :as time]
+            [auto-ap.graphql.utils
+             :refer
+             [->graphql <-graphql assert-admin assert-can-see-client result->page]]
             [auto-ap.parse.util :as parse]
-            [datomic.api :as d]
-            [auto-ap.parse.templates :as t]
-            [auto-ap.datomic.clients :as d-clients]
+            [auto-ap.utils :refer [by dollars=]]
+            [clj-time.coerce :as coerce]
+            [clj-time.core :as time]
+            [clojure.string :as str]
             [clojure.tools.logging :as log]
+            [datomic.api :as d]
             [unilog.context :as lc]))
 
 (defn get-ledger-page [context args value]
@@ -217,7 +217,8 @@
                                           :db/id vendor_name})))
                               {}
                               (:entries args))
-          all-vendors (into all-vendors new-hidden-vendors)
+          _ (audit-transact-batch (vec (vals new-hidden-vendors)) (:id context))
+          all-vendors (by :vendor/name (d-vendors/get-graphql {}))
           all-accounts  (transduce (map (comp str :account/numeric-code)) conj #{} (a/get-accounts))
           transaction (doall (map
                               (assoc-error (fn [entry]
@@ -250,7 +251,8 @@
                                                    :journal-entry/client [:client/code (:client_code entry)]
                                                    :journal-entry/date (coerce/to-date (parse/parse-value :clj-time "MM/dd/yyyy" (:date entry)))
                                                    :journal-entry/external-id (:external_id entry)
-                                                   :journal-entry/vendor (:db/id (all-vendors (:vendor_name entry)))
+                                                   :journal-entry/vendor (:db/id (doto (all-vendors (:vendor_name entry))
+                                                                                   println))
                                                    :journal-entry/amount (:amount entry)
                                                    :journal-entry/note (:note entry)
                                                    :journal-entry/cleared-against (:cleared_against entry)
@@ -286,12 +288,11 @@
           retraction (mapv (fn [x] [:db/retractEntity [:journal-entry/external-id (:journal-entry/external-id x)]])
                            success)]
       (log/info "manual ledger import has " (count success) " new rows")
-      (run! (fn [batch]
-              (log/info "transacting retraction batch" (first batch))
-              @(d/transact (d/connect uri) batch)) (partition-all 100 retraction))
-      (run! (fn [batch]
-              (log/info "transacting success batch" (first batch))
-              @(d/transact (d/connect uri) batch)) (partition-all 100 success))
+      
+
+      (audit-transact-batch retraction (:id context))
+      (audit-transact-batch success (:id context))
+      
       {:successful (map (fn [x] {:external_id (:journal-entry/external-id x)}) success)
        :existing []
        :errors (map (fn [x] {:external_id (:external_id x)

src/clj/auto_ap/graphql/transaction_rules.clj

@@ -1,20 +1,26 @@
 (ns auto-ap.graphql.transaction-rules
-  (:require [auto-ap.datomic.transaction-rules :as tr]
-            [auto-ap.datomic.transactions :as t]
-            [datomic.api :as d]
-            [auto-ap.datomic :refer [remove-nils uri merge-query replace-nils-with-retract]]
+  (:require [auto-ap.datomic
+             :refer
+             [audit-transact merge-query remove-nils replace-nils-with-retract uri]]
+            [auto-ap.datomic.transaction-rules :as tr]
+            [auto-ap.datomic.transactions :as d-transactions]
+            [auto-ap.graphql.utils
+             :refer
+             [->graphql
+              <-graphql
+              assert-admin
+              ident->enum-f
+              limited-clients
+              result->page
+              snake->kebab]]
+            [auto-ap.rule-matching :as rm]
             [auto-ap.utils :refer [dollars=]]
-            [auto-ap.graphql.utils :refer [->graphql <-graphql limited-clients assert-admin result->page snake->kebab ident->enum-f]]
-            [clj-time.coerce :as c]
+            [clj-time.coerce :as coerce]
             [clojure.set :as set]
             [clojure.string :as str]
-            [auto-ap.datomic.transactions :as d-transactions]
-            [auto-ap.rule-matching :as rm]
-            [clj-time.coerce :as coerce]
-            [clojure.tools.logging :as log])
-  (:import [java.time.temporal ChronoField]))
-
-
+            [clojure.tools.logging :as log]
+            [datomic.api :as d])
+  (:import java.time.temporal.ChronoField))
 
 (defn get-transaction-rule-page [context args value]
   (let [args (assoc args :id (:id context))
@@ -52,7 +58,7 @@
     (when-not (:transaction-rule/description existing-transaction-rule)
       (throw (ex-info "Transaction rule not found" {:validation-error "Transaction Rule not found"})))
 
-    @(d/transact (d/connect uri) [[:db/retractEntity transaction_rule_id]])
+    (audit-transact [[:db/retractEntity transaction_rule_id]] (:id context))
     transaction_rule_id))
 
 (defn upsert-transaction-rule [context {{:keys [id description yodlee_merchant_id note client_id bank_account_id amount_lte amount_gte vendor_id accounts transaction_approval_status dom_gte dom_lte]} :transaction_rule :as z} value]
@@ -67,9 +73,10 @@
                      (nil? yodlee_merchant_id)) 
             (let [error (str "You must provide a description or a yodlee merchant")]
               (throw (ex-info error {:validation-error error}))))
-        transaction (replace-nils-with-retract #:transaction-rule {:db/id (if id
-                                                                            id
-                                                                            "transaction-rule")
+        rule-id (if id
+                  id
+                  "transaction-rule")
+        transaction (replace-nils-with-retract #:transaction-rule {:db/id rule-id
                                                                    :description description
                                                                    :note note
                                                                    :client client_id
@@ -84,16 +91,13 @@
                                                                    (some->> transaction_approval_status
                                                                             name
                                                                             snake->kebab
-                                                                            (keyword "transaction-approval-status"))
-                                                                   :accounts (map transaction-rule-account->entity accounts)}
+                                                                            (keyword "transaction-approval-status"))}
                                                existing-transaction)
 
 
-        transaction (into transaction
-                          (map (fn [d]
-                                 [:db/retract id :transaction-rule/accounts d])
-                               deleted))
-        transaction-result @(d/transact (d/connect uri) transaction)]
+        transaction (conj transaction
+                          [:reset rule-id :transaction-rule/accounts (map transaction-rule-account->entity accounts)])
+        transaction-result (audit-transact  transaction (:id context))]
     (-> (tr/get-by-id (or (-> transaction-result :tempids (get "transaction-rule"))
                                            id))
         ((ident->enum-f :transaction-rule/transaction-approval-status))

src/clj/auto_ap/graphql/users.clj

@@ -1,8 +1,7 @@
 (ns auto-ap.graphql.users
-  (:require [auto-ap.datomic.users :as d-users]
-            [datomic.api :as d]
-            [auto-ap.datomic :refer [uri]]
-            [auto-ap.graphql.utils :refer [->graphql assert-admin]])) 
+  (:require [auto-ap.datomic :refer [audit-transact]]
+            [auto-ap.datomic.users :as d-users]
+            [auto-ap.graphql.utils :refer [->graphql assert-admin]]))
 
 (def role->datomic-role {":none" :user-role/none
                          ":admin" :user-role/admin
@@ -18,12 +17,11 @@
                               (filter #(not (new-clients %)) ))]
     
     
-    @(d/transact (d/connect uri)
-                 
-                 (-> [{:db/id (:db/id user)
-                       :user/role (role->datomic-role (:role edit_user))  
-                       :user/clients new-clients}]
-                     (into (map (fn [c] [:db/retract (:db/id user) :user/clients c]) clients-to-remove))))
+    (audit-transact (-> [{:db/id (:db/id user)
+                          :user/role (role->datomic-role (:role edit_user))  
+                          :user/clients new-clients}]
+                        (into (map (fn [c] [:db/retract (:db/id user) :user/clients c]) clients-to-remove)))
+                    (:id context))
     (->graphql
      (d-users/get-by-id (:id edit_user)))))
 

src/clj/auto_ap/graphql/vendors.clj

@@ -3,7 +3,7 @@
             [auto-ap.datomic.vendors :as d-vendors]
             [auto-ap.time :refer [parse iso-date]]
             [datomic.api :as d]
-            [auto-ap.datomic :refer [uri remove-nils audit-transact]]
+            [auto-ap.datomic :refer [uri remove-nils audit-transact conn]]
             [clj-time.coerce :as coerce]
             [clojure.set :as set]))
 
@@ -86,19 +86,17 @@
         (->graphql))))
 
 (defn merge-vendors [context {:keys [from to]} value]
-  (let [conn (d/connect uri)
-        transaction (->> (d/query {:query {:find '[?x ?a2]
+  (let [transaction (->> (d/query {:query {:find '[?x ?a2]
                                            :in '[$ ?vendor-from ]
                                            :where ['[?x ?a ?vendor-from]
                                                    '[?a :db/ident ?a2]]}
-                                   :args [(d/db conn)
-                                          from]})
+                                   :args [(d/db conn) from]})
                          (mapcat (fn [[src attr]]
 
                                    [[:db/retract src attr from]
                                     [:db/add src attr to]])))
         transaction (conj transaction [:db/retractEntity from])]
-    @(d/transact conn transaction)
+    (audit-transact transaction (:id context))
     to))
 
 (defn get-graphql [context args value]