remove cache directory and work on disbursements

Author: oryono

.gitignore

@@ -26,3 +26,6 @@ momoapi_elixir-*.tar
 
 momoapi_elixir.iml
 
+.elixir_ls
+
+config

config/config.exs

@@ -19,6 +19,19 @@ defmodule MomoapiElixir.Auth do
     end
   end
 
+  def authorise_disbursements(%{subscription_key: subscription_key} = config) do
+    basic_auth_token = create_basic_auth_token(config)
+    headers = [
+      {"Authorization", "Basic #{basic_auth_token}"},
+      {"Ocp-Apim-Subscription-Key", subscription_key}
+    ]
+    case post("/disbursement/token/", [], headers) do
+      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
+        %{"access_token" => access_token} = Poison.decode!(body)
+        access_token
+    end
+  end
+
   def create_basic_auth_token(%{user_id: user_id, api_key: api_key}) do
     Base.encode64("#{user_id}:#{api_key}")
   end

lib/momoapi_elixir/auth.ex

@@ -1,28 +1,25 @@
 defmodule MomoapiElixir.Collection do
-  use HTTPoison.Base
+  use GenServer
 
-  @base_url Application.get_env(:momoapi_elixir, :base_url) || "https://sandbox.momodeveloper.mtn.com"
-
-  @config %{
-    subscription_key: Application.get_env(:momoapi_elixir, :collections_subscription_key),
-    user_id: Application.get_env(:momoapi_elixir, :collections_user_id),
-    api_key: Application.get_env(:momoapi_elixir, :collections_api_key),
-    callback_url: Application.get_env(:momoapi_elixir, :collections_callback_url),
-    target_environment: Application.get_env(:momoapi_elixir, :target_environment)
-  }
-
-  def process_request_url(url) do
-    @base_url <> url
+  defmodule Option do
+    @enforce_keys ~w(subscription_key user_id api_key)a
+    defstruct subscription_key: nil, user_id: nil, api_key: nil, callback_url: nil, target_environment: "sandbox"
   end
 
-  def process_request_headers(headers) do
-    headers |> set_subscription_key(@config.subscription_key) |> set_target_environment(@config.target_environment || "sandbox")
+  defmodule Client do
+    use HTTPoison.Base
+    @base_url Application.get_env(:momoapi_elixir, :base_url) || "https://sandbox.momodeveloper.mtn.com"
+
+    def process_request_url(url) do
+      @base_url <> url
+    end
   end
 
-  def process_response_body(body) do
-    body |> Poison.decode!()
+  def start(%Option{} = opts) do
+    GenServer.start(__MODULE__, opts, name: __MODULE__)
   end
 
+  # Client
   @doc """
   This operation is used to request a payment from a consumer (Payer). The payer will be asked to authorize the payment.
   The transaction will be executed once the payer has authorized the payment. The requesttopay will be in status PENDING
@@ -35,73 +32,115 @@ defmodule MomoapiElixir.Collection do
     externalId: "123456",
     payer: %{
       partyIdType: "MSISDN",
-      partyId: "256784275529"
+      partyId: "46733123450"
     },
     payerMessage: "testing",
     payeeNote: "hello"
   }
 
   """
   def request_to_pay(body) do
-    token = MomoapiElixir.Auth.authorise_collections(@config)
-    headers = add_reference_id(reference_id()) |> add_token(token)
-    request_to_pay(headers, body)
-  end
-
-  defp request_to_pay(headers, body) do
-    case post("/collection/v1_0/requesttopay", Poison.encode!(body), headers) do
-      {:ok, %HTTPoison.Response{status_code: 202, body: _body}} -> reference_id
-    end
+    body = validate_collections(body)
+    GenServer.call(__MODULE__, {:request_to_pay, body})
   end
 
   @doc"""
   Get the balance of the account
   """
   def get_balance do
-    token = MomoapiElixir.Auth.authorise_collections(@config)
-    headers = add_reference_id(reference_id()) |> add_token(token)
-    get_balance(headers)
-  end
-
-  defp get_balance(headers) do
-    case get("/collection/v1_0/account/balance", headers) do
-      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> body
-    end
+    GenServer.call(__MODULE__, :get_balance)
   end
 
-
   @doc """
   This method is used to retrieve transaction information. You can invoke it at intervals until your transaction fails or succeeds
   """
   def get_transaction_status(reference_id) do
-    token = MomoapiElixir.Auth.authorise_collections(@config)
-    headers = add_reference_id(reference_id()) |> add_token(token)
-    get_transaction_status(headers, reference_id)
+    GenServer.call(__MODULE__, {:get_transaction_status, reference_id})
+  end
+
+  # Callbacks
+  def init(%Option{subscription_key: subscription_key, user_id: user_id, api_key: api_key}) do
+    token = MomoapiElixir.Auth.authorise_collections(
+      %{subscription_key: subscription_key, user_id: user_id, api_key: api_key}
+    )
+    {:ok, %{subscription_key: subscription_key, token: token}}
+  end
+
+  def handle_call({:request_to_pay, body}, _from, state) do
+    reference_id = reference_id()
+    body_encoded = Poison.encode!(body)
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Reference-Id", reference_id},
+      {"X-Target-Environment", "sandbox"}
+    ]
+    case Client.post("/collection/v1_0/requesttopay", body_encoded, headers) do
+      {:ok, %HTTPoison.Response{status_code: 202, body: _body}} -> {:reply, reference_id, state}
+      {:ok, %HTTPoison.Response{status_code: 500, body: body}} -> {:reply, {:error, %{code: 500, body: Poison.decode!(body)}}, state}
+      {:ok, %HTTPoison.Response{status_code: 500, body: ""}} -> {:reply, {:error, %{code: 500, body: ""}}, state }
+      {:ok, %HTTPoison.Response{status_code: 400, body: ""}} -> {:reply, {:error, %{code: 400, body: ""}}, state}
+      {:ok, %HTTPoison.Response{status_code: 400, body: body}} -> {:reply, {:error, %{code: 400, body: Poison.decode!(body)}}, state}
+    end
   end
 
-  def get_transaction_status(headers, reference_id) do
-    case get("/collection/v1_0/requesttopay/#{reference_id}", headers) do
-      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> body
+  def handle_call(:get_balance, _from, state) do
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Target-Environment", "sandbox"}
+    ]
+    case Client.get("/collection/v1_0/account/balance", headers) do
+      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> {:reply, Poison.decode!(body), state}
+      {:ok, %HTTPoison.Response{body: body, status_code: 404}} -> {:reply, {:error, Poison.decode!(body)}, state}
+      {:ok, %HTTPoison.Response{body: body, status_code: 500}} -> {:reply, {:error, Poison.decode!(body)}, state}
     end
   end
 
+  def handle_call({:get_transaction_status, reference_id}, _from, state) do
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Target-Environment", "sandbox"},
+      {"X-Reference-Id", reference_id},
+    ]
+    case Client.get("/collection/v1_0/requesttopay/#{reference_id}", headers) do
+      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> {:reply, Poison.decode!(body), state}
+    end
+
+  end
+
   defp reference_id do
     UUID.uuid4()
   end
 
-  defp set_subscription_key(headers \\ [], subscription_key) do
-    [{"Ocp-Apim-Subscription-Key", subscription_key} | headers]
+  defp validate_collections(
+        %{
+          amount: amount
+        }
+      ) when is_nil(amount) or amount == "" do
+    raise "Amount is required"
   end
 
-  defp set_target_environment(headers \\ [], target_environment) do
-    [{"X-Target-Environment", target_environment} | headers]
+  defp validate_collections(
+        %{
+          currency: currency
+        }
+      ) when is_nil(currency) or currency == "" do
+    raise "Currency is required"
   end
 
-  defp add_reference_id(headers \\ [], reference_id) do
-    [{"X-Reference-Id", reference_id} | headers]
+  defp validate_collections(
+        %{
+          payer: %{
+            partyId: party_id
+          },
+        }
+      ) when is_nil(party_id) or party_id == "" do
+    raise "Party id is required"
   end
 
-  defp add_token(headers \\ [], token) do
-    [{"Authorization", "Bearer #{token}"} | headers]
+  defp validate_collections(body) do
+    body
   end
 end

lib/momoapi_elixir/collection.ex

@@ -1,13 +1,139 @@
 defmodule MomoapiElixir.Disbursement do
-  def transfer do
-    #
+  use GenServer
+
+  defmodule Option do
+    @enforce_keys ~w(subscription_key user_id api_key)a
+    defstruct subscription_key: nil, user_id: nil, api_key: nil, callback_url: nil, target_environment: "sandbox"
+  end
+
+  defmodule Client do
+    use HTTPoison.Base
+    @base_url Application.get_env(:momoapi_elixir, :base_url) || "https://sandbox.momodeveloper.mtn.com"
+
+    def process_request_url(url) do
+      @base_url <> url
+    end
+  end
+
+  def start(%Option{} = opts) do
+    GenServer.start(__MODULE__, opts, name: __MODULE__)
+  end
+
+  @doc """
+  %{
+      amount: "100",
+      currency: "EUR",
+      externalId: "947354",
+      payee: %{
+        partyIdType: "MSISDN",
+        partyId: "+256776564739"
+      },
+      payerMessage: "testing",
+      payeeNote: "hello"
+  }
+  """
+
+  def transfer(body) do
+    body = validate_disbursements(body)
+    GenServer.call(__MODULE__, {:transfer, body})
   end
 
-  def get_balance(headers) do
-    #
+  def get_balance do
+    GenServer.call(__MODULE__, :get_balance)
   end
 
   def get_transaction_status(reference_id) do
-    #
+    GenServer.call(__MODULE__, {:get_transaction_status, reference_id})
+  end
+
+  # Callbacks
+  def init(%Option{subscription_key: subscription_key, user_id: user_id, api_key: api_key}) do
+    token = MomoapiElixir.Auth.authorise_disbursements(
+      %{subscription_key: subscription_key, user_id: user_id, api_key: api_key}
+    )
+    {:ok, %{subscription_key: subscription_key, token: token}}
+  end
+
+  def handle_call({:transfer, body}, _from, state) do
+    reference_id = reference_id()
+    body_encoded = Poison.encode!(body)
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Reference-Id", reference_id},
+      {"X-Target-Environment", "sandbox"}
+    ]
+    case Client.post("/disbursement/v1_0/transfer", body_encoded, headers) do
+      {:ok, %HTTPoison.Response{status_code: 202, body: _body}} ->
+        {:reply, reference_id, state}
+      {:ok, %HTTPoison.Response{status_code: 500, body: body}} ->
+        {:reply, {:error, %{code: 500, body: Poison.decode!(body)}}, state}
+      {:ok, %HTTPoison.Response{status_code: 500, body: ""}} ->
+        {:reply, {:error, %{code: 500, body: ""}}, state}
+      {:ok, %HTTPoison.Response{status_code: 400, body: ""}} ->
+        {:reply, {:error, %{code: 400, body: ""}}, state}
+      {:ok, %HTTPoison.Response{status_code: 400, body: body}} ->
+        {:reply, {:error, %{code: 400, body: Poison.decode!(body)}}, state}
+    end
+  end
+
+  def handle_call(:get_balance, _from, state) do
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Target-Environment", "sandbox"}
+    ]
+    case Client.get("/disbursement/v1_0/account/balance", headers) do
+      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> {:reply, Poison.decode!(body), state}
+      {:ok, %HTTPoison.Response{body: body, status_code: 404}} -> {:reply, {:error, Poison.decode!(body)}, state}
+      {:ok, %HTTPoison.Response{body: body, status_code: 500}} -> {:reply, {:error, Poison.decode!(body)}, state}
+      {:ok, %HTTPoison.Response{body: body, status_code: 503}} -> {:reply, {:error, Poison.decode!(body)}, state}
+    end
+  end
+
+  def handle_call({:get_transaction_status, reference_id}, _from, state) do
+    headers = [
+      {"Authorization", "Bearer #{state.token}"},
+      {"Ocp-Apim-Subscription-Key", state.subscription_key},
+      {"X-Target-Environment", "sandbox"},
+      {"X-Reference-Id", reference_id},
+    ]
+    case Client.get("/disbursement/v1_0/transfer/#{reference_id}", headers) do
+      {:ok, %HTTPoison.Response{body: body, status_code: 200}} -> {:reply, Poison.decode!(body), state}
+    end
+  end
+
+  defp reference_id do
+    UUID.uuid4()
+  end
+
+  defp validate_disbursements(
+         %{
+           amount: amount
+         }
+       ) when is_nil(amount) or amount == "" do
+    raise "Amount is required"
+  end
+
+  defp validate_disbursements(
+         %{
+           currency: currency
+         }
+       ) when is_nil(currency) or currency == "" do
+    raise "Currency is required"
+  end
+
+  defp validate_disbursements(
+         %{
+           payer: %{
+             partyId: party_id
+           },
+         }
+       ) when is_nil(party_id) or party_id == "" do
+    raise "Party id is required"
+  end
+
+  defp validate_disbursements(body) do
+    body
   end
 end

lib/momoapi_elixir/disbursement.ex

@@ -1,7 +1,6 @@
 defmodule Mix.Tasks.Provision do
   use Mix.Task
 
-#  @reference_id UUID.uuid4()
   @base_url "https://sandbox.momodeveloper.mtn.com"
 
   @shortdoc "Creates the user id and user api key."