phoenix_gen_api

defmodule PhoenixGenApi.Structs.Request do
  @moduledoc """
  Request struct for internal using, convert data map from websocket api.

  Data from websocket api has payload like this:

  ```Elixir
  %{
    "request_id" => "request_id",
    "request_type" => "request_type",
    "service" => "service",
    "user_id" => "user_id",
    "device_id" => "device_id",
    "args" => %{}
  }
  ```

  We need to convert it to struct for internal using.

  Like this:

  ```Elixir
  %PhoenixGenApi.Structs.Request{
    request_id: "request_id",
    request_type: "request_type",
    service: "service",
    user_id: "user_id",
    device_id: "device_id",
    args: %{}
  }
  ```

  Explain:
  - user_id: string, user's id in system.
    User's id in system. It need to check permission.

  - device_id: string, device id of current connection.
    Device id of current connection.

  - request_type: string, request type.
    Request type. Using for identify function to call in system.

  - request_id: string, unique id for request. Make by client.
    Unique id for request. Make by client. Using for identify response.

  - service: string, service name.
    Service name. Using for identify service to call in system.

  - args: map, field -> value, arguments for request.
    Arguments for request. Using for call function in system.
  """

  alias __MODULE__

  @typedoc "Request struct for internal using, convert data map from websocket api."

  @type t :: %__MODULE__{
          user_id: String.t() | nil,
          device_id: String.t() | nil,
          request_type: String.t(),
          request_id: String.t(),
          service: String.t(),
          args: map(),
          user_roles: [String.t()] | nil,
          version: String.t() | nil
        }

  @derive Nestru.Decoder
  defstruct [
    # user's id in system.
    :user_id,
    # device id of current connection.
    :device_id,
    # request type.
    :request_type,
    # unique id for request. Make by client.
    :request_id,
    # service name.
    :service,
    # field -> value, arguments for request.
    args: %{},
    # user roles for permission checking.
    user_roles: nil,
    # version of the API request.
    version: nil
  ]

  @doc """
  Create Request from params for convert data map from websocket api.
  """
  def decode!(params = %{}) do
    request = Nestru.decode!(params, Request)

    request = %{request | args: request.args || %{}}
    request = %{request | user_roles: validate_user_roles(request.user_roles)}

    request
  end

  defp validate_user_roles(nil), do: nil

  defp validate_user_roles(roles) when is_list(roles) do
    Enum.filter(roles, &is_binary/1) |> Enum.reject(&(byte_size(&1) == 0))
  end

  defp validate_user_roles(_), do: nil
end