224 lines
12 KiB
Clojure
224 lines
12 KiB
Clojure
(ns auto-ap.graphql.accounts
|
|
(:require
|
|
[auto-ap.datomic :refer [audit-transact conn]]
|
|
[auto-ap.datomic.accounts :as d-accounts]
|
|
[auto-ap.graphql.utils
|
|
:refer [->graphql
|
|
<-graphql
|
|
assert-admin
|
|
assert-can-see-client
|
|
can-see-client?
|
|
cleanse-query
|
|
enum->keyword
|
|
is-admin?
|
|
limited-clients
|
|
result->page]]
|
|
[auto-ap.solr :as solr]
|
|
[datomic.api :as dc]
|
|
[iol-ion.tx :refer [random-tempid]]
|
|
[com.brunobonacci.mulog :as mu]))
|
|
|
|
(defn get-graphql [context args _]
|
|
(assert-admin (:id context))
|
|
(let [args (assoc args :id (:id context))
|
|
[accounts accounts-count ] (d-accounts/get-graphql (<-graphql args))]
|
|
(result->page accounts accounts-count :accounts args)))
|
|
|
|
(defn get-all-graphql [context args _]
|
|
(assert-admin (:id context))
|
|
(let [args (assoc args :id (:id context))
|
|
[accounts _ ] (d-accounts/get-graphql (assoc (<-graphql args) :per-page Integer/MAX_VALUE))]
|
|
(map ->graphql accounts)))
|
|
|
|
(defn default-for-vendor [context args _]
|
|
(assert-can-see-client (:id context) (:client_id args))
|
|
(let [result (d-accounts/get-for-vendor (:vendor_id args) (:client_id args))]
|
|
(->graphql (d-accounts/clientize result (:client_id args)))))
|
|
|
|
(defn upsert-account [context args _]
|
|
(let [{{:keys [id client-overrides numeric-code location applicability account-set name invoice-allowance vendor-allowance type]} :account} (<-graphql args)]
|
|
(when-not id
|
|
(when (seq (dc/q {:find ['?e]
|
|
:in '[$ ?account-set ?numeric-code]
|
|
:where ['[?e :account/account-set ?account-set]
|
|
'[?e :account/numeric-code ?numeric-code]]}
|
|
(dc/db conn) account-set numeric-code))
|
|
|
|
(throw (ex-info (str "Account set " account-set " already has an account for code " numeric-code)
|
|
{} ))))
|
|
(let [result (audit-transact [[:upsert-entity
|
|
(cond-> {:db/id (or id "new-account")
|
|
:account/name name
|
|
:account/search-terms name
|
|
:account/type (keyword "account-type" (clojure.core/name type))
|
|
:account/applicability (or (enum->keyword applicability "account-applicability")
|
|
:account-applicability/global)
|
|
:account/invoice-allowance (some-> invoice-allowance (enum->keyword "allowance"))
|
|
:account/vendor-allowance (some-> vendor-allowance (enum->keyword "allowance"))
|
|
:account/default-allowance :allowance/allowed
|
|
:account/account-set account-set
|
|
:account/location location
|
|
:account/numeric-code numeric-code
|
|
:account/code (str numeric-code)
|
|
:account/client-overrides (mapv
|
|
(fn [client-override]
|
|
{:db/id (or (:id client-override) (random-tempid))
|
|
:account-client-override/client (:client-id client-override)
|
|
:account-client-override/name (:name client-override)
|
|
:account-client-override/search-terms (:name client-override)})
|
|
client-overrides)}
|
|
id (dissoc :account/numeric-code :account/code))]]
|
|
(:id context))
|
|
updated-account (d-accounts/get-by-id (or id (get-in result [:tempids "new-account"])))]
|
|
(mu/log ::account-updated :account updated-account)
|
|
(solr/index-documents-raw solr/impl
|
|
"accounts"
|
|
(into [{"id" (:db/id updated-account)
|
|
"account_id" (:db/id updated-account)
|
|
"name" (:account/name updated-account)
|
|
"numeric_code" (:account/numeric-code updated-account)
|
|
"location" (:account/location updated-account)
|
|
"applicability" (clojure.core/name (:account/applicability updated-account))}]
|
|
(for [o (:account/client-overrides updated-account)]
|
|
{"id" (:db/id o)
|
|
"account_id" (:db/id updated-account)
|
|
"name" (:account-client-override/name o)
|
|
"numeric_code" (:account/numeric-code updated-account)
|
|
"location" (:account/location updated-account)
|
|
"applicability" (clojure.core/name (:account/applicability updated-account))
|
|
"client_id" (:db/id (:account-client-override/client o))
|
|
"account_client_override_id" (:db/id o)}))
|
|
)
|
|
(->graphql
|
|
updated-account))))
|
|
|
|
(def search-pattern [:db/id
|
|
:account/numeric-code
|
|
:account/location
|
|
{:account/vendor-allowance [:db/ident]
|
|
:account/default-allowance [:db/ident]
|
|
:account/invoice-allowance [:db/ident]}])
|
|
(defn search- [id query client]
|
|
(let [client-part (if (some->> client (can-see-client? id))
|
|
(format "((applicability:(global OR optional) AND -client_id:*) OR (account_client_override_id:* AND client_id:%s))" client)
|
|
"(applicability:(global OR optional) AND -client_id:*)"
|
|
|
|
)
|
|
query (format "_text_:(%s) AND %s" (cleanse-query query) client-part)]
|
|
(mu/log ::searching :search-query query)
|
|
(for [{:keys [account_id name] :as g} (solr/query solr/impl "accounts"
|
|
{"query" query
|
|
"fields" "id, name, client_id, numeric_code, applicability, account_id"})]
|
|
|
|
{:account_id (first account_id)
|
|
:name (first name)})))
|
|
|
|
(defn search [context {query :query client :client_id allowance :allowance vendor-id :vendor_id} _]
|
|
(when client
|
|
(assert-can-see-client (:id context) client))
|
|
(let [num (some-> (re-find #"([0-9]+)" query)
|
|
second
|
|
(not-empty )
|
|
Integer/parseInt)
|
|
|
|
valid-allowances (cond-> #{:allowance/allowed
|
|
:allowance/warn}
|
|
(is-admin? (:id context)) (conj :allowance/admin-only))
|
|
allowance (cond (= allowance :vendor)
|
|
:account/vendor-allowance
|
|
(= allowance :invoice)
|
|
:account/invoice-allowance
|
|
:else
|
|
:account/default-allowance)
|
|
|
|
vendor-account (when vendor-id
|
|
(-> (dc/q '[:find ?da
|
|
:in $ ?v
|
|
:where [?v :vendor/default-account ?da]]
|
|
(dc/db conn)
|
|
vendor-id)
|
|
ffirst))
|
|
xform (comp
|
|
(filter (fn [[_ a]]
|
|
(or
|
|
(valid-allowances (-> a allowance :db/ident))
|
|
(= (:db/id a) vendor-account))))
|
|
(map (fn [[n a]]
|
|
{:name (str (:account/numeric-code a) " - " n)
|
|
:id (:db/id a)
|
|
:location (:account/location a)
|
|
:warning (when (= :allowance/warn (-> a allowance :db/ident))
|
|
"This account is not typically used for this purpose.")})))]
|
|
(if query
|
|
(if num
|
|
(->> (dc/q '[:find ?n (pull ?i pattern)
|
|
:in $ ?numeric-code ?allowance pattern
|
|
:where [?i :account/numeric-code ?numeric-code]
|
|
[?i :account/name ?n]
|
|
(or [?i :account/applicability :account-applicability/global]
|
|
[?i :account/applicability :account-applicability/optional]
|
|
[?i :account/applicability :account-applicability/customized])]
|
|
(dc/db conn)
|
|
num
|
|
allowance
|
|
search-pattern)
|
|
(sequence xform))
|
|
(->> (search- (:id context) query client)
|
|
(sequence
|
|
(comp (map (fn [i] [(:name i) (dc/pull (dc/db conn) search-pattern (:account_id i))]))
|
|
xform))))
|
|
[])))
|
|
|
|
(defn rebuild-search-index []
|
|
(solr/index-documents-raw
|
|
solr/impl
|
|
"accounts"
|
|
(for [result (map first (dc/qseq {:query '[:find (pull ?aco [:account-client-override/search-terms :account-client-override/client :db/id {:account/_client-overrides [:account/numeric-code :account/location :db/id {:account/applicability [:db/ident]}]}])
|
|
:in $
|
|
:where [?aco :account-client-override/client ]
|
|
[?aco :account-client-override/search-terms ]
|
|
[_ :account/client-overrides ?aco]]
|
|
:args [(dc/db conn)]}))
|
|
:when (:account/numeric-code (:account/_client-overrides result))]
|
|
{"id" (:db/id result)
|
|
"account_id" (:db/id (:account/_client-overrides result))
|
|
"account_client_override_id" (str (:db/id result))
|
|
"name" (:account-client-override/search-terms result)
|
|
"client_id" (str (:db/id (:account-client-override/client result)))
|
|
"numeric_code" (:account/numeric-code (:account/_client-overrides result))
|
|
"location" (:account/location (:account/_client-overrides result))
|
|
"applicability" (name (:db/ident (:account/applicability (:account/_client-overrides result))))}))
|
|
(solr/index-documents-raw
|
|
solr/impl
|
|
"accounts"
|
|
(for [result (map first (dc/qseq {:query '[:find (pull ?a [:account/numeric-code
|
|
:account/search-terms
|
|
{:account/applicability [:db/ident]}
|
|
:db/id
|
|
:account/location])
|
|
:in $
|
|
:where [?a :account/search-terms ]]
|
|
:args [(dc/db conn)]}))
|
|
:when (:account/search-terms result)
|
|
]
|
|
{"id" (:db/id result)
|
|
"account_id" (:db/id result)
|
|
"name" (:account/search-terms result)
|
|
"numeric_code" (:account/numeric-code result)
|
|
"location" (:account/location result)
|
|
"applicability" (name (:db/ident (:account/applicability result)))})))
|
|
|
|
#_(dc/transact conn
|
|
[{:db/ident :account-client-override/k2
|
|
:db/valueType :db.type/tuple
|
|
:db/tupleAttrs [:account/_client-overrides :account-client-override/client ]
|
|
:db/cardinality :db.cardinality/one
|
|
:db/unique :db.unique/identity}])
|
|
|
|
#_(dc/q '[:find ?o
|
|
:where [_ :account-client-override/k ?o]]
|
|
(dc/db conn))
|
|
|
|
|
|
#_(dc/pull (dc/db conn) '[*] [:db/ident :account-client-override/k])
|