First step in coding sales.

src/clj/auto_ap/datomic/migrate.clj

@@ -115,6 +115,31 @@
                                 []))]
     [existing-accounts]))
 
+
+(defn apply-idents-to-well-known [conn]
+  (let [[ccp-square] (d/q '[:find [?v]
+                          :where [?v :vendor/name "CCP Square"]]
+                        (d/db conn))
+        [receipts-split] (d/q '[:find [?a]
+                              :where [?a :account/numeric-code 12990]]
+                            (d/db conn))
+        [ccp] (d/q '[:find [?a]
+                   :where [?a :account/numeric-code 12100]]
+                 (d/db conn))
+        [accounts-payable] (d/q '[:find [?a]
+                                :where [?a :account/numeric-code 21000]]
+                              (d/db conn))]
+    [[{:db/id ccp :db/ident :account/ccp}]
+     [{:db/id ccp-square
+       :db/ident :vendor/ccp-square
+       :vendor/name "CCP Square"
+       :vendor/default-account :account/ccp}
+      {:db/id receipts-split
+       :db/ident :account/receipts-split}
+      
+      {:db/id accounts-payable
+       :db/ident :account/accounts-payable}]]))
+
 (defn migrate [conn]
   (let [
         norms-map (merge {:auto-ap/base-schema {:txes auto-ap.datomic/base-schema}
@@ -443,7 +468,10 @@
                                                                 :db/doc "error message for a failed job"
                                                                 :db/valueType :db.type/string
                                                                 :db/cardinality :db.cardinality/one}]]
-                                                       :requires [:auto-ap/add-transaction-import2]}}
+                                                       :requires [:auto-ap/add-transaction-import2]}
+                          :auto-ap/apply-idents-to-well-known {:txes-fn `apply-idents-to-well-known
+                                                               :requires [:auto-ap/add-general-ledger6
+                                                                          :auto-ap/add-account-to-vendor]}}
                          
 
 

src/clj/auto_ap/import/transactions.clj

@@ -223,8 +223,15 @@
 (defn maybe-clear-expected-deposit [{:transaction/keys [amount client date] :as transaction}]
   (when (>= amount 0.0)
     (when-let [expected-deposit (find-expected-deposit client amount (coerce/to-date-time date))]
-      (assoc transaction  :transaction/expected-deposit {:db/id expected-deposit
+      (assoc transaction
-                                                         :expected-deposit/status :expected-deposit-status/cleared}))))
+             :transaction/expected-deposit {:db/id expected-deposit
+                                            :expected-deposit/status :expected-deposit-status/cleared}
+             :transaction/accounts [{:transaction-account/account :account/ccp
+                                     :transaction-account/amount amount
+                                     :transaction-account/location "A"}]
+             :transaction/approval-status :transaction-approval-status/approved
+             :transaction/vendor :vendor/ccp-square
+             ))))
 
 (defn maybe-code [{:transaction/keys [client amount] :as transaction} apply-rules valid-locations]
   (if-let [unpaid-invoices (seq (match-transaction-to-unpaid-invoices amount client))]
@@ -249,9 +256,6 @@
          code-fn)]))
 
 
-
-
-
 (defn get-existing [bank-account]
   (log/info "looking up bank account data for" bank-account)
   (into {}

src/clj/auto_ap/ledger.clj

@@ -17,10 +17,12 @@
                         (map :a)
                         (map namespace)
                         set)]
+    (println namespaces changes)
     (cond (namespaces "invoice" )   [[:invoice e]]
           (namespaces "invoice-expense-account" ) [[:invoice (:db/id (:invoice/_expense-accounts entity))]]
           (namespaces "transaction-account" ) [[:transaction (:db/id (:transaction/_accounts entity))]]
           (namespaces "transaction" )   [[:transaction e]]
+          (namespaces "expected-deposit" )   [[:expected-deposit e]]
           :else nil)))
 
 
@@ -33,6 +35,7 @@
     (cond (namespaces "invoice" )   :invoice
           (namespaces "invoice-expense-account" )   :invoice-expense-account
           (namespaces "transaction-account" )   :transaction-account
+          (namespaces "expected-deposit" )   :expected-deposit
           :else nil)))
 
 (defmulti entity-change->ledger (fn [_ [type]]
@@ -57,7 +60,7 @@
         :journal-entry/vendor (:db/id (:invoice/vendor entity))
         :journal-entry/amount (Math/abs (:invoice/total entity))
 
-        :journal-entry/line-items (into [(cond-> {:journal-entry-line/account (:db/id (a/get-account-by-numeric-code-and-sets 21000 ["default"])) 
+        :journal-entry/line-items (into [(cond-> {:journal-entry-line/account :account/accounts-payable 
                                                   :journal-entry-line/location "A"
                                                   }
                                            credit-invoice? (assoc :journal-entry-line/debit (Math/abs (:invoice/total entity)))
@@ -120,6 +123,26 @@
         
         :journal-entry/cleared true}))))
 
+(defmethod entity-change->ledger :expected-deposit
+  [db [type id]]
+  (let [{:expected-deposit/keys [total client date]} (d/pull db '[:expected-deposit/total :expected-deposit/client :expected-deposit/date] id)]
+    #:journal-entry
+    {:source "expected-deposit"
+     :original-entity id
+
+     :client client
+     :date date
+     :amount total
+     :vendor :vendor/ccp-square
+     :line-items [#:journal-entry-line
+                  {:credit total
+                   :location "A"
+                   :account :account/receipts-split}
+                  #:journal-entry-line
+                  {:debit total
+                   :location "A"
+                   :account :account/ccp}]}))
+
 (defmethod entity-change->ledger :invoice-expense-account
   [db [entity changes]]
   nil

test/clj/auto_ap/import/transactions_test.clj

@@ -171,6 +171,17 @@
                       :expected-deposit/status :expected-deposit-status/cleared}
                      (:transaction/expected-deposit transaction-result)))))
 
+        (t/testing "Should credit CCP"
+          (let [[transaction-result] (sut/transaction->txs (assoc base-transaction
+                                                                  :transaction/date #inst "2021-07-03T00:00:00-08:00"
+                                                                  :transaction/amount 100.0)
+                                                           (d/entity (d/db conn) bank-account-id)
+                                                           noop-rule)]
+            (t/is (= [{:transaction-account/account :account/ccp
+                       :transaction-account/amount 100.0
+                       :transaction-account/location "A"}]
+                     (:transaction/accounts transaction-result)))))
+
         (t/testing "Should not match old expected deposits"
           (let [[transaction-result] (sut/transaction->txs (assoc base-transaction
                                                                   :transaction/date #inst "2021-07-13"

test/clj/auto_ap/ledger_test.clj

@@ -0,0 +1,56 @@
+(ns auto-ap.ledger-test
+  (:require [auto-ap.datomic :refer [conn uri]]
+            [auto-ap.datomic.migrate :as m]
+            [auto-ap.ledger :as sut]
+            [clojure.test :as t]
+            [datomic.api :as d]))
+
+(defn wrap-setup
+  [f]
+  (with-redefs [auto-ap.datomic/uri "datomic:mem://datomic-transactor:4334/invoice"]
+    (d/create-database uri)
+    (with-redefs [auto-ap.datomic/conn (d/connect uri)]
+      (m/migrate auto-ap.datomic/conn)
+      (f)
+      (d/release auto-ap.datomic/conn)
+      (d/delete-database uri))))
+
+(t/use-fixtures :each wrap-setup)
+
+
+(t/deftest entity-change->ledger
+  (t/testing "Should code an expected deposit"
+    (let [{:strs [ed ccp receipts-split client]}
+          (:tempids  @(d/transact conn [#:expected-deposit {:status :expected-deposit-status/pending
+                                                            :client {:db/id "client"
+                                                                     :client/code "BRYCE"
+                                                                     :client/locations ["M"]}
+                                                            :total 4.0
+                                                            :fee 1.0
+                                                            :date #inst "2021-01-01T00:00:00-08:00"
+                                                            :location "M"
+                                                            :db/id "ed"}]))
+          result (sut/entity-change->ledger (d/db conn) [:expected-deposit ed])]
+      (t/is (= #:journal-entry
+               {:source "expected-deposit"
+                :client {:db/id client}
+                :date #inst "2021-01-01T00:00:00-08:00"
+                :original-entity ed
+                :vendor :vendor/ccp-square
+                :amount 4.0
+                }
+               (dissoc result :journal-entry/line-items)))
+
+      (t/testing "should debit ccp"
+        (t/is (= [#:journal-entry-line
+                  {:debit 4.0
+                   :location "A"
+                   :account :account/ccp}]
+                 (filter :journal-entry-line/debit (:journal-entry/line-items result))))
+        )
+      (t/testing "should credit receipts split ccp"
+        (t/is (= [#:journal-entry-line
+                  {:credit 4.0
+                   :location "A"
+                   :account :account/receipts-split}]
+                 (filter :journal-entry-line/credit (:journal-entry/line-items result))))))))