element (clj)

(require '[clojure.data.xml :as xml])

(def xml-example (xml/element :root {} (xml/element :element {} "Some text here")))

(ns cmr.search.services.aql.converters.spatial
  "Handles converting AQL spatial conditions into spatial search conditions"
  (:require [clojure.data.xml :as x]
            [cmr.search.services.aql.conversion :as c]
            [cmr.common.xml :as cx]
            [cmr.spatial.point :as p]
            [cmr.spatial.ring-relations :as rr]
            [cmr.spatial.mbr :as m]
            [cmr.spatial.polygon :as poly]
            [cmr.spatial.line-string :as ls]
            [cmr.search.models.query :as qm]))

(defmulti spatial-element->shape
  "Converts a aql spatial area element into a spatial shape"
  (fn [elem]
    (:tag elem)))

(defmethod spatial-element->shape :IIMSPoint
  [element]
  (let [{{^String lat :lat ^String lon :long} :attrs} element]
    (p/point (Double. lon) (Double. lat))))

(defmethod spatial-element->shape :IIMSPolygon
  [element]
  (let [points (map spatial-element->shape
                    (cx/elements-at-path element [:IIMSLRing :IIMSPoint]))]
    (poly/polygon :geodetic [(rr/ring :geodetic points)])))

(defmethod spatial-element->shape :IIMSBox
  [element]
  (let [[lower-left
         upper-right] (map spatial-element->shape
                           (cx/elements-at-path element [:IIMSPoint]))]
    (m/mbr (:lon lower-left) (:lat upper-right) (:lon upper-right) (:lat lower-left))))

(defmethod spatial-element->shape :IIMSLine
  [element]
  (ls/line-string
    :geodetic (map spatial-element->shape
                   (cx/elements-at-path element [:IIMSPoint]))))

(defmethod c/element->condition :spatial
  [concept-type element]
  ;; TOOD TwoDCoordinateSystem could be a second child of spatial
  (qm/->SpatialCondition (spatial-element->shape (first (:content element)))))

(ns cmr.common.test.xml
  (:require [clojure.test :refer :all]
            [cmr.common.xml :as cx]
            [clojure.data.xml :as x]
            [clj-time.core :as t]))

(deftest element-at-path-test
  (are [xml path] (= (when xml (x/parse-str xml))
                     (cx/element-at-path parsed-sample-xml path))
       "<alpha>45</alpha>" [:inner :alpha]
       "<bravo>ovarb</bravo>" [:inner :bravo]
       nil [:foo]
       nil [:top :foo]
       nil [:foo :bar]))

(def sample-multiple-elements-xml
  "<top>
    <inner ia=\"1\" ib=\"foo\">
      <alpha>45</alpha>
      <alpha>46</alpha>
      <bravo>ovarb</bravo>
      <bravo>ovary</bravo>
      <single>single_value</single>
      <datetime>1986-10-14T04:03:27.456Z</datetime>
      <datetime>1988-10-14T04:03:27.456Z</datetime>
      <single_datetime>1989-10-14T04:03:27.456Z</single_datetime>
    </inner>
  </top>")

(def parsed-sample-multiple-elements-xml
  (x/parse-str sample-multiple-elements-xml))

(deftest elements-at-path-test
  (are [xml path] (= (:content (x/parse-str xml))
                     (cx/elements-at-path parsed-sample-multiple-elements-xml path))
       "<a><alpha>45</alpha><alpha>46</alpha></a>" [:inner :alpha]
       "<a><bravo>ovarb</bravo><bravo>ovary</bravo></a>" [:inner :bravo]
       "<a><single>single_value</single></a>" [:inner :single]))

(deftest contents-at-path-test
  (are [expected path] (= expected (cx/contents-at-path parsed-sample-multiple-elements-xml path))
       [["45"] ["46"]] [:inner :alpha]
       [["ovarb"] ["ovary"]] [:inner :bravo]
       [["single_value"]] [:inner :single]
       [] [:foo]))

(deftest strings-at-path-test
  (are [expected path] (= expected (cx/strings-at-path parsed-sample-multiple-elements-xml path))
       ["45" "46"] [:inner :alpha]
       ["ovarb" "ovary"] [:inner :bravo]
       ["single_value"] [:inner :single]
       [] [:foo]
       [] [:inner :foo]))

(deftest datetimes-at-path-test
  (are [expected path] (= expected (cx/datetimes-at-path parsed-sample-multiple-elements-xml path))
       [(t/date-time 1986 10 14 4 3 27 456) (t/date-time 1988 10 14 4 3 27 456)] [:inner :datetime]
       [(t/date-time 1989 10 14 4 3 27 456)] [:inner :single_datetime]
       [] [:foo]
       [] [:inner :foo]))

(ns clojure.data.xml.spec
  (:require [clojure.spec :as s]
            [#?(:cljs cljs.spec.impl.gen :clj clojure.spec.gen) :as gen]
            clojure.test.check.generators
            [clojure.data.xml :as xml]
            [clojure.data.xml.name :as name]
            [clojure.data.xml.name :as node]
            #?@(:cljs [[clojure.data.xml.js.dom :as dom]])
            [clojure.string :as str]))

#?(:cljs
   (do (s/def ::dom/Element (s/with-gen (partial instance? dom/Element)
                              #(gen/fmap dom/element-node (s/gen ::node/Element))))
       (s/def ::dom/Text (s/with-gen (partial instance? dom/Text)
                           #(gen/fmap dom/text-node (gen/string-ascii))))))