165 lines
6.3 KiB
Clojure
165 lines
6.3 KiB
Clojure
(ns auto-ap.parse
|
|
(:require
|
|
[auto-ap.parse.csv :as csv]
|
|
[auto-ap.parse.excel :as excel]
|
|
[auto-ap.parse.templates :as t]
|
|
[auto-ap.parse.util :as u]
|
|
[clj-fuzzy.metrics :as m]
|
|
[clojure.java.shell :as sh]
|
|
[clojure.set :as set]
|
|
[clojure.string :as str]
|
|
[auto-ap.logging :as alog]))
|
|
|
|
(def last-text (atom nil))
|
|
|
|
|
|
(defn template-applies? [text {:keys [keywords]}]
|
|
(every? #(re-find % text) keywords))
|
|
|
|
(defn extract-template
|
|
([text template]
|
|
(alog/info ::template-determined
|
|
:template (str template))
|
|
|
|
(if (:multi template)
|
|
(mapcat
|
|
#(extract-template % text (dissoc template :multi))
|
|
(str/split text (:multi template)))
|
|
|
|
(extract-template text text template)))
|
|
([text full-text template]
|
|
(when (and template
|
|
(or (not (:multi-match? template))
|
|
(re-find (:multi-match? template) text )))
|
|
[(->> template
|
|
:extract
|
|
(reduce-kv
|
|
(fn [result k v]
|
|
(let [value (some-> (or (first (map second (re-seq v text)))
|
|
(first (map second (re-seq v full-text))))
|
|
str/trim )
|
|
[value-parser parser-params] (-> template :parser k)]
|
|
(assoc result k (try
|
|
(u/parse-value value-parser parser-params value)
|
|
(catch Exception e
|
|
(alog/warn ::cant-parse-value :error e :raw value))))))
|
|
{:vendor-code (:vendor template)
|
|
:text text
|
|
:full-text full-text}))])))
|
|
|
|
(defn parse [text]
|
|
(reset! last-text text)
|
|
(->> t/pdf-templates
|
|
(filter (partial template-applies? text))
|
|
first
|
|
(extract-template text)))
|
|
|
|
|
|
(defmulti parse-file (fn [_ filename] (.toLowerCase (last (str/split filename #"\." )))))
|
|
|
|
(defmethod parse-file
|
|
"pdf"
|
|
[file _]
|
|
(-> (sh/sh "pdftotext" "-layout" file "-")
|
|
:out
|
|
parse))
|
|
|
|
(defmethod parse-file
|
|
"csv"
|
|
[file filename]
|
|
(csv/parse-file file filename))
|
|
|
|
(defmethod parse-file
|
|
"xls"
|
|
[file filename]
|
|
(excel/parse-file file filename))
|
|
|
|
|
|
(defmethod parse-file
|
|
"xlsx"
|
|
[file filename]
|
|
(excel/parse-file file filename))
|
|
|
|
(defn best-match
|
|
([clients invoice-client-name]
|
|
(best-match clients invoice-client-name 0.25))
|
|
([clients invoice-client-name threshold]
|
|
(let [fuzzy-match (->> clients
|
|
(mapcat (fn [{:keys [:client/matches :client/name] :as client :or {matches []}}]
|
|
(map (fn [m]
|
|
(let [similarity-index (m/jaccard (.toLowerCase invoice-client-name) (.toLowerCase m))
|
|
similarity-index (cond
|
|
(and (= 0 similarity-index)
|
|
(= (.toLowerCase invoice-client-name) (.toLowerCase m)))
|
|
0
|
|
|
|
(= 0 similarity-index)
|
|
0.1
|
|
|
|
:else
|
|
similarity-index)]
|
|
[client similarity-index]))
|
|
(conj matches name))))
|
|
(filter #(<= (second %) threshold))
|
|
(sort-by second)
|
|
first)
|
|
|
|
word-set (set (filter (complement str/blank?) (str/split (.toLowerCase invoice-client-name) #"[\s:\-]" )))
|
|
client-word-match (->> clients
|
|
(map
|
|
(fn [{:keys [:client/matches :client/name] :as client :or {matches []}}]
|
|
(let [client-words (-> #{}
|
|
(into
|
|
(mapcat
|
|
(fn [match] (str/split (.toLowerCase match) #"\s" ))
|
|
matches))
|
|
(into
|
|
(str/split (.toLowerCase name) #"\s" )))]
|
|
[client (count (set/intersection client-words word-set))])))
|
|
(filter (fn [[_ c]] (> c 0)))
|
|
(sort-by (fn [[_ c]] c))
|
|
reverse
|
|
first)]
|
|
(or fuzzy-match client-word-match))))
|
|
|
|
(defn exact-match
|
|
([clients invoice-client-name]
|
|
(->> clients
|
|
(filter (fn [{:keys [:client/matches :client/location-matches :client/locations :client/name] :as client :or {matches []}}]
|
|
(seq
|
|
(filter (fn [m]
|
|
(and
|
|
m
|
|
invoice-client-name
|
|
(= (.toLowerCase invoice-client-name) (.toLowerCase m))))
|
|
(conj matches name)))))
|
|
first)))
|
|
|
|
(defn best-location-match [client text full-text]
|
|
(or (->> client
|
|
:client/location-matches
|
|
(mapcat (fn [{:keys [:location-match/location :location-match/matches]}]
|
|
|
|
(map (fn [match] [location match]) matches)))
|
|
(filter (fn [[_ match]]
|
|
(re-find (re-pattern (str "(?i)" match)) text)) )
|
|
first
|
|
first)
|
|
(->> client
|
|
:client/location-matches
|
|
(mapcat (fn [{:keys [:location-match/location :location-match/matches]}]
|
|
(map (fn [match] [location match]) matches)))
|
|
(filter (fn [[_ match]] (re-find (re-pattern (str "(?i)" match)) full-text)) )
|
|
first
|
|
first)
|
|
(:client/default-location client)
|
|
(first (:client/locations client))))
|
|
|
|
#_{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
|
|
(defn dbg-parse [v]
|
|
(println v)
|
|
(map
|
|
(fn [x] (dissoc x :full-text :text))
|
|
(parse v)))
|
|
|