WIP

Author: Marcelo Amancio de Lima Santos

lib/account/websocket/channel/account.ex

@@ -27,7 +27,7 @@ channel Helix.Account.Websocket.Channel.Account do
     authenticated on the socket.
   + base errors
   """
-  join _, AccountJoin
+  join "account:" <> _, AccountJoin
 
   @doc """
   Forces a bootstrap to happen. It is the exact same operation ran during join.

lib/core/validator/validator.ex

@@ -8,6 +8,8 @@ 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}$/
+
   @spec validate_input(input :: String.t, input_type, opts :: term) ::
     {:ok, validated_input :: String.t}
     | :error
@@ -24,6 +26,9 @@ defmodule Helix.Core.Validator do
   def validate_input(input, :password, _),
     do: validate_password(input)
 
+  def validate_input(input, :money, _),
+    do: validate_money(input)
+
   def validate_input(input, :hostname, _),
     do: validate_hostname(input)
 
@@ -33,6 +38,9 @@ defmodule Helix.Core.Validator do
   def validate_input(input, :reply_id, _),
     do: validate_reply_id(input)
 
+  def validate_input(input, :token, _),
+    do: validate_token(input)
+
   defp validate_hostname(v) when not is_binary(v),
     do: :error
   defp validate_hostname(v) do
@@ -43,6 +51,16 @@ defmodule Helix.Core.Validator do
     end
   end
 
+  defp validate_token(v) when not is_binary(v),
+    do: :error
+  defp validate_token(v) do
+    if Regex.match?(@regex_token, v) do
+      {:ok, v}
+    else
+      :error
+    end
+  end
+
   defp validate_password(input),
     do: validate_hostname(input)  # TODO
 
@@ -51,4 +69,7 @@ defmodule Helix.Core.Validator do
 
   defp validate_reply_id(v),
     do: validate_hostname(v)  # TODO
+
+  defp validate_money(v),
+    do: validate_hostname(v)
 end

lib/event/dispatcher.ex

@@ -301,10 +301,18 @@ defmodule Helix.Event.Dispatcher do
     BankHandler.Bank.Account,
     :password_reveal_processed
 
+  event BankEvent.ChangePassword.Processed,
+    BankHandler.Bank.Account,
+    :password_change_processed
+
   event BankEvent.Bank.Account.Password.Revealed,
     EntityHandler.Database,
     :bank_password_revealed
 
+  event BankEvent.Bank.Account.Password.Changed,
+    BankHandler.Bank.Account,
+    :bank_password_changed
+
   event BankEvent.Bank.Account.Login,
     EntityHandler.Database,
     :bank_account_login

lib/process/executable.ex

@@ -318,18 +318,25 @@ defmodule Helix.Process.Executable do
             src_acc_number: BankAccount.account | nil
           }
         @doc false
-        defp get_source_bank_account(_, _, _, _),
-          do: %{src_atm_id: nil, src_acc_number: nil}
+        defp get_source_bank_account(_, _, _, meta) do
+          %{
+            src_atm_id: Map.get(meta, :src_atm_id, nil),
+            src_acc_number: Map.get(meta, :src_acc_number, nil)
+          }
+        end
 
         @spec get_target_bank_account(Server.t, Server.t, params, meta) ::
           %{
             tgt_atm_id: Server.t | nil,
             tgt_acc_number: BankAccount.account | nil
           }
         @doc false
-        defp get_target_bank_account(_, _, _, _),
-          do: %{tgt_atm_id: nil, tgt_acc_number: nil}
-
+        defp get_target_bank_account(_, _, _, meta) do
+          %{
+            tgt_atm_id: Map.get(meta, :tgt_atm_id, nil),
+            tgt_acc_number: Map.get(meta, :tgt_acc_number, nil)
+          }
+        end
         @spec get_target_process(Server.t, Server.t, params, meta) ::
           %{tgt_process_id: Process.t | nil}
         @doc false

lib/process/model/process.ex

@@ -77,6 +77,7 @@ defmodule Helix.Process.Model.Process do
     | :cracker_bruteforce
     | :cracker_overflow
     | :install_virus
+    | :bank_change_password
 
   @typedoc """
   List of signals a process may receive during its lifetime.

lib/server/websocket/channel/server.ex

@@ -293,7 +293,7 @@ channel Helix.Server.Websocket.Channel.Server do
   Disables the PublicFTP server of the player.
 
   Params: none
-  
+
   Returns: %{}
 
   Errors:

lib/universe/bank/action/bank.ex

@@ -10,6 +10,7 @@ defmodule Helix.Universe.Bank.Action.Bank do
   alias Helix.Universe.Bank.Internal.BankAccount, as: BankAccountInternal
   alias Helix.Universe.Bank.Internal.BankToken, as: BankTokenInternal
   alias Helix.Universe.Bank.Internal.BankTransfer, as: BankTransferInternal
+  alias Helix.Universe.Bank.Henforcer.Bank, as: BankHenforcer
   alias Helix.Universe.Bank.Model.ATM
   alias Helix.Universe.Bank.Model.BankAccount
   alias Helix.Universe.Bank.Model.BankToken
@@ -22,6 +23,8 @@ defmodule Helix.Universe.Bank.Action.Bank do
     as: BankAccountUpdatedEvent
   alias Helix.Universe.Bank.Event.Bank.Account.Password.Revealed,
     as: BankAccountPasswordRevealedEvent
+  alias Helix.Universe.Bank.Event.Bank.Account.Password.Changed,
+    as: BankAccountPasswordChangedEvent
   alias Helix.Universe.Bank.Event.Bank.Account.Token.Acquired,
     as: BankAccountTokenAcquiredEvent
 
@@ -185,9 +188,7 @@ defmodule Helix.Universe.Bank.Action.Bank do
   """
   def reveal_password(account, token_id, revealed_by) do
     with \
-      token = %{} <- BankQuery.fetch_token(token_id),
-      true <- account.account_number == token.account_number,
-      true <- account.atm_id == token.atm_id
+      {true, relay} <- BankHenforcer.token_valid?(account, token_id)
     do
       event = BankAccountPasswordRevealedEvent.new(account, revealed_by)
 
@@ -198,6 +199,21 @@ defmodule Helix.Universe.Bank.Action.Bank do
     end
   end
 
+  @spec change_password(BankAccount.t, Entity.id) ::
+  {:ok, BankAccount.t, [BankAccountPasswordChangedEvent.t]}
+   | {:error, :internal}
+   def change_password(account, changed_by) do
+     event = BankAccountPasswordChangedEvent.new(account, changed_by)
+     {:ok, account, [event]}
+   end
+
+  @spec update_password(BankAccount.t) ::
+  {:ok, BankAccount.t}
+  | {:error, :internal}
+  defdelegate update_password(account),
+    to: BankAccountInternal,
+    as: :change_password
+
   @spec login_password(BankAccount.t, String.t, Entity.idt) ::
     {:ok, BankAccount.t, [BankAccountLoginEvent.t]}
     | term
@@ -226,12 +242,14 @@ defmodule Helix.Universe.Bank.Action.Bank do
     | term
   def login_token(account, token_id, login_by) do
     with \
-      token = %{} <- BankQuery.fetch_token(token_id),
-      true <- token.account_number == account.account_number
+      {true, relay} <- BankHenforcer.token_valid?(account, token_id)
     do
       event = BankAccountLoginEvent.new(account, login_by, token_id)
 
       {:ok, account, [event]}
+    else
+      {false, reason, _} ->
+        {:error, reason}
     end
   end
 

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

@@ -5,6 +5,7 @@ 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
@@ -15,6 +16,8 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
 
   alias Helix.Universe.Bank.Process.Bank.Account.RevealPassword,
     as: BankAccountRevealPasswordProcess
+  alias Helix.Universe.Bank.Process.Bank.Account.ChangePassword,
+    as: BankAccountChangePasswordProcess
 
   @typep relay :: Event.relay
 
@@ -29,7 +32,12 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
 
   Emits: ProcessCreatedEvent
   """
-  @spec reveal_password(BankAccount.t, BankToken.id, Server.t, Server.t, relay) ::
+  @spec reveal_password(
+    BankAccount.t,
+    BankToken.id,
+    Server.t,
+    Server.t,
+    relay) ::
     {:ok, Process.t}
     | BankAccountRevealPasswordProcess.executable_error
   def reveal_password(account, token_id, gateway, atm, relay) do
@@ -46,6 +54,41 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
     BankAccountRevealPasswordProcess.execute(gateway, atm, params, meta, relay)
   end
 
+  @spec open(Account.id, ATM.id) ::
+  {:ok, BankAccount.t}
+  | {:error, :internal}
+  @doc """
+  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}
+    end
+  end
+
+  @spec change_password(BankAccount.t, Server.t, Server.t, relay) ::
+  {:ok, Process.t}
+  | BankAccountChangePasswordProcess.executable_error
+  @doc """
+  Starts a ChangePasswordProcess
+
+  Emits: ProcessCreatedEvent
+  """
+  def change_password(account, gateway, atm, relay) do
+    meta = %{
+      network_id: NetworkQuery.internet().network_id,
+      src_atm_id: atm.server_id,
+      src_acc_number: account.account_number,
+      bounce: nil
+    }
+
+    BankAccountChangePasswordProcess.execute(gateway, atm, %{}, meta, relay)
+  end
   @doc """
   Logs into a bank account using a password. If the given password matches the
   current account password, the login is successful, in which case a BankLogin
@@ -74,9 +117,9 @@ defmodule Helix.Universe.Bank.Action.Flow.BankAccount do
         {:ok, _, events} <- BankAction.login_password(acc, password, entity),
         on_success(fn -> Event.emit(events) end),
 
-        {:ok, _, connection} <- start_connection.()
+        {:ok, tunnel, connection} <- start_connection.()
       do
-        {:ok, connection}
+        {:ok, tunnel, connection}
       end
     end
   end

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

@@ -63,7 +63,11 @@ defmodule Helix.Universe.Bank.Action.Flow.BankTransfer do
 
       meta = %{
         network_id: tunnel.network_id,
-        bounce: tunnel.bounce_id
+        bounce: tunnel.bounce_id,
+        src_atm_id: from_account.atm_id,
+        src_acc_number: from_account.account_number,
+        tgt_atm_id: to_account.atm_id,
+        tgt_acc_number: to_account.account_number
       }
 
       BankTransferProcess.execute(gateway, target_atm, params, meta, relay)

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

@@ -23,4 +23,26 @@ defmodule Helix.Universe.Bank.Event.Bank.Account.Password do
       }
     end
   end
+
+  event Changed do
+
+   alias Helix.Entity.Model.Entity
+   alias Helix.Universe.Bank.Model.BankAccount
+
+   @type t :: %__MODULE__{
+     entity_id: Entity.id,
+     account: BankAccount.t
+   }
+
+   event_struct [:entity_id, :account]
+
+   @spec new(BankAccount.t, Entity.id) ::
+   t
+   def new(account = %BankAccount{}, entity_id) do
+     %__MODULE__{
+       entity_id: entity_id,
+       account: account
+     }
+   end
+  end
 end