update BankAccount open and close tests

Author: Marcelo Amancio de Lima Santos

lib/core/validator/validator.ex

@@ -9,7 +9,7 @@ defmodule Helix.Core.Validator do
 
   @regex_hostname ~r/^[a-zA-Z0-9-_.@#]{1,20}$/
 
-  @regex_token ~r/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+  @uuid ~r/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
 
   @spec validate_input(input :: String.t, input_type, opts :: term) ::
     {:ok, validated_input :: String.t}
@@ -55,7 +55,7 @@ defmodule Helix.Core.Validator do
   defp validate_token(v) when not is_binary(v),
     do: :error
   defp validate_token(v) do
-    if Regex.match?(@regex_token, v) do
+    if Regex.match?(@uuid, v) do
       {:ok, v}
     else
       :error
@@ -73,4 +73,5 @@ defmodule Helix.Core.Validator do
 
   defp validate_money(v),
     do: validate_hostname(v)
+
 end

lib/event/notificable/notificable.ex

@@ -104,7 +104,8 @@ defprotocol Helix.Event.Notificable do
   @type whom_to_notify ::
     %{
       optional(:server) => [Server.id],
-      optional(:account) => [Account.id]
+      optional(:account) => [Account.id],
+      optional(:bank_acc) => [term]
     }
 
   @spec generate_payload(event :: struct, Socket.t) ::

lib/event/notification_handler.ex

@@ -12,6 +12,7 @@ defmodule Helix.Event.NotificationHandler do
   alias Helix.Universe.Bank.Model.BankAccount
 
   @type channel_account_id :: Account.id | Entity.id
+  @type channel_bank_id :: {ATM.id, BankAccount.account}
 
   @doc """
   Handler responsible for guiding the event through the Notificable flow. It
@@ -36,6 +37,18 @@ defmodule Helix.Event.NotificationHandler do
   @spec channel_mapper(Notificable.whom_to_notify) ::
     channels :: [String.t]
   defp channel_mapper(whom_to_notify, acc \\ [])
+  defp channel_mapper(notify = %{bank_acc: bank_accs}, acc) do
+    acc =
+      bank_accs
+      |> Utils.ensure_list()
+      |> Enum.uniq()
+      |> get_bank_channels()
+      |> List.flatten()
+      |> Kernel.++(acc)
+
+      channel_mapper(Map.delete(notify, :bank_acc), acc)
+  end
+
   defp channel_mapper(notify = %{server: servers}, acc) do
     acc =
       servers
@@ -96,6 +109,13 @@ defmodule Helix.Event.NotificationHandler do
   defp get_account_channels(account_id),
     do: ["account:" <> to_string(account_id)]
 
+  @spec get_bank_channels([channel_bank_id] | channel_bank_id) ::
+    channels :: [String.t]
+  defp get_bank_channels(bank_accs) when is_list(bank_accs),
+    do: Enum.map(bank_accs, &get_bank_channels/1)
+  defp get_bank_channels({atm_id, account_number}),
+    do: ["bank:" <> to_string(account_number) <> "@" <> to_string(atm_id)]
+
   defp concat(a, b),
     do: a <> to_string(b)
 end

lib/software/model/file.ex

@@ -214,8 +214,8 @@ defmodule Helix.Software.Model.File do
     path_size = (byte_size(path) - 1) * 8
 
     case path do
-      <<path::bits-size(path_size)>> <> "/" ->
-        <<path::bits-size(path_size)>>
+      <<path::binary-size(path_size)>> <> "/" ->
+        <<path::binary-size(path_size)>>
       path ->
         path
     end

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) ::
@@ -118,7 +128,7 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
 
   Emits: BankAccountLoginEvent, (ConnectionStartedEvent)
   """
-  def login_password(atm_id, account_number, gateway_id, bounce_id, password) do
+  def login_password(atm_id, account_number, gateway_id, bounce_id, password, relay) do
     acc = BankQuery.fetch_account(atm_id, account_number)
     entity = EntityQuery.fetch_by_server(gateway_id)
 
@@ -137,7 +147,7 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
       with \
         true <- not is_nil(acc),
         {:ok, _, events} <- BankAction.login_password(acc, password, entity),
-        on_success(fn -> Event.emit(events) end),
+        on_success(fn -> Event.emit(events, from: relay) end),
 
         {:ok, tunnel, connection} <- start_connection.()
       do
@@ -153,7 +163,7 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
 
   Emits: BankAccountLoginEvent, (ConnectionStartedEvent)
   """
-  def login_token(atm_id, account_number, gateway_id, bounce_id, token) do
+  def login_token(atm_id, account_number, gateway_id, bounce_id, token, relay) do
     acc = BankQuery.fetch_account(atm_id, account_number)
     entity = EntityQuery.fetch_by_server(gateway_id)
 
@@ -172,7 +182,7 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
       with \
         true <- not is_nil(acc),
         {:ok, _, events} <- BankAction.login_token(acc, token, entity),
-        on_success(fn -> Event.emit(events) end),
+        on_success(fn -> Event.emit(events, from: relay) end),
 
         {:ok, tunnel, connection} <- start_connection.()
       do

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
 
@@ -101,25 +101,47 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
 
   event Login do
 
+    alias Helix.Account.Model.Account
     alias Helix.Entity.Model.Entity
+    alias Helix.Entity.Query.Entity, as: EntityQuery
     alias Helix.Universe.Bank.Model.BankAccount
     alias Helix.Universe.Bank.Model.BankToken
 
-    event_struct [:entity_id, :account, :token_id]
+    event_struct [:entity_id, :notify_owner, :account, :token_id]
 
     @type t :: %__MODULE__{
       entity_id: Entity.id,
       account: BankAccount.t,
       token_id: BankToken.id | nil
     }
 
-    @spec new(BankAccount.t, Entity.id) ::
+    @spec new(BankAccount.t, Entity.idt) ::
       t
-    def new(account = %BankAccount{}, entity_id, token_id \\ nil) do
+    def new(account, entity_or_entity_id, token_id \\ nil)
+    def new(account = %BankAccount{}, entity = %Entity{}, token_id) do
+      is_account? = entity.entity_type == :account
+
+      %__MODULE__{
+        entity_id: entity.entity_id,
+        account: account,
+        token_id: token_id,
+        notify_owner: is_account?
+      }
+    end
+    def new(account = %BankAccount{}, entity_id = %Entity.ID{}, token_id) do
+      is_account? = EntityQuery.fetch(entity_id).entity_type == :account
+      entity_id =
+        if is_account? do
+          %Account.ID{id: entity_id.id, root: Account}
+        else
+          entity_id
+        end
+
       %__MODULE__{
         entity_id: entity_id,
         account: account,
-        token_id: token_id
+        token_id: token_id,
+        notify_owner: is_account?
       }
     end
 
@@ -129,7 +151,7 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
       the local data.
       """
 
-      @event :bank_login_event
+      @event :bank_login
 
       @doc false
       def generate_payload(event, _socket) do
@@ -145,9 +167,27 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
       end
 
       def whom_to_notify(event) do
-        %{
-          account: event.entity_id
-        }
+        atm_id = event.account.atm_id
+        bank_account = event.account.account_number
+
+        entity_id =
+          case event.entity_id do
+            entity = %Entity{} ->
+              %Account.ID{id: entity.entity_id.id, root: Account}
+            entity_id = %Entity.ID{} ->
+              %Account.ID{id: entity_id.id, root: Account}
+          end
+
+        base_map =
+          %{
+            bank_acc: [{atm_id, bank_account}]
+          }
+
+        if event.notify_owner do
+          Map.merge(%{account: entity_id}, base_map)
+        else
+          base_map
+        end
       end
     end
   end
@@ -175,7 +215,7 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
 
     notify do
 
-      @event :bank_logout_event
+      @event :bank_logout
 
       def generate_payload(event, _socket) do
         data =