update BankAccount open and close tests

Author: Marcelo Amancio de Lima Santos

lib/universe/bank/action/bank.ex

@@ -105,25 +105,26 @@ defmodule Helix.Universe.Bank.Action.Bank do
     to: BankTransferInternal,
     as: :abort
 
-  @spec open_account(Account.idt, ATM.id) ::
+  @spec open_account(Account.id, ATM.id) ::
     {:ok, BankAccount.t, [BankAccountUpdatedEvent.t]}
-    | {:error, Ecto.Changeset.t}
+    | {:error, :internal}
   @doc """
   Opens a bank account.
   """
-  def open_account(owner, atm) do
-    bank =
-      atm
+  def open_account(owner, atm_id) do
+    bank_id =
+      atm_id
       |> EntityQuery.fetch_by_server()
       |> Map.get(:entity_id)
       |> NPCQuery.fetch()
+      |> Map.get(:npc_id)
 
-    case BankAccountInternal.create(owner, atm, bank) do
+    case BankAccountInternal.create(owner, atm_id, bank_id) do
       {:ok, bank_acc} ->
         {:ok, bank_acc, [BankAccountUpdatedEvent.new(bank_acc, :created)]}
 
-      error ->
-        error
+      {:error, _} ->
+        {:error, :internal}
     end
   end
 
@@ -225,12 +226,12 @@ defmodule Helix.Universe.Bank.Action.Bank do
     end
   end
 
-  @spec change_password(BankAccount.t, Entity.id) ::
+  @spec change_password(BankAccount.t) ::
   {:ok, BankAccount.t, [BankAccountPasswordChangedEvent.t]}
    | {:error, :internal}
-   def change_password(account, changed_by) do
+   def change_password(account) do
      with {:ok, account} <- update_password(account) do
-       event = BankAccountPasswordChangedEvent.new(account, changed_by)
+       event = BankAccountPasswordChangedEvent.new(account)
 
        {:ok, account, [event]}
      else

lib/universe/bank/action/flow/bank_account.ex

@@ -3,6 +3,7 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
   import HELF.Flow
 
   alias Helix.Event
+  alias Helix.Entity.Model.Entity
   alias Helix.Entity.Query.Entity, as: EntityQuery
   alias Helix.Network.Action.Flow.Tunnel, as: TunnelFlow
   alias Helix.Network.Query.Network, as: NetworkQuery
@@ -15,6 +16,8 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
 
   alias Helix.Universe.Bank.Process.Bank.Account.AccountCreate,
     as: BankAccountCreateProcess
+  alias Helix.Universe.Bank.Process.Bank.Account.AccountClose,
+    as: BankAccountCloseProcess
   alias Helix.Universe.Bank.Process.Bank.Account.RevealPassword,
     as: BankAccountRevealPasswordProcess
   alias Helix.Universe.Bank.Process.Bank.Account.ChangePassword,
@@ -62,29 +65,36 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
   Starts the `bank_account_create` process.
   """
   def open(gateway, account_id, atm, relay) do
-    entity_id = Entity.ID.cast!(to_string(account_id.id))
+    entity_id = Entity.ID.cast!(to_string(account_id))
+    atm_id = atm.server_id
 
     meta = %{
-      src_atm_id: atm.server_id,
+      network_id: NetworkQuery.internet().network_id,
+      bounce: nil,
       source_entity_id: entity_id
     }
 
-    BankAccountCreateProcess.execute(gateway, atm, %{}, meta, relay)
+    BankAccountCreateProcess.execute(gateway, atm, %{atm_id: atm_id}, meta, relay)
   end
 
-  @spec close(BankAccount.t) ::
+  @spec close(Server.t, BankAccount.t, Server.t, relay) ::
   {:ok, Process.t}
   | BankAccountCloseProcess.executable_error
   @doc """
   Starts the `bank_account_close` process.
   """
   def close(gateway, bank_account, atm, relay) do
     meta = %{
-      src_atm_id: bank_account.server_id,
-      src_account_number: bank_account.account_number
+      network_id: NetworkQuery.internet().network_id,
+      bounce: nil
+    }
+
+    params = %{
+      atm_id: bank_account.atm_id,
+      account_number: bank_account.account_number
     }
 
-    BankAccountCloseProcess.execute(gateway, atm, %{}, meta, relay)
+    BankAccountCloseProcess.execute(gateway, atm, params, meta, relay)
   end
 
   @spec change_password(BankAccount.t, Server.t, Server.t, relay) ::

lib/universe/bank/event/account_close.ex

@@ -17,20 +17,21 @@ defmodule Helix.Universe.Bank.Event.AccountClose do
 
     event_struct [:atm_id, :account_number]
 
-    @spec new(ATM.id, BankAccount.account) :: t
-
-    def new(atm_id, account_number) do
+    @spec new(Process.t, AccountCloseProcess.t) :: t
+    def new(process = %Process{}, data = %AccountCloseProcess{}) do
       %__MODULE__{
-        atm_id: atm_id,
-        account_number: account_number
+        atm_id: data.atm_id,
+        account_number: data.account_number
       }
     end
 
-    @spec new(Process.t, AccountCloseProcess.t) :: t
-    def new(process = %Process{}, data = %AccountCloseProcess{}) do
+    @spec new(ATM.id, BankAccount.account):: t
+
+    def new(atm_id, account_number) do
       %__MODULE__{
-        atm_id: process.src_atm_id,
-        account_number: process.src_acc_number
+        atm_id: atm_id,
+        account_number: account_number
       }
     end
   end
+end

lib/universe/bank/event/account_create.ex

@@ -32,8 +32,9 @@ defmodule Helix.Universe.Bank.Event.AccountCreate do
     @spec new(Process.t, AccountCreateProcess.t) :: t
     def new(process = %Process{}, data = %AccountCreateProcess{}) do
       %__MODULE__{
-        atm_id: process.src_atm_id,
+        atm_id: process.data.atm_id,
         requester: process.source_entity_id
       }
     end
   end
+end

lib/universe/bank/event/bank/account.ex

@@ -1,4 +1,4 @@
-defmodule Helix.Universe.Bank.Event.Bank.Account do
+  defmodule Helix.Universe.Bank.Event.Bank.Account do
 
   import Helix.Event
 

lib/universe/bank/event/bank/account/password.ex

@@ -22,27 +22,61 @@ defmodule Helix.Universe.Bank.Event.Bank.Account.Password do
         account: account
       }
     end
+
+    notify do
+
+      @event :bank_password_revealed
+
+      @doc false
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: event.account.atm_id,
+            account_number: event.account.account_number,
+            password: event.account.password
+          }
+      end
+
+      def whom_to_notify(event),
+        do: %{account: event.entity_id}
+    end
   end
 
   event Changed do
 
-   alias Helix.Entity.Model.Entity
-   alias Helix.Universe.Bank.Model.BankAccount
+    alias Helix.Entity.Model.Entity
+    alias Helix.Universe.Bank.Model.BankAccount
 
-   @type t :: %__MODULE__{
-     entity_id: Entity.id,
-     account: BankAccount.t
-   }
+    @type t :: %__MODULE__{
+      account: BankAccount.t
+    }
 
-   event_struct [:entity_id, :account]
+    event_struct [:account]
 
-   @spec new(BankAccount.t, Entity.id) ::
-   t
-   def new(account = %BankAccount{}, entity_id) do
-     %__MODULE__{
-       entity_id: entity_id,
-       account: account
-     }
-   end
+    @spec new(BankAccount.t) ::
+    t
+    def new(account = %BankAccount{}) do
+      %__MODULE__{
+        account: account
+      }
+    end
+
+    notify do
+
+      @event :bank_password_changed
+
+      @doc false
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: event.account.atm_id,
+            account_number: event.account.account_number,
+            password: event.account.password
+          }
+      end
+
+      def whom_to_notify(event),
+        do: %{account: event.account.owner_id}
+    end
   end
 end

lib/universe/bank/event/bank/account/token.ex

@@ -29,5 +29,24 @@ defmodule Helix.Universe.Bank.Event.Bank.Account.Token do
         account: account
       }
     end
+
+    notify do
+
+      @event :bank_token_acquired
+
+      @doc false
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: to_string(event.account.atm_id),
+            account_number: to_string(event.account.account_number),
+            token_id: event.token.token_id
+          }
+      end
+
+      @doc false
+      def whom_to_notify(event),
+        do: %{account: event.entity_id}
+    end
   end
 end

lib/universe/bank/event/handler/bank/account.ex

@@ -5,6 +5,7 @@ defmodule Helix.Universe.Bank.Event.Handler.Bank.Account do
   alias Helix.Event
   alias Helix.Entity.Query.Entity, as: EntityQuery
   alias Helix.Universe.Bank.Action.Bank, as: BankAction
+  alias Helix.Universe.Bank.Query.Bank, as: BankQuery
 
   alias Helix.Software.Event.Virus.Collected, as: VirusCollectedEvent
   alias Helix.Universe.Bank.Event.Bank.Account.Removed,
@@ -13,6 +14,8 @@ defmodule Helix.Universe.Bank.Event.Handler.Bank.Account do
     as: BankAccountUpdatedEvent
   alias Helix.Universe.Bank.Event.AccountCreate.Processed,
     as: AccountCreateProcessedEvent
+  alias Helix.Universe.Bank.Event.AccountClose.Processed,
+    as: AccountCloseProcessedEvent
   alias Helix.Universe.Bank.Event.RevealPassword.Processed,
     as: RevealPasswordProcessedEvent
   alias Helix.Universe.Bank.Event.ChangePassword.Processed,
@@ -24,7 +27,7 @@ defmodule Helix.Universe.Bank.Event.Handler.Bank.Account do
     flowing do
       with \
         {:ok, _bank_account, events} <-
-          BankAction.open_account(event.requester, event.atm),
+          BankAction.open_account(event.requester, event.atm_id),
         on_success(fn -> Event.emit(events, from: event) end)
       do
         :ok
@@ -33,12 +36,12 @@ defmodule Helix.Universe.Bank.Event.Handler.Bank.Account do
   end
 
  def account_close_processed(event = %AccountCloseProcessedEvent{}) do
-    flowing
+    flowing do
       with \
-        bank_account = BankQuery.fetch_account(event.atm_id, event.account_number)
-        true <- not is_nil(bank_account),
-        {:ok, events} <- BankAction.close_account(bank_account),
-        on_success(fn -> Event.emit(events) end)
+        bank_acc = BankQuery.fetch_account(event.atm_id, event.account_number),
+        true <- not is_nil(bank_acc),
+        {:ok, events} <- BankAction.close_account(bank_acc),
+        on_success(fn -> Event.emit(events, from: event) end)
       do
         :ok
       end
@@ -80,9 +83,7 @@ defmodule Helix.Universe.Bank.Event.Handler.Bank.Account do
       with \
            changed_by = %{} <- EntityQuery.fetch_by_server(event.gateway_id),
            {:ok, _bank_account, events} <-
-           BankAction.change_password(
-             event.account, changed_by.entity_id
-           ),
+           BankAction.change_password(event.account),
           on_success(fn -> Event.emit(events, from: event) end)
       do
         :ok