Add handlers for LogForgeProcessedEvent

Author: renatomassaro

lib/balance/software.ex

@@ -29,5 +29,6 @@ balance Software do
       |> mul(modules.overflow.version)
 
     bruteforce + overflow
+    # |> float_div(2)
   end
 end

lib/event/dispatcher.ex

@@ -144,9 +144,10 @@ defmodule Helix.Event.Dispatcher do
   ##############################################################################
 
   # All
+  event LogEvent.Forge.Processed
   event LogEvent.Log.Created
   event LogEvent.Log.Deleted
-  # event LogEvent.Log.Modified
+  event LogEvent.Log.Revised
 
   ##############################################################################
   # Process events
@@ -209,8 +210,6 @@ defmodule Helix.Event.Dispatcher do
   event SoftwareEvent.File.Transfer.Processed
   event SoftwareEvent.Firewall.Started
   event SoftwareEvent.Firewall.Stopped
-  event SoftwareEvent.LogForge.LogCreate.Processed
-  event SoftwareEvent.LogForge.LogEdit.Processed
   event SoftwareEvent.Virus.Collect.Processed
   event SoftwareEvent.Virus.Collected
   event SoftwareEvent.Virus.Installed
@@ -249,14 +248,6 @@ defmodule Helix.Event.Dispatcher do
     ProcessHandler.Cracker,
     :firewall_stopped
 
-  event SoftwareEvent.LogForge.LogCreate.Processed,
-    LogHandler.Log,
-    :log_forge_conclusion
-
-  event SoftwareEvent.LogForge.LogEdit.Processed,
-    LogHandler.Log,
-    :log_forge_conclusion
-
   event SoftwareEvent.Virus.Collect.Processed,
     SoftwareHandler.Virus,
     :handle_collect

lib/event/loggable/flow.ex

@@ -322,10 +322,9 @@ defmodule Helix.Event.Loggable.Flow do
         {_, _, ip_next} = bounce_map[idx + 1]
 
         data = %{ip_prev: ip_prev, ip_next: ip_next, network_id: network_id}
-        # TODO
-        log_type = {:connection_bounced, LogType.new(:connection_bounced, data)}
+        log_info = {:connection_bounced, LogType.new(:connection_bounced, data)}
 
-        entry = build_entry(server_id, entity_id, log_type)
+        entry = build_entry(server_id, entity_id, log_info)
 
         {idx + 1, acc ++ [entry]}
       end

lib/event/loggable/utils.ex

@@ -39,7 +39,7 @@ defmodule Helix.Event.Loggable.Utils do
       end
     end)
     |> elem(0)
-    |> Enum.reverse
+    |> Enum.reverse()
     |> List.to_string()
   end
 

lib/id/domain.ex

@@ -26,10 +26,10 @@ defmodule Helix.ID.Domain do
       crc_bruteforce:   23
       crc_overflow:     33
       install_virus:    43
-      log_forger:       53
-      virus_collect:    63
-      wire_transfer:    73
-      bank_reveal_pass: 83
+      virus_collect:    53
+      wire_transfer:    63
+      bank_reveal_pass: 73
+      log_forge:        83
       reserved_until:   F3
       reserved_until:   F4
 
@@ -154,10 +154,11 @@ defmodule Helix.ID.Domain do
     {{:process, :cracker_bruteforce}, 0x23},
     {{:process, :cracker_overflow}, 0x33},
     {{:process, :install_virus}, 0x43},
-    {{:process, :log_forger}, 0x53},
-    {{:process, :virus_collect}, 0x63},
-    {{:process, :wire_transfer}, 0x73},
-    {{:process, :bank_reveal_password}, 0x83},
+    {{:process, :virus_collect}, 0x53},
+    {{:process, :wire_transfer}, 0x63},
+    {{:process, :bank_reveal_password}, 0x73},
+    {{:process, :log_forge_create}, 0x83},
+    {{:process, :log_forge_edit}, 0x83},
     {{:server, :desktop}, 0x05},
     {{:server, :mobile}, 0x15},
     {{:server, :npc}, 0x25},

lib/log/action/log.ex

@@ -1,20 +1,4 @@
 defmodule Helix.Log.Action.Log do
-  @moduledoc """
-  Functions to work with in-game logs.
-
-  An in-game log is a record registering an action done by an entity on a
-  server.
-
-  It can be forged and recovered to a previous state.
-
-  Its forging mechanics is implemented as an stack where the last revision is
-  the currently displayed message and to see the original log all revisions must
-  be recovered.
-
-  Note that on Log context _forging_ and _revising_ are used interchangeably and
-  means changing the current message of a log by adding a (forged) revision to
-  it's stack.
-  """
 
   alias Helix.Entity.Model.Entity
   alias Helix.Server.Model.Server
@@ -23,13 +7,16 @@ defmodule Helix.Log.Action.Log do
 
   alias Helix.Log.Event.Log.Created, as: LogCreatedEvent
   alias Helix.Log.Event.Log.Deleted, as: LogDeletedEvent
-  alias Helix.Log.Event.Log.Modified, as: LogModifiedEvent
+  alias Helix.Log.Event.Log.Revised, as: LogRevisedEvent
 
   @spec create(Server.id, Entity.id, Log.info, pos_integer | nil) ::
     {:ok, Log.t, [LogCreatedEvent.t]}
     | :error
   @doc """
   Creates a new log linked to `entity` on `server` with `log_info` as content.
+
+  This log may be natural (created automatically by the game as a result to a
+  player's action) or artificial (explicitly created using LogForger.Edit).
   """
   def create(server_id, entity_id, log_info, forge_version \\ nil) do
     case LogInternal.create(server_id, entity_id, log_info, forge_version) do

lib/log/event/handler/log.ex

@@ -2,14 +2,12 @@ defmodule Helix.Log.Event.Handler.Log do
   @moduledoc false
 
   alias Helix.Event
-  alias Helix.Log.Action.Log, as: LogAction
   alias Helix.Event.Loggable
+  alias Helix.Log.Action.Log, as: LogAction
+  alias Helix.Log.Model.Log
   alias Helix.Log.Query.Log, as: LogQuery
 
-  alias Helix.Software.Event.LogForge.LogCreate.Processed,
-    as: LogForgeCreateComplete
-  alias Helix.Software.Event.LogForge.LogEdit.Processed,
-    as: LogForgeEditComplete
+  alias Helix.Log.Event.Forge.Processed, as: LogForgeProcessedEvent
 
   @doc """
   Generic event handler for all Helix events. If the event implement the
@@ -28,24 +26,36 @@ defmodule Helix.Log.Event.Handler.Log do
   end
 
   @doc """
-  Forges a revision onto a log or creates a fake new log
-  """
-  def log_forge_conclusion(event = %LogForgeEditComplete{}) do
-    {:ok, _, events} =
-      event.target_log_id
-      |> LogQuery.fetch()
-      |> LogAction.revise(event.entity_id, event.message, event.version)
+  Handler called right after a `LogForgeProcess` has completed. It will then
+  either create a new log out of thin air, or edit an existing log.
 
-    Event.emit(events, from: event)
+  Emits: `LogCreatedEvent`, `LogRevisedEvent`
+  """
+  def log_forge_processed(event = %LogForgeProcessedEvent{action: :create}) do
+    # `action` is `:create`, so we'll create a new log out of thin air!
+    result =
+      LogAction.create(
+        event.server_id, event.entity_id, event.log_info, event.forger_version
+      )
+
+    with {:ok, _, events} <- result do
+      Event.emit(events)
+    end
   end
 
-  def log_forge_conclusion(event = %LogForgeCreateComplete{}) do
-    {:ok, _, events} = LogAction.create(
-      event.target_id,
-      event.entity_id,
-      event.message,
-      event.version)
+  def log_forge_processed(event = %LogForgeProcessedEvent{action: :edit}) do
+    # `action` is `:edit`, so we'll stack up a revision on an existing log
+    revise = fn log ->
+      LogAction.revise(
+        log, event.entity_id, event.log_info, event.forger_version
+      )
+    end
 
-    Event.emit(events, from: event)
+    with \
+      log = %Log{} <- LogQuery.fetch(event.target_log_id),
+      {:ok, _, events} <- revise.(log)
+    do
+      Event.emit(events)
+    end
   end
 end

lib/log/event/log.ex

@@ -5,25 +5,27 @@ defmodule Helix.Log.Event.Log do
   event Created do
     @moduledoc """
     LogCreatedEvent is fired when a brand new log entry is added to the server.
+
+    The newly created log may be either natural (automatically created by the
+    game) or artificial (explicitly created by the player through LogForge
+    mechanics). Either way, the receiving end of the event (Client) DOES NOT
+    know whether the log is natural or artificial.
     """
 
-    alias Helix.Server.Model.Server
     alias Helix.Log.Model.Log
 
     @type t ::
       %__MODULE__{
-        log: Log.t,
-        server_id: Server.id
+        log: Log.t
       }
 
-    event_struct [:server_id, :log]
+    event_struct [:log]
 
     @spec new(Log.t) ::
       t
     def new(log = %Log{}) do
       %__MODULE__{
-        log: log,
-        server_id: log.server_id
+        log: log
       }
     end
 
@@ -40,83 +42,72 @@ defmodule Helix.Log.Event.Log do
       end
 
       def whom_to_publish(event),
-        do: %{server: event.server_id}
+        do: %{server: event.log.server_id}
     end
   end
 
-  # event Modified do
-  #   @moduledoc """
-  #   LogModifiedEvent is fired when an existing log has changed (revised) or
-  #   has been recovered.
+  event Revised do
+    @moduledoc """
+    `LogRevisedEvent` is fired when an existing log had a revision added to it.
 
-  #   TODO: we'll probably want to create a LogRecovered event instead.
-  #   """
+    The revision may be stacked up on a natural or artificial log - the log
+    origin is transparent to the Client.
+    """
 
-  #   alias Helix.Server.Model.Server
-  #   alias Helix.Log.Model.Log
+    alias Helix.Log.Model.Log
 
-  #   @type t ::
-  #     %__MODULE__{
-  #       log: Log.t,
-  #       server_id: Server.id
-  #     }
+    event_struct [:log]
 
-  #   event_struct [:server_id, :log]
+    @type t ::
+      %__MODULE__{
+        log: Log.t
+      }
 
-  #   @spec new(Log.t) ::
-  #     t
-  #   def new(log = %Log{}) do
-  #     %__MODULE__{
-  #       log: log,
-  #       server_id: log.server_id
-  #     }
-  #   end
+    @spec new(Log.t) ::
+      t
+    def new(log = %Log{}) do
+      %__MODULE__{
+        log: log
+      }
+    end
 
-  #   publish do
+    publish do
 
-  #     alias HELL.ClientUtils
+      alias Helix.Log.Public.Index, as: LogIndex
 
-  #     @event :log_modified
+      @event :log_revised
 
-  #     def generate_payload(event, _socket) do
-  #       data = %{
-  #         log_id: to_string(event.log.log_id),
-  #         server_id: to_string(event.server_id),
-  #         timestamp: ClientUtils.to_timestamp(event.log.creation_time),
-  #         message: event.log.message
-  #       }
+      def generate_payload(event, _socket) do
+        data = LogIndex.render_log(event.log)
 
-  #       {:ok, data}
-  #     end
+        {:ok, data}
+      end
 
-  #     def whom_to_publish(event),
-  #       do: %{server: event.server_id}
-  #   end
-  # end
+      def whom_to_publish(event),
+        do: %{server: event.log.server_id}
+    end
+  end
 
   event Deleted do
     @moduledoc """
     LogDeletedEvent is fired when a forged log is recovered beyond its original
     revision, leading to the log deletion.
     """
 
-    alias Helix.Server.Model.Server
     alias Helix.Log.Model.Log
 
     @type t ::
       %__MODULE__{
-        log: Log.t,
-        server_id: Server.id
+        log: Log.t
       }
 
-    event_struct [:server_id, :log]
+    event_struct [:log]
 
     @spec new(Log.t) ::
       t
     def new(log = %Log{}) do
       %__MODULE__{
-        log: log,
-        server_id: log.server_id
+        log: log
       }
     end
 
@@ -126,15 +117,14 @@ defmodule Helix.Log.Event.Log do
 
       def generate_payload(event, _socket) do
         data = %{
-          log_id: to_string(event.log.log_id),
-          server_id: to_string(event.server_id)
+          log_id: to_string(event.log.log_id)
         }
 
         {:ok, data}
       end
 
       def whom_to_publish(event),
-        do: %{server: event.server_id}
+        do: %{server: event.log.server_id}
     end
   end
 end

lib/log/process/recover.ex

@@ -14,6 +14,7 @@ defmodule Helix.Software.Model.File.Module do
   use Ecto.Schema
 
   import Ecto.Changeset
+  import HELL.Ecto.Macros
 
   alias Ecto.Changeset
   alias HELL.Constant
@@ -129,11 +130,8 @@ defmodule Helix.Software.Model.File.Module do
     end
   end
 
-  defmodule Query do
+  query do
 
-    import Ecto.Query
-
-    alias Ecto.Queryable
     alias HELL.Constant
     alias Helix.Software.Model.File