Makes beginning of new invoice

src/clj/auto_ap/graphql/accounts.clj

@@ -39,9 +39,7 @@
 (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:*)"
+                      "(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"
@@ -137,8 +135,7 @@
                                               :in $
                                               :where [?a :account/search-terms]]
                                      :args  [(dc/db conn)]}))
-          :when  (:account/search-terms result)
+         :when  (:account/search-terms result)]
-          ]
      {"id"            (:db/id result)
       "account_id"            (:db/id result)
       "name"          (:account/search-terms result)

src/clj/auto_ap/graphql/vendors.clj

@@ -114,8 +114,7 @@
                                                                                                             "secondary")
                                                                                                    :name (:name secondary_contact)
                                                                                                    :phone (:phone secondary_contact)
-                                                                                                   :email (:email secondary_contact)})
+                                                                                                   :email (:email secondary_contact)}))
-                                                                           )
                                                       :search-terms [name]}
                                       (is-admin? (:id context)) (assoc
                                                                  :vendor/legal-entity-name (:legal_entity_name in)

src/clj/auto_ap/ssr/invoices.clj

@@ -3,7 +3,7 @@
             [auto-ap.datomic
              :refer [add-sorter-fields apply-pagination apply-sort-3
                      audit-transact conn merge-query observable-query
-                     pull-many]]
+                     pull-attr pull-many]]
             [auto-ap.datomic.accounts :as d-accounts]
             [auto-ap.datomic.bank-accounts :as d-bank-accounts]
             [auto-ap.datomic.invoices :as d-invoices]
@@ -23,6 +23,7 @@
              :refer [wrap-admin wrap-client-redirect-unauthenticated]]
             [auto-ap.solr :as solr]
             [auto-ap.ssr-routes :as ssr-routes]
+            [auto-ap.ssr.common-handlers :refer [add-new-entity-handler]]
             [auto-ap.ssr.components :as com]
             [auto-ap.ssr.components.link-dropdown :refer [link-dropdown]]
             [auto-ap.ssr.components.multi-modal :as mm]
@@ -390,6 +391,7 @@
    (pay-button* {:ids (selected->ids request
                                      (:query-params request))})))
 
+;; TODO test as a real user
 (def grid-page
   (helper/build {:id                 "entity-table"
                  :nav                com/main-aside-nav
@@ -412,7 +414,10 @@
                                                   "Void selected"))
                                     (when (can? (:identity request) {:subject :invoice :activity :pay})
                                       (pay-button* {:ids (selected->ids request
-                                                                        (:query-params request))}))])
+                                                                        (:query-params request))}))
+                                    (when (can? (:identity request) {:subject :invoice :activity :create})
+                                      (com/button {:hx-get (bidi/path-for ssr-routes/only-routes ::route/new-wizard)}
+                                                  "New invoice"))])
                  :row-buttons (fn [_ entity]
                                 [(when (= :invoice-status/unpaid (:invoice/status entity))
                                    (com/icon-button {:hx-delete (bidi/path-for ssr-routes/only-routes
@@ -923,7 +928,7 @@
      :validation-route ::route/pay-wizard-navigate)))
 
 (defn add-handwritten-check [request wizard snapshot]
-  (let [invoices (d-invoices/get-multi (map :invoice-id (:invoices snapshot))) ;; TODO shouldn't need datomic
+  (let [invoices (d-invoices/get-multi (map :invoice-id (:invoices snapshot)))
         bank-account-id (:bank-account snapshot)
         bank-account (d-bank-accounts/get-by-id bank-account-id)
         _ (when-not (= 1 (count (set (map (comp :db/id :invoice/vendor) invoices))))
@@ -960,6 +965,7 @@
 ;; Thought is to put it into the pay function itself
 ;; balance should only go to negative if total was negative
 ;; balance should stay positive if total was positive
+;; NOTE: payable-ids function could be used.
 
 ;; TODO support crediting from balance
 (defrecord PayWizard [form-params current-step invoice-by-id]
@@ -1057,7 +1063,7 @@
                                                   :payment-type/cash
                                                   (= :credit (:method snapshot))
                                                   :payment-type/credit
-                                                  :else :payment-type/debit) ;; TODO might not be right
+                                                  :else :payment-type/debit)
                                             identity)))]
       (modal-response
        (com/modal {}
@@ -1080,6 +1086,325 @@
 (def pay-wizard
   (->PayWizard nil nil nil))
 
+(def new-form-schema
+  [:map
+   [:invoice/client [:entity-map {:pull [:db/id :client/name :client/accounts]}]]
+   [:invoice/vendor [:entity-map {:pull [:db/id :vendor/name]}]]])
+
+(defrecord BasicDetailsStep [linear-wizard]
+  mm/ModalWizardStep
+  (step-name [_]
+    "Basic Details")
+  (step-key [_]
+    :basic-details)
+
+  (edit-path [_ _]
+    [])
+
+  (step-schema [_]
+    (mut/select-keys (mm/form-schema linear-wizard) #{:invoice/client :invoice/vendor}))
+
+  (render-step [this request]
+    (mm/default-render-step
+     linear-wizard this
+     :head [:div.p-2 "New invoice"]
+     :body (mm/default-step-body
+            {}
+            [:div {}
+             (fc/with-field :invoice/client
+               (if (:client request)
+                 (com/hidden {:name (fc/field-name)
+                              :value (:db/id (:client request))})
+                 (com/validated-field
+                  {:label  "Client"
+                   :errors (fc/field-errors)}
+                  [:div.w-96
+                   (com/typeahead {:name        (fc/field-name)
+                                   :error?      (fc/error?)
+                                   :class       "w-96"
+                                   :placeholder "Search..."
+                                   :url         (bidi/path-for ssr-routes/only-routes :company-search)
+                                   :value       (fc/field-value)
+                                   :content-fn  (fn [c] (pull-attr (dc/db conn) :client/name c))})])))
+             (fc/with-field :invoice/vendor
+               (com/validated-field
+                {:label  "Vendor"
+                 :errors (fc/field-errors)}
+                [:div.w-96
+                 (com/typeahead {:name        (fc/field-name)
+                                 :error?      (fc/error?)
+                                 :class       "w-96"
+                                 :placeholder "Search..."
+                                 :url         (bidi/path-for ssr-routes/only-routes :vendor-search)
+                                 :value       (fc/field-value)
+                                 :content-fn  (fn [c] (pull-attr (dc/db conn) :vendor/name c))})]))
+             (fc/with-field :invoice/date
+               (com/validated-field
+                {:label "Date"
+                 :errors (fc/field-errors)}
+                [:div {:class "w-24"}
+                 (com/date-input {:value (-> (fc/field-value)
+                                             (atime/unparse-local atime/normal-date))
+                                  :name (fc/field-name)
+                                  :error? (fc/field-errors)
+                                  :placeholder "1/1/2024"})]))
+             (fc/with-field :invoice/due
+               (com/validated-field
+                {:label "Due (optional)"
+                 :errors (fc/field-errors)}
+                [:div {:class "w-24"}
+                 (com/date-input {:value (-> (fc/field-value)
+                                             (atime/unparse-local atime/normal-date))
+                                  :name (fc/field-name)
+                                  :error? (fc/field-errors)
+                                  :placeholder "1/1/2024"})]))
+             (fc/with-field :invoice/scheduled-payment
+               (com/validated-field
+                {:label "Scheduled payment (optional)"
+                 :errors (fc/field-errors)}
+                [:div {:class "w-24"}
+                 (com/date-input {:value (-> (fc/field-value)
+                                             (atime/unparse-local atime/normal-date))
+                                  :name (fc/field-name)
+                                  :error? (fc/field-errors)
+                                  :placeholder "1/1/2024"})]))
+
+             (fc/with-field :invoice/invoice-number
+               (com/validated-field
+                {:label "Invoice Number"
+                 :errors (fc/field-errors)}
+                [:div {:class "w-24"}
+                 (com/text-input {:value (-> (fc/field-value))
+                                  :name (fc/field-name)
+                                  :error? (fc/field-errors)
+                                  :placeholder "HA-123"})]))
+             (fc/with-field :invoice/total
+               (com/validated-field
+                {:label "Total"
+                 :errors (fc/field-errors)}
+                [:div {:class "w-16"}
+                 (com/money-input {:value (-> (fc/field-value))
+                                   :name (fc/field-name)
+                                   :class "w-24"
+                                   :error? (fc/field-errors)
+                                   :placeholder "212.44"})]))])
+
+     :footer
+     (mm/default-step-footer linear-wizard this :validation-route ::route/new-wizard-navigate)
+     :validation-route ::route/new-wizard-navigate)))
+
+(defn- location-select*
+  [{:keys [name account-location client-locations value]}]
+  (com/select {:options (into [["" ""]]
+                              (cond account-location
+                                    [[account-location account-location]]
+
+                                    (seq client-locations)
+                                    (into [["Shared" "Shared"]]
+                                          (for [cl client-locations]
+                                            [cl cl]))
+                                    :else
+                                    [["Shared" "Shared"]]))
+               :name  name
+               :value value
+               :class "w-full"}))
+
+(defn- account-typeahead*
+  [{:keys [name value client-id x-model]}]
+  [:div.flex.flex-col
+   (com/typeahead {:name        name
+                   :placeholder "Search..."
+                   :url         (str (bidi/path-for ssr-routes/only-routes :account-search) "?client-id=" client-id)
+                   :id          name
+                   :x-model     x-model
+                   :value       value
+                   :content-fn  (fn [value]
+                                  (:account/name (d-accounts/clientize (dc/pull (dc/db conn) d-accounts/default-read value)
+                                                                       client-id)))})])
+
+(defn- transaction-rule-account-row*
+  [account client-id client-locations]
+  (com/data-grid-row
+   (-> {:x-data   (hx/json {:accountId (or (:db/id (fc/field-value (:transaction-rule-account/account account)))
+                                           (fc/field-value (:transaction-rule-account/account account)))
+                            :location (fc/field-value (:transaction-rule-account/location account))
+                            :show      (boolean (not (fc/field-value (:new? account))))})
+        :data-key "show"
+        :x-ref    "p"}
+       hx/alpine-mount-then-appear)
+   (let [account-name (fc/field-name (:transaction-rule-account/account account))]
+     (list
+
+      (fc/with-field :db/id
+        (com/hidden {:name  (fc/field-name)
+                     :value (fc/field-value)}))
+      (fc/with-field :transaction-rule-account/account
+        (com/data-grid-cell
+         {}
+         (com/validated-field
+          {:errors (fc/field-errors)}
+          [:div {:hx-trigger "changed"
+                 :hx-target  "next div"
+                 :hx-vals    (format "js:{name: '%s', 'client-id': event.detail.clientId || '', value: event.detail.accountId || ''}" account-name)
+                 :hx-get     (str (bidi/path-for ssr-routes/only-routes ::route/account-typeahead))
+                 :x-init     "$watch('clientId', cid => $dispatch('changed', $data));"}]
+          (account-typeahead* {:value     (fc/field-value)
+                               :client-id client-id
+                               :name      (fc/field-name)
+                               :x-model   "accountId"}))))
+      (fc/with-field :transaction-rule-account/location
+        (com/data-grid-cell
+         {}
+         (com/validated-field
+          {:errors (fc/field-errors)
+           :x-data (hx/json {:location (fc/field-value)})}
+          [:div {:hx-trigger "changed"
+                 :hx-target  "next *"
+                 :hx-swap "outerHTML"
+                 :hx-vals    (format "js:{name: '%s', 'client-id': event.detail.clientId || '', 'account-id': event.detail.accountId || '', value: event.detail.location || ''}" (fc/field-name))
+                 :hx-get     (bidi/path-for ssr-routes/only-routes ::route/location-select)
+                 :x-init     "$watch('clientId', cid => $dispatch('changed', $data)); $watch('accountId', cid =>  $dispatch('changed', $data) )"}]
+          (location-select* {:name             (fc/field-name)
+                             :account-location (:account/location (cond->> (:transaction-rule-account/account @account)
+                                                                    (nat-int? (:transaction-rule-account/account @account)) (dc/pull (dc/db conn)
+                                                                                                                                     '[:account/location])))
+                             :client-locations client-locations
+                             :x-model         "location"
+                             :value            (fc/field-value)}))))
+      (fc/with-field :transaction-rule-account/percentage
+        (com/data-grid-cell
+         {}
+         (com/validated-field
+          {:errors (fc/field-errors)}
+          (com/money-input {:name  (fc/field-name)
+                            :class "w-16"
+                            :value (some-> (fc/field-value)
+                                           (* 100)
+                                           (long))}))))))
+   (com/data-grid-cell {:class "align-top"}
+                       (com/a-icon-button {"@click.prevent.stop" "show=false; setTimeout(() => $refs.p.remove(), 500)"} svg/x))))
+
+(defrecord AccountsStep [linear-wizard]
+  mm/ModalWizardStep
+  (step-name [_]
+    "Details")
+  (step-key [_]
+    :accounts)
+
+  (edit-path [_ _]
+    [])
+
+  (step-schema [_]
+    (mut/select-keys (mm/form-schema linear-wizard) #{}))
+
+  (render-step [this {{:keys [snapshot]} :multi-form-state :as request}]
+    (mm/default-render-step
+     linear-wizard this
+     :head [:div.p-2 "Invoice accounts "]
+     :body (mm/default-step-body
+            {}
+            [:div {}
+             (:client/name (:invoice/client snapshot))
+             (fc/with-field :invoice/expense-accounts
+               (com/validated-field
+                {:errors (fc/field-errors)}
+                (com/data-grid {:headers [(com/data-grid-header {} "Account")
+                                          (com/data-grid-header {:class "w-32"} "Location")
+                                          (com/data-grid-header {:class "w-16"} "%")
+                                          (com/data-grid-header {:class "w-16"})]}
+                               (fc/cursor-map #(transaction-rule-account-row* % 
+                                                                              (some->> snapshot :invoice/client :db/id) 
+                                                                              (some->> snapshot :invoice/client :client/locations)))
+                               (com/data-grid-new-row {:colspan   4
+                                                       :hx-get    (bidi/path-for ssr-routes/only-routes
+                                                                                 ::route/new-wizard-new-account)
+                                                       :index     (count (fc/field-value))
+                                                       :tr-params (hx/bind-alpine-vals {} {"client-id" "clientId"})}
+                                                      "New account")))) ])
+     :footer
+     (mm/default-step-footer linear-wizard this :validation-route ::route/new-wizard-navigate)
+     :validation-route ::route/new-wizard-navigate)))
+
+
+
+(defrecord NewWizard2 [_ current-step]
+  mm/LinearModalWizard
+  (hydrate-from-request
+    [this request]
+    this)
+  (navigate [this step-key]
+    (assoc this :current-step step-key))
+  (get-current-step [this]
+    (if current-step
+      (mm/get-step this current-step)
+      (mm/get-step this :basic-details)))
+  (render-wizard [this {:keys [multi-form-state] :as request}]
+    (alog/peek ::MFS multi-form-state)
+    (mm/default-render-wizard
+     this request
+     :form-params
+     (-> mm/default-form-props
+         (assoc :hx-post
+                (str (bidi/path-for ssr-routes/only-routes ::route/pay-submit))))))
+  (steps [_]
+    [:basic-details
+     :accounts])
+
+  (get-step [this step-key]
+    (let [step-key-result (mc/parse  mm/step-key-schema step-key)
+          [step-key-type step-key] step-key-result]
+      (get {:basic-details (->BasicDetailsStep this)
+            :accounts (->AccountsStep this)}
+           step-key)))
+  (form-schema [_] new-form-schema)
+  (submit [this {:keys [multi-form-state request-method identity] :as request}]
+    #_(let [snapshot (mc/decode
+                      payment-form-schema
+                      (:snapshot multi-form-state)
+                      mt/strip-extra-keys-transformer)
+            _ (exception->4xx
+               #(if (= :handwrite-check (:method snapshot))
+                  (when (or (not (some? (:check-number snapshot)))
+                            (= "" (:check-number snapshot)))
+                    (throw (Exception. "Check number is required")))
+                  true))
+            result (exception->4xx
+                    #(if  (= :handwrite-check (:method snapshot))
+                       (add-handwritten-check request this snapshot)
+                       (print-checks-internal (map (fn [i] {:invoice-id (:invoice-id i)
+                                                            :amount     (:amount i)})
+                                                   (:invoices snapshot))
+                                              (:client snapshot)
+                                              (:bank-account snapshot)
+                                              (cond (= :print-check (:method snapshot))
+                                                    :payment-type/check
+                                                    (= :debit (:method snapshot))
+                                                    :payment-type/debit
+                                                    (= :cash (:method snapshot))
+                                                    :payment-type/cash
+                                                    (= :credit (:method snapshot))
+                                                    :payment-type/credit
+                                                    :else :payment-type/debit)
+                                              identity)))]
+        (modal-response
+         (com/modal {}
+                    (com/modal-card-advanced
+                     {:class "transition duration-300 ease-in-out htmx-swapping:-translate-x-2/3 htmx-swapping:opacity-0 htmx-swapping:scale-0 htmx-added:translate-x-2/3 htmx-added:opacity-0 htmx-added:scale-0 scale-100 translate-x-0 opacity-100"}
+                     (com/modal-body {}
+                                     [:div.flex.flex-col.mt-4.space-y-4.items-center
+                                      [:div.w-24.h-24.bg-green-50.rounded-full.p-4.text-green-300.animate-gg
+                                       svg/thumbs-up]
+                                      (when-not (:pdf-url result)
+                                        [:div "That's a wrap. Your payment is complete."])
+                                      (when (:pdf-url result)
+                                        [:div "Your checks are ready. Click "
+                                         (com/link {:href (:pdf-url result) :target "_new"} "here")
+                                         " to download and print."])
+                                      (when (:pdf-url result)
+                                        [:div.text-xs.italic [:em "Remember to turn off all scaling and margins."]])])))
+         :headers {"hx-trigger" "invalidated"}))))
+
+(def new-wizard (->NewWizard2 nil nil))
 
 
 (defn wrap-status-from-source [handler]
@@ -1091,33 +1416,8 @@
                     (= ::route/all-page matched-current-page-route) (assoc-in [:route-params :status] nil))]
       (handler request))))
 
-(def key->handler
+(defn payable-ids [ids]
-  (apply-middleware-to-all-handlers
+  (->> (dc/q '[:find ?i
-   {::route/all-page              (-> (helper/page-route grid-page)
-                                      (wrap-implied-route-param :status nil))
-    ::route/paid-page              (-> (helper/page-route grid-page)
-                                       (wrap-implied-route-param :status :invoice-status/paid))
-    ::route/unpaid-page              (-> (helper/page-route grid-page)
-                                         (wrap-implied-route-param :status :invoice-status/unpaid))
-    ::route/voided-page              (-> (helper/page-route grid-page)
-                                         (wrap-implied-route-param :status :invoice-status/voided))
-    ::route/pay-button (-> pay-button
-                           (wrap-schema-enforce :query-schema  query-schema))
-    ::route/delete (-> delete
-                       (wrap-entity [:route-params :db/id] default-read)
-                       (wrap-schema-enforce :route-params [:map [:db/id entity-id]]))
-    ::route/bulk-delete-confirm  (-> bulk-delete-dialog-confirm
-                                     (wrap-schema-enforce :form-schema  query-schema)
-                                     (wrap-admin))
-    ::route/bulk-delete  (-> bulk-delete-dialog
-                             (wrap-admin))
-    ::route/pay-wizard (-> mm/open-wizard-handler
-
-                           (mm/wrap-wizard pay-wizard)
-                           (mm/wrap-init-multi-form-state (fn [request]
-                                                            (exception->notification
-                                                             #(let [selected-ids (selected->ids request (:query-params request))
-                                                                    selected-ids (->> (dc/q '[:find ?i
                :in $ [?i ...]
                :where [?i :invoice/status :invoice-status/unpaid]
                [?i :invoice/client ?c]
@@ -1125,8 +1425,13 @@
                [?i :invoice/date ?d]
                [(>= ?d ?lu)]]
              (dc/db conn)
-                                                                                            selected-ids)
+             ids)
-                                                                                      (map first))
+       (map first)))
+
+(defn initial-pay-wizard-state [request]
+  (exception->notification
+   #(let [selected-ids (selected->ids request (:query-params request))
+          selected-ids (payable-ids selected-ids)
           _  (when (= 0 (count selected-ids))
                (throw (ex-info "No selected invoices are applicable for payment" {:type :notification})))
 
@@ -1153,7 +1458,56 @@
                                 :handwritten-date (time/now)}
                                []
                                {:mode :simple
-                                                                                          :has-warning? (boolean has-warning?)}))))))
+                                :has-warning? (boolean has-warning?)}))))
+
+(defn initial-new-wizard-state [request]
+  (mm/->MultiStepFormState {:TODO nil}
+                           []
+                           {}))
+
+(def key->handler
+  (apply-middleware-to-all-handlers
+   {::route/all-page              (-> (helper/page-route grid-page)
+                                      (wrap-implied-route-param :status nil))
+    ::route/paid-page              (-> (helper/page-route grid-page)
+                                       (wrap-implied-route-param :status :invoice-status/paid))
+    ::route/unpaid-page              (-> (helper/page-route grid-page)
+                                         (wrap-implied-route-param :status :invoice-status/unpaid))
+    ::route/voided-page              (-> (helper/page-route grid-page)
+                                         (wrap-implied-route-param :status :invoice-status/voided))
+    ::route/pay-button (-> pay-button
+                           (wrap-schema-enforce :query-schema  query-schema))
+    ::route/delete (-> delete
+                       (wrap-entity [:route-params :db/id] default-read)
+                       (wrap-schema-enforce :route-params [:map [:db/id entity-id]]))
+    ::route/bulk-delete-confirm  (-> bulk-delete-dialog-confirm
+                                     (wrap-schema-enforce :form-schema  query-schema)
+                                     (wrap-admin))
+    ::route/bulk-delete  (-> bulk-delete-dialog
+                             (wrap-admin))
+    ::route/pay-wizard (-> mm/open-wizard-handler
+
+                           (mm/wrap-wizard pay-wizard)
+                           (mm/wrap-init-multi-form-state initial-pay-wizard-state))
+    ::route/new-wizard (-> mm/open-wizard-handler
+
+                           (mm/wrap-wizard new-wizard)
+                           (mm/wrap-init-multi-form-state initial-new-wizard-state))
+    ::route/new-wizard-navigate (-> mm/next-handler
+                                    (mm/wrap-wizard new-wizard)
+                                    (mm/wrap-decode-multi-form-state))
+    ::route/new-wizard-new-account (->
+                                    (add-new-entity-handler [:step-params :invoice/expense-accounts]
+                                                            (fn render [cursor request]
+                                                              (transaction-rule-account-row*
+                                                               cursor
+                                                               (:client-id (:query-params request))
+                                                               (some->> (:client-id (:query-params request)) (pull-attr (dc/db conn) :client/locations))))
+                                                            (fn build-new-row [base _]
+                                                              (assoc base :transaction-rule-account/location "Shared")))
+                                    (wrap-schema-enforce :query-schema [:map
+                                                                        [:client-id {:optional true}
+                                                                         [:maybe entity-id]]]))
     ::route/pay-submit              (-> mm/submit-handler
 
                                         (mm/wrap-wizard pay-wizard)

src/cljc/auto_ap/routes/invoice.cljc

@@ -3,6 +3,9 @@
                                             "/unpaid" ::unpaid-page
                                             "/paid" ::paid-page
                                             "/voided" ::voided-page}
+             "/new" {:get ::new-wizard
+                     "/navigate" ::new-wizard-navigate
+                     "/account/new" ::new-wizard-new-account}
              "/pay-button" ::pay-button
              "/pay" {:get ::pay-wizard
                      "/navigate" ::pay-wizard-navigate