/src/engulf/database.clj

(ns engulf.database
  (:require [engulf.formula :as forumla]
            [engulf.settings :as settings]
            [engulf.utils :as utils]
            [cheshire.core :as json]
            [clojure.java.jdbc :as jdbc]
            [clojure.walk :as walk])
  (:use korma.db korma.core)
  (:import java.util.UUID))

(defn connect
  "Connect to the db specified in settings"
  []
  (defdb db (assoc (:jdbc settings/all)
              :naming {:entity (partial jdbc/as-quoted-str \`)
                       :fields  #(.replace ^String % "-" "_")
                       :keyword #(.replace ^String % "-" "_") })))

(defn- dash-keys
  "Convert underscores in a record map's keys into dashes"
  [records]
   (letfn [(kdasherize [s] (keyword (.replaceAll (name s) "_" "-")))
           (fmt-kv [[k v]] [(kdasherize k) v])
           (remap [m] (into {} (map fmt-kv m)))]
     (if (map? records)
       (remap records)
       (map remap records)) ))

(defn- serialize-record-params
  [{:keys [params last-result] :as record}]
  (reduce
   (fn [m [k v]]
     (condp = k
       :params (assoc m k (json/generate-string v))
       :last-result (assoc m k (json/generate-string v))
       (assoc m k v)))
   {}
   record))

(defn- deserialize-record-params
  [records]
  (letfn [(deserialize [record]
            (-> record
                (update-in [:params] (comp walk/keywordize-keys json/parse-string))
                (update-in [:last-result] json/parse-string)))]
    (if (map? records)
      (deserialize records)
      (map deserialize records) )))

(defn- serialize-record-value
  [record]
  (update-in record [:value] json/generate-string))

(defn- deserialize-record-value
  [record]
  (update-in record [:value] json/parse-string))

(defentity results
  (pk :uuid)
  (prepare serialize-record-value)
  (transform (comp deserialize-record-value dash-keys)))

(defentity jobs
  (pk :uuid)
  (prepare serialize-record-params)
  (transform (comp deserialize-record-params dash-keys))
  (has-many results {:fk :job_uuid}))