check printing

src/clj/auto_ap/graphql/checks.clj

@@ -8,13 +8,289 @@
             [auto-ap.db.invoices-checks :as invoices-checks]
             [auto-ap.db.checks :as checks]
             [auto-ap.datomic.checks :as d-checks]
+            [auto-ap.datomic.invoices :as d-invoices]
+            [auto-ap.datomic.vendors :as d-vendors]
+            [auto-ap.datomic.clients :as d-clients]
+            [auto-ap.datomic.bank-accounts :as d-bank-accounts]
+            [auto-ap.db.invoices-checks :as invoices-checks]
             [auto-ap.db.vendors :as vendors]
             [auto-ap.db.invoices :as invoices]
+            [auto-ap.db.utils :refer [query]]
             [auto-ap.datomic :refer [uri]]
             [auto-ap.utils :refer [by]]
+            [auto-ap.numeric :refer [num->words]]
+            [config.core :refer [env]] 
             [auto-ap.db.companies :as companies]
-            [auto-ap.time :refer [parse normal-date iso-date]]))
+            [auto-ap.time :refer [parse normal-date iso-date local-now]]
+            [amazonica.aws.s3 :as s3]
+            [clojure.string :as str]
+            [clj-pdf.core :as pdf]
+            [clj-time.format :as f]
+            [clj-time.core :as time]
+            [clojure.java.io :as io])
+  (:import [java.text DecimalFormat]
+           [java.util UUID]
+           [java.io ByteArrayOutputStream])) 
+ 
 
+(def parser (f/formatter "MM/dd/YYYY"))
+(defn date->str [t] 
+  (f/unparse parser t))
+
+(defn distribute [nums]
+  (let [sum (reduce + 0 nums)]
+    (map #(* 100 (/ % sum)) nums)))
+
+(defn split-memo [memo]
+  (str/join "\n"
+            (reverse
+             (take 6
+                   (concat
+                    (reduce
+                     (fn [[line & rest ] word]
+                       (let [line (or line "")]
+                         (if (> (+ (count line) (count word)) 50)
+                           (concat [word line] rest)
+                           (concat [(str line " " word)]
+                                   rest))))
+                     []
+                     (str/split memo #" "))
+                    (repeat ""))))))
+
+(defn make-check-pdf [check]
+  (let [output-stream (ByteArrayOutputStream.)]
+    (pdf/pdf
+     [{:left-margin 25 :right-margin 0 :top-margin 0 :bottom-margin 0 :size :letter}
+      (let [{:keys [paid-to company check date amount memo] {print-as :print-as vendor-name :name :as vendor} :vendor} check
+            df (DecimalFormat. "#,###.00") 
+            word-amount (num->words amount)
+            
+            amount (str "--" (.format df  amount) "--")]
+            
+        [:table {:num-cols 12 :border false :leading 11 :widths (distribute [2 3 3 3 3 3 3 3 3 2 2 2])}
+         [(let [{:keys [name bank] {:keys [street1 street2 city state zip ]} :address} company]
+            [:cell {:colspan 3 } [:paragraph {:leading 14} name "\n" street1 "\n" (str city ", " state " " zip)] ])
+          (let [{{:keys [name acct]} :bank} company]
+            [:cell {:colspan 7 :align :center} [:paragraph {:style :bold} name] [:paragraph {:size 8 :leading 8} acct]])
+          [:cell {:colspan 2 :size 13}
+           check]]
+
+         [[:cell {:colspan 9}]
+          [:cell {:colspan 3 :leading -10} date]] 
+         [[:cell {:colspan 12 :size 14}]
+          ]
+
+         [[:cell {:size 13 :leading 13} "PAY"]
+          [:cell {:size 8 :leading 8 }  "TO THE ORDER OF"]
+          [:cell {:colspan 7} (if (seq print-as)
+                                print-as
+                                vendor-name)]
+          [:cell {:colspan 3} amount]]
+
+         [[:cell {}]
+          [:cell {:colspan 8}  (str " -- " word-amount " " (str/join "" (take (max
+                                                                           2
+                                                                           (- 97
+                                                                                  (count word-amount)))
+                                                                          (repeat "-"))))
+           [:line {:line-width 0.15 :color [50 50 50]}]]
+          [:cell {:colspan 3}]]
+
+         
+         [[:cell {:size 9 :leading 11.5} "\n\n\n\n\nMEMO"]
+          [:cell {:colspan 5 :leading 11.5} (split-memo memo) 
+           [:line {:line-width 0.15 :color [50 50 50]}]]
+          [:cell {:colspan 6  }  (if (:signature-file company)
+                                                        [:image { :top-margin 90 :xscale 0.30 :yscale 0.30 :align :center}
+
+                                                         (:signature-file company)]
+                                                        [:spacer])]]
+
+         #_[
+          #_[:cell {:colspan 5} #_memo ]
+          #_[:cell {:colspan 6}]]
+
+         [[:cell {:colspan 2}]
+          [:cell {:colspan 10 :leading 30}
+           [:phrase {:size 18 :ttf-name "public/micrenc.ttf"} (str "c" check "c a" (:routing (:bank company)) "a " (:acct-number (:bank company)) "c")]]]
+         
+         [[:cell {:colspan 12 :leading 18} [:spacer]]]
+         
+         [[:cell]
+          (into
+           [:cell {:colspan 9}]
+           (let [{:keys [name]
+                  {:keys [street1 city state zip bank]} :address} company]
+             (list
+              [:paragraph "  " name]
+              [:paragraph "  " street1]
+              [:paragraph "  " city ", " state " " zip]
+              )))
+          [:cell {:colspan 2 :size 13}
+           check]]
+
+         [[:cell {:colspan 12 :leading 74} [:spacer]]]
+
+         [[:cell]
+          [:cell {:colspan 5}  [:paragraph 
+                                "             " vendor-name "\n"
+                                "             " (:street1 (:address vendor)) "\n"
+                                "             " (:city (:address vendor)) ", " (:state (:address vendor)) " " (:zip (:address vendor))]]
+          [:cell {:align :right}
+           "Paid to:\n"
+           "Amount:\n"
+           "Date:\n"]
+
+          [:cell {:colspan 5}
+           [:paragraph paid-to]
+           [:paragraph amount]
+           [:paragraph date]]]
+
+         [[:cell {:colspan 3} "Memo:"]
+          [:cell {:colspan 9} memo]]
+
+         [[:cell {:colspan 12} [:spacer]]]
+         [[:cell {:colspan 12} [:spacer]]]
+         [[:cell {:colspan 12} [:spacer]]]
+         [[:cell {:colspan 12} [:spacer]]]
+
+         [[:cell {:colspan 5}] 
+          [:cell {:align :right :colspan 2}
+           "Check:\n"
+           "Vendor:\n"
+           "Bank Account:\n"
+           "Paid To:\n"
+           "Amount:\n"
+           "Date:\n"]
+
+          [:cell {:colspan 5}
+           [:paragraph check]
+           [:paragraph vendor-name]
+           [:paragraph (:name (:bank company))]
+           [:paragraph paid-to]
+           [:paragraph amount]
+           [:paragraph date]]]
+         [[:cell {:colspan 3} "Memo:"]
+          [:cell {:colspan 9} memo]]
+         ])]
+     output-stream)
+    (.toByteArray output-stream)))
+
+(defn make-pdfs [checks]
+  (loop [[check & checks] checks]
+    (when check
+      (s3/put-object :bucket-name (:data-bucket env)
+                     :key (:s3-key check)
+                     :input-stream (-> check
+                                       :pdf-data
+                                       make-check-pdf
+                                       (io/make-input-stream {}))
+                     :metadata {:content-type "application/pdf"})
+      (recur checks))))
+
+(defn merge-pdfs [keys]
+  (let [merged-pdf-stream (java.io.ByteArrayOutputStream.)
+        uuid (str (UUID/randomUUID))]
+    (apply pdf/collate (concat [{:size :letter} merged-pdf-stream] (->> keys
+                                                        (map #(s3/get-object (:data-bucket env) %))
+                                                        (map :input-stream))))
+    (s3/put-object :bucket-name (:data-bucket env)
+                   :key (str "merged-checks/" uuid ".pdf")
+                   :input-stream (io/make-input-stream (.toByteArray merged-pdf-stream) {})
+                   :metadata {:content-length (count (.toByteArray merged-pdf-stream))
+                              :content-type "application/pdf"})
+    (str "http://" (:data-bucket env) ".s3-website-us-east-1.amazonaws.com/merged-checks/" uuid ".pdf")))
+
+
+
+(defmulti check-for-invoices (fn [invoices vendor-id vendors company bank-account type index invoice-amounts]
+                               type))
+
+(defmethod check-for-invoices "check" [invoices vendor-id vendors company bank-account type index invoice-amounts]
+  (let [uuid (str (UUID/randomUUID))
+        vendor (vendors vendor-id)
+        
+
+        memo (str "Invoice #'s: "
+                  (str/join ", "
+                            (map (fn [i]
+                                   (str (:invoice/invoice-number i) "(" (invoice-amounts (:db/id i)) ")"))
+                                 invoices)))]
+    
+    {:payment/s3-uuid uuid
+     :payment/s3-key (str "checks/" uuid ".pdf") 
+     :payment/s3-url (str "http://" (:data-bucket env) ".s3-website-us-east-1.amazonaws.com/checks/" uuid ".pdf")
+     :payment/check-number (+ index (:bank-account/check-number bank-account))
+     :payment/type :payment-type/check
+     :payment/bank-account (:db/id bank-account)
+     :payment/amount (reduce + 0 (map (comp invoice-amounts :db/id) invoices))
+     :payment/memo  memo
+     :payment/vendor (:db/id vendor)
+     :payment/client (:db/id company)
+     :payment/date (time/now)
+     #_#_:payment/pdf-data {:vendor vendor
+                :paid-to (or (:vendor/paid-to vendor) (:vendor/name vendor))
+                :amount (reduce + 0 (map (comp invoice-amounts :db/id) invoices))
+                :check (str (+ index (:bank-account/check-number bank-account)))
+                :memo  memo
+                :date (date->str (local-now))
+                :company {:name (:name company)
+                          :address (:address company)
+                          :signature-file (:signature-file company)
+                          :bank {:name (:bank-account/bank-name bank-account)
+                                 :acct (:bank-account/bank-code bank-account)
+                                 :routing (:bank-account/routing bank-account)
+                                 :acct-number (:bank-account/number bank-account)}}}
+     
+     :payment/invoices (map :db/id invoices)}))
+
+(defmethod check-for-invoices "debit" [invoices vendor-id vendors company bank-account type index invoice-amounts]
+  (let [vendor (vendors vendor-id)]
+    {:type "debit"
+     :bank-account-id (:db/id bank-account)
+     :amount (reduce + 0 (map (comp invoice-amounts :db/id) invoices))
+     :status "cleared"
+     :memo  "Debit"
+     :vendor-id (:db/id vendor)
+     :client-id (:db/id company)
+     :date (time/now)
+     :invoices (map :db/id invoices)}))
+
+(defmethod check-for-invoices "cash" [invoices vendor-id vendors company bank-account type index invoice-amounts]
+  (let [vendor (vendors vendor-id)]
+    {:type "cash"
+     :bank-account-id (:db/id bank-account)
+     :amount (reduce + 0 (map (comp invoice-amounts :db/id) invoices))
+     :status "cleared"
+     :memo  "Cash"
+     :vendor-id (:db/id vendor)
+     :client-id (:db/id company)
+     :date (time/now)
+     :invoices (map :db/id invoices)}))
+
+(defn print-checks [invoice-payments client-id bank-account-id type]
+  
+  (let [client-id (Long/parseLong client-id)
+        bank-account-id (Long/parseLong bank-account-id)
+        invoices (d-invoices/get-multi (map :invoice-id invoice-payments))
+        client (d-clients/get-by-id client-id)
+        vendors (by :db/id (d-vendors/get-graphql {}))
+        invoice-amounts (by (comp #(Long/parseLong %) :invoice-id) :amount invoice-payments)
+        invoices-grouped-by-vendor (group-by (comp :db/id :invoice/vendor) invoices)
+        
+        bank-account (d-bank-accounts/get-by-id bank-account-id)
+        checks (-> (for [[[vendor-id invoices] index] (map vector invoices-grouped-by-vendor (range))]
+                     [invoices (check-for-invoices invoices vendor-id vendors client bank-account type index invoice-amounts)])
+                   doall)]
+
+    (clojure.pprint/pprint checks)
+    @(d/transact (d/connect uri) (map second checks))
+    
+    
+    {:invoices [] #_(invoices/get-multi (map :id (mapcat first checks)))
+     :pdf-url nil #_(if (= type "check")
+                      (merge-pdfs (map (comp :s3-key second) checks))
+                      nil)}))
 
 (defn get-payment-page [context args value]
   (let [args (assoc args :id (:id context))
@@ -55,7 +331,7 @@
   (let [check (d-checks/get-by-id id)]
     (assert (or (= :payment-status/pending (:payment/status check))
                 (#{:payment-type/cash :payment-type/debit} (:payment/type check))))
-    (assert-can-see-company (:id context) (:company-id check))
+    (assert-can-see-company (:id context) (:client-id check))
     (let [removing-payments (mapcat (fn [x]
                                       (let [invoice (:invoice-payment/invoice x)
                                             new-balance (+ (:invoice/outstanding-balance invoice)