Basic OrientDB HTTP/REST backend to Phoenix web framework

orient_connector.ex

defmodule Phtest.OrientConnector do
  use Jazz
  @base_url "http://localhost:2480/"
  @database "Phtest"
  @user "admin"
  @password "admin"
  @basic_auth [basic_auth: {@user, @password}]

  def get(document_id, type) do
    OrientConnector.get_document(document_id)
      |> OrientConnector.from_map(type)
  end

  def insert(document) do
    OrientConnector.to_map(document)
      |> OrientConnector.post
  end
  
  def update(document, id) do
    OrientConnector.to_map(document)
    |> OrientConnector.put(id)
  end

  def delete(document) do
    OrientConnector.delete_document(document.id)
  end

  defp get_document(id) do
    url = @base_url <> "document/" <>
      @database <> "/#{convert_to_http_rid(id)}"
    IO.inspect url
    response = HTTPoison.get!(url, [], [hackney: @basic_auth])
    JSON.decode!(response.body)
  end
  

  def query(query_text, limit \\ nil) do
    # http://<server>:[<port>]/query/<database>/<language>/<query-text>[/<limit>][/<fetchPlan>]
    url = @base_url <> "query/" <> 
      @database <> "/sql/" <> 
      query_text <> (limit == nil && "" || "/#{limit}")
    
    response = HTTPoison.get!(url, [], [hackney: @basic_auth])
    {:ok, result} = JSON.decode(response.body)
    IO.inspect result["result"]
  end

  defp post(document) do
    IO.inspect document
    # http://<server>:[<port>]/document/<database>
    url = @base_url <> "document/" <>
      @database
    {:ok, json} = JSON.encode(document)
    IO.inspect url
    #IO.inspect json
    #IO.inspect 
    HTTPoison.post(url, json, [], [hackney: @basic_auth])
  end

  defp put(document, id) do
    # http://<server>:[<port>]/document/<database>[/<record-id>][?updateMode=full|partial]
    url = @base_url <> "document/" <>
      @database <> "/#{convert_to_http_rid(id)}"
    {:ok, json} = JSON.encode(document)
    IO.inspect url
    #IO.inspect 
    HTTPoison.put(url, json, [], [hackney: @basic_auth])
  end

  defp delete_document(id) do
    # http://<server>:[<port>]/document/<database>/<record-id>
    url = @base_url <> "document/" <>
      @database <> "/#{convert_to_http_rid id}"
    #IO.inspect
    HTTPoison.delete(url, [], [hackney: @basic_auth])
  end

  def from_map(document, type) do
    Enum.reduce(document, type, fn(tuple, t) ->
        {k,v} = convert_from_odb_field(tuple)
        Map.put(t, k, v)
      end)
  end

  def to_map(document) do
    Map.to_list(document)
    |> Enum.map(&(convert_to_odb_field(&1)))
    |> Enum.filter(fn({k, v}) ->
      k != :__struct__ end)
    |> Enum.reduce(%{}, fn({k,v}, map) ->
      Map.put(map, k, v) end)
  end

  defp convert_from_odb_field({"@class", value}) do
    convert_from_odb_field {"class", value}
  end
  defp convert_from_odb_field({"@version", value}) do
    convert_from_odb_field({"version", value})
  end

  defp convert_from_odb_field({"@rid", value}) do
    "#" <> rest = value
    convert_from_odb_field {"id", String.replace(rest, ":", "_")}
  end

  defp convert_from_odb_field({key, value}) do
    if is_atom(key) do
      {key, value}
    else
      { String.to_atom(key), value }
    end
  end

  defp convert_to_odb_field({:class, value}), do: {"@class", value}
  defp convert_to_odb_field({:version, value}), do: {"@version", value}
  defp convert_to_odb_field({:id, value}) do
    unless (String.strip(value) == "") do
      {"@rid", "#" <> String.replace(value, "_", ":")}
    else
      {"@rid", ""}
    end
  end
  defp convert_to_odb_field(tuple), do: tuple

  defp convert_to_http_rid(id) do
    id |> String.replace "_", ":"
  end

  defp convert_from_http_rid(id) do
    id |> String.replace ":", "_"
  end
end