so many bug fixes.

scratch-sessions/fix_pending_transactions.clj

@@ -0,0 +1,88 @@
+(ns fix-pending-transactions)
+
+
+(def potential-matches
+ (d/query {:query {:find ['(pull ?e1 [:db/id :transaction/date])
+                          '(pull ?e2 [:db/id :transaction/date])]
+                   :in ['$]
+                   :where ['[?e1 :transaction/status "PENDING"]
+                           '[?e1 :transaction/description-original ?e1-d]
+                           '[?e1 :transaction/amount ?e1-a]
+                           #_'[?e1 :transaction/date ?e1-dt]
+                           
+                           '[?e2 :transaction/description-original ?e1-d]
+                           '[?e2 :transaction/amount ?e1-a]
+                           #_'[?e2 :transaction/date e1-dt]
+                           '[?e2 :transaction/status "POSTED"]]}
+           :args [(d/db (d/connect uri))]})
+ )
+
+(def all-pending
+  (d/query {:query {:find ['?e1]
+                    :in ['$]
+                    :where ['[?e1 :transaction/status "PENDING"]]}
+            :args [(d/db (d/connect uri))]}))
+
+(def checkless
+  (d/query {:query {:find ['?e1]
+                    :in ['$]
+                    :where ['[?e1 :transaction/status "PENDING"]
+                            '(not [?e1 :transaction/payment])
+                            ]}
+            :args [(d/db (d/connect uri))]}))
+
+(def checked
+  (d/query {:query {:find ['?e1 '(pull ?z [:payment/amount :payment/type :payment/status {:payment/client [:client/code]}])]
+                    :in ['$]
+                    :where ['[?e1 :transaction/status "PENDING"]
+                            '[?e1 :transaction/payment ?z]
+                            ]}
+            :args [(d/db (d/connect uri))]}))
+
+(count checkless)
+(count all-pending)
+(count checked)
+(take 4 checked)
+
+(def match-lookup (->> potential-matches
+                       (reduce
+                        (fn [acc x]
+                          (into acc (map
+                                     #(vector (:db/id %) x)
+                                     x)))
+                        {})))
+
+(take 2 potential-matches)
+
+(take 3 match-lookup)
+
+(->> checked
+     (map first)
+     (map #(if (get match-lookup %)
+             (d/pull (d/db (d/connect uri)) '[*] (:db/id (second (get match-lookup %)))) 
+             )))
+
+(defn revert-transactions [ids]
+  (->> 
+   (d/query {:query {:find ['(pull ?id [:db/id {:journal-entry/_original-entity [:db/id]
+                                                :transaction/payment [:db/id]} ])]
+                     :in ['$ '[?id ...]]
+                     :where ['[?id :transaction/status]]}
+             :args [(d/db (d/connect uri)) ids]})
+   (mapcat (fn [[transaction]]
+             (let [ledger-id (:db/id (first (:journal-entry/_original-entity transaction)))
+                   payment-id (:db/id (:transaction/payment transaction))]
+               (cond-> [[:db/retractEntity (:db/id transaction)]]
+                 ledger-id (conj [:db/retractEntity ledger-id])
+                 payment-id (conj {:db/id payment-id
+                                   :payment/status :payment-status/pending})))))
+   (into [])))
+
+#_(doseq [result (partition-all 200 (revert-transactions (map first checked)))]
+  (println "proccesed 1")
+  @(d/transact (d/connect uri) result ))
+
+(map second checked)
+
+
+(re-find #"(?i)check(card|[^0-9]+([0-9]*))" "Check-1205")

scratch-sessions/fixing_transactions_manually_imported_incorrectl.clj

@@ -0,0 +1,51 @@
+(ns fixing-transactions-manually-imported-incorrectl)
+
+
+;; This buffer is for Clojure experiments and evaluation.
+
+;; Press C-j to evaluate the last expression.
+
+;; You can also press C-u C-j to evaluate the expression and pretty-print its result.
+
+(def t (auto-ap.yodlee.core/get-specific-transactions 24249175))
+(def all-ts (auto-ap.yodlee.core/get-transactions))
+
+(filter  all-ts)
+
+(first all-ts)
+
+(def g (auto-ap.yodlee.import/get-existing))
+(map 
+ :transaction/yodlee-merchant
+ (let [all-bank-accounts (get-all-bank-accounts)
+       transaction->bank-account (comp (by :bank-account/yodlee-account-id all-bank-accounts) :accountId)
+       all-rules (tr/get-all)]
+   (transactions->txs all-ts transaction->bank-account (rm/rule-applying-fn all-rules) (get-existing))))
+
+(count g)
+
+(g (digest/sha-256 (str 2553824503)))
+
+(require '[clojure.java.io :as io])
+
+
+(with-open [writer (java.io.StringWriter.)]
+  (clojure.data.csv/write-csv writer
+                              (->> 
+                               (d/query {:query {:find ['?e]
+                                                 :in ['$]
+                                                 :where ['[?e :transaction/id ?tid]
+                                                         '[?e :transaction/date ?d]
+                                                         '(not [?e :transaction/type])]}
+                                         :args [(d/since (d/db (d/connect uri)) #inst "2020-06-01")]})
+                               (map first)
+                               vec
+                               (d/pull-many (d/db (d/connect uri))
+                                            [:db/id
+                                             :transaction/date :transaction/id :transaction/amount
+                                             :transaction/description-original
+                                             {:transaction/client [:client/code]}
+                                             {:transaction/bank-account [:bank-account/code]}])
+                               (map (fn [r]
+                                      [(:transaction/id r) (:db/id r) (:transaction/amount r) (coerce/to-date-time (:transaction/date r)) (:transaction/description-original r) (:bank-account/code (:transaction/bank-account r)) (:client/code (:transaction/client r))]))))
+  (println (.toString writer)))