Rename IRC.{Message,Trigger} to Nola.{Message,Trigger}, refs T77.

33 files changed, 128 insertions, 113 deletions

diff --git a/lib/irc/admin_handler.ex b/lib/irc/admin_handler.ex
index 282f3c2..a462789 100644
--- a/lib/irc/admin_handler.ex
+++ b/lib/irc/admin_handler.ex
@@ -18,7 +18,7 @@ defmodule Nola.Irc.AdminHandler do
     {:ok, client}
   end
 
-  def handle_info({:irc, :trigger, "op", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}, sender: sender}}, client) do
+  def handle_info({:irc, :trigger, "op", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang}, sender: sender}}, client) do
     if IRC.admin?(sender) do
       m.replyfun.({:mode, "+o"})
     else
diff --git a/lib/irc/connection.ex b/lib/irc/connection.ex
index 9bb09ed..037b7d6 100644
--- a/lib/irc/connection.ex
+++ b/lib/irc/connection.ex
@@ -24,9 +24,9 @@ defmodule IRC.Connection do
   * `triggers` -- all triggers
   * `trigger:TRIGGER` -- any message with a trigger `TRIGGER`
 
-  ## Replying to %IRC.Message{}
+  ## Replying to %Nola.Message{}
 
-  Each `IRC.Message` comes with a dedicated `replyfun`, to which you only have to pass either:
+  Each `Nola.Message` comes with a dedicated `replyfun`, to which you only have to pass either:
 
   """
   def irc_doc, do: nil
@@ -294,7 +294,7 @@ defmodule IRC.Connection do
       if !Map.get(user.options, :puppet) do
         reply_fun = fn(text) -> irc_reply(state, {chan, sender}, text) end
         account = Nola.Account.lookup(sender)
-        message = %IRC.Message{id: FlakeId.get(), transport: :irc, at: NaiveDateTime.utc_now(), text: text, network: state.network,
+        message = %Nola.Message{id: FlakeId.get(), transport: :irc, at: NaiveDateTime.utc_now(), text: text, network: state.network,
                                account: account, sender: sender, channel: chan, replyfun: reply_fun,
                                trigger: extract_trigger(text)}
         message = case Nola.UserTrack.messaged(message) do
@@ -311,7 +311,7 @@ defmodule IRC.Connection do
   def handle_info({:received, text, sender}, state) do
     reply_fun = fn(text) -> irc_reply(state, {sender.nick, sender}, text) end
     account = Nola.Account.lookup(sender)
-    message = %IRC.Message{id: FlakeId.get(), transport: :irc, text: text, network: state.network, at: NaiveDateTime.utc_now(),
+    message = %Nola.Message{id: FlakeId.get(), transport: :irc, text: text, network: state.network, at: NaiveDateTime.utc_now(),
                            account: account, sender: sender, replyfun: reply_fun, trigger: extract_trigger(text)}
     message = case Nola.UserTrack.messaged(message) do
       :ok -> message
@@ -401,11 +401,11 @@ defmodule IRC.Connection do
 
   def publish(pub), do: publish(pub, [])
 
-  def publish(m = %IRC.Message{trigger: nil}, keys) do
+  def publish(m = %Nola.Message{trigger: nil}, keys) do
     dispatch(["messages"] ++ keys, {:irc, :text, m})
   end
 
-  def publish(m = %IRC.Message{trigger: t = %IRC.Trigger{trigger: trigger}}, keys) do
+  def publish(m = %Nola.Message{trigger: t = %Nola.Trigger{trigger: trigger}}, keys) do
     dispatch(["triggers", "#{m.network}/#{m.channel}:triggers", "trigger:"<>trigger], {:irc, :trigger, trigger, m})
   end
 
@@ -445,7 +445,7 @@ defmodule IRC.Connection do
     def extract_trigger(unquote(trigger)<>text) do
       text = String.strip(text)
       [trigger | args] = String.split(text, " ")
-      %IRC.Trigger{type: unquote(name), trigger: String.downcase(trigger), args: args}
+      %Nola.Trigger{type: unquote(name), trigger: String.downcase(trigger), args: args}
     end
   end
 
@@ -463,7 +463,7 @@ defmodule IRC.Connection do
             |> List.flatten()
     outputs = for line <- lines do
       ExIRC.Client.msg(client, :privmsg, target, line)
-      {:irc, :out, %IRC.Message{id: FlakeId.get(), transport: :irc, network: network,
+      {:irc, :out, %Nola.Message{id: FlakeId.get(), transport: :irc, network: network,
               channel: target, text: line, sender: %ExIRC.SenderInfo{nick: state.conn.nick}, at: NaiveDateTime.utc_now(), meta: %{self: true}}}
     end
     for f <- outputs, do: dispatch(["irc:outputs", "#{network}/#{target}:outputs"], f)
diff --git a/lib/irc/irc.ex b/lib/irc/irc.ex
index 93525e4..a1d97a2 100644
--- a/lib/irc/irc.ex
+++ b/lib/irc/irc.ex
@@ -1,25 +1,5 @@
 defmodule IRC do
 
-  defmodule Message do
-    @derive {Poison.Encoder, except: [:replyfun]}
-    defstruct [:id,
-      :text,
-      {:transport, :irc},
-      :network,
-               :account,
-               :sender,
-               :channel,
-               :trigger,
-               :replyfun,
-               :at,
-               {:meta, %{}}
-              ]
-  end
-  defmodule Trigger do
-    @derive Poison.Encoder
-    defstruct [:type, :trigger, :args]
-  end
-
   def send_message_as(account, network, channel, text, force_puppet \\ false) do
     connection = IRC.Connection.get_network(network)
     if connection && (force_puppet || IRC.PuppetConnection.whereis(account, connection)) do
diff --git a/lib/irc/puppet_connection.ex b/lib/irc/puppet_connection.ex
index 75a06f3..2604876 100644
--- a/lib/irc/puppet_connection.ex
+++ b/lib/irc/puppet_connection.ex
@@ -152,7 +152,7 @@ defmodule IRC.PuppetConnection do
     reply_fun = fn(text) ->
       IRC.Connection.broadcast_message(state.network, channel, text)
     end
-    message = %IRC.Message{id: FlakeId.get(), at: NaiveDateTime.utc_now(), text: text, network: state.network, account: account, sender: sender, channel: channel, replyfun: reply_fun, trigger: IRC.Connection.extract_trigger(text), meta: meta}
+    message = %Nola.Message{id: FlakeId.get(), at: NaiveDateTime.utc_now(), text: text, network: state.network, account: account, sender: sender, channel: channel, replyfun: reply_fun, trigger: IRC.Connection.extract_trigger(text), meta: meta}
     message = case Nola.UserTrack.messaged(message) do
                 :ok -> message
                 {:ok, message} -> message
diff --git a/lib/matrix/room.ex b/lib/matrix/room.ex
index 757aad0..299d7cc 100644
--- a/lib/matrix/room.ex
+++ b/lib/matrix/room.ex
@@ -120,7 +120,7 @@ defmodule Nola.Matrix.Room do
     end
   end
 
-  def handle_irc(message = %IRC.Message{account: account}, state) do
+  def handle_irc(message = %Nola.Message{account: account}, state) do
     unless Map.get(message.meta, :puppet) && Map.get(message.meta, :from) == self() do
         opts = if Map.get(message.meta, :self) || is_nil(account) do
         []
diff --git a/lib/nola/account.ex b/lib/nola/account.ex
index 06ca993..31e237c 100644
--- a/lib/nola/account.ex
+++ b/lib/nola/account.ex
@@ -198,7 +198,7 @@ defmodule Nola.Account do
     end
   end
 
-  defp do_lookup(message = %IRC.Message{account: account_id}, make_default) when is_binary(account_id) do
+  defp do_lookup(message = %Nola.Message{account: account_id}, make_default) when is_binary(account_id) do
     get(account_id)
   end
 
diff --git a/lib/nola/message.ex b/lib/nola/message.ex
new file mode 100644
index 0000000..4ceb9b9
--- /dev/null
+++ b/lib/nola/message.ex
@@ -0,0 +1,23 @@
+defmodule Message do
+  @moduledoc """
+  Well, a message!
+
+  """
+
+  @derive {Poison.Encoder, except: [:replyfun]}
+
+  defstruct [
+    :id,
+    :text,
+     {:transport, :irc},
+     :network,
+     :account,
+     :sender,
+     :channel,
+     :trigger,
+     :replyfun,
+     :at,
+     {:meta, %{}}
+   ]
+
+end
diff --git a/lib/nola/trigger.ex b/lib/nola/trigger.ex
new file mode 100644
index 0000000..b6502c3
--- /dev/null
+++ b/lib/nola/trigger.ex
@@ -0,0 +1,12 @@
+defmodule Trigger do
+  @moduledoc "A `Nola.Message` parsed command/trigger."
+
+  @derive Poison.Encoder
+
+  defstruct [
+    :type,
+    :trigger,
+    :args
+  ]
+
+end
diff --git a/lib/nola/user_track.ex b/lib/nola/user_track.ex
index 2a051f9..720fb58 100644
--- a/lib/nola/user_track.ex
+++ b/lib/nola/user_track.ex
@@ -237,7 +237,7 @@ defmodule Nola.UserTrack do
   #  end)
   #end
 
-  def messaged(%IRC.Message{network: network, account: account, channel: chan, sender: %{nick: nick}} = m) do
+  def messaged(%Nola.Message{network: network, account: account, channel: chan, sender: %{nick: nick}} = m) do
     {user, account} = if user = find_by_nick(network, nick) do
       {touch_struct(user, chan), account || Nola.Account.lookup(user)}
     else
@@ -248,7 +248,7 @@ defmodule Nola.UserTrack do
     Storage.insert(User.to_tuple(user))
     if chan, do: Nola.Membership.touch(account, network, chan)
     if !m.account do
-      {:ok, %IRC.Message{m | account: account}}
+      {:ok, %Nola.Message{m | account: account}}
     else
       :ok
     end
diff --git a/lib/plugins/account.ex b/lib/plugins/account.ex
index 96405bb..20abab7 100644
--- a/lib/plugins/account.ex
+++ b/lib/plugins/account.ex
@@ -21,7 +21,7 @@ defmodule Nola.Plugins.Account do
       {:ok, nil}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "help"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "help"}}, state) do
       text = [
         "account: show current account and auth token",
         "auth: show authentications methods",
@@ -38,7 +38,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "auth"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "auth"}}, state) do
       spec = [{{:"$1", :"$2"}, [{:==, :"$2", {:const, account.id}}], [:"$1"]}]
       predicates = :dets.select(Nola.Account.file("predicates"), spec)
       text = for {net, {key, value}} <- predicates, do: "#{net}: #{to_string(key)}: #{value}"
@@ -46,7 +46,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "whoami"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "whoami"}}, state) do
       users = for user <- Nola.UserTrack.find_by_account(m.account) do
         chans = Enum.map(user.privileges, fn({chan, _}) -> chan end)
                 |> Enum.join(" ")
@@ -56,7 +56,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "account"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "account"}}, state) do
       account = Nola.Account.lookup(m.sender)
       text = ["Account Id: #{account.id}",
         "Authenticate to this account from another network: \"auth #{account.id} #{account.token}\" to the other bot!"]
@@ -64,7 +64,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{sender: sender, text: "auth"<>_}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{sender: sender, text: "auth"<>_}}, state) do
       #account = Nola.Account.lookup(m.sender)
       case String.split(m.text, " ") do
         ["auth", id, token] ->
@@ -75,13 +75,13 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "set-name "<>name}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "set-name "<>name}}, state) do
       Nola.Account.update_account_name(account, name)
       m.replyfun.("Name changed: #{name}")
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "disable-sms"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "disable-sms"}}, state) do
       if Nola.Account.get_meta(m.account, "sms-number") do
         Nola.Account.delete_meta(m.account, "sms-number")
         m.replfyun.("SMS disabled.")
@@ -91,14 +91,14 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "web"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "web"}}, state) do
       auth_url = Untappd.auth_url()
       login_url = Nola.AuthToken.new_url(m.account.id, nil)
       m.replyfun.("-> " <> login_url)
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "enable-sms"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "enable-sms"}}, state) do
       code = String.downcase(EntropyString.small_id())
       Nola.Account.put_meta(m.account, "sms-validation-code", code)
       Nola.Account.put_meta(m.account, "sms-validation-target", m.network)
@@ -109,7 +109,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "enable-telegram"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "enable-telegram"}}, state) do
       code = String.downcase(EntropyString.small_id())
       Nola.Account.delete_meta(m.account, "telegram-id")
       Nola.Account.put_meta(m.account, "telegram-validation-code", code)
@@ -120,14 +120,14 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "enable-untappd"}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "enable-untappd"}}, state) do
       auth_url = Untappd.auth_url()
       login_url = Nola.AuthToken.new_url(m.account.id, {:external_redirect, auth_url})
       m.replyfun.(["To link your Untappd account, open this URL:", login_url])
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "getmeta"<>_}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "getmeta"<>_}}, state) do
       result = case String.split(m.text, " ") do
         ["getmeta"] ->
           for {k, v} <- Nola.Account.get_all_meta(m.account) do
@@ -150,7 +150,7 @@ defmodule Nola.Plugins.Account do
       {:noreply, state}
     end
 
-    def handle_info({:irc, :text, m = %IRC.Message{text: "setusermeta"<>_}}, state) do
+    def handle_info({:irc, :text, m = %Nola.Message{text: "setusermeta"<>_}}, state) do
       result = case String.split(m.text, " ") do
         ["setusermeta", key, value] ->
           Nola.Account.put_user_meta(m.account, key, value)
diff --git a/lib/plugins/alcoolog.ex b/lib/plugins/alcoolog.ex
index cc56c4f..41b5a4f 100644
--- a/lib/plugins/alcoolog.ex
+++ b/lib/plugins/alcoolog.ex
@@ -101,12 +101,12 @@ defmodule Nola.Plugins.Alcoolog do
   end
 
   @eau ["santo", "santeau"]
-  def handle_info({:irc, :trigger, santeau, m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) when santeau in @eau do
+  def handle_info({:irc, :trigger, santeau, m = %Nola.Message{trigger: %Nola.Trigger{args: _, type: :bang}}}, state) when santeau in @eau do
     Nola.Plugins.Txt.reply_random(m, "alcoolog.santo")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "soif", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "soif", m = %Nola.Message{trigger: %Nola.Trigger{args: _, type: :bang}}}, state) do
     now = DateTime.utc_now()
           |> Timex.Timezone.convert("Europe/Paris")
     apero = format_duration_from_now(%DateTime{now | hour: 18, minute: 0, second: 0}, false)
@@ -161,7 +161,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "sobrepour", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "sobrepour", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     args = Enum.join(args, " ")
     {:ok, now} = DateTime.now("Europe/Paris", Tzdata.TimeZoneDatabase)
     time = case args do
@@ -220,20 +220,20 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolog", m = %Nola.Message{trigger: %Nola.Trigger{args: [], type: :plus}}}, state) do
     {:ok, token} = Nola.Token.new({:alcoolog, :index, m.sender.network, m.channel})
     url = NolaWeb.Router.Helpers.alcoolog_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel), token)
     m.replyfun.("-> #{url}")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolog", m = %Nola.Message{trigger: %Nola.Trigger{args: [], type: :bang}}}, state) do
     url = NolaWeb.Router.Helpers.alcoolog_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel))
     m.replyfun.("-> #{url}")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcool", m = %IRC.Message{trigger: %IRC.Trigger{args: args = [cl, deg], type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "alcool", m = %Nola.Message{trigger: %Nola.Trigger{args: args = [cl, deg], type: :bang}}}, state) do
     {cl, _} = Util.float_paparse(cl)
     {deg, _} = Util.float_paparse(deg)
     points = Alcool.units(cl, deg)
@@ -253,7 +253,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: [cl, deg | comment], type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "santai", m = %Nola.Message{trigger: %Nola.Trigger{args: [cl, deg | comment], type: :bang}}}, state) do
     santai(m, state, cl, deg, comment)
     {:noreply, state}
   end
@@ -263,14 +263,14 @@ defmodule Nola.Plugins.Alcoolog do
     "{{message.sender.nick}}: et voilà la petite sœur !"
   ]
 
-  def handle_info({:irc, :trigger, "bis", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "bis", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     handle_info({:irc, :trigger, "moar", m}, state)
   end
-  def handle_info({:irc, :trigger, "again", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "again", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     handle_info({:irc, :trigger, "moar", m}, state)
   end
 
-  def handle_info({:irc, :trigger, "moar", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "moar", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     case get_statistics_for_nick(state, m.account.id) do
       {_, obj = {_, _date, _points, _active, cl, deg, _name, comment, _meta}} ->
         cl = case args do
@@ -461,7 +461,7 @@ defmodule Nola.Plugins.Alcoolog do
     end
   end
 
-  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "santai", m = %Nola.Message{trigger: %Nola.Trigger{args: _, type: :bang}}}, state) do
     m.replyfun.("!santai <cl> <degrés> [commentaire]")
     {:noreply, state}
   end
@@ -580,7 +580,7 @@ defmodule Nola.Plugins.Alcoolog do
     end
   end
 
-  def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :dot}}}, state) do
+  def handle_info({:irc, :trigger, "sobre", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :dot}}}, state) do
     nicks = Nola.Membership.expanded_members_or_friends(m.account, m.network, m.channel)
     |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end)
     |> Enum.filter(fn({_nick, status}) -> status && status.sober_in && status.sober_in > 0 end)
@@ -610,7 +610,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "sobre", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     account = case args do
       [nick] -> Nola.Account.find_always_by_nick(m.network, m.channel, nick)
       [] -> m.account
@@ -641,7 +641,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :dot}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolisme", m = %Nola.Message{trigger: %Nola.Trigger{args: [], type: :dot}}}, state) do
     nicks = Nola.Membership.expanded_members_or_friends(m.account, m.network, m.channel)
     |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end)
     |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end)
@@ -672,7 +672,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [time], type: :dot}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolisme", m = %Nola.Message{trigger: %Nola.Trigger{args: [time], type: :dot}}}, state) do
     time = case time do
       "semaine" -> 7
       string ->
@@ -795,14 +795,14 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolisme", m = %Nola.Message{trigger: %Nola.Trigger{args: [], type: :plus}}}, state) do
     meta = get_user_meta(state, m.account.id)
     hf = if meta.sex, do: "h", else: "f"
     m.replyfun.("+alcoolisme sexe: #{hf} poids: #{meta.weight} facteur de perte: #{meta.loss_factor}")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [h, weight | rest], type: :plus}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolisme", m = %Nola.Message{trigger: %Nola.Trigger{args: [h, weight | rest], type: :plus}}}, state) do
     h = case h do
       "h" -> true
       "f" -> false
@@ -842,7 +842,7 @@ defmodule Nola.Plugins.Alcoolog do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :minus}}}, state) do
+  def handle_info({:irc, :trigger, "santai", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :minus}}}, state) do
     case get_statistics_for_nick(state, m.account.id) do
       {_, obj = {_, date, points, _last_active, _cl, _deg, type, descr, _meta}} ->
         :dets.delete_object(state.dets, obj)
@@ -862,7 +862,7 @@ defmodule Nola.Plugins.Alcoolog do
   end
 
 
-  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "alcoolisme", m = %Nola.Message{trigger: %Nola.Trigger{args: args, type: :bang}}}, state) do
     {account, duration} = case args do
       [nick | rest] -> {Nola.Account.find_always_by_nick(m.network, m.channel, nick), rest}
       [] -> {m.account, []}
diff --git a/lib/plugins/boursorama.ex b/lib/plugins/boursorama.ex
index 77977a5..025a250 100644
--- a/lib/plugins/boursorama.ex
+++ b/lib/plugins/boursorama.ex
@@ -25,7 +25,7 @@ defmodule Nola.Plugins.Boursorama do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, cac, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) when cac in ["cac40", "caca40"] do
+  def handle_info({:irc, :trigger, cac, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang}}}, state) when cac in ["cac40", "caca40"] do
     case HTTPoison.get(@cac40_url, [], []) do
       {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
         html = Floki.parse(body)
diff --git a/lib/plugins/calc.ex b/lib/plugins/calc.ex
index e58e1b1..2ff6cb4 100644
--- a/lib/plugins/calc.ex
+++ b/lib/plugins/calc.ex
@@ -16,7 +16,7 @@ defmodule Nola.Plugins.Calc do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, "calc", message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: expr_list}}}, state) do
+  def handle_info({:irc, :trigger, "calc", message = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: expr_list}}}, state) do
     expr = Enum.join(expr_list, " ")
     result = try do
       case Abacus.eval(expr) do
diff --git a/lib/plugins/coronavirus.ex b/lib/plugins/coronavirus.ex
index 31483aa..afd8a33 100644
--- a/lib/plugins/coronavirus.ex
+++ b/lib/plugins/coronavirus.ex
@@ -38,7 +38,7 @@ defmodule Nola.Plugins.Coronavirus do
     {:noreply, %{data: data}}
   end
 
-  def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :bang, args: args}}}, state) when args in [
+  def handle_info({:irc, :trigger, "coronavirus", m = %Nola.Message{trigger: %{type: :bang, args: args}}}, state) when args in [
     [], ["morts"], ["confirmés"], ["soignés"], ["malades"], ["n"], ["nmorts"], ["nsoignés"], ["nconfirmés"]] do
     {field, name} = case args do
       ["confirmés"] -> {:confirmed, "confirmés"}
@@ -72,7 +72,7 @@ defmodule Nola.Plugins.Coronavirus do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :bang, args: location}}}, state) do
+  def handle_info({:irc, :trigger, "coronavirus", m = %Nola.Message{trigger: %{type: :bang, args: location}}}, state) do
     location = Enum.join(location, " ") |> String.downcase()
     if data = Map.get(state.data, location) do
       m.replyfun.("coronavirus: #{location}: "
@@ -84,7 +84,7 @@ defmodule Nola.Plugins.Coronavirus do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :query, args: location}}}, state) do
+  def handle_info({:irc, :trigger, "coronavirus", m = %Nola.Message{trigger: %{type: :query, args: location}}}, state) do
     m.replyfun.("https://github.com/CSSEGISandData/COVID-19")
     {:noreply, state}
   end
diff --git a/lib/plugins/correction.ex b/lib/plugins/correction.ex
index 067f468..b50733b 100644
--- a/lib/plugins/correction.ex
+++ b/lib/plugins/correction.ex
@@ -17,11 +17,11 @@ defmodule Nola.Plugins.Correction do
   end
 
   # Trigger fallback
-  def handle_info({:irc, :trigger, _, m = %IRC.Message{}}, state) do
+  def handle_info({:irc, :trigger, _, m = %Nola.Message{}}, state) do
     {:noreply, correction(m, state)}
   end
 
-  def handle_info({:irc, :text, m = %IRC.Message{}}, state) do
+  def handle_info({:irc, :text, m = %Nola.Message{}}, state) do
     {:noreply, correction(m, state)}
   end
 
diff --git a/lib/plugins/gpt.ex b/lib/plugins/gpt.ex
index 1171d19..f89bec1 100644
--- a/lib/plugins/gpt.ex
+++ b/lib/plugins/gpt.ex
@@ -46,7 +46,7 @@ defmodule Nola.Plugins.Gpt do
     {:ok, %__MODULE__{temprefs: new_temp_refs()}}
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [prompt | args]}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: [prompt | args]}}}, state) do
     case Couch.get(@couch_db, prompt) do
       {:ok, prompt} -> {:noreply, prompt(m, prompt, Enum.join(args, " "), state)}
       {:error, :not_found} ->
@@ -59,7 +59,7 @@ defmodule Nola.Plugins.Gpt do
     end
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: []}}}, state) do
     case Couch.get(@couch_db, "_all_docs") do
       {:ok, %{"rows" => []}} -> m.replyfun.("gpt: no prompts available")
       {:ok, %{"rows" => prompts}} ->
@@ -72,7 +72,7 @@ defmodule Nola.Plugins.Gpt do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :plus, args: [ref_or_id | args]}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :plus, args: [ref_or_id | args]}}}, state) do
     id = lookup_temp_ref(ref_or_id, state.temprefs, ref_or_id)
     case Couch.get(@couch_run_db, id) do
       {:ok, run} ->
@@ -88,7 +88,7 @@ defmodule Nola.Plugins.Gpt do
     end
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: ["offensive" | text]}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :query, args: ["offensive" | text]}}}, state) do
     text = Enum.join(text, " ")
     {moderate?, moderation} = moderation(text, m.account.id)
     reply = cond do
@@ -100,7 +100,7 @@ defmodule Nola.Plugins.Gpt do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: ["show", ref_or_id]}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :query, args: ["show", ref_or_id]}}}, state) do
     id = lookup_temp_ref(ref_or_id, state.temprefs, ref_or_id)
     url = if m.channel do
       NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :result, m.network, NolaWeb.format_chan(m.channel), id)
@@ -111,7 +111,7 @@ defmodule Nola.Plugins.Gpt do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: [prompt]}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :query, args: [prompt]}}}, state) do
     url = if m.channel do
       NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :prompt, m.network, NolaWeb.format_chan(m.channel), prompt)
     else
diff --git a/lib/plugins/logger.ex b/lib/plugins/logger.ex
index 77bee8b..3d643d3 100644
--- a/lib/plugins/logger.ex
+++ b/lib/plugins/logger.ex
@@ -52,7 +52,7 @@ defmodule Nola.Plugins.Logger do
       state
   end
 
-  def format_to_db(msg = %IRC.Message{id: id}) do
+  def format_to_db(msg = %Nola.Message{id: id}) do
     msg
     |> Poison.encode!()
     |> Map.drop("id")
diff --git a/lib/plugins/outline.ex b/lib/plugins/outline.ex
index 1f1c1e1..ba8314d 100644
--- a/lib/plugins/outline.ex
+++ b/lib/plugins/outline.ex
@@ -32,26 +32,26 @@ defmodule Nola.Plugins.Outline do
     {:ok, %__MODULE__{file: file, hosts: hosts}}
   end
 
-  def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :plus, args: [host]}}}, state) do
+  def handle_info({:irc, :trigger, "outline", message = %Nola.Message{trigger: %Nola.Trigger{type: :plus, args: [host]}}}, state) do
     state = %{state | hosts: [host | state.hosts]}
     save(state)
     message.replyfun.("ok")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :minus, args: [host]}}}, state) do
+  def handle_info({:irc, :trigger, "outline", message = %Nola.Message{trigger: %Nola.Trigger{type: :minus, args: [host]}}}, state) do
     state = %{state | hosts: List.delete(state.hosts, host)}
     save(state)
     message.replyfun.("ok")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [url]}}}, state) do
+  def handle_info({:irc, :trigger, "outline", message = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: [url]}}}, state) do
     line = "-> #{outline(url)}"
     message.replyfun.(line)
   end
 
-  def handle_info({:irc, :text, message = %IRC.Message{text: text}}, state) do
+  def handle_info({:irc, :text, message = %Nola.Message{text: text}}, state) do
     String.split(text)
     |> Enum.map(fn(word) ->
       if String.starts_with?(word, "http://") || String.starts_with?(word, "https://") do
diff --git a/lib/plugins/preums.ex b/lib/plugins/preums.ex
index 505ce7f..83d99cd 100644
--- a/lib/plugins/preums.ex
+++ b/lib/plugins/preums.ex
@@ -122,7 +122,7 @@ defmodule Nola.Plugins.Preums do
   end
 
   # Latest
-  def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "preums", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang}}}, state) do
     channelkey = {m.network, m.channel}
     state = handle_preums(m, state)
     tz = timezone(channelkey)
@@ -151,7 +151,7 @@ defmodule Nola.Plugins.Preums do
   end
 
   # Stats
-  def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :dot}}}, state) do
+  def handle_info({:irc, :trigger, "preums", m = %Nola.Message{trigger: %Nola.Trigger{type: :dot}}}, state) do
     channel = {m.network, m.channel}
     state = handle_preums(m, state)
     top = topnicks(state.dets, channel, sort_by: :score)
@@ -173,7 +173,7 @@ defmodule Nola.Plugins.Preums do
   end
 
   # Help
-  def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :query}}}, state) do
+  def handle_info({:irc, :trigger, "preums", m = %Nola.Message{trigger: %Nola.Trigger{type: :query}}}, state) do
     state = handle_preums(m, state)
     msg = "!preums - preums du jour, .preums top preumseurs"
     m.replymsg.(msg)
@@ -181,13 +181,13 @@ defmodule Nola.Plugins.Preums do
   end
 
   # Trigger fallback
-  def handle_info({:irc, :trigger, _, m = %IRC.Message{}}, state) do
+  def handle_info({:irc, :trigger, _, m = %Nola.Message{}}, state) do
     state = handle_preums(m, state)
     {:noreply, state}
   end
 
   # Message fallback
-  def handle_info({:irc, :text, m = %IRC.Message{}}, state) do
+  def handle_info({:irc, :text, m = %Nola.Message{}}, state) do
     {:noreply, handle_preums(m, state)}
   end
 
@@ -236,11 +236,11 @@ defmodule Nola.Plugins.Preums do
     Keyword.get(channel_settings, :tz, default) || default
   end
 
-  defp handle_preums(%IRC.Message{channel: nil}, state) do
+  defp handle_preums(%Nola.Message{channel: nil}, state) do
     state
   end
 
-  defp handle_preums(m = %IRC.Message{text: text, sender: sender}, state) do
+  defp handle_preums(m = %Nola.Message{text: text, sender: sender}, state) do
     channel = {m.network, m.channel}
     tz = timezone(channel)
     {:ok, now} = DateTime.now(tz, Tzdata.TimeZoneDatabase)
diff --git a/lib/plugins/quatre_cent_vingt.ex b/lib/plugins/quatre_cent_vingt.ex
index 254f5ce..6b3cc46 100644
--- a/lib/plugins/quatre_cent_vingt.ex
+++ b/lib/plugins/quatre_cent_vingt.ex
@@ -45,7 +45,7 @@ defmodule Nola.Plugins.QuatreCentVingt do
 
   for coeff <- @coeffs do
     qvc = to_string(420 * coeff)
-    def handle_info({:irc, :trigger, unquote(qvc), m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :bang}}}, dets) do
+    def handle_info({:irc, :trigger, unquote(qvc), m = %Nola.Message{trigger: %Nola.Trigger{args: [], type: :bang}}}, dets) do
       {count, last} = get_statistics_for_nick(dets, m.account.id)
       count = count + unquote(coeff)
       text = achievement_text(count)
@@ -64,7 +64,7 @@ defmodule Nola.Plugins.QuatreCentVingt do
     end
   end
 
-  def handle_info({:irc, :trigger, "420", m = %IRC.Message{trigger: %IRC.Trigger{args: [nick], type: :bang}}}, dets) do
+  def handle_info({:irc, :trigger, "420", m = %Nola.Message{trigger: %Nola.Trigger{args: [nick], type: :bang}}}, dets) do
     account = Nola.Account.find_by_nick(m.network, nick)
     if account do
       text = case get_statistics_for_nick(dets, m.account.id) do
diff --git a/lib/plugins/radio_france.ex b/lib/plugins/radio_france.ex
index a2a1c7b..d95c54a 100644
--- a/lib/plugins/radio_france.ex
+++ b/lib/plugins/radio_france.ex
@@ -29,21 +29,21 @@ defmodule Nola.Plugins.RadioFrance do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, "rf", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) do
+  def handle_info({:irc, :trigger, "rf", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang}}}, state) do
     handle_info({:irc, :trigger, "radiofrance", m}, state)
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: []}}}, state) do
     m.replyfun.("radiofrance: précisez la station!")
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do
+  def handle_info({:irc, :trigger, @trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: args}}}, state) do
     now(args_to_station(args), m)
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) when trigger in @shortcuts do
+  def handle_info({:irc, :trigger, trigger, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: args}}}, state) when trigger in @shortcuts do
     now(args_to_station([trigger | args]), m)
     {:noreply, state}
   end
diff --git a/lib/plugins/seen.ex b/lib/plugins/seen.ex
index cdebd59..045702c 100644
--- a/lib/plugins/seen.ex
+++ b/lib/plugins/seen.ex
@@ -19,7 +19,7 @@ defmodule Nola.Plugins.Seen do
     {:ok, %{dets: dets}}
   end
 
-  def handle_info({:irc, :trigger, "seen", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [nick]}}}, state) do
+  def handle_info({:irc, :trigger, "seen", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: [nick]}}}, state) do
     witness(m, state)
     m.replyfun.(last_seen(m.channel, nick, state))
     {:noreply, state}
@@ -35,7 +35,7 @@ defmodule Nola.Plugins.Seen do
     {:noreply, state}
   end
 
-  defp witness(%IRC.Message{channel: channel, text: text, sender: %{nick: nick}}, %{dets: dets}) do
+  defp witness(%Nola.Message{channel: channel, text: text, sender: %{nick: nick}}, %{dets: dets}) do
     :dets.insert(dets, {{channel, nick}, DateTime.utc_now(), text})
     :ok
   end
diff --git a/lib/plugins/sms.ex b/lib/plugins/sms.ex
index afc1eb1..a3b7b7d 100644
--- a/lib/plugins/sms.ex
+++ b/lib/plugins/sms.ex
@@ -33,7 +33,7 @@ defmodule Nola.Plugins.Sms do
       else
         "!"<>message
       end
-      message = %IRC.Message{
+      message = %Nola.Message{
         id: FlakeId.get(),
         transport: :sms,
         network: "sms",
@@ -95,7 +95,7 @@ defmodule Nola.Plugins.Sms do
     :ignore
   end
 
-  def handle_info({:irc, :trigger, "sms", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [nick | text]}}}, state) do
+  def handle_info({:irc, :trigger, "sms", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: [nick | text]}}}, state) do
     with \
         {:tree, false} <- {:tree, m.sender.nick == "Tree"},
         {_, %Nola.Account{} = account} <- {:account, Nola.Account.find_always_by_nick(m.network, m.channel, nick)},
diff --git a/lib/plugins/tell.ex b/lib/plugins/tell.ex
index 43da9e7..bc1f24e 100644
--- a/lib/plugins/tell.ex
+++ b/lib/plugins/tell.ex
@@ -33,7 +33,7 @@ defmodule Nola.Plugins.Tell do
     {:noreply, state}
   end
 
-  def handle_info({:irc, :trigger, "tell", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [target | message]}}}, state) do
+  def handle_info({:irc, :trigger, "tell", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: [target | message]}}}, state) do
     do_tell(state, m, target, message)
     {:noreply, state}
   end
diff --git a/lib/plugins/untappd.ex b/lib/plugins/untappd.ex
index e1731bd..e409172 100644
--- a/lib/plugins/untappd.ex
+++ b/lib/plugins/untappd.ex
@@ -22,7 +22,7 @@ defmodule Nola.Plugins.Untappd do
     {:ok, %{}}
   end
 
-  def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %{type: :bang, args: args}}}, state) do
+  def handle_info({:irc, :trigger, _, m = %Nola.Message{trigger: %{type: :bang, args: args}}}, state) do
     case Untappd.search_beer(Enum.join(args, " "), limit: 1) do
       {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => [result | _]}}}} ->
         %{"beer" => beer, "brewery" => brewery} = result
@@ -44,7 +44,7 @@ defmodule Nola.Plugins.Untappd do
   end
 
 
-  def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %{type: :query, args: args}}}, state) do
+  def handle_info({:irc, :trigger, _, m = %Nola.Message{trigger: %{type: :query, args: args}}}, state) do
     case Untappd.search_beer(Enum.join(args, " ")) do
       {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => results}}}} ->
         beers = for %{"beer" => beer, "brewery" => brewery} <- results do
diff --git a/lib/plugins/user_mention.ex b/lib/plugins/user_mention.ex
index f26f1d6..e7c7420 100644
--- a/lib/plugins/user_mention.ex
+++ b/lib/plugins/user_mention.ex
@@ -19,7 +19,7 @@ defmodule Nola.Plugins.UserMention do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, nick, message = %IRC.Message{sender: sender, account: account, network: network, channel: channel, trigger: %IRC.Trigger{type: :at, args: content}}}, state) do
+  def handle_info({:irc, :trigger, nick, message = %Nola.Message{sender: sender, account: account, network: network, channel: channel, trigger: %Nola.Trigger{type: :at, args: content}}}, state) do
     nick = nick
     |> String.trim(":")
     |> String.trim(",")
diff --git a/lib/plugins/wikipedia.ex b/lib/plugins/wikipedia.ex
index caef306..47b14da 100644
--- a/lib/plugins/wikipedia.ex
+++ b/lib/plugins/wikipedia.ex
@@ -19,11 +19,11 @@ defmodule Nola.Plugins.Wikipedia do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do
+  def handle_info({:irc, :trigger, _, message = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: []}}}, state) do
     irc_random(message)
     {:noreply, state}
   end
-  def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do
+  def handle_info({:irc, :trigger, _, message = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: args}}}, state) do
     irc_search(Enum.join(args, " "), message)
     {:noreply, state}
   end
diff --git a/lib/plugins/wolfram_alpha.ex b/lib/plugins/wolfram_alpha.ex
index 02c1c51..120af16 100644
--- a/lib/plugins/wolfram_alpha.ex
+++ b/lib/plugins/wolfram_alpha.ex
@@ -19,7 +19,7 @@ defmodule Nola.Plugins.WolframAlpha do
     {:ok, nil}
   end
 
-  def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: query}}}, state) do
+  def handle_info({:irc, :trigger, _, m = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: query}}}, state) do
     query = Enum.join(query, " ")
     params = %{
       "appid" => Keyword.get(Application.get_env(:nola, :wolframalpha, []), :app_id, "NO_APP_ID"),
diff --git a/lib/plugins/youtube.ex b/lib/plugins/youtube.ex
index e23fd45..39bf03d 100644
--- a/lib/plugins/youtube.ex
+++ b/lib/plugins/youtube.ex
@@ -20,7 +20,7 @@ defmodule Nola.Plugins.YouTube do
     {:ok, %__MODULE__{}}
   end
 
-  def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do
+  def handle_info({:irc, :trigger, _, message = %Nola.Message{trigger: %Nola.Trigger{type: :bang, args: args}}}, state) do
     irc_search(Enum.join(args, " "), message)
     {:noreply, state}
   end
diff --git a/lib/telegram/room.ex b/lib/telegram/room.ex
index cc10e90..8e95ca8 100644
--- a/lib/telegram/room.ex
+++ b/lib/telegram/room.ex
@@ -121,7 +121,7 @@ defmodule Nola.TelegramRoom do
     handle_info({:irc, nil, message}, state)
   end
 
-  def handle_info({:irc, _, message = %IRC.Message{sender: %{nick: nick}, text: text}}, state) do
+  def handle_info({:irc, _, message = %Nola.Message{sender: %{nick: nick}, text: text}}, state) do
     if Map.get(message.meta, :from) == self() do
     else
       body = if Map.get(message.meta, :self), do: text, else: "<#{nick}> #{text}"
diff --git a/lib/telegram/telegram.ex b/lib/telegram/telegram.ex
index dd23146..9a2812d 100644
--- a/lib/telegram/telegram.ex
+++ b/lib/telegram/telegram.ex
@@ -195,7 +195,7 @@ defmodule Nola.Telegram do
       true ->
         "!"<>text
     end
-      message = %IRC.Message{
+      message = %Nola.Message{
         id: FlakeId.get(),
         transport: :telegram,
       network: "telegram",
diff --git a/lib/tmpl.ex b/lib/tmpl.ex
index 62c2a46..e4489ac 100644
--- a/lib/tmpl.ex
+++ b/lib/tmpl.ex
@@ -56,7 +56,7 @@ defmodule Tmpl do
 
   end
 
-  def render(template, msg = %IRC.Message{}, context \\ %{}, safe \\ true) do
+  def render(template, msg = %Nola.Message{}, context \\ %{}, safe \\ true) do
     do_render(template, Map.put(context, "message", msg), safe)
   end
 
diff --git a/lib/web/live/chat_live.html.heex b/lib/web/live/chat_live.html.heex
index 29cd6a1..470604f 100644
--- a/lib/web/live/chat_live.html.heex
+++ b/lib/web/live/chat_live.html.heex
@@ -24,7 +24,7 @@
 
       <ul class="pt-4 pl-4">
           <%= for message <- @backlog do %>
-              <%= if is_map(message) && Map.get(message, :__struct__) == IRC.Message do %>
+              <%= if is_map(message) && Map.get(message, :__struct__) == Nola.Message do %>
               <li class="flex gap-2 place-items-center message"
                   data-account-id={message.account.id}>
                 <NolaWeb.MessageComponent.content