converts accounts.'

src/clj/auto_ap/datomic/migrate.clj

@@ -227,7 +227,8 @@
                                                            {:db/ident :account-client-override/name
                                                             :db/doc "client override"
                                                             :db/valueType :db.type/string
-                                                            :db/cardinality :db.cardinality/one}]]} }]
+                                                            :db/cardinality :db.cardinality/one}]]}
+                   }]
       (println "Conforming database...")
       (c/ensure-conforms  conn norms-map)
       (when (not (seq args))

src/clj/auto_ap/datomic/migrate/add_general_ledger.clj

@@ -3,7 +3,11 @@
             [auto-ap.datomic :refer [remove-nils]]
             [auto-ap.datomic.accounts :as accounts]
             [auto-ap.expense-accounts :as expense-accounts]
-            [auto-ap.ledger :as ledger]))
+            [auto-ap.ledger :as ledger]
+            [auto-ap.utils :refer [by]]
+            [clojure.java.io :as io]
+            [clojure.string :as str])
+  (:import [org.apache.commons.io.input BOMInputStream]))
 
 (defn test-run [txs-set]
   #_(println "processing " (count txs-set))
@@ -458,6 +462,11 @@
                      (partition-all 100))]
     results))
 
+
+
+
+#_(convert-accounts (d/connect auto-ap.datomic/uri))
+
 #_(do (doseq [tran (convert-transactions (d/connect auto-ap.datomic/uri))]
         @(d/transact (d/connect auto-ap.datomic/uri) tran))
       (println "done."))

src/clj/user.clj

@@ -1,9 +1,14 @@
 (ns user
   (:require [auto-ap.datomic :refer [uri]]
-            [datomic.api :as d]
 
+            [auto-ap.utils :refer [by]]
+            [datomic.api :as d]
+            [clojure.data.csv :as csv]
             [clj-time.coerce :as c]
-            [clj-time.core :as t]))
+            [clj-time.core :as t]
+            [clojure.java.io :as io]
+            [clojure.string :as str])
+  (:import [org.apache.commons.io.input BOMInputStream]))
 
 (defn mark-until-date [client end]
   (let [conn (d/connect uri)]
@@ -66,3 +71,78 @@
 
 
 
+(defn load-accounts [conn]
+  (let [[header & rows] (-> "master-account-list.csv" (io/resource) io/input-stream (BOMInputStream.) (io/reader) csv/read-csv)
+        headers (map read-string header)
+        code->existing-account (by :account/numeric-code (map first (d/query {:query {:find ['(pull ?e [:account/numeric-code
+                                                                                                        :db/id])]
+                                                                                      :in ['$]
+                                                                                      :where ['[?e :account/name]]}
+                                                                              :args [(d/db conn)]})))  
+
+        also-merge-txes (fn [also-merge old-account-id]
+                          (let [[sunset-account]
+                                (first (d/query {:query {:find ['?a ]
+                                                         :in ['$ '?ac ]
+                                                         :where ['[?a :account/numeric-code ?ac]]}
+                                                 :args [(d/db conn) also-merge ]}))]
+                               (into (mapv
+                                      (fn [[entity id sunset-account]]
+                                        [:db/add entity id old-account-id])
+                                      (d/query {:query {:find ['?e '?id '?a ]
+                                                        :in ['$ '?ac ]
+                                                        :where ['[?a :account/numeric-code ?ac]
+                                                                '[?e ?at ?a]
+                                                                '[?at :db/ident ?id]]}
+                                                :args [(d/db conn) also-merge ]}))
+                                     [[:db/retractEntity sunset-account]])))
+
+        txes (transduce
+              (comp
+               (map (fn ->map  [r]
+                      (into {} (map vector header r))))
+               (map (fn parse-map [r]
+                      {:old-account-id (:db/id (code->existing-account
+                                                (or 
+                                                 (if (= (get r "IOL Account #")
+                                                        "NEW")
+                                                   nil
+                                                   (Integer/parseInt (get r "IOL Account #")))
+                                                 (Integer/parseInt (get r "Account #")))))
+                       :new-account-number (Integer/parseInt (get r "Account #"))
+                       :name (get r "Default Name")
+                       :location (when-not (str/blank? (get r "Forced Location"))
+                                   (get r "Forced Location"))
+                       :also-merge (when-not (str/blank? (get r "IOL # additional"))
+                                     (Integer/parseInt (get r "IOL # additional")))
+                       :account-type (keyword "account-type"
+                                              (str/lower-case (get r "Account Type")))
+                       :applicability (keyword "account-applicability"
+                                               (condp = (get r "Visiblity (Per-customer, Visible by default, hidden by default)")
+                                                 "Visible by default"
+                                                 "global"
+
+                                                 "Hidden by default"
+                                                 "optional"
+
+                                                 "Per Customer"
+                                                 "customized"))}))
+               (mapcat (fn ->tx [{:keys [old-account-id new-account-number name location also-merge account-type applicability]}]
+                         (let [tx [(cond-> {:account/name name
+                                            :account/type account-type
+                                            :account/applicability applicability
+                                            :account/numeric-code new-account-number}
+                                     old-account-id (assoc :db/id old-account-id)
+                                     location (assoc :account/location location))]]
+                           (if also-merge
+                             (into tx
+                                   (also-merge-txes also-merge old-account-id))
+                             tx)
+                           ))))
+
+
+              conj
+              []
+              rows)]
+    @(d/transact conn txes))
+  )