Makes integreat run on datomic cloud

src/clj/auto_ap/graphql/invoices.clj

@@ -1,6 +1,8 @@
 (ns auto-ap.graphql.invoices
   (:require
-   [auto-ap.datomic :refer [conn remove-nils uri]]
+   [auto-ap.datomic
+    :refer [conn remove-nils upsert-entity]]
+   [auto-ap.ledger :refer [transact-with-ledger]]
    [auto-ap.datomic.clients :as d-clients]
    [auto-ap.datomic.invoices :as d-invoices]
    [auto-ap.datomic.vendors :as d-vendors]
@@ -21,11 +23,12 @@
    [auto-ap.utils :refer [dollars=]]
    [clj-time.coerce :as coerce]
    [clj-time.core :as time]
-   [clojure.set :as set]
    [clojure.tools.logging :as log]
    [datomic.api :as d]
    [manifold.deferred :as de]
-   [com.brunobonacci.mulog :as mu]))
+   [com.brunobonacci.mulog :as mu]
+   [com.walmartlabs.lacinia.util :refer [attach-resolvers]]
+   [datomic.client.api :as dc]))
 
 (defn ->graphql [invoice user ]
   (if (= "admin" (:user/role user))
@@ -61,7 +64,7 @@
 (defn reject-invoices [context {:keys [invoices]} _]
   (assert-power-user (:id context))
   (doseq [i invoices]
-    (assert-can-see-client (:id context) (:db/id (:invoice/client (d/entity (d/db conn) i)))))
+    (assert-can-see-client (:id context) (:db/id (:invoice/client (dc/pull (dc/db conn) [{:invoice/client [:db/id]}]  i)))))
   (let [transactions (map (fn [i] [:db/retractEntity i]) invoices)]
     (transact-with-ledger transactions (:id context))
     invoices))
@@ -69,7 +72,9 @@
 (defn approve-invoices [context {:keys [invoices]} _]
   (assert-power-user (:id context))
   (doseq [i    invoices
-          :let [invoice (d/entity (d/db conn) i)]]
+          :let [invoice (dc/pull (dc/db conn) [{:invoice/client [:db/id]}
+                                               :invoice/date]
+                                i)]]
     (assert-can-see-client (:id context) (-> invoice :invoice/client :db/id))
     (assert-not-locked (-> invoice :invoice/client :db/id) (-> invoice :invoice/date)))
   (let [transactions (map (fn [i] {:db/id i :invoice/import-status :import-status/imported}) invoices)]
@@ -104,34 +109,25 @@
                                    due))
         _ (when-not (:db/id account)
             (throw (ex-info (str "Vendor '" (:vendor/name vendor) "' does not have a default expense acount.") {:vendor-id vendor_id})))]
-    (cond->
-     {:db/id "invoice"
-      :invoice/invoice-number invoice_number
-      :invoice/client client_id
-      :invoice/vendor vendor_id
-      :invoice/import-status :import-status/imported
-      :invoice/total total
-      :invoice/outstanding-balance total
-      :invoice/status :invoice-status/unpaid
-      :invoice/date  (coerce/to-date date)
-      :invoice/expense-accounts (map expense-account->entity
-                                     expense_accounts)}
-      due (assoc :invoice/due (coerce/to-date due))
-      scheduled_payment (assoc :invoice/scheduled-payment  (coerce/to-date scheduled_payment)))))
-
-(defn deleted-expense-accounts [invoice expense-accounts]
-  (let [current-expense-accounts (:invoice/expense-accounts invoice)
-        specified-ids (->> expense-accounts
-                           (map :id)
-                           set)
-        existing-ids (->> current-expense-accounts
-                          (map :db/id)
-                          set)]
-    (set/difference existing-ids specified-ids)))
+    `(upsert-entity ~{:db/id                       "invoice"
+                      :invoice/invoice-number      invoice_number
+                      :invoice/client              client_id
+                      :invoice/vendor              vendor_id
+                      :invoice/import-status       :import-status/imported
+                      :invoice/total               total
+                      :invoice/outstanding-balance total
+                      :invoice/status              :invoice-status/unpaid
+                      :invoice/date                (coerce/to-date date)
+                      :invoice/expense-accounts    (map expense-account->entity
+                                                        expense_accounts)
+                      :invoice/due                 (coerce/to-date due)
+                      :invoice/scheduled-payment   (coerce/to-date scheduled_payment)})))
 
 (defn assert-valid-expense-accounts [expense_accounts vendor_id]
   (doseq [expense-account expense_accounts
-          :let [account (d/entity (d/db conn) (:account_id expense-account))]]
+          :let [account (dc/pull (dc/db conn)
+                                 [:account/location]
+                                 (:account_id expense-account))]]
     (when (empty? (:location expense-account))
       (throw (ex-info "Expense account is missing location" {:validation-error "Expense account is missing location"})))
 
@@ -178,7 +174,7 @@
   (assert-valid-expense-accounts expense_accounts vendor_id)
   (assert-invoice-amounts-add-up in)
 
-  (let [transaction-result (transact-with-ledger [(add-invoice-transaction in)] (:id context))]
+  (let [transaction-result (transact-with-ledger (add-invoice-transaction in) (:id context))]
     (-> (d-invoices/get-by-id (get-in transaction-result [:tempids "invoice"]))
         (->graphql (:id context)))))
 
@@ -218,23 +214,21 @@
 
         paid-amount (- (:invoice/total invoice) (:invoice/outstanding-balance invoice))
         _ (assert-can-see-client (:id context) (:db/id (:invoice/client invoice)))
-        deleted (deleted-expense-accounts invoice expense_accounts)
         _ (assert-not-locked (:db/id (:invoice/client invoice)) (:date in))
         _ (assert-valid-expense-accounts expense_accounts vendor_id)
         _ (assert-invoice-amounts-add-up in)
 
-        updated-invoice (cond-> {:db/id id
-                                 :invoice/invoice-number invoice_number
-                                 :invoice/date (coerce/to-date date)
+        updated-invoice {:db/id                  id
+                         :invoice/invoice-number invoice_number
+                         :invoice/date           (coerce/to-date date)
 
-                                 :invoice/total total
-                                 :invoice/outstanding-balance (- total paid-amount)
-                                 :invoice/expense-accounts (map expense-account->entity
-                                                                expense_accounts)}
-                          due (assoc :invoice/due (coerce/to-date due))
-                          scheduled_payment (assoc :invoice/scheduled-payment (coerce/to-date scheduled_payment)))]
-    (transact-with-ledger (concat [updated-invoice]
-                            (map (fn [d] [:db/retract id :invoice/expense-accounts d]) deleted))
+                         :invoice/total               total
+                         :invoice/outstanding-balance (- total paid-amount)
+                         :invoice/expense-accounts    (map expense-account->entity
+                                                        expense_accounts)
+                         :invoice/due                 (coerce/to-date due)
+                         :invoice/scheduled-payment   (coerce/to-date scheduled_payment)}]
+    (transact-with-ledger [`(upsert-entity ~updated-invoice)]
                     (:id context))
     (-> (d-invoices/get-by-id id)
         (->graphql (:id context)))))
@@ -300,15 +294,15 @@
     (log/info "Voiding " (count all-ids) args)
     (transact-with-ledger
       (->> all-ids
-           (d/q '[:find [(pull ?i [:db/id :invoice/date {:invoice/expense-accounts [:db/id]}
-                                   ]) ...]
+           (dc/q '[:find (pull ?i [:db/id :invoice/date {:invoice/expense-accounts [:db/id]}])
                   :in $ [?i ...]
                   :where (not [_ :invoice-payment/invoice ?i])
                   [?i :invoice/client ?c]
                   [(get-else $ ?c :client/locked-until #inst "2000-01-01") ?lu]
                   [?i :invoice/date ?d]
                   [(>= ?d ?lu)]]
-                (d/db conn))
+                (dc/db conn))
+           (map first)
            (mapcat
              (fn [i]
                (into 
@@ -328,16 +322,15 @@
   (let [invoice (d-invoices/get-by-id id)
         _ (assert-can-see-client (:id context) (:db/id (:invoice/client invoice)))
         _ (assert-not-locked  (:db/id (:invoice/client invoice)) (:invoice/date invoice))
-        conn (d/connect uri)
-        history (d/history (d/db conn))
-        txs (d/query {:query {:find ['?tx '?e '?original-status '?original-outstanding '?total '?ea '?ea-amount]
-                              :where ['[?e :invoice/status :invoice-status/voided ?tx true]
-                                      '[?e :invoice/status ?original-status ?tx false]
-                                      '[?e :invoice/outstanding-balance ?original-outstanding ?tx false]
-                                      '[?e :invoice/total ?total ?tx false]
-                                      '[?ea :invoice-expense-account/amount ?ea-amount ?tx false]]
-                              :in ['$ '?e]}
-                      :args [history id]})
+        history (dc/history (dc/db conn))
+        txs (dc/q {:query {:find  ['?tx '?e '?original-status '?original-outstanding '?total '?ea '?ea-amount]
+                           :where ['[?e :invoice/status :invoice-status/voided ?tx true]
+                                   '[?e :invoice/status ?original-status ?tx false]
+                                   '[?e :invoice/outstanding-balance ?original-outstanding ?tx false]
+                                   '[?e :invoice/total ?total ?tx false]
+                                   '[?ea :invoice-expense-account/amount ?ea-amount ?tx false]]
+                           :in    ['$ '?e]}
+                   :args  [history id]})
         [last-transaction] (->> txs (sort-by first) (last))]
     (transact-with-ledger [(->> txs
                           (filter (fn [[tx]] (= tx last-transaction)))
@@ -354,7 +347,11 @@
         (->graphql (:id context)))))
 
 (defn unautopay-invoice [context {id :invoice_id} _]
-  (let [invoice (d/entity (d/db conn) id)]
+  (let [invoice (dc/pull (dc/db conn) [{:invoice/client [:db/id]}
+                                       :invoice-payment/_invoice
+                                       :invoice/total
+                                       :invoice/scheduled-payment
+                                       :invoice/date] id)]
     (assert (:invoice/client invoice))
     (assert-can-see-client (:id context) (:db/id (:invoice/client invoice)))
     (assert-not-locked (:db/id (:invoice/client invoice)) (:invoice/date invoice))
@@ -370,18 +367,15 @@
 (defn edit-expense-accounts [context args _]
   (assert-can-see-client (:id context) (:db/id (:invoice/client (d-invoices/get-by-id (:invoice_id args)))))
   (let [invoice-id (:invoice_id args)
-        invoice (d-invoices/get-by-id invoice-id)
-        _ (assert-not-locked (:db/id (:invoice/client invoice)) (:invoice/date invoice))
-        _ (assert-valid-expense-accounts (:expense_accounts args) (:db/id (:invoice/vendor invoice )))
-        deleted (deleted-expense-accounts invoice (:expense_accounts args))
-        updated {:db/id  invoice-id
-                 :invoice/expense-accounts (map
-                                            expense-account->entity
-                                            (:expense_accounts args))}]
+        invoice    (d-invoices/get-by-id invoice-id)
+        _          (assert-not-locked (:db/id (:invoice/client invoice)) (:invoice/date invoice))
+        _          (assert-valid-expense-accounts (:expense_accounts args) (:db/id (:invoice/vendor invoice )))]
 
-    (transact-with-ledger (concat [updated]
-                            (map (fn [d] [:db/retract invoice-id :invoice/expense-accounts d]) deleted))
-                    (:id context))
+    (transact-with-ledger [`(upsert-entity ~{:db/id                    invoice-id
+                                             :invoice/expense-accounts (map
+                                                                         expense-account->entity
+                                                                         (:expense_accounts args))})]
+                          (:id context))
     (->graphql
       (d-invoices/get-by-id (:invoice_id args))
       (:id context))))