odoo.ex

defmodule Odoo do
  @moduledoc """
  Library to access Odoo JSON-RPC API from Elixir.

  Provides the following methods for interacting with Odoo:

  - login
  - search
  - search_read
  - read
  - read_group
  - create
  - write
  - delete
  - execute

  """

  @doc """

  - Login in Odoo and set session_id for future calls

  ### Params (required)
  - user: string  Odoo user
  - password: string  Odoo password
  - database: string  Odoo database
  - url: string  Odoo url, http or https

  ### Example

  ```
  iex> {:ok, odoo} = Odoo.login(
    "admin", "admin", "mydatabasename", "https://mydatabasename.odoo.com")
  {:ok,
  %Odoo.Session{
    cookie: "session_id=c8e544d0b305920adgsfdfdsa7b0cfe; Expires=Fri, 06-May-2022 23:16:12 GMT; Max-Age=7776000; HttpOnly; Path=/",
    database: "mydatabasename",
    password: "admin",
    url: "https://mydatabasename.odoo.com",
    user: "admin",
    user_context: %{"lang" => "en_US", "tz" => "Asia/Calcutta", "uid" => 2}
  }}

  ```
  """
  @spec login(String.t(), String.t(), String.t(), String.t()) ::
          {:ok, %Odoo.Session{}} | {:error, String.t()}
  def login(user, password, database, url) do
    case check_params(user, password, database, url) do
      {:ok, _} ->
        Odoo.Core.login(user, password, database, url)

      {:error, message} ->
        {:error, message}
    end
  end

  @doc """

  ### Example

  - Search and read with default options (limit, domain, fields, offset and order)

  ```{:ok, res} = Odoo.search_read(odoo, "res.partner")```

  - Put options to tune the query:

  ```elixir
  {:ok, partners} = Odoo.search_read(
    odoo,
    "res.partner",
    [
      limit: 1,
      domain: [["name", "ilike", "Antonio"]],
      fields: ["name", "street"],
      offset: 11,
      order: "name asc"])

  {:ok,
  [
    %{
      "id" => 226,
      "name" => "Antonio Fulanito de tal",
      "street" => "Calle principal 1"
    }
    ]}
    ```

    - Search and read active and archived records (by default odoo only return active records)

    ```elixir
    {:ok, partners} = Odoo.search_read(
      odoo,
      "res.partner", [
        fields: ["name"],
        offset: 0,
            limit: 10,
            order: "id",
            domain: [["active", "in", [true,false]]]
          ]
          )
          ```

  """
  @type option ::
          {:limit, non_neg_integer()}
          | {:offset, non_neg_integer()}
          | {:order, String.t()}
          | {:fields, [String.t(), ...]}
          | {:domain, [list(), ...]}
  @spec search_read(%Odoo.Session{}, String.t(), [option]) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def search_read(odoo = %Odoo.Session{}, model, opts \\ []) do
    Odoo.Core.search_read(odoo, model, opts)
  end

  @doc """
  - Search by domain. Return single id or id list.

  ### Params

  - Arguments in keyword list format.

  - Required opts:
  - domain: list of list

  - Optional arguments
  - limit: int, max number of rows to return from odoo
  - offset: int, offset over the default values to return

  ### Example
  ```elixir
  iex>  {:ok, partner_ids} = Odoo.search(
  odoo, "res.partner",
  [ domain:
      [
        ["name", "ilike", "Antonia%"],
        ["customer", "=", true],
        ["create_date",">=","2021-06-01"]
      ],
      limit: 5,
      offset: 10,
      order: "name"
  ])
  {:ok,
    %Odoo.Result{
      data: '[44]',
      model: "res.partner",
      opts: [domain: [["name", "ilike", "Lorraine%"], ["customer", "=", true],
        ["create_date",">=","2021-06-01"]]]
    }}

  ```

  - Return one value is a single integer for the id
  - Return more than one value is a list of integers
  - Can also return {:error, message} if the operation fails.
  """
  @type option_valid_for_search ::
          {:limit, non_neg_integer()}
          | {:offset, non_neg_integer()}
          | {:order, String.t()}
          | {:domain, [list(), ...]}
  @spec search(%Odoo.Session{}, String.t(), [option_valid_for_search]) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def search(odoo = %Odoo.Session{}, model, opts \\ []) do
    Odoo.Core.search(odoo, model, opts)
  end

  @doc """
  - Create objects
  - Return {:ok, new_object_id} or {:error, message}

  ## Example

        iex> {:ok, product_id} = Odoo.create(
          odoo, "product.product", [name: "mi mega producto3"])
      {:ok, 63}

  """
  @type odoo_fields :: keyword()
  @spec create(%Odoo.Session{}, String.t(), [odoo_fields]) ::
          {:ok, integer()} | {:error, String.t()}
  def create(odoo = %Odoo.Session{}, model, opts \\ []) do
    Odoo.Core.create(odoo, model, opts)
  end

  @doc """
  - Read objects by id
  - Return {:ok, objects_list} or {:error, message}

  ### Example

  ```elixir
  iex> {:ok, product} = Odoo.read(
  odoo, "product.product", [63], [fields: ["name", "categ_id"]])

  {:ok,
  %Odoo.Result{
    data: [
      %{"id" => 63, "name" => "mi mega producto3", "categ_id" => [1, "All"]}
    ],
    model: "product.product",
    opts: [fields: ["name", "categ_id"]]
  }}

  ```
  """
  @type option_valid_for_read :: {:fields, [String.t(), ...]}
  @spec read(%Odoo.Session{}, String.t(), [non_neg_integer(), ...], [option_valid_for_read]) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def read(odoo = %Odoo.Session{}, model, object_id, opts \\ []) do
    Odoo.Core.read(odoo, model, object_id, opts)
  end

  @doc """
    - Read and group objects

    ### Params

    - :fields
    - :domain
    - :groupby
    - :lazy
    - :orderby
    - :offset

  ### Example

  ```elixir
  iex> {:ok, result} = Odoo.read_group(
  odoo, "account.invoice", [
    domain: [["date_invoice", ">=", "2021-11-01"]],
    groupby: ["date_invoice:month"],
    fields: ["number", "partner_id"],
    limit: 2,
    lazy: true])

    {:ok,
     %Odoo.Result{
      data: [
    %{
      "__domain" => [
     "&",
     "&",
     ["date_invoice", ">=", "2022-01-01"],
     ["date_invoice", "<", "2022-02-01"],
     ["date_invoice", ">=", "2021-11-01"]
     ],
     "date_invoice:month" => "enero 2022",
     "date_invoice_count" => 61
     },
     %{
       "__domain" => [
         "&",
         "&",
         ["date_invoice", ">=", "2022-02-01"],
         ["date_invoice", "<", "2022-03-01"],
         ["date_invoice", ">=", "2021-11-01"]
         ],
      "date_invoice:month" => "febrero 2022",
      "date_invoice_count" => 32
    }
    ]}}

  ```

  """
  @type option_valid_for_read_group ::
          {:domain, [list(), ...]}
          | {:fields, [String.t(), ...]}
          | {:groupby, [String.t(), ...]}
          | {:limit, non_neg_integer()}
          | {:lazy, bool()}
  @spec read_group(%Odoo.Session{}, String.t(), [option_valid_for_read]) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def read_group(odoo = %Odoo.Session{}, model, opts \\ []) do
    Odoo.Core.read_group(odoo, model, opts)
  end

  @doc """
  - Update objects by id

  ### Example

  ```elixir
  iex> {:ok, result}=Odoo.write odoo, "product.product", [63], [name: "Mega Pro 3"]
  {:ok,
  %Odoo.Result{
   data: true,
   model: "product.product",
   opts: [name: "Mega Pro 3"]
  }}

  Example adding a many2many value to an odoo object:

  category_to_link_id = 9
  {:ok, result} = Odoo.write(
      odoo,
      "res.partner",
      partner_ids,
      [category_id: [[4, category_to_link_id]] ])
  ```
  """
  @spec write(%Odoo.Session{}, String.t(), list(non_neg_integer()), keyword()) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def write(odoo = %Odoo.Session{}, model, object_id, fields \\ []) do
    Odoo.Core.write(odoo, model, object_id, fields)
  end

  @doc """
    - Delete objects by id

    ### Example

    ```elixir
  iex(10)> {:ok, result} = Odoo.delete odoo, "product.template", [116]
  {:ok, %Odoo.Result{data: true, model: "product.template", opts: 't'}}
      ```

  """
  def delete(odoo = %Odoo.Session{}, model, object_id) do
    Odoo.Core.delete(odoo, model, object_id)
  end

  @doc """
  Pagination over results in search_read (call to api odoo)

  ### Example

  ```elixir
  iex> {:ok, result} = Odoo.search_read(
    ...>      odoo, "product.product", limit: 5, fields: ["name"], order: "id asc")
    {:ok,
    %Odoo.Result{
      data: [
      %{"id" => 1, "name" => "Restaurant Expenses"},
      %{"id" => 2, "name" => "Hotel Accommodation"},
      %{"id" => 3, "name" => "Virtual Interior Design"},
      %{"id" => 4, "name" => "Virtual Home Staging"},
      %{"id" => 5, "name" => "Office Chair"}
      ],
      model: "product.product",
      opts: [limit: 5, fields: ["name"], order: "id asc"]
  }}
  iex> {:ok, result2} = Odoo.next(odoo, result)
  {:ok,
  %Odoo.Result{
    data: [
      %{"id" => 6, "name" => "Office Lamp"},
      %{"id" => 7, "name" => "Office Design Software"},
      %{"id" => 8, "name" => "Desk Combination"},
      %{"id" => 9, "name" => "Customizable Desk"},
      %{"id" => 10, "name" => "Customizable Desk"}
      ],
      model: "product.product",
    opts: [offset: 5, limit: 5, fields: ["name"], order: "id asc"]
  }}

  ```
  """
  def next(odoo = %Odoo.Session{}, result) do
    new_opts = Odoo.Result.next(result.opts)
    Odoo.search_read(odoo, result.model, new_opts)
  end

  @doc """

  Get previous page results (call to api odoo)

  ### Example

  ```elixir
  iex> {:ok, odoo} = Odoo.login(
  ...>    "admin", "admin", "mydatabasename", "https://mydatabasename.odoo.com")
  {:ok,
  %Odoo.Session{
  cookie: "session_id=c8e544d0b305920afgdgsfdfdsa7b0cfe; Expires=Fri, 06-May-2022 23:16:12 GMT; Max-Age=7776000; HttpOnly; Path=/",
  database: "mydatabasename",
  password: "admin",
  url: "https://mydatabasename.odoo.com",
  user: "admin",
  user_context: %{"lang" => "en_US", "tz" => "Asia/Calcutta", "uid" => 2}
  }}
  iex> {:ok, result} = Odoo.search_read(
  ...>      odoo, "product.product", limit: 5, fields: ["name"], order: "id asc")
  {:ok,
  %Odoo.Result{
  data: [
  %{"id" => 1, "name" => "Restaurant Expenses"},
  %{"id" => 2, "name" => "Hotel Accommodation"},
  %{"id" => 3, "name" => "Virtual Interior Design"},
  %{"id" => 4, "name" => "Virtual Home Staging"},
  %{"id" => 5, "name" => "Office Chair"}
  ],
  model: "product.product",
  opts: [limit: 5, fields: ["name"], order: "id asc"]
  }}
  iex> {:ok, result2} = Odoo.next(odoo, result)
  {:ok,
  %Odoo.Result{
  data: [
  %{"id" => 6, "name" => "Office Lamp"},
  %{"id" => 7, "name" => "Office Design Software"},
  %{"id" => 8, "name" => "Desk Combination"},
  %{"id" => 12, "name" => "Customizable Desk"},
  %{"id" => 13, "name" => "Customizable Desk"}
  ],
  model: "product.product",
  opts: [offset: 5, limit: 5, fields: ["name"], order: "id asc"]
  }}
  iex> {:ok, result3} = Odoo.prev(odoo, result2)
  {:ok,
  %Odoo.Result{
  data: [
  %{"id" => 1, "name" => "Restaurant Expenses"},
  %{"id" => 2, "name" => "Hotel Accommodation"},
  %{"id" => 3, "name" => "Virtual Interior Design"},
  %{"id" => 4, "name" => "Virtual Home Staging"},
  %{"id" => 5, "name" => "Office Chair"}
  ],
  model: "product.product",
  opts: [offset: 0, limit: 5, fields: ["name"], order: "id asc"]
  }}
  ```

  """
  def prev(odoo = %Odoo.Session{}, result) do
    new_opts = Odoo.Result.prev(result.opts)
    Odoo.search_read(odoo, result.model, new_opts)
  end

  @doc """

  Execute a method on a model (call to api odoo).

  * Confirm a sale order with id 3
  iex> {:ok, res2} = Odoo.execute(odoo, "sale.order", "action_confirm", [3])
  {:ok, %Odoo.Result{data: true, model: "sale.order", opts: [3]}}

  """
  @spec execute(Odoo.Session.t(), String.t(), String.t(), list(non_neg_integer())) ::
          {:ok, %Odoo.Result{}} | {:error, String.t()}
  def execute(odoo = %Odoo.Session{}, model, method, args) do
    Odoo.Core.execute(odoo, model, method, args)
  end

  defp check_params(user, password, database, url) do
    cond do
      is_nil(user) or String.length(user) == 0 ->
        {:error, "User is required"}

      is_nil(password) || String.length(password) == 0 ->
        {:error, "Password is required"}

      is_nil(database) || String.length(database) == 0 ->
        {:error, "Database is required"}

      is_nil(url) || String.length(url) == 0 ->
        {:error, "Url is required"}

      true ->
        {:ok, "ok"}
    end
  end
end