diff --git a/lib/irc/account.ex b/lib/irc/account.ex
index beb8daa..46c7f6e 100644
--- a/lib/irc/account.ex
+++ b/lib/irc/account.ex
@@ -1,451 +1,451 @@
 defmodule IRC.Account do
   alias IRC.UserTrack.User
 
   @moduledoc """
   Account registry....
 
   Maps a network predicate:
     * `{net, {:nick, nickname}}`
     * `{net, {:account, account}}`
     * `{net, {:mask, user@host}}`
   to an unique identifier, that can be shared over multiple networks.
 
   If a predicate cannot be found for an existing account, a new account will be made in the database.
 
   To link two existing accounts from different network onto a different one, a merge operation is provided.
 
   """
 
   # FIXME: Ensure uniqueness of name?
 
   @derive {Poison.Encoder, except: [:token]}
   defstruct [:id, :name, :token]
   @type t :: %__MODULE__{id: id(), name: String.t()}
   @type id :: String.t()
 
   defimpl Inspect, for: __MODULE__ do
     import Inspect.Algebra
 
     def inspect(%{id: id, name: name}, opts) do
       concat(["#IRC.Account[", id, " ", name, "]"])
     end
   end
 
   def file(base) do
     to_charlist(LSG.data_path() <> "/account_#{base}.dets")
   end
 
   defp from_struct(%__MODULE__{id: id, name: name, token: token}) do
     {id, name, token}
   end
 
   defp from_tuple({id, name, token}) do
     %__MODULE__{id: id, name: name, token: token}
   end
 
   def start_link() do
     GenServer.start_link(__MODULE__, [], [name: __MODULE__])
   end
 
   def init(_) do
     {:ok, accounts} = :dets.open_file(file("db"), [])
     {:ok, meta} = :dets.open_file(file("meta"), [])
     {:ok, predicates} = :dets.open_file(file("predicates"), [{:type, :set}])
     {:ok, %{accounts: accounts, meta: meta, predicates: predicates}}
   end
 
   def get(id) do
     case :dets.lookup(file("db"), id) do
       [account] -> from_tuple(account)
       _ -> nil
     end
   end
 
   def get_by_name(name) do
     spec = [{{:_, :"$1", :_}, [{:==, :"$1", {:const, name}}], [:"$_"]}]
     case :dets.select(file("db"), spec) do
       [account] -> from_tuple(account)
       _ -> nil
     end
   end
 
   def get_meta(%__MODULE__{id: id}, key, default \\ nil) do
     case :dets.lookup(file("meta"), {id, key}) do
       [{_, value}] -> (value || default)
       _ -> default
     end
   end
 
   @spec find_meta_accounts(String.t()) :: [{account :: t(), value :: String.t()}, ...]
   @doc "Find all accounts that have a meta of `key`."
   def find_meta_accounts(key) do
     spec = [{{{:"$1", :"$2"}, :"$3"}, [{:==, :"$2", {:const, key}}], [{{:"$1", :"$3"}}]}]
     for {id, val} <- :dets.select(file("meta"), spec), do: {get(id), val}
   end
 
   @doc "Find an account given a specific meta `key` and `value`."
   @spec find_meta_account(String.t(), String.t()) :: t() | nil
   def find_meta_account(key, value) do
     #spec = [{{{:"$1", :"$2"}, :"$3"}, [:andalso, {:==, :"$2", {:const, key}}, {:==, :"$3", {:const, value}}], [:"$1"]}]
     spec = [{{{:"$1", :"$2"}, :"$3"}, [{:andalso, {:==, :"$2", {:const, key}}, {:==, {:const, value}, :"$3"}}], [:"$1"]}]
     case :dets.select(file("meta"), spec) do
       [id] -> get(id)
       _ -> nil
     end
   end
 
   def get_all_meta(%__MODULE__{id: id}) do
     spec = [{{{:"$1", :"$2"}, :"$3"}, [{:==, :"$1", {:const, id}}], [{{:"$2", :"$3"}}]}]
     :dets.select(file("meta"), spec)
   end
 
   def put_user_meta(account = %__MODULE__{}, key, value) do
     put_meta(account, "u:"<>key, value)
   end
 
   def put_meta(%__MODULE__{id: id}, key, value) do
     :dets.insert(file("meta"), {{id, key}, value})
   end
 
   def delete_meta(%__MODULE__{id: id}, key) do
     :dets.delete(file("meta"), {id, key})
   end
 
   def all_accounts() do
     :dets.traverse(file("db"), fn(obj) -> {:continue, from_tuple(obj)} end)
   end
 
   def all_predicates() do
     :dets.traverse(file("predicates"), fn(obj) -> {:continue, obj} end)
   end
 
   def all_meta() do
     :dets.traverse(file("meta"), fn(obj) -> {:continue, obj} end)
   end
 
   def merge_account(old_id, new_id) do
     if old_id != new_id do
       spec = [{{:"$1", :"$2"}, [{:==, :"$2", {:const, old_id}}], [:"$1"]}]
       predicates = :dets.select(file("predicates"), spec)
       for pred <- predicates, do: :ok = :dets.insert(file("predicates"), {pred, new_id})
       spec = [{{{:"$1", :"$2"}, :"$3"}, [{:==, :"$1", {:const, old_id}}], [{{:"$2", :"$3"}}]}]
       metas = :dets.select(file("meta"), spec)
       for {k,v} <- metas do
         :dets.delete(file("meta"), {{old_id, k}})
         :ok = :dets.insert(file("meta"), {{new_id, k}, v})
       end
       :dets.delete(file("db"), old_id)
       IRC.Membership.merge_account(old_id, new_id)
       IRC.UserTrack.merge_account(old_id, new_id)
       IRC.Connection.dispatch("account", {:account_change, old_id, new_id})
       IRC.Connection.dispatch("conn", {:account_change, old_id, new_id})
     end
     :ok
   end
 
   @doc "Find an account by a logged in user"
   def find_by_nick(network, nick) do
     do_lookup(%ExIRC.SenderInfo{nick: nick, network: network}, false)
   end
 
   @doc "Always find an account by nickname, even if offline. Uses predicates and then account name."
   def find_always_by_nick(network, chan, nick) do
     with \
       nil <- find_by_nick(network, nick),
          nil <- do_lookup(%User{network: network, nick: nick}, false),
          nil <- get_by_name(nick)
     do
       nil
     else
       %__MODULE__{} = account ->
         memberships = IRC.Membership.of_account(account)
         if Enum.any?(memberships, fn({net, ch}) -> (net == network) or (chan && chan == ch) end) do
           account
         else
           nil
         end
     end
   end
 
   def find(something) do
     do_lookup(something, false)
   end
 
   def lookup(something, make_default \\ true) do
     account = do_lookup(something, make_default)
     if account && Map.get(something, :nick) do
       IRC.Connection.dispatch("account", {:account_auth, Map.get(something, :nick), account.id})
     end
     account
   end
 
   def handle_info(_, state) do
     {:noreply, state}
   end
 
   def handle_cast(_, state) do
     {:noreply, state}
   end
 
   def handle_call(_, _, state) do
     {:noreply, state}
   end
 
   def terminate(_, state) do
     for {_, dets} <- state do
       :dets.sync(dets)
       :dets.close(dets)
     end
   end
 
   defp do_lookup(message = %IRC.Message{account: account_id}, make_default) when is_binary(account_id) do
     get(account_id)
   end
 
   defp do_lookup(sender = %ExIRC.Who{}, make_default) do
     if user = IRC.UserTrack.find_by_nick(sender) do
       lookup(user, make_default)
     else
       #FIXME this will never work with continued lookup by other methods as Who isn't compatible
       lookup_by_nick(sender, :dets.lookup(file("predicates"), {sender.network,{:nick, sender.nick}}), make_default)
     end
   end
 
   defp do_lookup(sender = %ExIRC.SenderInfo{}, make_default) do
     lookup(IRC.UserTrack.find_by_nick(sender), make_default)
   end
 
   defp do_lookup(user = %User{account: id}, make_default) when is_binary(id) do
     get(id)
   end
 
   defp do_lookup(user = %User{network: server, nick: nick}, make_default) do
     lookup_by_nick(user, :dets.lookup(file("predicates"), {server,{:nick, nick}}), make_default)
   end
 
   defp do_lookup(nil, _) do
     nil
   end
 
   defp lookup_by_nick(_, [{_, id}], _make_default) do
     get(id)
   end
 
   defp lookup_by_nick(user, _, make_default) do
     #authenticate_by_host(user)
     if make_default, do: new_account(user), else: nil
   end
 
   def new_account(nick) do
     id = EntropyString.large_id()
     :dets.insert(file("db"), {id, nick, EntropyString.token()})
     get(id)
   end
 
-  defp new_account(%{nick: nick, network: server}) do
+  def new_account(%{nick: nick, network: server}) do
     id = EntropyString.large_id()
     :dets.insert(file("db"), {id, nick, EntropyString.token()})
     :dets.insert(file("predicates"), {{server, {:nick, nick}}, id})
     get(id)
   end
 
   def update_account_name(account = %__MODULE__{id: id}, name) do
     account = %__MODULE__{account | name: name}
     :dets.insert(file("db"), from_struct(account))
     get(id)
   end
 
   def get_predicates(%__MODULE__{} = account) do
     spec = [{{:"$1", :"$2"}, [{:==, :"$2", {:const, account.id}}], [:"$1"]}]
     :dets.select(file("predicates"), spec)
   end
 
   defmodule AccountPlugin do
     @moduledoc """
     # Account
 
     * **account** Get current account id and token
     * **auth `<account-id>` `<token>`** Authenticate and link the current nickname to an account
     * **auth** list authentications methods
     * **whoami** list currently authenticated users
     * **web** get a one-time login link to web
     * **enable-telegram** Link a Telegram account
     * **enable-sms** Link a SMS number
     * **enable-untappd** Link a Untappd account
     * **set-name** set account name
     * **setusermeta puppet-nick `<nick>`** Set puppet IRC nickname
     """
 
     def irc_doc, do: @moduledoc
     def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)
     def init(_) do
       {:ok, _} = Registry.register(IRC.PubSub, "messages:private", [])
       {:ok, nil}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "help"}}, state) do
       text = [
         "account: show current account and auth token",
         "auth: show authentications methods",
         "whoami: list authenticated users",
         "set-name <name>: set account name",
         "web: login to web",
         "enable-sms | disable-sms: enable/change or disable sms",
         "enable-telegram: link/change telegram",
         "enable-untappd: link untappd account",
         "getmeta: show meta datas",
         "setusermeta: set user meta",
       ]
       m.replyfun.(text)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "auth"}}, state) do
       spec = [{{:"$1", :"$2"}, [{:==, :"$2", {:const, account.id}}], [:"$1"]}]
       predicates = :dets.select(IRC.Account.file("predicates"), spec)
       text = for {net, {key, value}} <- predicates, do: "#{net}: #{to_string(key)}: #{value}"
       m.replyfun.(text)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "whoami"}}, state) do
       users = for user <- IRC.UserTrack.find_by_account(m.account) do
         chans = Enum.map(user.privileges, fn({chan, _}) -> chan end)
                 |> Enum.join(" ")
         "#{user.network} - #{user.nick}!#{user.username}@#{user.host} - #{chans}"
       end
       m.replyfun.(users)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "account"}}, state) do
       account = IRC.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!"]
       m.replyfun.(text)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{sender: sender, text: "auth"<>_}}, state) do
       #account = IRC.Account.lookup(m.sender)
       case String.split(m.text, " ") do
         ["auth", id, token] ->
           join_account(m, id, token)
         _ ->
           m.replyfun.("Invalid parameters")
       end
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{account: account, text: "set-name "<>name}}, state) do
       IRC.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
       if IRC.Account.get_meta(m.account, "sms-number") do
         IRC.Account.delete_meta(m.account, "sms-number")
         m.replfyun.("SMS disabled.")
       else
         m.replyfun.("SMS already disabled.")
       end
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{text: "web"}}, state) do
       auth_url = Untappd.auth_url()
       login_url = LSG.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
       code = String.downcase(EntropyString.small_id())
       IRC.Account.put_meta(m.account, "sms-validation-code", code)
       IRC.Account.put_meta(m.account, "sms-validation-target", m.network)
       number = LSG.IRC.SmsPlugin.my_number()
       text = "To enable or change your number for SMS messaging, please send:"
              <> " \"enable #{code}\" to #{number}"
       m.replyfun.(text)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{text: "enable-telegram"}}, state) do
       code = String.downcase(EntropyString.small_id())
       IRC.Account.delete_meta(m.account, "telegram-id")
       IRC.Account.put_meta(m.account, "telegram-validation-code", code)
       IRC.Account.put_meta(m.account, "telegram-validation-target", m.network)
       text = "To enable or change your number for telegram messaging, please open #{LSG.Telegram.my_path()} and send:"
              <> " \"/enable #{code}\""
       m.replyfun.(text)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{text: "enable-untappd"}}, state) do
       auth_url = Untappd.auth_url()
       login_url = LSG.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
       result = case String.split(m.text, " ") do
         ["getmeta"] ->
           for {k, v} <- IRC.Account.get_all_meta(m.account) do
             case k do
               "u:"<>key -> "(user) #{key}: #{v}"
               key -> "#{key}: #{v}"
             end
           end
         ["getmeta", key] ->
           value = IRC.Account.get_meta(m.account, key)
           text = if value do
             "#{key}: #{value}"
           else
             "#{key} is not defined"
           end
         _ ->
           "usage: getmeta [key]"
       end
       m.replyfun.(result)
       {:noreply, state}
     end
 
     def handle_info({:irc, :text, m = %IRC.Message{text: "setusermet"<>_}}, state) do
       result = case String.split(m.text, " ") do
         ["setusermeta", key, value] ->
           IRC.Account.put_user_meta(m.account, key, value)
           "ok"
         _ ->
           "usage: setusermeta <key> <value>"
       end
       m.replyfun.(result)
       {:noreply, state}
     end
 
     def handle_info(_, state) do
       {:noreply, state}
     end
 
     defp join_account(m, id, token) do
       old_account = IRC.Account.lookup(m.sender)
       new_account = IRC.Account.get(id)
       if new_account && token == new_account.token do
         case IRC.Account.merge_account(old_account.id, new_account.id) do
           :ok ->
             if old_account.id == new_account.id do
               m.replyfun.("Already authenticated, but hello")
             else
               m.replyfun.("Accounts merged!")
             end
           _ -> m.replyfun.("Something failed :(")
         end
       else
         m.replyfun.("Invalid token")
       end
     end
 
   end
 
 end
diff --git a/lib/irc/connection.ex b/lib/irc/connection.ex
index 1e94003..9382714 100644
--- a/lib/irc/connection.ex
+++ b/lib/irc/connection.ex
@@ -1,521 +1,521 @@
 defmodule IRC.Connection do
   require Logger
   use Ecto.Schema
 
   @moduledoc """
   # IRC Connection
 
   Provides a nicer abstraction over ExIRC's handlers.
 
   ## Start connections
 
   ```
   IRC.Connection.start_link(host: "irc.random.sh", port: 6697, nick: "pouetbot", channels: ["#dev"])
 
   ## PubSub topics
 
   * `account` -- accounts change
     * {:account_change, old_account_id, new_account_id} # Sent when account merged
     * {:accounts, [{:account, network, channel, nick, account_id}] # Sent on bot join
     * {:account, network, nick, account_id} # Sent on user join
   * `message` -- aill messages (without triggers)
   * `message:private` -- all messages without a channel
   * `message:#CHANNEL` -- all messages within `#CHANNEL`
   * `triggers` -- all triggers
   * `trigger:TRIGGER` -- any message with a trigger `TRIGGER`
 
   ## Replying to %IRC.Message{}
 
   Each `IRC.Message` comes with a dedicated `replyfun`, to which you only have to pass either:
 
   """
   def irc_doc, do: nil
 
   @min_backoff :timer.seconds(5)
   @max_backoff :timer.seconds(2*60)
 
   embedded_schema do
     field :network, :string
     field :host, :string
     field :port, :integer
     field :nick, :string
     field :user, :string
     field :name, :string
     field :pass, :string
     field :tls, :boolean, default: false
     field :channels, {:array, :string}, default: []
   end
 
   defmodule Supervisor do
     use DynamicSupervisor
 
     def start_link() do
       DynamicSupervisor.start_link(__MODULE__, [], name: __MODULE__)
     end
 
     def start_child(%IRC.Connection{} = conn) do
       spec = %{id: conn.id, start: {IRC.Connection, :start_link, [conn]}, restart: :transient}
       DynamicSupervisor.start_child(__MODULE__, spec)
     end
 
     @impl true
     def init(_init_arg) do
       DynamicSupervisor.init(
         strategy: :one_for_one,
         max_restarts: 10,
         max_seconds: 1
       )
     end
   end
 
 
   def changeset(params) do
     import Ecto.Changeset
 
     %__MODULE__{id: EntropyString.large_id()}
     |> cast(params, [:network, :host, :port, :nick, :user, :name, :pass, :channels, :tls])
     |> validate_required([:host, :port, :nick, :user, :name])
     |> apply_action(:insert)
   end
 
   def to_tuple(%__MODULE__{} = conn) do
     {conn.id, conn.network, conn.host, conn.port, conn.nick, conn.user, conn.name, conn.pass, conn.tls, conn.channels, nil}
   end
 
   def from_tuple({id, network, host, port, nick, user, name, pass, tls, channels, _}) do
     %__MODULE__{id: id, network: network, host: host, port: port, nick: nick, user: user, name: name, pass: pass, tls: tls, channels: channels}
   end
 
   ## -- MANAGER API
 
   def setup() do
     :dets.open_file(dets(), [])
   end
 
   def dets(), do: to_charlist(LSG.data_path("/connections.dets"))
 
   def lookup(id) do
     case :dets.lookup(dets(), id) do
       [object | _] -> from_tuple(object)
       _ -> nil
     end
   end
 
   def connections() do
     :dets.foldl(fn(object, acc) -> [from_tuple(object) | acc] end, [], dets())
   end
 
   def start_all() do
     for conn <- connections(), do: {conn, IRC.Connection.Supervisor.start_child(conn)}
   end
 
   def get_network(network, channel \\ nil) do
     spec = [{{:_, :"$1", :_, :_, :_, :_, :_, :_, :_, :_, :_},
       [{:==, :"$1", {:const, network}}], [:"$_"]}]
     results = Enum.map(:dets.select(dets(), spec), fn(object) -> from_tuple(object) end)
     if channel do
       Enum.find(results, fn(conn) -> Enum.member?(conn.channels, channel) end)
     else
       List.first(results)
     end
   end
 
   def get_host_nick(host, port, nick) do
     spec = [{{:_, :_, :"$1", :"$2", :"$3", :_, :_, :_, :_, :_, :_},
       [{:andalso,
         {:andalso, {:==, :"$1", {:const, host}}, {:==, :"$2", {:const, port}}},
         {:==, :"$3", {:const, nick}}}],
       [:"$_"]}
     ]
     case :dets.select(dets(), spec) do
       [object] -> from_tuple(object)
       [] -> nil
     end
   end
 
   def delete_connection(%__MODULE__{id: id} = conn) do
     :dets.delete(dets(), id)
     stop_connection(conn)
     :ok
   end
 
   def start_connection(%__MODULE__{} = conn) do
     IRC.Connection.Supervisor.start_child(conn)
   end
 
   def stop_connection(%__MODULE__{id: id}) do
     case :global.whereis_name(id) do
       pid when is_pid(pid) ->
         GenServer.stop(pid, :normal)
       _ -> :error
     end
   end
 
   def add_connection(opts) do
     case changeset(opts) do
       {:ok, conn} ->
         if existing = get_host_nick(conn.host, conn.port, conn.nick) do
           {:error, {:existing, conn}}
         else
           :dets.insert(dets(), to_tuple(conn))
           IRC.Connection.Supervisor.start_child(conn)
         end
       error -> error
     end
   end
 
   def update_connection(connection) do
     :dets.insert(dets(), to_tuple(connection))
   end
 
   def start_link(conn) do
     GenServer.start_link(__MODULE__, [conn], name: {:global, conn.id})
   end
 
   def broadcast_message(net, chan, message) do
     dispatch("conn", {:broadcast, net, chan, message}, IRC.ConnectionPubSub)
   end
   def broadcast_message(list, message) when is_list(list) do
     for {net, chan} <- list do
       broadcast_message(net, chan, message)
     end
   end
 
   def privmsg(channel, line) do
     GenServer.cast(__MODULE__, {:privmsg, channel, line})
   end
 
   def init([conn]) do
     Logger.metadata(conn: conn.id)
     backoff = :backoff.init(@min_backoff, @max_backoff)
               |> :backoff.type(:jitter)
     {:ok, %{client: nil, backoff: backoff, conn: conn, connected_server: nil, connected_port: nil, network: conn.network}, {:continue, :connect}}
   end
 
   @triggers %{
     "!" => :bang,
     "+" => :plus,
     "-" => :minus,
     "?" => :query,
     "." => :dot,
     "~" => :tilde,
     "@" => :at,
     "++" => :plus_plus,
     "--" => :minus_minus,
     "!!" => :bang_bang,
     "??" => :query_query,
     ".." => :dot_dot,
     "~~" => :tilde_tilde,
     "@@" => :at_at
   }
 
   def handle_continue(:connect, state) do
     client_opts = []
                   |> Keyword.put(:network, state.conn.network)
     {:ok, _} = Registry.register(IRC.ConnectionPubSub, "conn", [])
     client = if state.client && Process.alive?(state.client) do
       Logger.info("Reconnecting client")
       state.client
     else
       Logger.info("Connecting")
       {:ok, client} = ExIRC.Client.start_link(debug: false)
       ExIRC.Client.add_handler(client, self())
       client
     end
 
     opts = [{:nodelay, true}]
     conn_fun = if state.conn.tls, do: :connect_ssl!, else: :connect!
     apply(ExIRC.Client, conn_fun, [client, to_charlist(state.conn.host), state.conn.port, opts])
 
     {:noreply, %{state | client: client}}
   end
 
   def handle_info(:disconnected, state) do
     {delay, backoff} = :backoff.fail(state.backoff)
     Logger.info("#{inspect(self())} Disconnected -- reconnecting in #{inspect delay}ms")
     Process.send_after(self(), :connect, delay)
     {:noreply, %{state | backoff: backoff}}
   end
 
   def handle_info(:connect, state) do
     {:noreply, state, {:continue, :connect}}
   end
 
   def handle_cast({:privmsg, channel, line}, state) do
     irc_reply(state, {channel, nil}, line)
     {:noreply, state}
   end
 
   # Connection successful
   def handle_info({:connected, server, port}, state) do
     Logger.info("#{inspect(self())} Connected to #{inspect(server)}:#{port} #{inspect state}")
     {_, backoff} = :backoff.succeed(state.backoff)
     ExIRC.Client.logon(state.client, state.conn.pass || "", state.conn.nick, state.conn.user, state.conn.name)
     {:noreply, %{state | backoff: backoff, connected_server: server, connected_port: port}}
   end
 
   # Logon successful
   def handle_info(:logged_in, state) do
     Logger.info("#{inspect(self())} Logged in")
     {_, backoff} = :backoff.succeed(state.backoff)
     Enum.map(state.conn.channels, &ExIRC.Client.join(state.client, &1))
     {:noreply, %{state | backoff: backoff}}
   end
 
   # ISUP
   def handle_info({:isup, network}, state) when is_binary(network) do
     IRC.UserTrack.clear_network(state.network)
     if network != state.network do
       Logger.warn("Possibly misconfigured network: #{network} != #{state.network}")
     end
     {:noreply, state}
   end
 
   # Been kicked
   def handle_info({:kicked, _sender, chan, _reason}, state) do
     ExIRC.Client.join(state.client, chan)
     {:noreply, state}
   end
 
   # Received something in a channel
   def handle_info({:received, text, sender, chan}, state) do
     user = if user = IRC.UserTrack.find_by_nick(state.network, sender.nick) do
       user
     else
       Logger.error("Could not lookup user for message: #{inspect {state.network, chan, sender.nick}}")
       user = IRC.UserTrack.joined(chan, sender, [])
       ExIRC.Client.who(state.client, chan) # Rewho everything in case of need ? We shouldn't not know that user..
       user
     end
     if !user do
       ExIRC.Client.who(state.client, chan) # Rewho everything in case of need ? We shouldn't not know that user..
       Logger.error("Could not lookup user nor create it for message: #{inspect {state.network, chan, sender.nick}}")
     else
       if !Map.get(user.options, :puppet) do
         reply_fun = fn(text) -> irc_reply(state, {chan, sender}, text) end
         account = IRC.Account.lookup(sender)
         message = %IRC.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 IRC.UserTrack.messaged(message) do
           :ok -> message
           {:ok, message} -> message
         end
         publish(message, ["#{message.network}/#{chan}:messages"])
       end
     end
     {:noreply, state}
   end
 
   # Received a private message
   def handle_info({:received, text, sender}, state) do
     reply_fun = fn(text) -> irc_reply(state, {sender.nick, sender}, text) end
     account = IRC.Account.lookup(sender)
-    message = %IRC.Message{id: FlakeId.get(), transport: irc, text: text, network: state.network, at: NaiveDateTime.utc_now(),
+    message = %IRC.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 IRC.UserTrack.messaged(message) do
       :ok -> message
       {:ok, message} -> message
     end
     publish(message, ["messages:private", "#{message.network}/#{account.id}:messages"])
     {:noreply, state}
   end
 
   ## -- Broadcast
   def handle_info({:broadcast, net, account = %IRC.Account{}, message}, state) do
     if net == state.conn.network do
       user = IRC.UserTrack.find_by_account(net, account)
       if user do
         irc_reply(state, {user.nick, nil}, message)
       end
     end
     {:noreply, state}
   end
   def handle_info({:broadcast, net, chan, message}, state) do
     if net == state.conn.network && Enum.member?(state.conn.channels, chan) do
       irc_reply(state, {chan, nil}, message)
     end
     {:noreply, state}
   end
 
   ## -- UserTrack
 
   def handle_info({:joined, channel}, state) do
     ExIRC.Client.who(state.client, channel)
     {:noreply, state}
   end
 
   def handle_info({:who, channel, whos}, state) do
     accounts = Enum.map(whos, fn(who = %ExIRC.Who{nick: nick, operator?: operator}) ->
       priv = if operator, do: [:operator], else: []
       # Don't touch -- on WHO the bot joined, not the users.
       IRC.UserTrack.joined(channel, who, priv, false)
       account = IRC.Account.lookup(who)
       if account do
         {:account, who.network, channel, who.nick, account.id}
       end
     end)
     |> Enum.filter(fn(x) -> x end)
     dispatch("account", {:accounts, accounts})
     {:noreply, state}
   end
 
   def handle_info({:quit, reason, sender}, state) do
     IRC.UserTrack.quitted(sender, reason)
     {:noreply, state}
   end
 
   def handle_info({:joined, channel, sender}, state) do
     IRC.UserTrack.joined(channel, sender, [])
     account = IRC.Account.lookup(sender)
     if account do
       dispatch("account", {:account, sender.network, channel, sender.nick, account.id})
     end
     {:noreply, state}
   end
 
   def handle_info({:kicked, nick, _by, channel, _reason}, state) do
     IRC.UserTrack.parted(state.network, channel, nick)
     {:noreply, state}
   end
 
   def handle_info({:parted, channel, %ExIRC.SenderInfo{nick: nick}}, state) do
     IRC.UserTrack.parted(state.network, channel, nick)
     {:noreply, state}
   end
 
   def handle_info({:mode, [channel, mode, nick]}, state) do
     track_mode(state.network, channel, nick, mode)
     {:noreply, state}
   end
 
   def handle_info({:nick_changed, old_nick, new_nick}, state) do
     IRC.UserTrack.renamed(state.network, old_nick, new_nick)
     {:noreply, state}
   end
 
   def handle_info(unhandled, client) do
     Logger.debug("unhandled: #{inspect unhandled}")
     {:noreply, client}
   end
 
   def publish(pub), do: publish(pub, [])
 
   def publish(m = %IRC.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
     dispatch(["triggers", "#{m.network}/#{m.channel}:triggers", "trigger:"<>trigger], {:irc, :trigger, trigger, m})
   end
 
   def publish_event(net, event = %{type: _}) when is_binary(net) do
     event = event
     |> Map.put(:at, NaiveDateTime.utc_now())
     |> Map.put(:network, net)
     dispatch("#{net}:events", {:irc, :event, event})
   end
   def publish_event({net, chan}, event = %{type: type}) do
     event = event
     |> Map.put(:at, NaiveDateTime.utc_now())
     |> Map.put(:network, net)
     |> Map.put(:channel, chan)
     dispatch("#{net}/#{chan}:events", {:irc, :event, event})
   end
 
   def dispatch(keys, content, sub \\ IRC.PubSub)
 
   def dispatch(key, content, sub) when is_binary(key), do: dispatch([key], content, sub)
   def dispatch(keys, content, sub) when is_list(keys) do
     Logger.debug("dispatch #{inspect keys} = #{inspect content}")
     for key <- keys do
       spawn(fn() -> Registry.dispatch(sub, key, fn h ->
         for {pid, _} <- h, do: send(pid, content)
       end) end)
     end
   end
 
   #
   # Triggers
   #
 
   def triggers, do: @triggers
 
   for {trigger, name} <- @triggers 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}
     end
   end
 
   def extract_trigger(_), do: nil
 
   #
   # IRC Replies
   #
 
   # irc_reply(ExIRC.Client pid, {channel or nick, ExIRC.Sender}, binary | replies
   # replies :: {:kick, reason} | {:kick, nick, reason} | {:mode, mode, nick}
   defp irc_reply(state = %{client: client, network: network}, {target, _}, text) when is_binary(text) or is_list(text) do
     lines = IRC.splitlong(text)
             |> Enum.map(fn(x) -> if(is_list(x), do: x, else: String.split(x, "\n")) end)
             |> 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,
               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)
   end
 
   defp irc_reply(%{client: client}, {target, %{nick: nick}}, {:kick, reason}) do
     ExIRC.Client.kick(client, target, nick, reason)
   end
 
   defp irc_reply(%{client: client}, {target, _}, {:kick, nick, reason}) do
     ExIRC.Client.kick(client, target, nick, reason)
   end
 
   defp irc_reply(%{client: client}, {target, %{nick: nick}}, {:mode, mode}) do
     ExIRC.Client.mode(%{client: client}, target, mode, nick)
   end
 
   defp irc_reply(%{client: client}, target, {:mode, mode, nick}) do
     ExIRC.Client.mode(client, target, mode, nick)
   end
 
   defp irc_reply(%{client: client}, target, {:channel_mode, mode}) do
     ExIRC.Client.mode(client, target, mode)
   end
 
   defp track_mode(network, channel, nick, "+o") do
     IRC.UserTrack.change_privileges(network, channel, nick, {[:operator], []})
     :ok
   end
 
   defp track_mode(network, channel, nick, "-o") do
     IRC.UserTrack.change_privileges(network, channel, nick, {[], [:operator]})
     :ok
   end
 
   defp track_mode(network, channel, nick, "+v") do
     IRC.UserTrack.change_privileges(network, channel, nick, {[:voice], []})
     :ok
   end
 
   defp track_mode(network, channel, nick, "-v") do
     IRC.UserTrack.change_privileges(network, channel, nick, {[], [:voice]})
     :ok
   end
 
   defp track_mode(network, channel, nick, mode) do
     Logger.warn("Unhandled track_mode: #{inspect {nick, mode}}")
     :ok
   end
 
   defp server(%{conn: %{host: host, port: port}}) do
     host <> ":" <> to_string(port)
   end
 
 end
diff --git a/lib/lsg_irc/base_plugin.ex b/lib/lsg_irc/base_plugin.ex
index ca2e8f3..7153c70 100644
--- a/lib/lsg_irc/base_plugin.ex
+++ b/lib/lsg_irc/base_plugin.ex
@@ -1,131 +1,131 @@
 defmodule LSG.IRC.BasePlugin do
 
   def irc_doc, do: nil
 
   def start_link() do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
   def init([]) do
     regopts = [plugin: __MODULE__]
     {:ok, _} = Registry.register(IRC.PubSub, "trigger:version", regopts)
     {:ok, _} = Registry.register(IRC.PubSub, "trigger:help", regopts)
     {:ok, _} = Registry.register(IRC.PubSub, "trigger:liquidrender", regopts)
     {:ok, _} = Registry.register(IRC.PubSub, "trigger:plugin", regopts)
     {:ok, _} = Registry.register(IRC.PubSub, "trigger:plugins", regopts)
     {:ok, nil}
   end
 
   def handle_info({:irc, :trigger, "plugins", msg = %{trigger: %{type: :bang, args: []}}}, _) do
     enabled_string = IRC.Plugin.enabled()
     |> Enum.map(fn(mod) ->
       mod
       |> Macro.underscore()
       |> String.split("/", parts: :infinity)
       |> List.last()
       |> String.replace("_plugin", "")
       |> Enum.sort()
     end)
     |> Enum.join(", ")
     msg.replyfun.("Enabled plugins: #{enabled_string}")
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :query, args: [plugin]}} = m}, _) do
     module = Module.concat([LSG.IRC, Macro.camelize(plugin<>"_plugin")])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module)
     do
       m.replyfun.("loaded, active: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil ->
         msg = case IRC.Plugin.get(module) do
           :disabled -> "disabled"
           {_, false, _} -> "disabled"
           _ -> "not active"
         end
         m.replyfun.(msg)
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :plus, args: [plugin]}} = m}, _) do
     module = Module.concat([LSG.IRC, Macro.camelize(plugin<>"_plugin")])
     with true <- Code.ensure_loaded?(module),
          IRC.Plugin.switch(module, true),
          {:ok, pid} <- IRC.Plugin.start(module)
     do
       m.replyfun.("started: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       :ignore -> m.replyfun.("disabled or throttled")
       {:error, _} -> m.replyfun.("start error")
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :tilde, args: [plugin]}} = m}, _) do
     module = Module.concat([LSG.IRC, Macro.camelize(plugin<>"_plugin")])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module),
          :ok <- GenServer.stop(pid),
          {:ok, pid} <- IRC.Plugin.start(module)
     do
       m.replyfun.("restarted: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil -> m.replyfun.("not active")
     end
     {:noreply, nil}
   end
 
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :minus, args: [plugin]}} = m}, _) do
     module = Module.concat([LSG.IRC, Macro.camelize(plugin<>"_plugin")])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module),
          :ok <- GenServer.stop(pid)
     do
       IRC.Plugin.switch(module, false)
       m.replyfun.("stopped: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil -> m.replyfun.("not active")
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "liquidrender", m = %{trigger: %{args: args}}}, _) do
     template = Enum.join(args, " ")
     m.replyfun.(Tmpl.render(template, m))
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "help", m = %{trigger: %{type: :bang}}}, _) do
     url = LSGWeb.Router.Helpers.irc_url(LSGWeb.Endpoint, :index, m.network, LSGWeb.format_chan(m.channel))
     m.replyfun.("-> #{url}")
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "version", message = %{trigger: %{type: :bang}}}, _) do
     {:ok, vsn} = :application.get_key(:lsg, :vsn)
     ver = List.to_string(vsn)
     url = LSGWeb.Router.Helpers.irc_url(LSGWeb.Endpoint, :index)
     elixir_ver = Application.started_applications() |> List.keyfind(:elixir, 0) |> elem(2) |> to_string()
     otp_ver = :erlang.system_info(:system_version) |> to_string() |> String.trim()
     system = :erlang.system_info(:system_architecture) |> to_string()
     message.replyfun.([
-       <<"🤖 I am a robot running", 2, "beautte, version #{ver}", 2, " — source: #{LSG.source_url()},
-      "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}"
+       <<"🤖 I am a robot running", 2, "beautte, version #{ver}", 2, " — source: #{LSG.source_url()}">>,
+      "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}",
       "👷‍♀️ Owner: href <href@random.sh>",
       "🌍 Web interface: #{url}"
     ])
     {:noreply, nil}
   end
 
   def handle_info(msg, _) do
     {:noreply, nil}
   end
 
 end
diff --git a/lib/lsg_telegram/room.ex b/lib/lsg_telegram/room.ex
index da774c8..4e86382 100644
--- a/lib/lsg_telegram/room.ex
+++ b/lib/lsg_telegram/room.ex
@@ -1,188 +1,188 @@
 defmodule LSG.TelegramRoom do
   require Logger
   @behaviour Telegram.ChatBot
   alias Telegram.Api
 
   @couch "bot-telegram-rooms"
 
   def rooms(), do: rooms(:with_docs)
 
   @spec rooms(:with_docs | :ids) :: [Map.t | integer( )]
   def rooms(:with_docs) do
     case Couch.get(@couch, :all_docs, include_docs: true) do
       {:ok, %{"rows" => rows}} -> {:ok, for(%{"doc" => doc} <- rows, do: doc)}
       error = {:error, _} -> error
     end
   end
 
   def rooms(:ids) do
     case Couch.get(@couch, :all_docs) do
       {:ok, %{"rows" => rows}} -> {:ok, for(%{"id" => id} <- rows, do: id)}
       error = {:error, _} -> error
     end
   end
 
   def room(id, opts \\ []) do
     Couch.get(@couch, id, opts)
   end
 
   # TODO: Create couch
   def setup() do
     :ok
   end
 
   def after_start() do
-    for id <- room_ids(), do: Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(LSG.Telegram, Integer.parse(id) |> elem(0))
+    for id <- room(:ids), do: Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(LSG.Telegram, Integer.parse(id) |> elem(0))
   end
 
   @impl Telegram.ChatBot
   def init(id) when is_integer(id) and id < 0 do
+    token = Keyword.get(Application.get_env(:lsg, :telegram, []), :key)
+    {:ok, chat} = Api.request(token, "getChat", chat_id: id)
     Logger.metadata(transport: :telegram, id: id, telegram_room_id: id)
     tg_room = case room(id) do
       {:ok, tg_room = %{"network" => _net, "channel" => _chan}} -> tg_room
       {:error, :not_found} ->
         [net, chan] = String.split(chat["title"], "/", parts: 2)
         {net, chan} = case IRC.Connection.get_network(net, chan) do
           %IRC.Connection{} -> {net, chan}
           _ -> {nil, nil}
         end
         {:ok, _id, _rev} = Couch.post(@couch, %{"_id" => id, "network" => net, "channel" => nil})
         {:ok, tg_room} = room(id)
         tg_room
     end
-    token = Keyword.get(Application.get_env(:lsg, :telegram, []), :key)
     %{"network" => net, "channel" => chan} = tg_room
     Logger.info("Starting ChatBot for room #{id} \"#{chat["title"]}\" #{inspect tg_room}")
-    {:ok, chat} = Api.request(token, "getChat", chat_id: id)
     irc_plumbed = if net && chan do
         {:ok, _} = Registry.register(IRC.PubSub, "#{net}/#{chan}:messages", plugin: __MODULE__)
         {:ok, _} = Registry.register(IRC.PubSub, "#{net}/#{chan}:triggers", plugin: __MODULE__)
         {:ok, _} = Registry.register(IRC.PubSub, "#{net}/#{chan}:outputs", plugin: __MODULE__)
         true
     else
       Logger.warn("Did not found telegram match for #{id} \"#{chat["title"]}\"")
       false
     end
     {:ok, %{id: id, net: net, chan: chan, irc: irc_plumbed}}
   end
 
   def init(id) do
     Logger.error("telegram_room: bad id (not room id)", transport: :telegram, id: id, telegram_room_id: id)
     :ignoree
   end
 
   defp find_or_create_meta_account(from = %{"id" => user_id}, state) do
     if account = IRC.Account.find_meta_account("telegram-id", user_id) do
       account
     else
       first_name = Map.get(from, "first_name")
       last_name = Map.get(from, "last_name")
       name = [first_name, last_name]
       |> Enum.filter(& &1)
       |> Enum.join(" ")
 
       username = Map.get(from, "username", first_name)
 
       account = username
       |> IRC.Account.new_account()
       |> IRC.Account.update_account_name(name)
       |> IRC.Account.put_meta("telegram-id", user_id)
 
       Logger.info("telegram_room: created account #{account.id} for telegram user #{user_id}")
       account
     end
   end
 
   def handle_update(%{"message" => %{"from" => from = %{"id" => user_id}, "text" => text}}, _token, state) do
     account = find_or_create_meta_account(from, state)
     connection = IRC.Connection.get_network(state.net)
     IRC.send_message_as(account, state.net, state.chan, text, true)
     {:ok, state}
   end
 
   def handle_update(data = %{"message" => %{"from" => from = %{"id" => user_id}, "location" => %{"latitude" => lat, "longitude" => lon}}}, _token, state) do
     account = find_or_create_meta_account(from, state)
     connection = IRC.Connection.get_network(state.net)
     IRC.send_message_as(account, state.net, state.chan, "@ #{lat}, #{lon}", true)
     {:ok, state}
   end
 
   for type <- ~w(photo voice video document animation) do
     def handle_update(data = %{"message" => %{unquote(type) => _}}, token, state) do
       upload(unquote(type), data, token, state)
     end
   end
 
   def handle_update(update, token, state) do
     {:ok, state}
   end
 
   def handle_info({:irc, _, _, message}, state) do
     handle_info({:irc, nil, message}, state)
   end
 
   def handle_info({:irc, _, message = %IRC.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}"
       LSG.Telegram.send_message(state.id, body)
     end
     {:ok, state}
   end
 
   def handle_info(info, state) do
     Logger.info("UNhandled #{inspect info}")
     {:ok, state}
   end
 
   defp upload(_type, %{"message" => m = %{"chat" => %{"id" => chat_id}, "from" => from = %{"id" => user_id}}}, token, state) do
     account = find_or_create_meta_account(from, state)
     if account do
       {content, type} = cond do
         m["photo"] -> {m["photo"], "photo"}
         m["voice"] -> {m["voice"], "voice message"}
         m["video"] -> {m["video"], "video"}
         m["document"] -> {m["document"], "file"}
         m["animation"] -> {m["animation"], "gif"}
       end
 
       file = if is_list(content) && Enum.count(content) > 1 do
         Enum.sort_by(content, fn(p) -> p["file_size"] end, &>=/2)
         |> List.first()
       else
         content
       end
 
       file_id = file["file_id"]
       file_unique_id = file["file_unique_id"]
       text = if(m["caption"], do: m["caption"] <> " ", else: "")
 
       spawn(fn() ->
         with \
           {:ok, file} <- Telegram.Api.request(token, "getFile", file_id: file_id),
           path = "https://api.telegram.org/file/bot#{token}/#{file["file_path"]}",
           {:ok, %HTTPoison.Response{status_code: 200, body: body}} <- HTTPoison.get(path),
           <<smol_body::binary-size(20), _::binary>> = body,
           {:ok, magic} <- GenMagic.Pool.perform(LSG.GenMagic, {:bytes, smol_body}),
           bucket = Application.get_env(:lsg, :s3, []) |> Keyword.get(:bucket),
           ext = Path.extname(file["file_path"]),
           s3path = "#{account.id}/#{file_unique_id}#{ext}",
           s3req = ExAws.S3.put_object(bucket, s3path, body, acl: :public_read, content_type: magic.mime_type),
           {:ok, _} <- ExAws.request(s3req)
         do
           path = LSGWeb.Router.Helpers.url(LSGWeb.Endpoint) <> "/files/#{s3path}"
           txt = "#{type}: #{text}#{path}"
           connection = IRC.Connection.get_network(state.net)
           IRC.send_message_as(account, state.net, state.chan, txt, true)
         else
           error ->
             Telegram.Api.request(token, "sendMessage", chat_id: chat_id, text: "File upload failed, sorry.")
             Logger.error("Failed upload from Telegram: #{inspect error}")
         end
       end)
 
       {:ok, state}
     end
   end
 
 end
diff --git a/lib/util.ex b/lib/util.ex
index ce46174..8bd3b9d 100644
--- a/lib/util.ex
+++ b/lib/util.ex
@@ -1,74 +1,74 @@
 defmodule Util do
 
   def to_naive_date_time(naive = %NaiveDateTime{}), do: naive
   def to_naive_date_time(datetime = %DateTime{}), do: DateTime.to_naive(datetime)
   def to_naive_date_time(timestamp) when is_integer(timestamp) do
     timestamp
     |> to_date_time()
     |> to_naive_date_time()
   end
 
   def to_date_time(naive_or_timestamp, timezone \\ "Europe/Paris")
 
   def to_date_time(date = %DateTime{}, timezone) do
-    DateTime.shift_zone!(data, timezone, Tzdata.TimeZoneDatabase)
+    DateTime.shift_zone!(date, timezone, Tzdata.TimeZoneDatabase)
   end
 
   def to_date_time(naive = %NaiveDateTime{}, timezone) do
     DateTime.from_naive!(naive, timezone, Tzdata.TimeZoneDatabase)
   end
 
   # todo: this is wrong.
   def to_date_time(timestamp, timezone) when is_integer(timestamp) do
     timestamp
     |> DateTime.from_unix!(:millisecond)
     |> DateTime.shift_zone!(timezone, Tzdata.TimeZoneDatabase)
   end
 
   def plusminus(number) when number > 0, do: "+#{number}"
   def plusminus(0), do: "0"
   def plusminus(number) when number < 0, do: "#{number}"
 
   def float_paparse(float) when is_float(float), do: {float, ""}
   def float_paparse(int) when is_integer(int), do: {(int+0.0), ""}
   def float_paparse(string) when is_binary(string) do
     string
     |> String.replace(",", ".")
     |> Float.parse()
   end
 
   def ets_mutate_select_each(ets, table, spec \\ [{:"$1", [], [:"$1"]}], fun) do
     ets.safe_fixtable(table, true)
     first = ets.select(table, spec, 1)
     do_ets_mutate_select_each(ets, table, fun, first)
   after
     ets.safe_fixtable(table, false)
   end
 
   defp do_ets_mutate_select_each(_, _, _, :'$end_of_table') do
     :ok
   end
 
   defp do_ets_mutate_select_each(ets, table, fun, {objs, continuation}) do
     for obj <- objs, do: fun.(table, obj)
     do_ets_mutate_select_each(ets, table, fun, ets.select(continuation))
   end
 
 
   def ets_mutate_each(ets, table, fun) do
     ets.safe_fixtable(table, true)
     first = ets.first(table)
     do_ets_mutate_each(ets, table, fun, first)
   after
     ets.safe_fixtable(table, false)
   end
 
   defp do_ets_mutate_each(ets, table, fun, key) do
     case ets.lookup(table, key) do
       [elem] -> fun.(table, elem)
       _ -> nil
     end
     do_ets_mutate_each(ets, table, fun, ets.next(table, key))
   end
 
 end
diff --git a/mix.exs b/mix.exs
index 05dd026..c9f2827 100644
--- a/mix.exs
+++ b/mix.exs
@@ -1,97 +1,98 @@
 defmodule LSG.Mixfile do
   use Mix.Project
 
   def project do
     [
       app: :lsg,
       version: version("0.2.6"),
       elixir: "~> 1.4",
       elixirc_paths: elixirc_paths(Mix.env),
       compilers: [:phoenix, :gettext] ++ Mix.compilers,
       start_permanent: Mix.env == :prod,
       deps: deps()
     ]
   end
 
   def application do
     [
       mod: {LSG.Application, []},
       extra_applications: [:logger, :runtime_tools]
     ]
   end
 
   defp elixirc_paths(:test), do: ["lib", "test/support"]
   defp elixirc_paths(_),     do: ["lib"]
 
   defp aliases do
     [
       "assets.deploy": ["make -C assets", "phx.digest"]
     ]
   end
 
   defp deps do
     [
       {:phoenix, "~> 1.6.0-rc.0", override: true},
       {:phoenix_pubsub, "~> 2.0"},
       {:phoenix_live_reload, "~> 1.0", only: :dev},
       {:phoenix_html, "~> 3.0"},
       {:phoenix_live_view, "~> 0.16.0"},
       {:phoenix_live_dashboard, "~> 0.5"},
       {:telemetry, "~> 1.0.0", override: true},
       {:telemetry_metrics, "~> 0.6"},
       {:telemetry_poller, "~> 0.5"},
       {:plug_cowboy, "~> 2.0"},
       {:cowlib, "~> 2.9.1", override: true},
       {:plug, "~> 1.7"},
       {:gettext, "~> 0.11"},
       {:httpoison, "~> 1.8", override: true},
       {:jason, "~> 1.0"},
       {:poison, "~> 4.0", override: true},
       {:floki, "~> 0.19.3"},
       {:ecto, "~> 3.4"},
       {:exirc, git: "https://git.random.sh/ircbot/exirc.git", branch: "fix-who-nick"},
       {:distillery, "~> 2.0"},
       {:earmark, "~> 1.2"},
       {:oauther, "~> 1.1"},
       {:extwitter, "~> 0.12.0"},
       {:entropy_string, "~> 1.0.0"},
       {:abacus, "~> 0.3.3"},
       {:ex_chain, github: "eljojo/ex_chain"},
       {:timex, "~> 3.6"},
       {:muontrap, "~> 0.5.1"},
       {:tzdata, "~> 1.0"},
       {:nimble_csv, "~> 0.7.0"},
       {:backoff, git: "https://github.com/ferd/backoff", branch: "master"},
       {:telegram, git: "https://github.com/hrefhref/telegram.git", branch: "master"},
       {:ex_aws, "~> 2.0"},
       {:ex_aws_s3, "~> 2.0"},
       {:gen_magic, git: "https://github.com/hrefhref/gen_magic", branch: "develop"},
       {:liquex, "~> 0.3"},
       {:html_entities, "0.4.0", override: true},
       {:file_size, "~> 3.0"},
       {:ex2ms, "~> 1.0"},
       {:polyjuice_client, git: "https://git.random.sh/ircbot/polyjuice_client.git", branch: "master", override: true},
       {:matrix_app_service, git: "https://git.random.sh/ircbot/matrix_app_service.ex.git", branch: "master"},
       {:sentry, "~> 8.0.5"},
       {:logger_json, "~> 4.3"},
       {:oauth2, "~> 2.0"},
       {:powerdnsex, git: "https://git.random.sh/ircbot/powerdnsex.git", branch: "master"},
       {:pfx, "~> 0.7.0"},
       {:flake_id, "~> 0.1.0"}
     ]
   end
 
   defp version(v) do
     {describe, 0} = System.cmd("git", ~w(describe --dirty --broken --all --tags --long))
     [_, rest] = String.split(describe, "/")
     info = String.trim(rest)
     env = cond do
       Mix.env() == :prod -> ""
       true -> "." <> to_string(Mix.env())
     end
-    build_date_tag = Timex.format!(DateTime.utc_now(), ".build%y%m%d@%H%M", :strftime)
+    #build_date_tag = Timex.format!(DateTime.utc_now(), ".build%y%m%d@%H%M", :strftime)
+    build_date_tag = ".build"
 
-    v <> "+" <> info <> env <> <> build_date_tag
+    v <> "+" <> info <> env <> build_date_tag
   end
 
 end