WIP

Author: Marcelo Amancio de Lima Santos

lib/account/websocket/channel/account.ex

@@ -14,7 +14,7 @@ channel Helix.Account.Websocket.Channel.Account do
   alias Helix.Network.Websocket.Requests.Bounce.Remove, as: BounceRemoveRequest
   alias Helix.Software.Websocket.Requests.Virus.Collect, as: VirusCollectRequest
   alias Helix.Story.Websocket.Requests.Email.Reply, as: EmailReplyRequest
-  alias Helix.Universe.Websocket.Channel.Requests.CreateAccount,
+  alias Helix.Universe.Bank.Websocket.Requests.CreateAccount,
     as: BankAccountCreateRequest
 
   @doc """

lib/core/validator/validator.ex

@@ -5,6 +5,7 @@ defmodule Helix.Core.Validator do
     | :hostname
     | :bounce_name
     | :reply_id
+    | :token
 
   @regex_hostname ~r/^[a-zA-Z0-9-_.@#]{1,20}$/
 

lib/event/notificable/notificable.ex

@@ -63,7 +63,7 @@ defprotocol Helix.Event.Notificable do
   action, also receive special treatment. Hence:
 
   - third AT attack_target - Third party on victim's server
-  - third AT attack_source - Third party on attacker's server. 
+  - third AT attack_source - Third party on attacker's server.
   - third AT random_server - Third party on unrelated (random) server.
 
   Last but not least, in some cases we do not have an attacker/victim
@@ -98,11 +98,14 @@ defprotocol Helix.Event.Notificable do
 
   alias Helix.Account.Model.Account
   alias Helix.Server.Model.Server
+  alias Helix.Universe.Bank.Model.ATM
+  alias Helix.Universe.Bank.Model.BankAccount
 
   @type whom_to_notify ::
     %{
       optional(:server) => [Server.id],
-      optional(:account) => [Account.id]
+      optional(:account) => [Account.id],
+      optional(:bank_account) => [{ATM.id, BankAccount.account}]
     }
 
   @spec generate_payload(event :: struct, Socket.t) ::

lib/event/notification_handler.ex

@@ -8,8 +8,11 @@ defmodule Helix.Event.NotificationHandler do
   alias Helix.Entity.Model.Entity
   alias Helix.Server.Model.Server
   alias Helix.Server.State.Websocket.Channel, as: ServerWebsocketChannelState
+  alias Helix.Universe.Bank.Model.ATM
+  alias Helix.Universe.Bank.Model.BankAccount
 
   @type channel_account_id :: Account.id | Entity.id
+  @type channel_bank_account_id :: {ATM.id, BankAccount.account}
 
   @doc """
   Handler responsible for guiding the event through the Notificable flow. It
@@ -51,13 +54,25 @@ defmodule Helix.Event.NotificationHandler do
       accounts
       |> Utils.ensure_list()
       |> Enum.uniq()
-      |> get_account_channels()
+      |> get_bank_account_channels()
       |> List.flatten()
       |> Kernel.++(acc)
 
     channel_mapper(Map.delete(notify, :account), acc)
   end
 
+  defp channel_mapper(notify = %{bank_account: bank_accs}, acc) do
+    acc =
+      bank_accs
+      |> Utils.ensure_list()
+      |> Enum.uniq()
+      |> get_bank_account_channels()
+      |> List.flatten()
+      |> Kernel.++(acc)
+
+    channel_mapper(Map.delete(notify, :bank_account), acc)
+  end
+
   defp channel_mapper(%{}, acc),
     do: acc
 
@@ -94,6 +109,15 @@ defmodule Helix.Event.NotificationHandler do
   defp get_account_channels(account_id),
     do: ["account:" <> to_string(account_id)]
 
+  @spec get_bank_account_channels(
+    [channel_bank_account_id] | channel_bank_account_id
+    ) ::
+    channels :: [String.t]
+  defp get_bank_account_channels(bank_accounts),
+    do: Enum.map(bank_accounts, &get_bank_account_channels/1)
+  defp get_bank_account_channels({atm_id, acc_num}),
+    do: ["bank:" <> to_string(atm_id) <> to_string(acc_num)]
+
   defp concat(a, b),
     do: a <> to_string(b)
 end

lib/universe/bank/action/bank.ex

@@ -27,6 +27,12 @@ defmodule Helix.Universe.Bank.Action.Bank do
     as: BankAccountPasswordChangedEvent
   alias Helix.Universe.Bank.Event.Bank.Account.Token.Acquired,
     as: BankAccountTokenAcquiredEvent
+  alias Helix.Universe.Bank.Event.Bank.Account.Removed,
+    as: BankAccountRemovedEvent
+  alias Helix.Universe.Bank.Event.Bank.Transfer.Successful,
+    as: BankTransferSuccessfulEvent
+  alias Helix.Universe.Bank.Event.Bank.Transfer.Failed,
+    as: BankTransferFailedEvent
 
   @spec start_transfer(BankAccount.t, BankAccount.t, pos_integer, Account.idt) ::
     {:ok, BankTransfer.t}
@@ -51,9 +57,8 @@ defmodule Helix.Universe.Bank.Action.Bank do
     as: :start
 
   @spec complete_transfer(BankTransfer.t) ::
-    :ok
-    | {:error, {:transfer, :notfound}}
-    | {:error, :internal}
+    {:ok, BankTransfer.t, [BankTransferSuccessfulEvent.t]}
+    | {:error, BankTransfer.t, [BankTransferFailedEvent.t]}
   @doc """
   Completes the transfer.
 
@@ -66,9 +71,19 @@ defmodule Helix.Universe.Bank.Action.Bank do
   This function should not be called directly by Public. Instead, it must be
   triggered by the BankTransferCompletedEvent.
   """
-  defdelegate complete_transfer(transfer),
-    to: BankTransferInternal,
-    as: :complete
+  def complete_transfer(transfer) do
+    case BankTransferInternal.complete(transfer) do
+      :ok ->
+        {:ok, transfer, [BankTransferSuccessfulEvent.new(transfer.transfer_id)]}
+
+      {:error, reason} ->
+        {
+          :error,
+          transfer,
+          [BankTransferFailedEvent.new(transfer.transfer_id, reason)]
+        }
+    end
+  end
 
   @spec abort_transfer(BankTransfer.t) ::
     :ok
@@ -91,7 +106,7 @@ defmodule Helix.Universe.Bank.Action.Bank do
     as: :abort
 
   @spec open_account(Account.idt, ATM.id) ::
-    {:ok, BankAccount.t}
+    {:ok, BankAccount.t, [BankAccountUpdatedEvent.t]}
     | {:error, Ecto.Changeset.t}
   @doc """
   Opens a bank account.
@@ -103,23 +118,34 @@ defmodule Helix.Universe.Bank.Action.Bank do
       |> Map.get(:entity_id)
       |> NPCQuery.fetch()
 
-    %{owner_id: owner, atm_id: atm, bank_id: bank}
-    |> BankAccountInternal.create()
+    case BankAccountInternal.create(owner, atm, bank) do
+      {:ok, bank_acc} ->
+        {:ok, bank_acc, [BankAccountUpdatedEvent.new(bank_acc, :created)]}
+
+      error ->
+        error
+    end
   end
 
   @spec close_account(BankAccount.t) ::
     :ok
-    | {:error, {:account, :notfound}}
-    | {:error, {:account, :notempty}}
+    | {:error, {:bank_account, :not_found}}
+    | {:error, {:bank_account, :not_empty}}
   @doc """
   Closes a bank account.
 
   May fail if the account is invalid or not empty. In order to close an account,
   its balance must be empty.
   """
-  defdelegate close_account(account),
-    to: BankAccountInternal,
-    as: :close
+  def close_account(account) do
+    case BankAccountInternal.close(account) do
+      :ok ->
+        {:ok, [BankAccountRemovedEvent.new(account)]}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
 
   @spec direct_deposit(BankAccount.t, BankAccount.amount) ::
     {:ok, BankAccount.t, [BankAccountUpdatedEvent.t]}

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

@@ -5,7 +5,6 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
   alias Helix.Event
   alias Helix.Entity.Query.Entity, as: EntityQuery
   alias Helix.Network.Action.Flow.Tunnel, as: TunnelFlow
-  alias Helix.Network.Model.Connection
   alias Helix.Network.Query.Network, as: NetworkQuery
   alias Helix.Process.Model.Process
   alias Helix.Server.Model.Server
@@ -61,13 +60,32 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
   Opens a new BankAccount to given Account.id
   """
   def open(account_id, atm_id) do
-    bank_account =
-      BankAction.open_account(account_id, atm_id)
-    case bank_account do
-      {:ok, bank_account} ->
-        {:ok, bank_account}
-      {:error, _} ->
-        {:error, :internal}
+    flowing do
+      with \
+        {:ok, bank_acc, events} <- BankAction.open_account(account_id, atm_id),
+        on_success(fn -> Event.emit(events) end)
+      do
+        {:ok, bank_acc}
+      else
+        _ ->
+          {:error, :internal}
+      end
+    end
+  end
+
+  @spec close(BankAccount.t) ::
+  :ok
+  | {:error, {:bank_account, :not_found}}
+  | {:error, {:bank_account, :not_empty}}
+  def close(bank_account) do
+    flowing do
+      with \
+        true <- not is_nil(bank_account),
+        {:ok, events} <- BankAction.close_account(bank_account),
+        on_success(fn -> Event.emit(events) end)
+      do
+        :ok
+      end
     end
   end
 

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

@@ -2,6 +2,47 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
 
   import Helix.Event
 
+  event Removed do
+
+    alias Helix.Universe.Bank.Model.BankAccount
+
+    event_struct [:account]
+
+    @type t ::
+      %__MODULE__{
+        account: BankAccount.t
+      }
+
+    @spec new(BankAccount.t) ::
+      t
+
+    def new(account = %BankAccount{}) do
+      %__MODULE__{
+        account: account
+      }
+    end
+
+    notify do
+
+      @event :bank_account_removed
+
+      @doc false
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: to_string(event.account.atm_id),
+            account_number: event.account.account_number
+          }
+
+        {:ok, data}
+      end
+
+      @doc false
+      def whom_to_notify(event),
+        do: %{account: event.account.owner_id}
+    end
+  end
+
   event Updated do
     @moduledoc """
     `BankAccountUpdatedEvent` is fired when the underlying bank account has
@@ -19,7 +60,7 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
         reason: reason
       }
 
-    @type reason :: :balance | :password
+    @type reason :: :balance | :password | :created
 
     @spec new(BankAccount.t, reason) ::
       t
@@ -81,5 +122,77 @@ defmodule Helix.Universe.Bank.Event.Bank.Account do
         token_id: token_id
       }
     end
+
+    notify do
+      @moduledoc """
+      Notifies the client of bank account login, so it can properly update
+      the local data.
+      """
+
+      @event :bank_login_event
+
+      @doc false
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: to_string(event.account.atm_id),
+            account_number: event.account.account_number,
+            balance: event.account.balance,
+            password: event.account.password
+          }
+
+        {:ok, data}
+      end
+
+      def whom_to_notify(event) do
+        atm_id = event.account.atm_id
+        account_number = event.account.account_number
+
+        %{
+          account: event.entity_id,
+          bank_account: {atm_id, account_number}
+        }
+      end
+    end
+  end
+
+  event Logout do
+
+    alias Helix.Entity.Model.Entity
+    alias Helix.Universe.Bank.Model.BankAccount
+
+    event_struct [:account, :entity_id]
+
+    @type t :: %__MODULE__{
+      account: BankAccount.t,
+      entity_id: Entity.id
+    }
+
+    @spec new(BankAccount.t, Entity.id) ::
+      t
+    def new(account = %BankAccount{}, entity_id = %Entity.ID{}) do
+      %__MODULE__{
+        account: account,
+        entity_id: entity_id
+      }
+    end
+
+    notify do
+
+      @event :bank_logout_event
+
+      def generate_payload(event, _socket) do
+        data =
+          %{
+            atm_id: to_string(event.account.atm_id),
+            account_number: event.account.account_number
+          }
+
+        {:ok, data}
+      end
+
+      def whom_to_notify(event),
+        do: %{account: event.entity_id}
+    end
   end
 end