No OneTemporary
Actions

Size

164 KB

Subscribers

None

View Options

	diff --git a/lib/irc.ex b/lib/irc.ex
	index dd1a5d2..3898068 100644
	--- a/lib/irc.ex
	+++ b/lib/irc.ex
	@@ -1,49 +1,49 @@
	defmodule Nola.Irc do
	require Logger

	def env(), do: Nola.env(:irc)
	def env(key, default \\ nil), do: Keyword.get(env(), key, default)

	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
	- IRC.PuppetConnection.start_and_send_message(account, connection, channel, text)
	+ connection = Nola.Irc.Connection.get_network(network)
	+ if connection && (force_puppet \|\| Nola.Irc.PuppetConnection.whereis(account, connection)) do
	+ Nola.Irc.PuppetConnection.start_and_send_message(account, connection, channel, text)
	else
	user = Nola.UserTrack.find_by_account(network, account)
	nick = if(user, do: user.nick, else: account.name)
	- IRC.Connection.broadcast_message(network, channel, "<#{nick}> #{text}")
	+ Nola.Irc.Connection.broadcast_message(network, channel, "<#{nick}> #{text}")
	end
	end

	def admin?(%Message{sender: sender}), do: admin?(sender)

	def admin?(%{nick: nick, user: user, host: host}) do
	for {n, u, h} <- Nola.IRC.env(:admins, []) do
	admin_part_match?(n, nick) && admin_part_match?(u, user) && admin_part_match?(h, host)
	end
	\|> Enum.any?
	end

	defp admin_part_match?(:_, _), do: true
	defp admin_part_match?(a, a), do: true
	defp admin_part_match?(_, _), do: false

	def application_childs do
	import Supervisor.Spec

	- IRC.Connection.setup()
	+ Nola.Irc.Connection.setup()

	[
	- worker(Registry, [[keys: :duplicate, name: IRC.ConnectionPubSub]], id: :registr_irc_conn),
	- supervisor(IRC.Connection.Supervisor, [], [name: IRC.Connection.Supervisor]),
	- supervisor(IRC.PuppetConnection.Supervisor, [], [name: IRC.PuppetConnection.Supervisor]),
	+ worker(Registry, [[keys: :duplicate, name: Nola.Irc.ConnectionPubSub]], id: :registr_irc_conn),
	+ supervisor(Nola.Irc.Connection.Supervisor, [], [name: Nola.Irc.Connection.Supervisor]),
	+ supervisor(Nola.Irc.PuppetConnection.Supervisor, [], [name: Nola.Irc.PuppetConnection.Supervisor]),
	]
	end

	# Start plugins first to let them get on connection events.
	def after_start() do
	Logger.info("Starting connections")
	- IRC.Connection.start_all()
	+ Nola.Irc.Connection.start_all()
	end

	end
	diff --git a/lib/irc/connection.ex b/lib/irc/connection.ex
	index cff556d..7a0ca9d 100644
	--- a/lib/irc/connection.ex
	+++ b/lib/irc/connection.ex
	@@ -1,521 +1,521 @@
	-defmodule IRC.Connection do
	+defmodule Nola.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"])
	+ Nola.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 %Nola.Message{}

	Each `Nola.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}
	+ def start_child(%Nola.Irc.Connection{} = conn) do
	+ spec = %{id: conn.id, start: {Nola.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(Nola.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)}
	+ for conn <- connections(), do: {conn, Nola.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)
	+ Nola.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)
	+ Nola.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)
	+ dispatch("conn", {:broadcast, net, chan, message}, Nola.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", [])
	+ {:ok, _} = Registry.register(Nola.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
	Nola.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 = Nola.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 = Nola.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 = Nola.Account.lookup(sender)
	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
	: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 = Nola.Account.lookup(sender)
	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
	{:ok, message} -> message
	end
	publish(message, ["messages:private", "#{message.network}/#{account.id}:messages"])
	{:noreply, state}
	end

	## -- Broadcast
	def handle_info({:broadcast, net, account = %Nola.Account{}, message}, state) do
	if net == state.conn.network do
	user = Nola.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.
	Nola.UserTrack.joined(channel, who, priv, false)
	account = Nola.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
	Nola.UserTrack.quitted(sender, reason)
	{:noreply, state}
	end

	def handle_info({:joined, channel, sender}, state) do
	Nola.UserTrack.joined(channel, sender, [])
	account = Nola.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
	Nola.UserTrack.parted(state.network, channel, nick)
	{:noreply, state}
	end

	def handle_info({:parted, channel, %ExIRC.SenderInfo{nick: nick}}, state) do
	Nola.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
	Nola.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 = %Nola.Message{trigger: nil}, keys) do
	dispatch(["messages"] ++ keys, {:irc, :text, m})
	end

	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

	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 \\ Nola.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, " ")
	%Nola.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 = Nola.Irc.Message.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, %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)
	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
	Nola.UserTrack.change_privileges(network, channel, nick, {[:operator], []})
	:ok
	end

	defp track_mode(network, channel, nick, "-o") do
	Nola.UserTrack.change_privileges(network, channel, nick, {[], [:operator]})
	:ok
	end

	defp track_mode(network, channel, nick, "+v") do
	Nola.UserTrack.change_privileges(network, channel, nick, {[:voice], []})
	:ok
	end

	defp track_mode(network, channel, nick, "-v") do
	Nola.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/irc/puppet_connection.ex b/lib/irc/puppet_connection.ex
	index 2604876..f5e2e5c 100644
	--- a/lib/irc/puppet_connection.ex
	+++ b/lib/irc/puppet_connection.ex
	@@ -1,238 +1,238 @@
	-defmodule IRC.PuppetConnection do
	+defmodule Nola.Irc.PuppetConnection do
	require Logger
	@min_backoff :timer.seconds(5)
	@max_backoff :timer.seconds(2*60)
	@max_idle :timer.hours(12)
	@env Mix.env

	defmodule Supervisor do
	use DynamicSupervisor

	def start_link() do
	DynamicSupervisor.start_link(__MODULE__, [], name: __MODULE__)
	end

	- def start_child(%Nola.Account{id: account_id}, %IRC.Connection{id: connection_id}) do
	- spec = %{id: {account_id, connection_id}, start: {IRC.PuppetConnection, :start_link, [account_id, connection_id]}, restart: :transient}
	+ def start_child(%Nola.Account{id: account_id}, %Nola.Irc.Connection{id: connection_id}) do
	+ spec = %{id: {account_id, connection_id}, start: {Nola.Irc.PuppetConnection, :start_link, [account_id, connection_id]}, 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 whereis(account = %Nola.Account{id: account_id}, connection = %IRC.Connection{id: connection_id}) do
	+ def whereis(account = %Nola.Account{id: account_id}, connection = %Nola.Irc.Connection{id: connection_id}) do
	{:global, name} = name(account_id, connection_id)
	case :global.whereis_name(name) do
	:undefined -> nil
	pid -> pid
	end
	end

	- def send_message(account = %Nola.Account{id: account_id}, connection = %IRC.Connection{id: connection_id}, channel, text) do
	+ def send_message(account = %Nola.Account{id: account_id}, connection = %Nola.Irc.Connection{id: connection_id}, channel, text) do
	GenServer.cast(name(account_id, connection_id), {:send_message, self(), channel, text})
	end

	- def start_and_send_message(account = %Nola.Account{id: account_id}, connection = %IRC.Connection{id: connection_id}, channel, text) do
	+ def start_and_send_message(account = %Nola.Account{id: account_id}, connection = %Nola.Irc.Connection{id: connection_id}, channel, text) do
	{:global, name} = name(account_id, connection_id)
	pid = whereis(account, connection)
	pid = if !pid do
	- case IRC.PuppetConnection.Supervisor.start_child(account, connection) do
	+ case Nola.Irc.PuppetConnection.Supervisor.start_child(account, connection) do
	{:ok, pid} -> pid
	{:error, {:already_started, pid}} -> pid
	end
	else
	pid
	end
	GenServer.cast(pid, {:send_message, self(), channel, text})
	end

	- def start(account = %Nola.Account{}, connection = %IRC.Connection{}) do
	- IRC.PuppetConnection.Supervisor.start_child(account, connection)
	+ def start(account = %Nola.Account{}, connection = %Nola.Irc.Connection{}) do
	+ Nola.Irc.PuppetConnection.Supervisor.start_child(account, connection)
	end

	def start_link(account_id, connection_id) do
	GenServer.start_link(__MODULE__, [account_id, connection_id], name: name(account_id, connection_id))
	end

	def name(account_id, connection_id) do
	{:global, {PuppetConnection, account_id, connection_id}}
	end

	def init([account_id, connection_id]) do
	account = %Nola.Account{} = Nola.Account.get(account_id)
	- connection = %IRC.Connection{} = IRC.Connection.lookup(connection_id)
	+ connection = %Nola.Irc.Connection{} = Nola.Irc.Connection.lookup(connection_id)
	Logger.metadata(puppet_conn: account.id <> "@" <> connection.id)
	backoff = :backoff.init(@min_backoff, @max_backoff)
	\|> :backoff.type(:jitter)
	idle = :erlang.send_after(@max_idle, self, :idle)
	{:ok, %{client: nil, backoff: backoff, idle: idle, connected: false, buffer: [], channels: [], connection_id: connection_id, account_id: account_id, connected_server: nil, connected_port: nil, network: connection.network}, {:continue, :connect}}
	end

	def handle_continue(:connect, state) do
	#ipv6 = if @env == :prod do
	# subnet = Nola.Subnet.assign(state.account_id)
	# Nola.Account.put_meta(Nola.Account.get(state.account_id), "subnet", subnet)
	# ip = Pfx.host(subnet, 1)
	# {:ok, ipv6} = :inet_parse.ipv6_address(to_charlist(ip))
	# System.cmd("add-ip6", [ip])
	# ipv6
	#end

	- conn = IRC.Connection.lookup(state.connection_id)
	+ conn = Nola.Irc.Connection.lookup(state.connection_id)
	client_opts = []
	\|> Keyword.put(:network, conn.network)
	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

	base_opts = [
	{:nodelay, true}
	]

	#{ip, opts} = case {ipv6, :inet_res.resolve(to_charlist(conn.host), :in, :aaaa)} do
	# {ipv6, {:ok, {:dns_rec, _dns_header, _query, rrs = [{:dns_rr, _, _, _, _, _, _, _, _, _} \| _], _, _}}} ->
	# ip = rrs
	# \|> Enum.map(fn({:dns_rr, _, :aaaa, :in, _, _, ipv6, _, _, _}) -> ipv6 end)
	# \|> Enum.shuffle()
	# \|> List.first()

	# opts = [
	# :inet6,
	# {:ifaddr, ipv6}
	# ]
	# {ip, opts}
	# _ ->
	{ip, opts} = {to_charlist(conn.host), []}
	#end

	conn_fun = if conn.tls, do: :connect_ssl!, else: :connect!
	apply(ExIRC.Client, conn_fun, [client, ip, conn.port, base_opts ++ opts])

	{:noreply, %{state \| client: client}}
	end

	def handle_continue(:connected, state) do
	state = Enum.reduce(Enum.reverse(state.buffer), state, fn(b, state) ->
	{:noreply, state} = handle_cast(b, state)
	state
	end)
	{:noreply, %{state \| buffer: []}}
	end

	def handle_cast(cast = {:send_message, _pid, _channel, _text}, state = %{connected: false, buffer: buffer}) do
	{:noreply, %{state \| buffer: [cast \| buffer]}}
	end

	def handle_cast({:send_message, pid, channel, text}, state = %{connected: true}) do
	channels = if !Enum.member?(state.channels, channel) do
	ExIRC.Client.join(state.client, channel)
	[channel \| state.channels]
	else
	state.channels
	end
	ExIRC.Client.msg(state.client, :privmsg, channel, text)

	meta = %{puppet: true, from: pid}
	account = Nola.Account.get(state.account_id)
	nick = make_nick(state)
	sender = %ExIRC.SenderInfo{network: state.network, nick: suffix_nick(nick), user: nick, host: "puppet."}
	reply_fun = fn(text) ->
	- IRC.Connection.broadcast_message(state.network, channel, text)
	+ Nola.Irc.Connection.broadcast_message(state.network, channel, text)
	end
	- 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 = %Nola.Message{id: FlakeId.get(), at: NaiveDateTime.utc_now(), text: text, network: state.network, account: account, sender: sender, channel: channel, replyfun: reply_fun, trigger: Nola.Irc.Connection.extract_trigger(text), meta: meta}
	message = case Nola.UserTrack.messaged(message) do
	:ok -> message
	{:ok, message} -> message
	end
	- IRC.Connection.publish(message, ["#{message.network}/#{channel}:messages"])
	+ Nola.Irc.Connection.publish(message, ["#{message.network}/#{channel}:messages"])

	idle = if length(state.buffer) == 0 do
	:erlang.cancel_timer(state.idle)
	:erlang.send_after(@max_idle, self(), :idle)
	else
	state.idle
	end

	{:noreply, %{state \| idle: idle, channels: channels}}
	end

	def handle_info(:idle, state) do
	ExIRC.Client.quit(state.client, "Puppet was idle for too long")
	ExIRC.Client.stop!(state.client)
	{:stop, :normal, state}
	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 \| connected: false, backoff: backoff}}
	end

	def handle_info(:connect, state) do
	{:noreply, state, {:continue, :connect}}
	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)
	base_nick = make_nick(state)
	ExIRC.Client.logon(state.client, "", suffix_nick(base_nick), base_nick, "#{base_nick}'s puppet")
	{: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)
	# Create an UserTrack entry for the client so it's authenticated to the right account_id already.
	Nola.UserTrack.connected(state.network, suffix_nick(make_nick(state)), make_nick(state), "puppet.", state.account_id, %{puppet: true})
	{:noreply, %{state \| backoff: backoff}}
	end

	# ISUP
	def handle_info({:isup, network}, state) do
	{:noreply, %{state \| network: network, connected: true}, {:continue, :connected}}
	end

	# Been kicked
	def handle_info({:kicked, _sender, chan, _reason}, state) do
	{:noreply, %{state \| channels: state.channels -- [chan]}}
	end

	def handle_info(_info, state) do
	{:noreply, state}
	end

	def make_nick(state) do
	account = Nola.Account.get(state.account_id)
	user = Nola.UserTrack.find_by_account(state.network, account)
	base_nick = if(user, do: user.nick, else: account.name)
	clean_nick = case String.split(base_nick, ":", parts: 2) do
	["@"<>nick, _] -> nick
	[nick] -> nick
	end
	clean_nick
	end

	if Mix.env == :dev do
	def suffix_nick(nick), do: "#{nick}[d]"
	else
	def suffix_nick(nick), do: "#{nick}[p]"
	end

	end
	diff --git a/lib/matrix.ex b/lib/matrix.ex
	index 9334816..0ad0836 100644
	--- a/lib/matrix.ex
	+++ b/lib/matrix.ex
	@@ -1,169 +1,169 @@
	defmodule Nola.Matrix do
	require Logger
	alias Polyjuice.Client

	@behaviour MatrixAppService.Adapter.Room
	@behaviour MatrixAppService.Adapter.Transaction
	@behaviour MatrixAppService.Adapter.User
	@env Mix.env

	def dets(part) do
	(Nola.data_path() <> "/matrix-#{to_string(part)}.dets") \|> String.to_charlist()
	end

	def setup() do
	{:ok, _} = :dets.open_file(dets(:rooms), [])
	{:ok, _} = :dets.open_file(dets(:room_aliases), [])
	{:ok, _} = :dets.open_file(dets(:users), [])
	:ok
	end

	def myself?("@_dev:random.sh"), do: true
	def myself?("@_bot:random.sh"), do: true
	def myself?("@_dev."<>_), do: true
	def myself?("@_bot."<>_), do: true
	def myself?(_), do: false

	def mxc_to_http(mxc = "mxc://"<>_) do
	uri = URI.parse(mxc)
	%URI{uri \| scheme: "https", path: "/_matrix/media/r0/download/#{uri.authority}#{uri.path}"}
	\|> URI.to_string()
	end

	def get_or_create_matrix_user(id) do
	if mxid = lookup_user(id) do
	mxid
	else
	opts = [
	type: "m.login.application_service",
	inhibit_login: true,
	device_id: "APP_SERVICE",
	initial_device_display_name: "Application Service",
	username: if(@env == :dev, do: "_dev.#{id}", else: "_bot.#{id}")
	]
	Logger.debug("Registering user for #{id}")
	{:ok, %{"user_id" => mxid}} = Polyjuice.Client.LowLevel.register(client(), opts)
	:dets.insert(dets(:users), {id, mxid})
	end
	end

	def lookup_user(id) do
	case :dets.lookup(dets(:users), id) do
	[{_, matrix_id}] -> matrix_id
	_ -> nil
	end
	end

	def user_name("@"<>name) do
	[username, _] = String.split(name, ":", parts: 2)
	username
	end

	def application_childs() do
	import Supervisor.Spec
	[
	- supervisor(Nola.Matrix.Room.Supervisor, [], [name: IRC.PuppetConnection.Supervisor]),
	+ supervisor(Nola.Matrix.Room.Supervisor, [], [name: Nola.Irc.PuppetConnection.Supervisor]),
	]
	end

	def after_start() do
	rooms = :dets.foldl(fn({id, _, _, _}, acc) -> [id \| acc] end, [], dets(:rooms))
	for room <- rooms, do: Nola.Matrix.Room.start(room)
	end

	def lookup_room(room) do
	case :dets.lookup(dets(:rooms), room) do
	[{_, network, channel, opts}] -> {:ok, Map.merge(opts, %{network: network, channel: channel})}
	_ -> {:error, :no_such_room}
	end
	end

	def lookup_room_alias(room_alias) do
	case :dets.lookup(dets(:room_aliases), room_alias) do
	[{_, room_id}] -> {:ok, room_id}
	_ -> {:error, :no_such_room_alias}
	end
	end

	def lookup_or_create_room(room_alias) do
	case lookup_room_alias(room_alias) do
	{:ok, room_id} -> {:ok, room_id}
	{:error, :no_such_room_alias} -> create_room(room_alias)
	end
	end

	def create_room(room_alias) do
	Logger.debug("Matrix: creating room #{inspect room_alias}")
	localpart = localpart(room_alias)
	with {:ok, network, channel} <- extract_network_channel_from_localpart(localpart),
	- %IRC.Connection{} <- IRC.Connection.get_network(network, channel),
	+ %Nola.Irc.Connection{} <- Nola.Irc.Connection.get_network(network, channel),
	room = [visibility: :public, room_alias_name: localpart, name: if(network == "random", do: channel, else: "#{network}/#{channel}")],
	{:ok, %{"room_id" => room_id}} <- Client.Room.create_room(client(), room) do
	Logger.info("Matrix: created room #{room_alias} #{room_id}")
	:dets.insert(dets(:rooms), {room_id, network, channel, %{}})
	:dets.insert(dets(:room_aliases), {room_alias, room_id})
	{:ok, room_id}
	else
	nil -> {:error, :no_such_network_channel}
	error -> error
	end
	end

	def localpart(room_alias) do
	[<<"#", localpart :: binary>>, _] = String.split(room_alias, ":", parts: 2)
	localpart
	end

	def extract_network_channel_from_localpart(localpart) do
	s = localpart
	\|> String.replace("dev.", "")
	\|> String.split("/", parts: 2)

	case s do
	[network, channel] -> {:ok, network, channel}
	[channel] -> {:ok, "random", channel}
	_ -> {:error, :invalid_localpart}
	end
	end

	@impl MatrixAppService.Adapter.Room
	def query_alias(room_alias) do
	case lookup_or_create_room(room_alias) do
	{:ok, room_id} ->
	Nola.Matrix.Room.start(room_id)
	:ok
	error -> error
	end
	end

	@impl MatrixAppService.Adapter.Transaction
	def new_event(event = %MatrixAppService.Event{}) do
	Logger.debug("New matrix event: #{inspect event}")
	if event.room_id do
	Nola.Matrix.Room.start_and_send_matrix_event(event.room_id, event)
	end
	:noop
	end

	@impl MatrixAppService.Adapter.User
	def query_user(user_id) do
	Logger.warn("Matrix lookup user: #{inspect user_id}")
	:error
	end

	def client(opts \\ []) do
	base_url = Application.get_env(:matrix_app_service, :base_url)
	access_token = Application.get_env(:matrix_app_service, :access_token)
	default_opts = [
	access_token: access_token,
	device_id: "APP_SERVICE",
	application_service: true,
	user_id: nil
	]
	opts = Keyword.merge(default_opts, opts)

	Polyjuice.Client.LowLevel.create(base_url, opts)
	end


	end
	diff --git a/lib/nola/account.ex b/lib/nola/account.ex
	index 31e237c..47e46b8 100644
	--- a/lib/nola/account.ex
	+++ b/lib/nola/account.ex
	@@ -1,263 +1,263 @@
	defmodule Nola.Account do
	alias Nola.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(["#Nola.Account[", id, " ", name, "]"])
	end
	end

	def file(base) do
	to_charlist(Nola.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)
	Nola.Membership.merge_account(old_id, new_id)
	Nola.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})
	+ Nola.Irc.Connection.dispatch("account", {:account_change, old_id, new_id})
	+ Nola.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 = Nola.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})
	+ Nola.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 = %Nola.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 = Nola.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(Nola.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

	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

	end
	diff --git a/lib/nola/user_track.ex b/lib/nola/user_track.ex
	index 720fb58..f6a02ae 100644
	--- a/lib/nola/user_track.ex
	+++ b/lib/nola/user_track.ex
	@@ -1,329 +1,329 @@
	defmodule Nola.UserTrack do
	@moduledoc """
	User Track DB & Utilities
	"""

	@ets Nola.UserTrack.Storage
	# {uuid, network, nick, nicks, privilege_map}
	# Privilege map:
	# %{"#channel" => [:operator, :voice]
	defmodule Storage do

	def delete(id) do
	op(fn(ets) -> :ets.delete(ets, id) end)
	end

	def insert(tuple) do
	op(fn(ets) -> :ets.insert(ets, tuple) end)
	end

	def clear_network(network) do
	op(fn(ets) ->
	spec = [
	{{:_, :"$1", :_, :_, :_, :_, :_, :_, :_, :_, :_, :_},
	[
	{:==, :"$1", {:const, network}}
	], [:"$_"]}
	]
	:ets.match_delete(ets, spec)
	end)
	end

	def op(fun) do
	GenServer.call(__MODULE__, {:op, fun})
	end

	def start_link do
	GenServer.start_link(__MODULE__, [], [name: __MODULE__])
	end

	def init([]) do
	ets = :ets.new(__MODULE__, [:set, :named_table, :protected, {:read_concurrency, true}])
	{:ok, ets}
	end

	def handle_call({:op, fun}, _from, ets) do
	returned = try do
	{:ok, fun.(ets)}
	rescue
	rescued -> {:error, rescued}
	catch
	rescued -> {:error, rescued}
	end
	{:reply, returned, ets}
	end

	def terminate(_reason, ets) do
	:ok
	end
	end

	defmodule Id, do: use EntropyString

	defmodule User do
	defstruct [:id, :account, :network, :nick, {:nicks, []}, :username, :host, :realname, {:privileges, %{}}, {:last_active, %{}}, {:options, %{}}]

	def to_tuple(u = %__MODULE__{}) do
	{u.id \|\| Nola.UserTrack.Id.large_id, u.network, u.account, String.downcase(u.nick), u.nick, u.nicks \|\| [], u.username, u.host, u.realname, u.privileges, u.last_active, u.options}
	end

	#tuple size: 11
	def from_tuple({id, network, account, _downcased_nick, nick, nicks, username, host, realname, privs, last_active, opts}) do
	struct = %__MODULE__{id: id, account: account, network: network, nick: nick, nicks: nicks, username: username, host: host, realname: realname, privileges: privs, last_active: last_active, options: opts}
	end
	end

	def find_by_account(%Nola.Account{id: id}) do
	#iex(15)> :ets.fun2ms(fn(obj = {_, net, acct, _, _, _, _, _, _}) when net == network and acct == account -> obj end)
	spec = [
	{{:_, :_, :"$2", :_, :_, :_, :_, :_, :_, :_, :_, :_},
	[
	{:==, :"$2", {:const, id}}
	], [:"$_"]}
	]
	results = :ets.select(@ets, spec)
	\|> Enum.filter(& &1)
	for obj <- results, do: User.from_tuple(obj)
	end

	def find_by_account(network, nil) do
	nil
	end

	def find_by_account(network, %Nola.Account{id: id}) do
	#iex(15)> :ets.fun2ms(fn(obj = {_, net, acct, _, _, _, _, _, _}) when net == network and acct == account -> obj end)
	spec = [
	{{:_, :"$1", :"$2", :_, :_, :_, :_, :_, :_, :_, :_, :_},
	[
	{:andalso, {:==, :"$1", {:const, network}},
	{:==, :"$2", {:const, id}}}
	], [:"$_"]}
	]
	case :ets.select(@ets, spec) do
	results = [_r \| _] ->
	result = results
	\|> Enum.reject(fn({_, net, _, _, _, _, _, _, _, _, actives, opts}) -> network != "matrix" && net == "matrix" end)
	\|> Enum.reject(fn({_, net, _, _, _, _, _, _, _, _, actives, opts}) -> network != "telegram" && net == "telegram" end)
	\|> Enum.reject(fn({_, _, _, _, _, _, _, _, _, _, actives, opts}) -> network not in ["matrix", "telegram"] && Map.get(opts, :puppet) end)
	\|> Enum.sort_by(fn({_, _, _, _, _, _, _, _, _, _, actives, _}) ->
	Map.get(actives, nil)
	end, {:desc, NaiveDateTime})
	\|> List.first

	if result, do: User.from_tuple(result)
	_ -> nil
	end
	end

	def clear_network(network) do
	Storage.clear_network(network)
	end


	def merge_account(old_id, new_id) do
	#iex(15)> :ets.fun2ms(fn(obj = {_, net, acct, _, _, _, _, _, _}) when net == network and acct == account -> obj end)
	spec = [
	{{:_, :_, :"$1", :_, :_, :_, :_, :_, :_, :_, :_, :_},
	[
	{:==, :"$1", {:const, old_id}}
	], [:"$_"]}
	]
	Enum.each(:ets.select(@ets, spec), fn({id, net, _, downcased_nick, nick, nicks, username, host, realname, privs, active, opts}) ->
	Storage.op(fn(ets) ->
	:ets.insert(@ets, {id, net, new_id, downcased_nick, nick, nicks, username, host, realname, privs, active, opts})
	end)
	end)
	end

	def find_by_nick(%ExIRC.Who{network: network, nick: nick}) do
	find_by_nick(network, nick)
	end


	def find_by_nick(%ExIRC.SenderInfo{network: network, nick: nick}) do
	find_by_nick(network, nick)
	end

	def find_by_nick(network, nick) do
	case :ets.match(@ets, {:"$1", network, :_, String.downcase(nick), :_, :_, :_, :_, :_, :_, :_, :_}) do
	[[id] \| _] -> lookup(id)
	_ ->
	nil
	end
	end

	def to_list, do: :ets.tab2list(@ets)

	def lookup(id) do
	case :ets.lookup(@ets, id) do
	[] -> nil
	[tuple] -> User.from_tuple(tuple)
	end
	end

	def operator?(network, channel, nick) do
	if user = find_by_nick(network, nick) do
	privs = Map.get(user.privileges, channel, [])
	Enum.member?(privs, :admin) \|\| Enum.member?(privs, :operator)
	else
	false
	end
	end

	def channel(network, channel) do
	Enum.filter(to_list(), fn({_, network, _, _, _, _, _, _, _, channels, _, _}) ->
	Map.get(channels, channel)
	end)
	end

	# TODO
	def connected(network, nick, user, host, account_id, opts \\ %{}) do
	if account = Nola.Account.get(account_id) do
	user = if user = find_by_nick(network, nick) do
	user
	else
	user = %User{id: Nola.UserTrack.Id.large_id, account: account_id, network: network, nick: nick, username: user, host: host, privileges: %{}, options: opts}
	Storage.op(fn(ets) ->
	:ets.insert(ets, User.to_tuple(user))
	end)
	user
	end

	- IRC.Connection.publish_event(network, %{type: :connect, user_id: user.id, account_id: user.account})
	+ Nola.Irc.Connection.publish_event(network, %{type: :connect, user_id: user.id, account_id: user.account})
	:ok
	else
	:error
	end
	end

	def joined(c, s), do: joined(c,s,[])

	def joined(channel, sender=%{nick: nick, user: uname, host: host}, privileges, touch \\ true) do
	privileges = if IRC.admin?(sender) do
	privileges ++ [:admin]
	else privileges end
	user = if user = find_by_nick(sender.network, nick) do
	%User{user \| username: uname, host: host, privileges: Map.put(user.privileges \|\| %{}, channel, privileges)}
	else
	user = %User{id: Nola.UserTrack.Id.large_id, network: sender.network, nick: nick, username: uname, host: host, privileges: %{channel => privileges}}

	account = Nola.Account.lookup(user).id
	user = %User{user \| account: account}
	end
	user = touch_struct(user, channel)

	if touch && user.account do
	Nola.Membership.touch(user.account, sender.network, channel)
	end

	Storage.op(fn(ets) ->
	:ets.insert(ets, User.to_tuple(user))
	end)

	- IRC.Connection.publish_event({sender.network, channel}, %{type: :join, user_id: user.id, account_id: user.account})
	+ Nola.Irc.Connection.publish_event({sender.network, channel}, %{type: :join, user_id: user.id, account_id: user.account})

	user
	end

	#def joined(network, channel, nick, privileges) do
	# user = if user = find_by_nick(network, nick) do
	# %User{user \| privileges: Map.put(user.privileges, channel, privileges)}
	# else
	# %User{nick: nick, privileges: %{channel => privileges}}
	# end
	#
	# Storage.op(fn(ets) ->
	# :ets.insert(ets, User.to_tuple(user))
	# end)
	#end

	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
	user = %User{network: network, nick: nick, privileges: %{}}
	account = Nola.Account.lookup(user)
	{%User{user \| account: account.id}, account}
	end
	Storage.insert(User.to_tuple(user))
	if chan, do: Nola.Membership.touch(account, network, chan)
	if !m.account do
	{:ok, %Nola.Message{m \| account: account}}
	else
	:ok
	end
	end

	def renamed(network, old_nick, new_nick) do
	if user = find_by_nick(network, old_nick) do
	old_account = Nola.Account.lookup(user)
	user = %User{user \| nick: new_nick, nicks: [old_nick\|user.nicks]}
	account = Nola.Account.lookup(user, false) \|\| old_account
	user = %User{user \| nick: new_nick, account: account.id, nicks: [old_nick\|user.nicks]}
	Storage.insert(User.to_tuple(user))
	channels = for {channel, _} <- user.privileges, do: channel
	- IRC.Connection.publish_event(network, %{type: :nick, user_id: user.id, account_id: account.id, nick: new_nick, old_nick: old_nick})
	+ Nola.Irc.Connection.publish_event(network, %{type: :nick, user_id: user.id, account_id: account.id, nick: new_nick, old_nick: old_nick})
	end
	end

	def change_privileges(network, channel, nick, {add, remove}) do
	if user = find_by_nick(network, nick) do
	privs = Map.get(user.privileges, channel)

	privs = Enum.reduce(add, privs, fn(priv, acc) -> [priv\|acc] end)
	privs = Enum.reduce(remove, privs, fn(priv, acc) -> List.delete(acc, priv) end)

	user = %User{user \| privileges: Map.put(user.privileges, channel, privs)}
	Storage.insert(User.to_tuple(user))
	- IRC.Connection.publish_event({network, channel}, %{type: :privileges, user_id: user.id, account_id: user.account, added: add, removed: remove})
	+ Nola.Irc.Connection.publish_event({network, channel}, %{type: :privileges, user_id: user.id, account_id: user.account, added: add, removed: remove})
	end
	end

	# XXX: Reason
	def parted(channel, %{network: network, nick: nick}) do
	parted(network, channel, nick)
	end

	def parted(network, channel, nick) do
	if user = find_by_nick(network, nick) do
	if user.account do
	Nola.Membership.touch(user.account, network, channel)
	end

	privs = Map.delete(user.privileges, channel)
	lasts = Map.delete(user.last_active, channel)
	if Enum.count(privs) > 0 do
	user = %User{user \| privileges: privs}
	Storage.insert(User.to_tuple(user))
	- IRC.Connection.publish_event({network, channel}, %{type: :part, user_id: user.id, account_id: user.account, reason: nil})
	+ Nola.Irc.Connection.publish_event({network, channel}, %{type: :part, user_id: user.id, account_id: user.account, reason: nil})
	else
	- IRC.Connection.publish_event(network, %{type: :quit, user_id: user.id, account_id: user.account, reason: "Left all known channels"})
	+ Nola.Irc.Connection.publish_event(network, %{type: :quit, user_id: user.id, account_id: user.account, reason: "Left all known channels"})
	Storage.delete(user.id)
	end
	end
	end

	def quitted(sender, reason) do
	if user = find_by_nick(sender.network, sender.nick) do
	if user.account do
	for {channel, _} <- user.privileges do
	Nola.Membership.touch(user.account, sender.network, channel)
	end
	- IRC.Connection.publish_event(sender.network, %{type: :quit, user_id: user.id, account_id: user.account, reason: reason})
	+ Nola.Irc.Connection.publish_event(sender.network, %{type: :quit, user_id: user.id, account_id: user.account, reason: reason})
	end
	Storage.delete(user.id)
	end
	end

	defp touch_struct(user = %User{last_active: last_active}, channel) do
	now = NaiveDateTime.utc_now()
	last_active = last_active
	\|> Map.put(channel, now)
	\|> Map.put(nil, now)
	%User{user \| last_active: last_active}
	end

	defp userchans(%{privileges: privileges}) do
	for({chan, _} <- privileges, do: chan)
	end
	end
	diff --git a/lib/plugins/alcoolog.ex b/lib/plugins/alcoolog.ex
	index 41b5a4f..28723d0 100644
	--- a/lib/plugins/alcoolog.ex
	+++ b/lib/plugins/alcoolog.ex
	@@ -1,1229 +1,1229 @@
	defmodule Nola.Plugins.Alcoolog do
	require Logger

	@moduledoc """
	# [alcoolog]({{context_path}}/alcoolog)

	* !santai `<cl \| (calc)>` `<degrés d'alcool> [annotation]`: enregistre un nouveau verre de `montant` d'une boisson à `degrés d'alcool`.
	* !santai `<cl \| (calc)>` `<beer name>`: enregistre un nouveau verre de `cl` de la bière `beer name`, et checkin sur Untappd.com.
	* **!moar `[cl]` : enregistre un verre équivalent au dernier !santai.
	* -santai: annule la dernière entrée d'alcoolisme.
	* .alcoolisme: état du channel en temps réel.
	* .alcoolisme `<semaine \| Xj>`: points par jour, sur X j.
	* !alcoolisme `[pseudo]`: affiche les points d'alcoolisme.
	* !alcoolisme `[pseudo]` `<semaine \| Xj>`: affiche les points d'alcoolisme par jour sur X j.
	* +alcoolisme `<h\|f>` `<poids en kg>` `[facteur de perte en mg/l (10, 15, 20, 25)]`: Configure votre profil d'alcoolisme.
	* .sobre: affiche quand la sobriété frappera sur le chan.
	* !sobre `[pseudo]`: affiche quand la sobriété frappera pour `[pseudo]`.
	* !sobrepour `<date>`: affiche tu pourras être sobre pour `<date>`, et si oui, combien de volumes d'alcool peuvent encore être consommés.
	* !alcoolog: ([voir]({{context_path}}/alcoolog)) lien pour voir l'état/statistiques et historique de l'alcoolémie du channel.
	* !alcool `<cl>` `<degrés>`: donne le nombre d'unités d'alcool dans `<cl>` à `<degrés>°`.
	* !soif: c'est quand l'apéro ?

	1 point = 1 volume d'alcool.

	Annotation: champ libre!

	---

	## `!txt`s

	* status utilisateur: `alcoolog.user_(sober\|legal\|legalhigh\|high\|toohigh\|sick)(\|_rising)`
	* mauvaises boissons: `alcoolog.drink_(negative\|zero\|negative)`
	* santo: `alcoolog.santo`
	* santai: `alcoolog.santai`
	* plus gros, moins gros: `alcoolog.(fatter\|thinner)`

	"""

	def irc_doc, do: @moduledoc

	def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)

	# tuple dets: {nick, date, volumes, current_alcohol_level, nom, commentaire}
	# tuple ets: {{nick, date}, volumes, current, nom, commentaire}
	# tuple meta dets: {nick, map}
	# %{:weight => float, :sex => true(h),false(f)}
	@pubsub ~w(account)
	@pubsub_triggers ~w(santai moar again bis santo santeau alcoolog sobre sobrepour soif alcoolisme alcool)
	@default_user_meta %{weight: 77.4, sex: true, loss_factor: 15}

	def data_state() do
	dets_filename = (Nola.data_path() <> "/" <> "alcoolisme.dets") \|> String.to_charlist
	dets_meta_filename = (Nola.data_path() <> "/" <> "alcoolisme_meta.dets") \|> String.to_charlist
	%{dets: dets_filename, meta: dets_meta_filename, ets: __MODULE__.ETS}
	end

	def init(_) do
	triggers = for(t <- @pubsub_triggers, do: "trigger:"<>t)
	for sub <- @pubsub ++ triggers do
	{:ok, _} = Registry.register(Nola.PubSub, sub, plugin: __MODULE__)
	end
	dets_filename = (Nola.data_path() <> "/" <> "alcoolisme.dets") \|> String.to_charlist
	{:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}])
	ets = :ets.new(__MODULE__.ETS, [:ordered_set, :named_table, :protected, {:read_concurrency, true}])
	dets_meta_filename = (Nola.data_path() <> "/" <> "alcoolisme_meta.dets") \|> String.to_charlist
	{:ok, meta} = :dets.open_file(dets_meta_filename, [{:type,:set}])
	traverse_fun = fn(obj, dets) ->
	case obj do
	object = {nick, naive = %NaiveDateTime{}, volumes, active, cl, deg, name, comment} ->
	date = naive
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.to_unix()
	new = {nick, date, volumes, active, cl, deg, name, comment, Map.new()}
	:dets.delete_object(dets, object)
	:dets.insert(dets, new)
	:ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, Map.new()})
	dets

	object = {nick, naive = %NaiveDateTime{}, volumes, active, cl, deg, name, comment, meta} ->
	date = naive
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.to_unix()
	new = {nick, date, volumes, active, cl, deg, name, comment, Map.new()}
	:dets.delete_object(dets, object)
	:dets.insert(dets, new)
	:ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, Map.new()})
	dets

	object = {nick, date, volumes, active, cl, deg, name, comment, meta} ->
	:ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, meta})
	dets

	_ ->
	dets
	end
	end
	:dets.foldl(traverse_fun, dets, dets)
	:dets.sync(dets)
	state = %{dets: dets, meta: meta, ets: ets}
	{:ok, state}
	end

	@eau ["santo", "santeau"]
	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 = %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)
	day_of_week = Date.day_of_week(now)
	{txt, apero?} = cond do
	now.hour >= 0 && now.hour < 6 ->
	{["apéro tardif ? Je dis OUI ! SANTAI !"], true}
	now.hour >= 6 && now.hour < 12 ->
	if day_of_week >= 6 do
	{["de l'alcool pour le petit dej ? le week-end, pas de problème !"], true}
	else
	{["C'est quand même un peu tôt non ? Prochain apéro #{apero}"], false}
	end
	now.hour >= 12 && (now.hour < 14) ->
	{["oui! c'est l'apéro de midi! (et apéro #{apero})",
	"tu peux attendre #{apero} ou y aller, il est midi !"
	], true}
	now.hour == 17 ->
	{[
	"ÇA APPROCHE !!! Apéro #{apero}",
	"BIENTÔT !!! Apéro #{apero}",
	"achetez vite les teilles, apéro dans #{apero}!",
	"préparez les teilles, apéro dans #{apero}!"
	], false}
	now.hour >= 14 && now.hour < 18 ->
	weekend = if day_of_week >= 6 do
	" ... ou maintenant en fait, c'est le week-end!"
	else
	""
	end
	{["tiens bon! apéro #{apero}#{weekend}",
	"courage... apéro dans #{apero}#{weekend}",
	"pas encore :'( apéro dans #{apero}#{weekend}"
	], false}
	true ->
	{[
	"C'EST L'HEURE DE L'APÉRO !!! SANTAIIIIIIIIIIII !!!!"
	], true}
	end

	txt = txt
	\|> Enum.shuffle()
	\|> Enum.random()

	m.replyfun.(txt)

	stats = get_full_statistics(state, m.account.id)
	if !apero? && stats.active > 0.1 do
	m.replyfun.("(... ou continue en fait, je suis pas ta mère !)")
	end

	{:noreply, state}
	end

	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
	"demain " <> time ->
	{h, m} = case String.split(time, [":", "h"]) do
	[hour, ""] ->
	IO.puts ("h #{inspect hour}")
	{h, _} = Integer.parse(hour)
	{h, 0}
	[hour, min] when min != "" ->
	{h, _} = Integer.parse(hour)
	{m, _} = Integer.parse(min)
	{h, m}
	[hour] ->
	IO.puts ("h #{inspect hour}")
	{h, _} = Integer.parse(hour)
	{h, 0}
	_ -> {0, 0}
	end
	secs = ((6060)24)
	day = DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase)
	%DateTime{day \| hour: h, minute: m, second: 0}
	"après demain " <> time ->
	secs = 2((6060)*24)
	DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase)
	datetime ->
	case Timex.Parse.DateTime.Parser.parse(datetime, "{}") do
	{:ok, dt} -> dt
	_ -> nil
	end
	end

	if time do
	meta = get_user_meta(state, m.account.id)
	stats = get_full_statistics(state, m.account.id)

	duration = round(DateTime.diff(time, now)/60.0)

	IO.puts "diff #{inspect duration} sober in #{inspect stats.sober_in}"

	if duration < stats.sober_in do
	int = stats.sober_in - duration
	m.replyfun.("désolé, aucune chance! tu seras sobre #{format_minute_duration(int)} après!")
	else
	remaining = duration - stats.sober_in
	if remaining < 30 do
	m.replyfun.("moins de 30 minutes de sobriété, c'est impossible de boire plus")
	else
	loss_per_minute = ((meta.loss_factor/100)/60)
	remaining_gl = (remaining-30)*loss_per_minute
	m.replyfun.("marge de boisson: #{inspect remaining} minutes, #{remaining_gl} g/l")
	end
	end

	end
	{:noreply, state}
	end

	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 = %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 = %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)
	meta = get_user_meta(state, m.account.id)
	k = if meta.sex, do: 0.7, else: 0.6
	weight = meta.weight
	gl = (10points)/(kweight)
	duration = round(gl/((meta.loss_factor/100)/60))+30
	sober_in_s = if duration > 0 do
	duration = Timex.Duration.from_minutes(duration)
	Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
	else
	""
	end

	m.replyfun.("Il y a #{Float.round(points+0.0, 4)} unités d'alcool dans #{cl}cl à #{deg}° (#{Float.round(gl + 0.0, 4)} g/l, #{sober_in_s})")
	{:noreply, state}
	end

	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

	@moar [
	"{{message.sender.nick}}: la même donc ?",
	"{{message.sender.nick}}: et voilà la petite sœur !"
	]

	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 = %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 = %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
	[cls] ->
	case Util.float_paparse(cls) do
	{cl, _} -> cl
	_ -> cl
	end
	_ -> cl
	end
	moar = @moar \|> Enum.shuffle() \|> Enum.random() \|> Tmpl.render(m) \|> m.replyfun.()
	santai(m, state, cl, deg, comment, auto_set: true)
	{_, obj = {_, date, points, _last_active, type, descr}} ->
	case Regex.named_captures(~r/^(?<cl>\d+[.]\d+)cl\s+(?<deg>\d+[.]\d+)°$/, type) do
	nil -> m.replyfun.("suce")
	u ->
	moar = @moar \|> Enum.shuffle() \|> Enum.random() \|> Tmpl.render(m) \|> m.replyfun.()
	santai(m, state, u["cl"], u["deg"], descr, auto_set: true)
	end
	_ -> nil
	end
	{:noreply, state}
	end

	defp santai(m, state, cl, deg, comment, options \\ []) do
	comment = cond do
	comment == [] -> nil
	is_binary(comment) -> comment
	comment == nil -> nil
	true -> Enum.join(comment, " ")
	end

	{cl, cl_extra} = case {Util.float_paparse(cl), cl} do
	{{cl, extra}, _} -> {cl, extra}
	{:error, "("<>_} ->
	try do
	{:ok, result} = Abacus.eval(cl)
	{result, nil}
	rescue
	_ -> {nil, "cl: invalid calc expression"}
	end
	{:error, _} -> {nil, "cl: invalid value"}
	end

	{deg, comment, auto_set, beer_id} = case Util.float_paparse(deg) do
	{deg, _} -> {deg, comment, Keyword.get(options, :auto_set, false), nil}
	:error ->
	beername = if(comment, do: "#{deg} #{comment}", else: deg)
	case Untappd.search_beer(beername, limit: 1) do
	{:ok, %{"response" => %{"beers" => %{"count" => count, "items" => [%{"beer" => beer, "brewery" => brewery} \| _]}}}} ->
	{Map.get(beer, "beer_abv"), "#{Map.get(brewery, "brewery_name")}: #{Map.get(beer, "beer_name")}", true, Map.get(beer, "bid")}
	_ ->
	{deg, "could not find beer", false, nil}
	end
	end

	cond do
	cl == nil -> m.replyfun.(cl_extra)
	deg == nil -> m.replyfun.(comment)
	cl >= 500 \|\| deg >= 100 -> Nola.Plugins.Txt.reply_random(m, "alcoolog.drink_toohuge")
	cl == 0 \|\| deg == 0 -> Nola.Plugins.Txt.reply_random(m, "alcoolog.drink_zero")
	cl < 0 \|\| deg < 0 -> Nola.Plugins.Txt.reply_random(m, "alcoolog.drink_negative")
	true ->
	points = Alcool.units(cl, deg)
	now = m.at \|\| DateTime.utc_now()
	\|> DateTime.to_unix(:millisecond)
	user_meta = get_user_meta(state, m.account.id)
	name = "#{cl}cl #{deg}°"
	old_stats = get_full_statistics(state, m.account.id)
	meta = %{}
	meta = Map.put(meta, "timestamp", now)
	meta = Map.put(meta, "weight", user_meta.weight)
	meta = Map.put(meta, "sex", user_meta.sex)
	:ok = :dets.insert(state.dets, {m.account.id, now, points, if(old_stats, do: old_stats.active, else: 0), cl, deg, name, comment, meta})
	true = :ets.insert(state.ets, {{m.account.id, now}, points, if(old_stats, do: old_stats.active, else: 0),cl, deg, name, comment, meta})
	#sante = @santai \|> Enum.map(fn(s) -> String.trim(String.upcase(s)) end) \|> Enum.shuffle() \|> Enum.random()
	sante = Nola.Plugins.Txt.random("alcoolog.santai")
	k = if user_meta.sex, do: 0.7, else: 0.6
	weight = user_meta.weight
	peak = Float.round((10points\|\|0.0)/(kweight), 4)
	stats = get_full_statistics(state, m.account.id)
	sober_add = if old_stats && Map.get(old_stats \|\| %{}, :sober_in) do
	mins = round(stats.sober_in - old_stats.sober_in)
	" [+#{mins}m]"
	else
	""
	end
	nonow = DateTime.utc_now()
	sober = nonow \|> DateTime.add(round(stats.sober_in*60), :second)
	\|> Timex.Timezone.convert("Europe/Paris")
	at = if nonow.day == sober.day do
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
	detail
	else
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
	detail
	end

	up = if stats.active_drinks > 1 do
	" " <> Enum.join(for(_ <- 1..stats.active_drinks, do: "▲")) <> ""
	else
	""
	end

	since_str = if stats.since && stats.since_min > 180 do
	"(depuis: #{stats.since_s}) "
	else
	""
	end

	msg = fn(nick, extra) ->
	"#{sante} #{nick} #{extra}#{up} #{format_points(points)} @#{stats.active}g/l [+#{peak} g/l]"
	<> " (15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) #{since_str}(sobriété #{at} (dans #{stats.sober_in_s})#{sober_add}) !"
	<> " (aujourd'hui #{stats.daily_volumes} points - #{stats.daily_gl} g/l)"
	end

	meta = if beer_id do
	Map.put(meta, "untappd:beer_id", beer_id)
	else
	meta
	end

	if beer_id do
	spawn(fn() ->
	case Untappd.maybe_checkin(m.account, beer_id) do
	{:ok, body} ->
	badges = get_in(body, ["badges", "items"])
	if badges != [] do
	badges_s = Enum.map(badges, fn(badge) -> Map.get(badge, "badge_name") end)
	\|> Enum.filter(fn(b) -> b end)
	\|> Enum.intersperse(", ")
	\|> Enum.join("")
	badge = if(length(badges) > 1, do: "badges", else: "badge")
	m.replyfun.("\\O/ Unlocked untappd #{badge}: #{badges_s}")
	end
	:ok
	{:error, {:http_error, error}} when is_integer(error) -> m.replyfun.("Checkin to Untappd failed: #{to_string(error)}")
	{:error, {:http_error, error}} -> m.replyfun.("Checkin to Untappd failed: #{inspect error}")
	_ -> :error
	end
	end)
	end

	local_extra = if auto_set do
	if comment do
	" #{comment} (#{cl}cl @ #{deg}°)"
	else
	"#{cl}cl @ #{deg}°"
	end
	else
	""
	end
	m.replyfun.(msg.(m.sender.nick, local_extra))
	notify = Nola.Membership.notify_channels(m.account) -- [{m.network,m.channel}]
	for {net, chan} <- notify do
	user = Nola.UserTrack.find_by_account(net, m.account)
	nick = if(user, do: user.nick, else: m.account.name)
	extra = " " <> present_type(name, comment) <> ""
	- IRC.Connection.broadcast_message(net, chan, msg.(nick, extra))
	+ Nola.Irc.Connection.broadcast_message(net, chan, msg.(nick, extra))
	end

	miss = cond do
	points <= 0.6 -> :small
	stats.active30m >= 2.9 && stats.active30m < 3 -> :miss3
	stats.active30m >= 1.9 && stats.active30m < 2 -> :miss2
	stats.active30m >= 0.9 && stats.active30m < 1 -> :miss1
	stats.active30m >= 0.45 && stats.active30m < 0.5 -> :miss05
	stats.active30m >= 0.20 && stats.active30m < 0.20 -> :miss025
	stats.active30m >= 3 && stats.active1h < 3.15 -> :small3
	stats.active30m >= 2 && stats.active1h < 2.15 -> :small2
	stats.active30m >= 1.5 && stats.active1h < 1.5 -> :small15
	stats.active30m >= 1 && stats.active1h < 1.15 -> :small1
	stats.active30m >= 0.5 && stats.active1h <= 0.51 -> :small05
	stats.active30m >= 0.25 && stats.active30m <= 0.255 -> :small025
	true -> nil
	end

	if miss do
	miss = Nola.Plugins.Txt.random("alcoolog.#{to_string(miss)}")
	if miss do
	for {net, chan} <- Nola.Membership.notify_channels(m.account) do
	user = Nola.UserTrack.find_by_account(net, m.account)
	nick = if(user, do: user.nick, else: m.account.name)
	- IRC.Connection.broadcast_message(net, chan, "#{nick}: #{miss}")
	+ Nola.Irc.Connection.broadcast_message(net, chan, "#{nick}: #{miss}")
	end
	end
	end
	end
	end

	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

	def get_all_stats() do
	Nola.Account.all_accounts()
	\|> Enum.map(fn(account) -> {account.id, get_full_statistics(account.id)} end)
	\|> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 \|\| status.active30m > 0) end)
	\|> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
	end

	def get_channel_statistics(account, network, nil) do
	Nola.Membership.expanded_members_or_friends(account, network, nil)
	\|> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end)
	\|> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 \|\| status.active30m > 0) end)
	\|> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
	end

	def get_channel_statistics(_, network, channel), do: get_channel_statistics(network, channel)

	def get_channel_statistics(network, channel) do
	Nola.Membership.expanded_members(network, channel)
	\|> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end)
	\|> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 \|\| status.active30m > 0) end)
	\|> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
	end

	@spec since() :: %{Nola.Account.id() => DateTime.t()}
	@doc "Returns the last time the user was at 0 g/l"
	def since() do
	:ets.foldr(fn({{acct, timestamp_or_date}, _vol, current, _cl, _deg, _name, _comment, _m}, acc) ->
	if !Map.get(acc, acct) && current == 0 do
	date = Util.to_date_time(timestamp_or_date)
	Map.put(acc, acct, date)
	else
	acc
	end
	end, %{}, __MODULE__.ETS)
	end

	def get_full_statistics(nick) do
	get_full_statistics(data_state(), nick)
	end

	defp get_full_statistics(state, nick) do
	case get_statistics_for_nick(state, nick) do
	{count, {_, last_at, last_points, last_active, last_cl, last_deg, last_type, last_descr, _meta}} ->
	{active, active_drinks} = current_alcohol_level(state, nick)
	{_, m30} = alcohol_level_rising(state, nick)
	{rising, m15} = alcohol_level_rising(state, nick, 15)
	{_, m5} = alcohol_level_rising(state, nick, 5)
	{_, h1} = alcohol_level_rising(state, nick, 60)

	trend = if rising do
	"▲"
	else
	"▼"
	end
	user_state = cond do
	active <= 0.0 -> :sober
	active <= 0.25 -> :low
	active <= 0.50 -> :legal
	active <= 1.0 -> :legalhigh
	active <= 2.5 -> :high
	active < 3 -> :toohigh
	true -> :sick
	end

	rising_file_key = if rising, do: "_rising", else: ""
	txt_file = "alcoolog." <> "user_" <> to_string(user_state) <> rising_file_key
	user_status = Nola.Plugins.Txt.random(txt_file)

	meta = get_user_meta(state, nick)
	minutes_til_sober = h1/((meta.loss_factor/100)/60)
	minutes_til_sober = cond do
	active < 0 -> 0
	m15 < 0 -> 15
	m30 < 0 -> 30
	h1 < 0 -> 60
	minutes_til_sober > 0 ->
	Float.round(minutes_til_sober+60)
	true -> 0
	end

	duration = Timex.Duration.from_minutes(minutes_til_sober)
	sober_in_s = if minutes_til_sober > 0 do
	Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
	else
	nil
	end

	since = if active > 0 do
	since()
	\|> Map.get(nick)
	end

	since_diff = if since, do: Timex.diff(DateTime.utc_now(), since, :minutes)
	since_duration = if since, do: Timex.Duration.from_minutes(since_diff)
	since_s = if since, do: Timex.Format.Duration.Formatter.lformat(since_duration, "fr", :humanized)

	{total_volumes, total_gl} = user_stats(state, nick)


	%{active: active, last_at: last_at, last_cl: last_cl, last_deg: last_deg, last_points: last_points, last_type: last_type, last_descr: last_descr,
	trend_symbol: trend,
	active5m: m5, active15m: m15, active30m: m30, active1h: h1,
	rising: rising,
	active_drinks: active_drinks,
	user_status: user_status,
	daily_gl: total_gl, daily_volumes: total_volumes,
	sober_in: minutes_til_sober, sober_in_s: sober_in_s,
	since: since, since_min: since_diff, since_s: since_s,
	}
	_ ->
	nil
	end
	end

	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)
	\|> Enum.sort_by(fn({_, status}) -> status.sober_in end, &</2)
	\|> Enum.map(fn({nick, stats}) ->
	now = DateTime.utc_now()
	sober = now \|> DateTime.add(round(stats.sober_in*60), :second)
	\|> Timex.Timezone.convert("Europe/Paris")
	at = if now.day == sober.day do
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
	detail
	else
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
	detail
	end
	"#{nick} sobre #{at} (dans #{stats.sober_in_s})"
	end)
	\|> Enum.intersperse(", ")
	\|> Enum.join("")
	\|> (fn(line) ->
	case line do
	"" -> "tout le monde est sobre......."
	line -> line
	end
	end).()
	\|> m.replyfun.()
	{:noreply, state}
	end

	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
	end

	if account do
	user = Nola.UserTrack.find_by_account(m.network, account)
	nick = if(user, do: user.nick, else: account.name)
	stats = get_full_statistics(state, account.id)
	if stats && stats.sober_in > 0 do
	now = DateTime.utc_now()
	sober = now \|> DateTime.add(round(stats.sober_in*60), :second)
	\|> Timex.Timezone.convert("Europe/Paris")
	at = if now.day == sober.day do
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
	detail
	else
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
	detail
	end
	m.replyfun.("#{nick} sera sobre #{at} (dans #{stats.sober_in_s})!")
	else
	m.replyfun.("#{nick} est déjà sobre. aidez le !")
	end
	else
	m.replyfun.("inconnu")
	end
	{:noreply, state}
	end

	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)
	\|> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
	\|> Enum.map(fn({nick, status}) ->
	trend_symbol = if status.active_drinks > 1 do
	Enum.join(for(_ <- 1..status.active_drinks, do: status.trend_symbol))
	else
	status.trend_symbol
	end
	since_str = if status.since_min > 180 do
	"depuis: #{status.since_s} \| "
	else
	""
	end
	"#{nick} #{status.user_status} #{trend_symbol} #{Float.round(status.active, 4)} g/l [#{since_str}sobre dans: #{status.sober_in_s}]"
	end)
	\|> Enum.intersperse(", ")
	\|> Enum.join("")

	msg = if nicks == "" do
	"wtf?!?! personne n'a bu!"
	else
	nicks
	end

	m.replyfun.(msg)
	{:noreply, state}
	end

	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 ->
	case Integer.parse(string) do
	{time, "j"} -> time
	{time, "J"} -> time
	_ -> nil
	end
	end

	if time do
	aday = time((24 60)*60)
	now = DateTime.utc_now()
	before = now
	\|> DateTime.add(-aday, :second)
	\|> DateTime.to_unix(:millisecond)
	over_time_stats(before, time, m, state)
	else
	m.replyfun.(".alcooolisme semaine\|Xj")
	end
	{:noreply, state}
	end

	def user_over_time(account, count) do
	user_over_time(data_state(), account, count)
	end

	def user_over_time(state, account, count) do
	delay = count((24 60)*60)
	now = DateTime.utc_now()
	before = DateTime.utc_now()
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	\|> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
	\|> DateTime.to_unix(:millisecond)
	#[
	# {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	# [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]}
	#]
	match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	[{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]}
	]
	:ets.select(state.ets, match)
	\|> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) ->
	date = DateTime.from_unix!(ts, :millisecond)
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)

	date = if date.hour <= 8 do
	DateTime.add(date, -(60(60(date.hour+1))), :second, Tzdata.TimeZoneDatabase)
	else
	date
	end
	\|> DateTime.to_date()

	Map.put(acc, date, Map.get(acc, date, 0) + vol)
	end)
	end

	def user_over_time_gl(account, count) do
	state = data_state()
	meta = get_user_meta(state, account.id)
	delay = count((24 60)*60)
	now = DateTime.utc_now()
	before = DateTime.utc_now()
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	\|> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
	\|> DateTime.to_unix(:millisecond)
	#[
	# {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	# [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]}
	#]
	match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	[{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]}
	]
	:ets.select(state.ets, match)
	\|> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) ->
	date = DateTime.from_unix!(ts, :millisecond)
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)

	date = if date.hour <= 8 do
	DateTime.add(date, -(60(60(date.hour+1))), :second, Tzdata.TimeZoneDatabase)
	else
	date
	end
	\|> DateTime.to_date()
	weight = meta.weight
	k = if meta.sex, do: 0.7, else: 0.6
	gl = (10vol)/(kweight)

	Map.put(acc, date, Map.get(acc, date, 0) + gl)
	end)
	end



	defp over_time_stats(before, j, m, state) do
	#match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _, _, _, _}) when date > before -> obj end)
	match = [{{{:_, :"$1"}, :_, :_, :_, :_, :_, :_, :_},
	[{:>, :"$1", {:const, before}}], [:"$_"]}
	]
	# tuple ets: {{nick, date}, volumes, current, nom, commentaire}
	members = Nola.Membership.members_or_friends(m.account, m.network, m.channel)
	drinks = :ets.select(state.ets, match)
	\|> Enum.filter(fn({{account, _}, _, _, _, _, _, _, _}) -> Enum.member?(members, account) end)
	\|> Enum.sort_by(fn({{_, ts}, _, _, _, _, _, _, _}) -> ts end, &>/2)

	top = Enum.reduce(drinks, %{}, fn({{nick, _}, vol, _, _, _, _, _, _}, acc) ->
	all = Map.get(acc, nick, 0)
	Map.put(acc, nick, all + vol)
	end)
	\|> Enum.sort_by(fn({_nick, count}) -> count end, &>/2)
	\|> Enum.map(fn({nick, count}) ->
	account = Nola.Account.get(nick)
	user = Nola.UserTrack.find_by_account(m.network, account)
	nick = if(user, do: user.nick, else: account.name)
	"#{nick}: #{Float.round(count, 4)}"
	end)
	\|> Enum.intersperse(", ")

	m.replyfun.("sur #{j} jours: #{top}")
	{:noreply, state}
	end

	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 = %Nola.Message{trigger: %Nola.Trigger{args: [h, weight \| rest], type: :plus}}}, state) do
	h = case h do
	"h" -> true
	"f" -> false
	_ -> nil
	end

	weight = case Util.float_paparse(weight) do
	{weight, _} -> weight
	_ -> nil
	end

	{factor} = case rest do
	[factor] ->
	case Util.float_paparse(factor) do
	{float, _} -> {float}
	_ -> {@default_user_meta.loss_factor}
	end
	_ -> {@default_user_meta.loss_factor}
	end

	if h == nil \|\| weight == nil do
	m.replyfun.("paramètres invalides")
	else
	old_meta = get_user_meta(state, m.account.id)
	meta = Map.merge(@default_user_meta, %{sex: h, weight: weight, loss_factor: factor})
	put_user_meta(state, m.account.id, meta)
	cond do
	old_meta.weight < meta.weight ->
	Nola.Plugins.Txt.reply_random(m, "alcoolog.fatter")
	old_meta.weight == meta.weight ->
	m.replyfun.("aucun changement!")
	true ->
	Nola.Plugins.Txt.reply_random(m, "alcoolog.thinner")
	end
	end

	{:noreply, state}
	end

	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)
	:ets.delete(state.ets, {m.account.id, date})
	m.replyfun.("supprimé: #{m.sender.nick} #{points} #{type} #{descr}")
	Nola.Plugins.Txt.reply_random(m, "alcoolog.delete")
	notify = Nola.Membership.notify_channels(m.account) -- [{m.network,m.channel}]
	for {net, chan} <- notify do
	user = Nola.UserTrack.find_by_account(net, m.account)
	nick = if(user, do: user.nick, else: m.account.name)
	- IRC.Connection.broadcast_message(net, chan, "#{nick} -santai #{points} #{type} #{descr}")
	+ Nola.Irc.Connection.broadcast_message(net, chan, "#{nick} -santai #{points} #{type} #{descr}")
	end
	{:noreply, state}
	_ ->
	{:noreply, state}
	end
	end


	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, []}
	end
	if account do
	duration = case duration do
	["semaine"] -> 7
	[j] ->
	case Integer.parse(j) do
	{j, "j"} -> j
	_ -> nil
	end
	_ -> nil
	end
	user = Nola.UserTrack.find_by_account(m.network, account)
	nick = if(user, do: user.nick, else: account.name)
	if duration do
	if duration > 90 do
	m.replyfun.("trop gros, ça rentrera pas")
	else
	# duration stats
	stats = user_over_time(state, account, duration)
	\|> Enum.sort_by(fn({k,_v}) -> k end, {:asc, Date})
	\|> Enum.map(fn({date, count}) ->
	"#{date.day}: #{Float.round(count, 2)}"
	end)
	\|> Enum.intersperse(", ")
	\|> Enum.join("")

	if stats == "" do
	m.replyfun.("alcoolisme a zéro sur #{duration}j :/")
	else
	m.replyfun.("alcoolisme de #{nick}, #{duration} derniers jours: #{stats}")
	end
	end
	else
	if stats = get_full_statistics(state, account.id) do
	trend_symbol = if stats.active_drinks > 1 do
	Enum.join(for(_ <- 1..stats.active_drinks, do: stats.trend_symbol))
	else
	stats.trend_symbol
	end
	# TODO: Lookup nick for account_id
	msg = "#{nick} #{stats.user_status} "
	<> (if stats.active > 0 \|\| stats.active15m > 0 \|\| stats.active30m > 0 \|\| stats.active1h > 0, do: ": #{trend_symbol} #{Float.round(stats.active, 4)}g/l ", else: "")
	<> (if stats.active30m > 0 \|\| stats.active1h > 0, do: "(15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) ", else: "")
	<> (if stats.sober_in > 0, do: "— Sobre dans #{stats.sober_in_s} ", else: "")
	<> (if stats.since && stats.since_min > 180, do: "— Paitai depuis #{stats.since_s} ", else: "")
	<> "— Dernier verre: #{present_type(stats.last_type, stats.last_descr)} [#{Float.round(stats.last_points+0.0, 4)}] "
	<> "#{format_duration_from_now(stats.last_at)} "
	<> (if stats.daily_volumes > 0, do: "— Aujourd'hui: #{stats.daily_volumes} #{stats.daily_gl}g/l", else: "")

	m.replyfun.(msg)
	else
	m.replyfun.("honteux mais #{nick} n'a pas l'air alcoolique du tout. /kick")
	end
	end
	else
	m.replyfun.("je ne connais pas cet utilisateur")
	end
	{:noreply, state}
	end


	# Account merge
	def handle_info({:account_change, old_id, new_id}, state) do
	spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, old_id}}], [:"$_"]}]
	Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) ->
	Logger.debug("alcolog/account_change:: merging #{old_id} -> #{new_id}")
	rename_object_owner(table, state.ets, obj, old_id, new_id)
	end)
	case :dets.lookup(state.meta, {:meta, old_id}) do
	[{_, meta}] ->
	:dets.delete(state.meta, {:meta, old_id})
	:dets.insert(state.meta, {{:meta, new_id}, meta})
	_ ->
	:ok
	end
	{:noreply, state}
	end

	def terminate(_, state) do
	for dets <- [state.dets, state.meta] do
	:dets.sync(dets)
	:dets.close(dets)
	end
	end

	defp rename_object_owner(table, ets, object = {old_id, date, volume, current, cl, deg, name, comment, meta}, old_id, new_id) do
	:dets.delete_object(table, object)
	:ets.delete(ets, {old_id, date})
	:dets.insert(table, {new_id, date, volume, current, cl, deg, name, comment, meta})
	:ets.insert(ets, {{new_id, date}, volume, current, cl, deg, name, comment, meta})
	end

	# Account: move from nick to account id
	def handle_info({:accounts, accounts}, state) do
	#for x={:account, _, _, _, _} <- accounts, do: handle_info(x, state)
	#{:noreply, state}
	mapping = Enum.reduce(accounts, Map.new, fn({:account, _net, _chan, nick, account_id}, acc) ->
	Map.put(acc, String.downcase(nick), account_id)
	end)
	spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [], [:"$_"]}]
	Logger.debug("accounts:: mappings #{inspect mapping}")
	Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj = {nick, _date, _vol, _cur, _cl, _deg, _name, _comment, _meta}) ->
	#Logger.debug("accounts:: item #{inspect(obj)}")
	if new_id = Map.get(mapping, nick) do
	Logger.debug("alcolog/accounts:: merging #{nick} -> #{new_id}")
	rename_object_owner(table, state.ets, obj, nick, new_id)
	end
	end)
	{:noreply, state}
	end

	def handle_info({:account, _net, _chan, nick, account_id}, state) do
	nick = String.downcase(nick)
	spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, nick}}], [:"$_"]}]
	Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) ->
	Logger.debug("alcoolog/account:: merging #{nick} -> #{account_id}")
	rename_object_owner(table, state.ets, obj, nick, account_id)
	end)
	case :dets.lookup(state.meta, {:meta, nick}) do
	[{_, meta}] ->
	:dets.delete(state.meta, {:meta, nick})
	:dets.insert(state.meta, {{:meta, account_id}, meta})
	_ ->
	:ok
	end
	{:noreply, state}
	end

	def handle_info(t, state) do
	Logger.debug("#{__MODULE__}: unhandled info #{inspect t}")
	{:noreply, state}
	end

	def nick_history(account) do
	spec = [
	{{{:"$1", :_}, :_, :_, :_, :_, :_, :_, :_},
	[{:==, :"$1", {:const, account.id}}],
	[:"$_"]}
	]
	:ets.select(data_state().ets, spec)
	end

	defp get_statistics_for_nick(state, account_id) do
	qvc = :dets.lookup(state.dets, account_id)
	\|> Enum.sort_by(fn({_, ts, _, _, _, _, _, _, _}) -> ts end, &</2)
	count = Enum.reduce(qvc, 0, fn({_nick, _ts, points, _active, _cl, _deg, _type, _descr, _meta}, acc) -> acc + (points\|\|0) end)
	last = List.last(qvc) \|\| nil
	{count, last}
	end

	def present_type(type, descr) when descr in [nil, ""], do: "#{type}"
	def present_type(type, description), do: "#{type} (#{description})"

	def format_points(int) when is_integer(int) and int > 0 do
	"+#{Integer.to_string(int)}"
	end
	def format_points(int) when is_integer(int) and int < 0 do
	Integer.to_string(int)
	end
	def format_points(int) when is_float(int) and int > 0 do
	"+#{Float.to_string(Float.round(int,4))}"
	end
	def format_points(int) when is_float(int) and int < 0 do
	Float.to_string(Float.round(int,4))
	end
	def format_points(0), do: "0"
	def format_points(0.0), do: "0"

	defp format_relative_timestamp(timestamp) do
	alias Timex.Format.DateTime.Formatters
	alias Timex.Timezone
	date = timestamp
	\|> DateTime.from_unix!(:millisecond)
	\|> Timezone.convert("Europe/Paris")

	{:ok, relative} = Formatters.Relative.relative_to(date, Timex.now("Europe/Paris"), "{relative}", "fr")
	{:ok, detail} = Formatters.Default.lformat(date, " ({h24}:{m})", "fr")

	relative <> detail
	end

	defp put_user_meta(state, account_id, meta) do
	:dets.insert(state.meta, {{:meta, account_id}, meta})
	:ok
	end

	defp get_user_meta(%{meta: meta}, account_id) do
	case :dets.lookup(meta, {:meta, account_id}) do
	[{{:meta, _}, meta}] ->
	Map.merge(@default_user_meta, meta)
	_ ->
	@default_user_meta
	end
	end
	# Calcul g/l actuel:
	# 1. load user meta
	# 2. foldr ets
	# for each object
	# get_current_alcohol
	# ((object g/l) - 0,15/l/60)* minutes_since_drink
	# if minutes_since_drink < 10, reduce g/l (?!)
	# acc + current_alcohol
	# stop folding when ?
	#

	def user_stats(account) do
	user_stats(data_state(), account.id)
	end

	defp user_stats(state = %{ets: ets}, account_id) do
	meta = get_user_meta(state, account_id)
	aday = (10 * 60)*60
	now = DateTime.utc_now()
	before = now
	\|> DateTime.add(-aday, :second)
	\|> DateTime.to_unix(:millisecond)
	#match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end)
	match = [
	{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	[
	{:>, :"$2", {:const, before}},
	{:"=:=", {:const, account_id}, :"$1"}
	], [:"$_"]}
	]
	# tuple ets: {{nick, date}, volumes, current, nom, commentaire}
	drinks = :ets.select(ets, match)
	# {date, single_peak}
	total_volume = Enum.reduce(drinks, 0.0, fn({{_, date}, volume, _, _, _, _, _, _}, acc) ->
	acc + volume
	end)
	k = if meta.sex, do: 0.7, else: 0.6
	weight = meta.weight
	gl = (10total_volume)/(kweight)
	{Float.round(total_volume + 0.0, 4), Float.round(gl + 0.0, 4)}
	end

	defp alcohol_level_rising(state, account_id, minutes \\ 30) do
	{now, _} = current_alcohol_level(state, account_id)
	soon_date = DateTime.utc_now
	\|> DateTime.add(minutes*60, :second)
	{soon, _} = current_alcohol_level(state, account_id, soon_date)
	soon = cond do
	soon < 0 -> 0.0
	true -> soon
	end
	#IO.puts "soon #{soon_date} - #{inspect soon} #{inspect now}"
	{soon > now, Float.round(soon+0.0, 4)}
	end

	defp current_alcohol_level(state = %{ets: ets}, account_id, now \\ nil) do
	meta = get_user_meta(state, account_id)
	aday = ((247) 60)*60
	now = if now do
	now
	else
	DateTime.utc_now()
	end
	before = now
	\|> DateTime.add(-aday, :second)
	\|> DateTime.to_unix(:millisecond)
	#match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end)
	match = [
	{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
	[
	{:>, :"$2", {:const, before}},
	{:"=:=", {:const, account_id}, :"$1"}
	], [:"$_"]}
	]
	# tuple ets: {{nick, date}, volumes, current, nom, commentaire}
	drinks = :ets.select(ets, match)
	\|> Enum.sort_by(fn({{_, date}, _, _, _, _, _, _, _}) -> date end, &</2)
	# {date, single_peak}
	{all, last_drink_at, gl, active_drinks} = Enum.reduce(drinks, {0.0, nil, [], 0}, fn({{_, date}, volume, _, _, _, _, _, _}, {all, last_at, acc, active_drinks}) ->
	k = if meta.sex, do: 0.7, else: 0.6
	weight = meta.weight
	peak = (10volume)/(kweight)
	date = case date do
	ts when is_integer(ts) -> DateTime.from_unix!(ts, :millisecond)
	date = %NaiveDateTime{} -> DateTime.from_naive!(date, "Etc/UTC")
	date = %DateTime{} -> date
	end
	last_at = last_at \|\| date
	mins_since = round(DateTime.diff(now, date)/60.0)
	#IO.puts "Drink: #{inspect({date, volume})} - mins since: #{inspect mins_since} - last drink at #{inspect last_at}"
	# Apply loss since `last_at` on `all`
	#
	all = if last_at do
	mins_since_last = round(DateTime.diff(date, last_at)/60.0)
	loss = ((meta.loss_factor/100)/60)*(mins_since_last)
	#IO.puts "Applying last drink loss: from #{all}, loss of #{inspect loss} (mins since #{inspect mins_since_first})"
	cond do
	(all-loss) > 0 -> all - loss
	true -> 0.0
	end
	else
	all
	end
	#IO.puts "Applying last drink current before drink: #{inspect all}"
	if mins_since < 30 do
	per_min = (peak)/30.0
	current = (per_min*mins_since)
	#IO.puts "Applying current drink 30m: from #{peak}, loss of #{inspect per_min}/min (mins since #{inspect mins_since})"
	{all + current, date, [{date, current} \| acc], active_drinks + 1}
	else
	{all + peak, date, [{date, peak} \| acc], active_drinks}
	end
	end)
	#IO.puts "last drink #{inspect last_drink_at}"
	mins_since_last = if last_drink_at do
	round(DateTime.diff(now, last_drink_at)/60.0)
	else
	0
	end
	# Si on a déjà bu y'a déjà moins 15 minutes (big up le binge drinking), on applique plus de perte
	level = if mins_since_last > 15 do
	loss = ((meta.loss_factor/100)/60)*(mins_since_last)
	Float.round(all - loss, 4)
	else
	all
	end
	#IO.puts "\n LEVEL #{inspect level}\n\n\n\n"
	cond do
	level < 0 -> {0.0, 0}
	true -> {level, active_drinks}
	end
	end

	defp format_duration_from_now(date, with_detail \\ true) do
	date = if is_integer(date) do
	date = DateTime.from_unix!(date, :millisecond)
	\|> Timex.Timezone.convert("Europe/Paris")
	else
	Util.to_naive_date_time(date)
	end
	now = DateTime.utc_now()
	\|> Timex.Timezone.convert("Europe/Paris")
	{:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(date, "({h24}:{m})", "fr")

	mins_since = round(DateTime.diff(now, date)/60.0)
	if ago = format_minute_duration(mins_since) do
	word = if mins_since > 0 do
	"il y a "
	else
	"dans "
	end
	word <> ago <> if(with_detail, do: " #{detail}", else: "")
	else
	"maintenant #{detail}"
	end
	end

	defp format_minute_duration(minutes) do
	sober_in_s = if (minutes != 0) do
	duration = Timex.Duration.from_minutes(minutes)
	Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
	else
	nil
	end
	end

	end
	diff --git a/lib/plugins/alcoolog_announcer.ex b/lib/plugins/alcoolog_announcer.ex
	index 937002e..f172d85 100644
	--- a/lib/plugins/alcoolog_announcer.ex
	+++ b/lib/plugins/alcoolog_announcer.ex
	@@ -1,269 +1,269 @@
	defmodule Nola.Plugins.AlcoologAnnouncer do
	require Logger

	@moduledoc """
	Annonce changements d'alcoolog
	"""

	@channel "#dmz"

	@seconds 30

	@apero [
	"C'EST L'HEURE DE L'APÉRRROOOOOOOO !!",
	"SAAAAANNNNNNNTTTTTTTTAAAAAAAAIIIIIIIIIIIIIIIIIIIIII",
	"APÉRO ? APÉRO !",
	{:timed, ["/!\\ à vos tires bouchons…", "… débouchez …", "… BUVEZ! SANTAIII!"]},
	"/!\\ ALERTE APÉRO /!\\",
	"CED !!! VASE DE ROUGE !",
	"DIDI UN PETIT RICARD™??!",
	"ALLEZ GUIGUI UNE PETITE BIERE ?",
	{:timed, ["/!\\ à vos tires bouchons…", "… débouchez …", "… BUVEZ! SANTAIII!"]},
	"APPPPAIIIRRREAAUUUUUUUUUUU"
	]

	def irc_doc, do: nil

	def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)

	def log(account) do
	dets_filename = (Nola.data_path() <> "/" <> "alcoologlog.dets") \|> String.to_charlist
	{:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}])
	from = ~U[2020-08-23 19:41:40.524154Z]
	to = ~U[2020-08-24 19:41:40.524154Z]
	select = [
	{{:"$1", :"$2", :_},
	[
	{:andalso,
	{:andalso, {:==, :"$1", {:const, account.id}},
	{:>, :"$2", {:const, DateTime.to_unix(from)}}},
	{:<, :"$2", {:const, DateTime.to_unix(to)}}}
	], [:"$_"]}
	]
	res = :dets.select(dets, select)
	:dets.close(dets)
	res
	end

	def init(_) do
	{:ok, _} = Registry.register(Nola.PubSub, "account", [])
	stats = get_stats()
	Process.send_after(self(), :stats, :timer.seconds(30))
	dets_filename = (Nola.data_path() <> "/" <> "alcoologlog.dets") \|> String.to_charlist
	{:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}])
	ets = nil # :ets.new(__MODULE__.ETS, [:ordered_set, :named_table, :protected, {:read_concurrency, true}])
	{:ok, {stats, now(), dets, ets}}#, {:continue, :traverse}}
	end

	def handle_continue(:traverse, state = {_, _, dets, ets}) do
	traverse_fun = fn(obj, dets) ->
	case obj do
	{nick, %DateTime{} = dt, active} ->
	:dets.delete_object(dets, obj)
	:dets.insert(dets, {nick, DateTime.to_unix(dt), active})
	IO.puts("ok #{inspect obj}")
	dets
	{nick, ts, value} ->
	:ets.insert(ets, { {nick, ts}, value })
	dets
	end
	end
	:dets.foldl(traverse_fun, dets, dets)
	:dets.sync(dets)
	IO.puts("alcoolog announcer fixed")
	{:noreply, state}
	end

	def alcohol_reached(old, new, level) do
	(old.active < level && new.active >= level) && (new.active5m >= level)
	end

	def alcohol_below(old, new, level) do
	(old.active > level && new.active <= level) && (new.active5m <= level)
	end


	def handle_info(:stats, {old_stats, old_now, dets, ets}) do
	stats = get_stats()
	now = now()

	if old_now.hour < 18 && now.hour == 18 do
	apero = Enum.shuffle(@apero)
	\|> Enum.random()

	case apero do
	{:timed, list} ->
	spawn(fn() ->
	for line <- list do
	- IRC.Connection.broadcast_message("evolu.net", "#dmz", line)
	+ Nola.Irc.Connection.broadcast_message("evolu.net", "#dmz", line)
	:timer.sleep(:timer.seconds(5))
	end
	end)
	string ->
	- IRC.Connection.broadcast_message("evolu.net", "#dmz", string)
	+ Nola.Irc.Connection.broadcast_message("evolu.net", "#dmz", string)
	end

	end

	#IO.puts "newstats #{inspect stats}"
	events = for {acct, old} <- old_stats do
	new = Map.get(stats, acct, nil)
	#IO.puts "#{acct}: #{inspect(old)} -> #{inspect(new)}"

	now = DateTime.to_unix(DateTime.utc_now())
	if new && new[:active] do
	:dets.insert(dets, {acct, now, new[:active]})
	:ets.insert(ets, {{acct, now}, new[:active]})
	else
	:dets.insert(dets, {acct, now, 0.0})
	:ets.insert(ets, {{acct, now}, new[:active]})
	end

	event = cond do
	old == nil -> nil
	(old.active > 0) && (new == nil) -> :sober
	new == nil -> nil
	alcohol_reached(old, new, 0.5) -> :stopconduire
	alcohol_reached(old, new, 1.0) -> :g1
	alcohol_reached(old, new, 2.0) -> :g2
	alcohol_reached(old, new, 3.0) -> :g3
	alcohol_reached(old, new, 4.0) -> :g4
	alcohol_reached(old, new, 5.0) -> :g5
	alcohol_reached(old, new, 6.0) -> :g6
	alcohol_reached(old, new, 7.0) -> :g7
	alcohol_reached(old, new, 10.0) -> :g10
	alcohol_reached(old, new, 13.74) -> :record
	alcohol_below(old, new, 0.5) -> :conduire
	alcohol_below(old, new, 1.0) -> :fini1g
	alcohol_below(old, new, 2.0) -> :fini2g
	alcohol_below(old, new, 3.0) -> :fini3g
	alcohol_below(old, new, 4.0) -> :fini4g
	(old.rising) && (!new.rising) -> :lowering
	true -> nil
	end
	{acct, event}
	end

	for {acct, event} <- events do
	message = case event do
	:g1 -> [
	"[vigicuite jaune] LE GRAMME! LE GRAMME O/",
	"début de vigicuite jaune ! LE GRAMME ! \\O/",
	"waiiiiiiii le grammmeee",
	"bourraiiiiiiiiiiide 1 grammeeeeeeeeeee",
	]
	:g2 -> [
	"[vigicuite orange] \\o_YAY 2 GRAMMES ! _o/",
	"PAITAIIIIIIIIII DEUX GRAMMEESSSSSSSSSSSSSSSSS",
	"bourrrrrraiiiiiiiiiiiiiiiide 2 grammeeeeeeeeeees",
	]
	:g3 -> [
	"et un ! et deux ! et TROIS GRAMMEEESSSSSSS",
	"[vigicuite rouge] _o/ BOURRAIIDDDEEEE 3 GRAMMESSSSSSSSS \\o/ \\o/"
	]
	:g4 -> [
	"[vigicuite écarlate] et un, et deux, et trois, ET QUATRES GRAMMEESSSSSSSSSSSSSSSSSSSssssss"
	]
	:g5 -> "[vigicuite écarlate+] PUTAIN 5 GRAMMES !"
	:g6 -> "[vigicuite écarlate++] 6 grammes ? Vous pouvez joindre Alcool info service au 0 980 980 930"
	:g7 -> "[vigicuite c'est la merde] 7 grammes. Le SAMU, c'est le 15."
	:g10 -> "BORDLE 10 GRAMMES"
	:record -> "RECORD DU MONDE BATTU ! >13.74g/l !!"
	:fini1g -> [
	"fin d'alerte vigicuite jaune, passage en vert (<1g/l)",
	"/!\\ alerte moins de 1g/l /!\\"
	]
	:fini2g -> [
	"t'as moins de 2 g/l, faut se reprendre là [vigicuite jaune]"
	]
	:fini3g -> [
	"fin d'alerte vigicuite rouge, passage en orange (<3g/l)"
	]
	:fini4g -> [
	"fin d'alerte vigicuite écarlate, passage en rouge (<4g/l)"
	]
	:lowering -> [
	"attention ça baisse!",
	"tu vas quand même pas en rester là ?",
	"IL FAUT CONTINUER À BOIRE !",
	"t'abandonnes déjà ?",
	"!santai ?",
	"faut pas en rester là",
	"il faut se resservir",
	"coucou faut reboire",
	"encore un petit verre ?",
	"abwaaaaaaaaaaaaarrrrrrrrrrrrrr",
	"taux d'alcoolémie en chute ! agissez avant qu'il soit trop tard!",
	"ÇA BAISSE !!"
	]
	:stopconduire -> [
	"0.5g! bientot le gramme?",
	"tu peux plus prendre la route... mais... tu peux prendre la route du gramme! !santai !",
	"fini la conduite!",
	"0.5! continues faut pas en rester là!",
	"beau début, continues !",
	"ça monte! 0.5g/l!"
	]
	:conduire -> [
	"tu peux conduire, ou recommencer à boire! niveau critique!",
	"!santai ?",
	"tu peux reprendre la route, ou reprendre la route du gramme..",
	"attention, niveau critique!",
	"il faut boire !!",
	"trop de sang dans ton alcool, c'est mauvais pour la santé",
	"faut pas en rester là !",
	]
	:sober -> [
	"sobre…",
	"/!\\ alerte sobriété /!\\",
	"... sobre?!?!",
	"sobre :(",
	"attention, t'es sobre :/",
	"danger, alcoolémie à 0.0 !",
	"sobre! c'était bien on recommence quand ?",
	"sobre ? Faut recommencer...",
	"T'es sobre. Ne te laisses pas abattre- ton caviste peut aider.",
	"Vous êtes sobre ? Ceci n'est pas une fatalité - resservez vous vite !"
	]
	_ -> nil
	end
	message = case message do
	m when is_binary(m) -> m
	m when is_list(m) -> m \|> Enum.shuffle() \|> Enum.random()
	nil -> nil
	end
	if message do
	#IO.puts("#{acct}: #{message}")
	account = Nola.Account.get(acct)
	for {net, chan} <- Nola.Membership.notify_channels(account) do
	user = Nola.UserTrack.find_by_account(net, account)
	nick = if(user, do: user.nick, else: account.name)
	- IRC.Connection.broadcast_message(net, chan, "#{nick}: #{message}")
	+ Nola.Irc.Connection.broadcast_message(net, chan, "#{nick}: #{message}")
	end
	end
	end

	timer()

	#IO.puts "tick stats ok"
	{:noreply, {stats,now,dets,ets}}
	end

	def handle_info(_, state) do
	{:noreply, state}
	end

	defp now() do
	DateTime.utc_now()
	\|> Timex.Timezone.convert("Europe/Paris")
	end

	defp get_stats() do
	Enum.into(Nola.Plugins.Alcoolog.get_all_stats(), %{})
	end

	defp timer() do
	Process.send_after(self(), :stats, :timer.seconds(@seconds))
	end

	end
	diff --git a/lib/plugins/say.ex b/lib/plugins/say.ex
	index 9bfe1bd..3df3ac8 100644
	--- a/lib/plugins/say.ex
	+++ b/lib/plugins/say.ex
	@@ -1,73 +1,73 @@
	defmodule Nola.Plugins.Say do

	def irc_doc do
	"""
	# say

	Say something...

	* !say `<channel>` `<text>` say something on `channel`
	* !asay `<channel>` `<text>` same but anonymously

	You must be a member of the channel.
	"""
	end

	def start_link() do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	def init([]) do
	regopts = [type: __MODULE__]
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:say", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:asay", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "messages:private", regopts)
	{:ok, nil}
	end

	def handle_info({:irc, :trigger, "say", m = %{trigger: %{type: :bang, args: [target \| text]}}}, state) do
	text = Enum.join(text, " ")
	say_for(m.account, target, text, true)
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "asay", m = %{trigger: %{type: :bang, args: [target \| text]}}}, state) do
	text = Enum.join(text, " ")
	say_for(m.account, target, text, false)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %{text: "say "<>rest}}, state) do
	case String.split(rest, " ", parts: 2) do
	[target, text] -> say_for(m.account, target, text, true)
	_ -> nil
	end
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %{text: "asay "<>rest}}, state) do
	case String.split(rest, " ", parts: 2) do
	[target, text] -> say_for(m.account, target, text, false)
	_ -> nil
	end
	{:noreply, state}
	end

	def handle_info(_, state) do
	{:noreply, state}
	end

	defp say_for(account, target, text, with_nick?) do
	for {net, chan} <- Nola.Membership.of_account(account) do
	chan2 = String.replace(chan, "#", "")
	if (target == "#{net}/#{chan}" \|\| target == "#{net}/#{chan2}" \|\| target == chan \|\| target == chan2) do
	if with_nick? do
	IRC.send_message_as(account, net, chan, text)
	else
	- IRC.Connection.broadcast_message(net, chan, text)
	+ Nola.Irc.Connection.broadcast_message(net, chan, text)
	end
	end
	end
	end

	end
	diff --git a/lib/plugins/sms.ex b/lib/plugins/sms.ex
	index a3b7b7d..8dd15ad 100644
	--- a/lib/plugins/sms.ex
	+++ b/lib/plugins/sms.ex
	@@ -1,165 +1,165 @@
	defmodule Nola.Plugins.Sms do
	@moduledoc """
	## sms

	* !sms `<nick>` `<message>` envoie un SMS.
	"""
	def short_irc_doc, do: false
	def irc_doc, do: @moduledoc
	require Logger

	def incoming(from, "enable "<>key) do
	key = String.trim(key)
	account = Nola.Account.find_meta_account("sms-validation-code", String.downcase(key))
	if account do
	net = Nola.Account.get_meta(account, "sms-validation-target")
	Nola.Account.put_meta(account, "sms-number", from)
	Nola.Account.delete_meta(account, "sms-validation-code")
	Nola.Account.delete_meta(account, "sms-validation-number")
	Nola.Account.delete_meta(account, "sms-validation-target")
	- IRC.Connection.broadcast_message(net, account, "SMS Number #{from} added!")
	+ Nola.Irc.Connection.broadcast_message(net, account, "SMS Number #{from} added!")
	send_sms(from, "Yay! Number linked to account #{account.name}")
	end
	end

	def incoming(from, message) do
	account = Nola.Account.find_meta_account("sms-number", from)
	if account do
	reply_fun = fn(text) ->
	send_sms(from, text)
	end
	- trigger_text = if Enum.any?(IRC.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(message, trigger) end) do
	+ trigger_text = if Enum.any?(Nola.Irc.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(message, trigger) end) do
	message
	else
	"!"<>message
	end
	message = %Nola.Message{
	id: FlakeId.get(),
	transport: :sms,
	network: "sms",
	channel: nil,
	text: message,
	account: account,
	sender: %ExIRC.SenderInfo{nick: account.name},
	replyfun: reply_fun,
	- trigger: IRC.Connection.extract_trigger(trigger_text)
	+ trigger: Nola.Irc.Connection.extract_trigger(trigger_text)
	}
	Logger.debug("converted sms to message: #{inspect message}")
	- IRC.Connection.publish(message, ["messages:sms"])
	+ Nola.Irc.Connection.publish(message, ["messages:sms"])
	message
	end
	end

	def my_number() do
	Keyword.get(Application.get_env(:nola, :sms, []), :number, "+33000000000")
	end

	def start_link() do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	def path() do
	account = Keyword.get(Application.get_env(:nola, :sms), :account)
	"https://eu.api.ovh.com/1.0/sms/#{account}"
	end

	def path(rest) do
	Path.join(path(), rest)
	end

	def send_sms(number, text) do
	url = path("/virtualNumbers/#{my_number()}/jobs")
	body = %{
	"message" => text,
	"receivers" => [number],
	#"senderForResponse" => true,
	#"noStopClause" => true,
	"charset" => "UTF-8",
	"coding" => "8bit"
	} \|> Poison.encode!()
	headers = [{"content-type", "application/json"}] ++ sign("POST", url, body)
	options = []
	case HTTPoison.post(url, body, headers, options) do
	{:ok, %HTTPoison.Response{status_code: 200}} -> :ok
	{:ok, %HTTPoison.Response{status_code: code} = resp} ->
	Logger.error("SMS Error: #{inspect resp}")
	{:error, code}
	{:error, error} -> {:error, error}
	end
	end

	def init([]) do
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:sms", [plugin: __MODULE__])
	:ok = register_ovh_callback()
	{:ok, %{}}
	:ignore
	end

	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)},
	{_, number} when not is_nil(number) <- {:number, Nola.Account.get_meta(account, "sms-number")}
	do
	text = Enum.join(text, " ")
	sender = if m.channel do
	"#{m.channel} <#{m.sender.nick}> "
	else
	"<#{m.sender.nick}> "
	end
	case send_sms(number, sender<>text) do
	:ok -> m.replyfun.("sent!")
	{:error, error} -> m.replyfun.("not sent, error: #{inspect error}")
	end
	else
	{:tree, _} -> m.replyfun.("Tree: va en enfer")
	{:account, _} -> m.replyfun.("#{nick} not known")
	{:number, _} -> m.replyfun.("#{nick} have not enabled sms")
	end
	{:noreply, state}
	end

	def handle_info(msg, state) do
	{:noreply, state}
	end

	defp register_ovh_callback() do
	url = path()
	body = %{
	"callBack" =>NolaWeb.Router.Helpers.sms_url(NolaWeb.Endpoint, :ovh_callback),
	"smsResponse" => %{
	"cgiUrl" => NolaWeb.Router.Helpers.sms_url(NolaWeb.Endpoint, :ovh_callback),
	"responseType" => "cgi"
	}
	} \|> Poison.encode!()
	headers = [{"content-type", "application/json"}] ++ sign("PUT", url, body)
	options = []
	case HTTPoison.put(url, body, headers, options) do
	{:ok, %HTTPoison.Response{status_code: 200}} ->
	:ok
	error -> error
	end
	end

	defp sign(method, url, body) do
	ts = DateTime.utc_now() \|> DateTime.to_unix()
	as = env(:app_secret)
	ck = env(:consumer_key)
	sign = Enum.join([as, ck, String.upcase(method), url, body, ts], "+")
	sign_hex = :crypto.hash(:sha, sign) \|> Base.encode16(case: :lower)
	headers = [{"X-OVH-Application", env(:app_key)}, {"X-OVH-Timestamp", ts},
	{"X-OVH-Signature", "$1$"<>sign_hex}, {"X-Ovh-Consumer", ck}]
	end

	def parse_number(num) do
	{:error, :todo}
	end

	defp env() do
	Application.get_env(:nola, :sms)
	end

	defp env(key) do
	Keyword.get(env(), key)
	end
	end
	diff --git a/lib/plugins/tell.ex b/lib/plugins/tell.ex
	index bc1f24e..b4d05dc 100644
	--- a/lib/plugins/tell.ex
	+++ b/lib/plugins/tell.ex
	@@ -1,106 +1,106 @@
	defmodule Nola.Plugins.Tell do
	use GenServer

	@moduledoc """
	# Tell

	* !tell `<nick>` `<message>`: tell `message` to `nick` when they reconnect.
	"""

	def irc_doc, do: @moduledoc
	def start_link() do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	def dets do
	(Nola.data_path() <> "/tell.dets") \|> String.to_charlist()
	end

	def tell(m, target, message) do
	GenServer.cast(__MODULE__, {:tell, m, target, message})
	end

	def init([]) do
	regopts = [plugin: __MODULE__]
	{:ok, _} = Registry.register(Nola.PubSub, "account", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:tell", regopts)
	{:ok, dets} = :dets.open_file(dets(), [type: :bag])
	{:ok, %{dets: dets}}
	end

	def handle_cast({:tell, m, target, message}, state) do
	do_tell(state, m, target, message)
	{:noreply, state}
	end

	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

	def handle_info({:account, network, channel, nick, account_id}, state) do
	messages = :dets.lookup(state.dets, {network, channel, account_id})
	if messages != [] do
	strs = Enum.map(messages, fn({_, from, message, at}) ->
	account = Nola.Account.get(from)
	user = Nola.UserTrack.find_by_account(network, account)
	fromnick = if user, do: user.nick, else: account.name
	"#{nick}: <#{fromnick}> #{message}"
	end)
	- Enum.each(strs, fn(s) -> IRC.Connection.broadcast_message(network, channel, s) end)
	+ Enum.each(strs, fn(s) -> Nola.Irc.Connection.broadcast_message(network, channel, s) end)
	:dets.delete(state.dets, {network, channel, account_id})
	end
	{:noreply, state}
	end

	def handle_info({:account_change, old_id, new_id}, state) do
	#:ets.fun2ms(fn({ {_net, _chan, target_id}, from_id, _, _} = obj) when (target_id == old_id) or (from_id == old_id) -> obj end)
	spec = [{{{:"$1", :"$2", :"$3"}, :"$4", :_, :_}, [{:orelse, {:==, :"$3", {:const, old_id}}, {:==, :"$4", {:const, old_id}}}], [:"$_"]}]
	Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) ->
	case obj do
	{ {net, chan, ^old_id}, from_id, message, at } = obj ->
	:dets.delete(obj)
	:dets.insert(table, {{net, chan, new_id}, from_id, message, at})
	{key, ^old_id, message, at} = obj ->
	:dets.delete(table, obj)
	:dets.insert(table, {key, new_id, message, at})
	_ -> :ok
	end
	end)
	{:noreply, state}
	end


	def handle_info(info, state) do
	{:noreply, state}
	end

	def terminate(_, state) do
	:dets.close(state.dets)
	:ok
	end

	defp do_tell(state, m, nick_target, message) do
	target = Nola.Account.find_always_by_nick(m.network, m.channel, nick_target)
	message = Enum.join(message, " ")
	with \
	{:target, %Nola.Account{} = target} <- {:target, target},
	{:same, false} <- {:same, target.id == m.account.id},
	target_user = Nola.UserTrack.find_by_account(m.network, target),
	target_nick = if(target_user, do: target_user.nick, else: target.name),
	present? = if(target_user, do: Map.has_key?(target_user.last_active, m.channel)),
	{:absent, true, _} <- {:absent, !present?, target_nick},
	{:message, message} <- {:message, message}
	do
	obj = { {m.network, m.channel, target.id}, m.account.id, message, NaiveDateTime.utc_now()}
	:dets.insert(state.dets, obj)
	m.replyfun.("will tell to #{target_nick}")
	else
	{:same, _} -> m.replyfun.("are you so stupid that you need a bot to tell yourself things ?")
	{:target, _} -> m.replyfun.("#{nick_target} unknown")
	{:absent, _, nick} -> m.replyfun.("#{nick} is here, tell yourself!")
	{:message, _} -> m.replyfun.("can't tell without a message")
	end
	end

	end
	diff --git a/lib/telegram.ex b/lib/telegram.ex
	index 9a2812d..dcd8b1f 100644
	--- a/lib/telegram.ex
	+++ b/lib/telegram.ex
	@@ -1,233 +1,233 @@
	defmodule Nola.Telegram do
	require Logger
	@behaviour Telegram.ChatBot

	def my_path() do
	"https://t.me/beauttebot"
	end

	def send_message(id, text, md2 \\ false) do
	md = if md2, do: "MarkdownV2", else: "Markdown"
	token = Keyword.get(Application.get_env(:nola, :telegram, []), :key)
	Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(Nola.Telegram, id)
	Telegram.Api.request(token, "sendMessage", chat_id: id, text: text, parse_mode: "Markdown")
	end

	@impl Telegram.ChatBot
	def init(chat_id) when chat_id < 0 do
	{:ok, state} = Nola.TelegramRoom.init(chat_id)
	{:ok, %{room_state: state}}
	end
	def init(chat_id) do
	Logger.info("Telegram session starting: #{chat_id}")
	account = Nola.Account.find_meta_account("telegram-id", chat_id)
	account_id = if account, do: account.id
	{:ok, %{account: account_id}}
	end

	@impl Telegram.ChatBot
	def handle_update(update, token, %{room_state: room_state}) do
	{:ok, room_state} = Nola.TelegramRoom.handle_update(update, token, room_state)
	{:ok, %{room_state: room_state}}
	end

	def handle_update(%{"message" => m = %{"chat" => %{"type" => "private"}, "text" => text = "/start"<>_}}, _token, state) do
	text = "Welcome to beautte!\n\nQuery the bot on IRC and say \"enable-telegram\" to continue."
	send_message(m["chat"]["id"], text)
	{:ok, %{account: nil}}
	end

	def handle_update(%{"message" => m = %{"chat" => %{"type" => "private"}, "text" => text = "/enable"<>_}}, _token, state) do
	key = case String.split(text, " ") do
	["/enable", key \| _] -> key
	_ -> "nil"
	end

	#Handled message "1247435154:AAGnSSCnySn0RuVxy_SUcDEoOX_rbF6vdq0" %{"message" =>
	# %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
	# "date" => 1591027272, "entities" =>
	# [%{"length" => 7, "offset" => 0, "type" => "bot_command"}],
	# "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
	# "message_id" => 11, "text" => "/enable salope"}, "update_id" => 764148578}
	account = Nola.Account.find_meta_account("telegram-validation-code", String.downcase(key))
	text = if account do
	net = Nola.Account.get_meta(account, "telegram-validation-target")
	Nola.Account.put_meta(account, "telegram-id", m["chat"]["id"])
	Nola.Account.put_meta(account, "telegram-username", m["chat"]["username"])
	Nola.Account.put_meta(account, "telegram-username", m["chat"]["username"])
	Nola.Account.delete_meta(account, "telegram-validation-code")
	Nola.Account.delete_meta(account, "telegram-validation-target")
	- IRC.Connection.broadcast_message(net, account, "Telegram #{m["chat"]["username"]} account added!")
	+ Nola.Irc.Connection.broadcast_message(net, account, "Telegram #{m["chat"]["username"]} account added!")
	"Yay! Linked to account #{account.name}."
	else
	"Token invalid"
	end
	send_message(m["chat"]["id"], text)
	{:ok, %{account: account.id}}
	end

	#[debug] Unhandled update: %{"message" =>
	# %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
	# "date" => 1591096015,
	# "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
	# "message_id" => 29,
	# "photo" => [
	# %{"file_id" => "AgACAgQAAxkBAAMdXtYyz4RQqLcpOlR6xKK3w3NayHAAAnCzMRuL4bFSgl_cTXMl4m5G_T0kXQADAQADAgADbQADZVMBAAEaBA",
	# "file_size" => 9544, "file_unique_id" => "AQADRv09JF0AA2VTAQAB", "height" => 95, "width" => 320},
	# %{"file_id" => "AgACAgQAAxkBAAMdXtYyz4RQqLcpOlR6xKK3w3NayHAAAnCzMRuL4bFSgl_cTXMl4m5G_T0kXQADAQADAgADeAADZFMBAAEaBA",
	# "file_size" => 21420, "file_unique_id" => "AQADRv09JF0AA2RTAQAB", "height" => 148, "width" => 501}]},
	# "update_id" => 218161546}

	for type <- ~w(photo voice video document animation) do
	def handle_update(data = %{"message" => %{unquote(type) => _}}, token, state) do
	start_upload(unquote(type), data, token, state)
	end
	end

	#[debug] Unhandled update: %{"callback_query" =>
	# %{
	# "chat_instance" => "-7948978714441865930", "data" => "evolu.net/#dmz",
	# "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
	# "id" => "8913804780149600",
	# "message" => %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
	# "date" => 1591098553, "from" => %{"first_name" => "devbeautte", "id" => 1293058838, "is_bot" => true, "username" => "devbeauttebot"},
	# "message_id" => 62,
	# "reply_markup" => %{"inline_keyboard" => [[%{"callback_data" => "random/#", "text" => "random/#"},
	# %{"callback_data" => "evolu.net/#dmz", "text" => "evolu.net/#dmz"}]]},
	# "text" => "Where should I send the file?"}
	# }
	# , "update_id" => 218161568}

	#def handle_update(t, %{"callback_query" => cb = %{"data" => "resend", "id" => id, "message" => m = %{"message_id" => m_id, "chat" => %{"id" => chat_id}, "reply_to_message" => op}}}) do
	#end

	def handle_update(%{"callback_query" => cb = %{"data" => "start-upload:"<>target, "id" => id, "message" => m = %{"message_id" => m_id, "chat" => %{"id" => chat_id}, "reply_to_message" => op}}}, t, state) do
	account = Nola.Account.find_meta_account("telegram-id", chat_id)
	if account do
	target = case String.split(target, "/") do
	["everywhere"] -> Nola.Membership.of_account(account)
	[net, chan] -> [{net, chan}]
	end
	Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "Processing...", reply_markup: %{})

	{content, type} = cond do
	op["photo"] -> {op["photo"], ""}
	op["voice"] -> {op["voice"], " a voice message"}
	op["video"] -> {op["video"], ""}
	op["document"] -> {op["document"], ""}
	op["animation"] -> {op["animation"], ""}
	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(op["caption"], do: ": "<> op["caption"] <> "", else: "")
	resend = %{"inline_keyboard" => [ [%{"text" => "re-share", "callback_data" => "resend"}] ]}
	spawn(fn() ->
	with \
	{:ok, file} <- Telegram.Api.request(t, "getFile", file_id: file_id),
	path = "https://api.telegram.org/file/bot#{t}/#{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(Nola.GenMagic, {:bytes, smol_body}),
	bucket = Application.get_env(:nola, :s3, []) \|> Keyword.get(:bucket),
	ext = Path.extname(file["file_path"]),
	s3path = "#{account.id}/#{file_unique_id}#{ext}",
	Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "Uploading...", reply_markup: %{}, parse_mode: "MarkdownV2"),
	s3req = ExAws.S3.put_object(bucket, s3path, body, acl: :public_read, content_type: magic.mime_type),
	{:ok, _} <- ExAws.request(s3req)
	do
	path = NolaWeb.Router.Helpers.url(NolaWeb.Endpoint) <> "/files/#{s3path}"
	sent = for {net, chan} <- target do
	txt = "sent#{type}#{text} #{path}"
	IRC.send_message_as(account, net, chan, txt)
	"#{net}/#{chan}"
	end
	if caption = op["caption"], do: as_irc_message(chat_id, caption, account)
	text = "Sent on " <> Enum.join(sent, ", ") <> " !"
	Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "_Sent!_", reply_markup: %{}, parse_mode: "MarkdownV2")
	else
	error ->
	Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "Something failed.", reply_markup: %{}, parse_mode: "MarkdownV2")
	Logger.error("Failed upload from Telegram: #{inspect error}")
	end
	end)
	end
	{:ok, state}
	end

	def handle_update(%{"message" => m = %{"chat" => %{"id" => id, "type" => "private"}, "text" => text}}, _, state) do
	account = Nola.Account.find_meta_account("telegram-id", id)
	if account do
	as_irc_message(id, text, account)
	end
	{:ok, state}
	end

	def handle_update(m, _, state) do
	Logger.debug("Unhandled update: #{inspect m}")
	{:ok, state}
	end

	@impl Telegram.ChatBot
	def handle_info(info, %{room_state: room_state}) do
	{:ok, room_state} = Nola.TelegramRoom.handle_info(info, room_state)
	{:ok, %{room_state: room_state}}
	end

	def handle_info(_info, state) do
	{:ok, state}
	end

	defp as_irc_message(id, text, account) do
	reply_fun = fn(text) -> send_message(id, text) end
	trigger_text = cond do
	String.starts_with?(text, "/") ->
	"/"<>text = text
	"!"<>text
	- Enum.any?(IRC.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(text, trigger) end) ->
	+ Enum.any?(Nola.Irc.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(text, trigger) end) ->
	text
	true ->
	"!"<>text
	end
	message = %Nola.Message{
	id: FlakeId.get(),
	transport: :telegram,
	network: "telegram",
	channel: nil,
	text: text,
	account: account,
	sender: %ExIRC.SenderInfo{nick: account.name},
	replyfun: reply_fun,
	- trigger: IRC.Connection.extract_trigger(trigger_text),
	+ trigger: Nola.Irc.Connection.extract_trigger(trigger_text),
	at: nil
	}
	- IRC.Connection.publish(message, ["messages:private", "messages:telegram", "telegram/#{account.id}:messages"])
	+ Nola.Irc.Connection.publish(message, ["messages:private", "messages:telegram", "telegram/#{account.id}:messages"])
	message
	end

	defp start_upload(_type, %{"message" => m = %{"chat" => %{"id" => id, "type" => "private"}}}, token, state) do
	account = Nola.Account.find_meta_account("telegram-id", id)
	if account do
	text = if(m["text"], do: m["text"], else: nil)
	targets = Nola.Membership.of_account(account)
	\|> Enum.map(fn({net, chan}) -> "#{net}/#{chan}" end)
	\|> Enum.map(fn(i) -> %{"text" => i, "callback_data" => "start-upload:#{i}"} end)
	kb = if Enum.count(targets) > 1 do
	[%{"text" => "everywhere", "callback_data" => "start-upload:everywhere"}] ++ targets
	else
	targets
	end
	\|> Enum.chunk_every(2)
	keyboard = %{"inline_keyboard" => kb}
	Telegram.Api.request(token, "sendMessage", chat_id: id, text: "Where should I send this file?", reply_markup: keyboard, reply_to_message_id: m["message_id"], parse_mode: "MarkdownV2")
	end
	{:ok, state}
	end

	end
	diff --git a/lib/telegram/room.ex b/lib/telegram/room.ex
	index 8e95ca8..f3c3715 100644
	--- a/lib/telegram/room.ex
	+++ b/lib/telegram/room.ex
	@@ -1,188 +1,188 @@
	defmodule Nola.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(Nola.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(:nola, :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}
	+ {net, chan} = case Nola.Irc.Connection.get_network(net, chan) do
	+ %Nola.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
	%{"network" => net, "channel" => chan} = tg_room
	Logger.info("Starting ChatBot for room #{id} \"#{chat["title"]}\" #{inspect tg_room}")
	irc_plumbed = if net && chan do
	{:ok, _} = Registry.register(Nola.PubSub, "#{net}/#{chan}:messages", plugin: __MODULE__)
	{:ok, _} = Registry.register(Nola.PubSub, "#{net}/#{chan}:triggers", plugin: __MODULE__)
	{:ok, _} = Registry.register(Nola.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 = Nola.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
	\|> Nola.Account.new_account()
	\|> Nola.Account.update_account_name(name)
	\|> Nola.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)
	+ connection = Nola.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)
	+ connection = Nola.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 = %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}"
	Nola.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(Nola.GenMagic, {:bytes, smol_body}),
	bucket = Application.get_env(:nola, :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 = NolaWeb.Router.Helpers.url(NolaWeb.Endpoint) <> "/files/#{s3path}"
	txt = "#{type}: #{text}#{path}"
	- connection = IRC.Connection.get_network(state.net)
	+ connection = Nola.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/web/context_plug.ex b/lib/web/context_plug.ex
	index fcdf42f..0a16340 100644
	--- a/lib/web/context_plug.ex
	+++ b/lib/web/context_plug.ex
	@@ -1,92 +1,92 @@
	defmodule NolaWeb.ContextPlug do
	import Plug.Conn
	import Phoenix.Controller

	def init(opts \\ []) do
	opts \|\| []
	end

	def get_account(conn) do
	cond do
	get_session(conn, :account) -> get_session(conn, :account)
	get_session(conn, :oidc_id) -> if account = Nola.Account.find_meta_account("identity-id", get_session(conn, :oidc_id)), do: account.id
	true -> nil
	end
	end

	def call(conn, opts) do
	account = with \
	{:account, account_id} when is_binary(account_id) <- {:account, get_account(conn)},
	{:account, account} when not is_nil(account) <- {:account, Nola.Account.get(account_id)}
	do
	account
	else
	_ -> nil
	end

	network = Map.get(conn.params, "network")
	network = if network == "-", do: nil, else: network

	oidc_account = Nola.Account.find_meta_account("identity-id", get_session(conn, :oidc_id))

	- conns = IRC.Connection.get_network(network)
	+ conns = Nola.Irc.Connection.get_network(network)
	chan = if c = Map.get(conn.params, "chan") do
	NolaWeb.reformat_chan(c)
	end
	- chan_conn = IRC.Connection.get_network(network, chan)
	+ chan_conn = Nola.Irc.Connection.get_network(network, chan)

	memberships = if account do
	Nola.Membership.of_account(account)
	end

	auth_required = cond do
	Keyword.get(opts, :restrict) == :public -> false
	account == nil -> true
	network == nil -> false
	Keyword.get(opts, :restrict) == :logged_in -> false
	network && chan ->
	!Enum.member?(memberships, {network, chan})
	network ->
	!Enum.any?(memberships, fn({n, _}) -> n == network end)
	end

	bot = cond do
	network && chan && chan_conn -> chan_conn.nick
	network && conns -> conns.nick
	true -> nil
	end


	cond do
	account && auth_required ->
	conn
	\|> put_status(404)
	\|> text("Page not found")
	\|> halt()
	auth_required ->
	conn
	\|> put_status(403)
	\|> render(NolaWeb.AlcoologView, "auth.html", bot: bot, no_header: true, network: network)
	\|> halt()
	(network && !conns) ->
	conn
	\|> put_status(404)
	\|> text("Page not found")
	\|> halt()
	(chan && !chan_conn) ->
	conn
	\|> put_status(404)
	\|> text("Page not found")
	\|> halt()
	true ->
	conn = conn
	\|> assign(:network, network)
	\|> assign(:chan, chan)
	\|> assign(:bot, bot)
	\|> assign(:account, account)
	\|> assign(:oidc_account, oidc_account)
	\|> assign(:memberships, memberships)
	end
	end

	end
	diff --git a/lib/web/controllers/alcoolog_controller.ex b/lib/web/controllers/alcoolog_controller.ex
	index 6337da5..8263df1 100644
	--- a/lib/web/controllers/alcoolog_controller.ex
	+++ b/lib/web/controllers/alcoolog_controller.ex
	@@ -1,323 +1,323 @@
	defmodule NolaWeb.AlcoologController do
	use NolaWeb, :controller
	require Logger

	plug NolaWeb.ContextPlug when action not in [:token]
	plug NolaWeb.ContextPlug, [restrict: :public] when action in [:token]

	def token(conn, %{"token" => token}) do
	case Nola.Token.lookup(token) do
	{:ok, {:alcoolog, :index, network, channel}} -> index(conn, nil, network, channel)
	err ->
	Logger.debug("AlcoologControler: token #{inspect err} invalid")
	conn
	\|> put_status(404)
	\|> text("Page not found")
	end
	end

	def nick(conn = %{assigns: %{account: account}}, params = %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	days = String.to_integer(Map.get(params, "days", "180"))
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	if friend? do
	stats = Nola.Plugins.Alcoolog.get_full_statistics(profile_account.id)
	history = for {{nick, ts}, points, active, cl, deg, type, descr, meta} <- Nola.Plugins.Alcoolog.nick_history(profile_account) do
	%{
	at: ts \|> DateTime.from_unix!(:millisecond),
	points: points,
	active: active,
	cl: cl,
	deg: deg,
	type: type,
	description: descr,
	meta: meta
	}
	end
	history = Enum.sort(history, &(DateTime.compare(&1.at, &2.at) != :lt))
	\|> IO.inspect()
	conn
	\|> assign(:title, "alcoolog #{nick}")
	\|> render("user.html", network: network, profile: profile_account, days: days, nick: nick, history: history, stats: stats)
	else
	conn
	\|> put_status(404)
	\|> text("Page not found")
	end
	end

	def nick_stats_json(conn = %{assigns: %{account: account}}, params = %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	if friend? do
	stats = Nola.Plugins.Alcoolog.get_full_statistics(profile_account.id)

	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(stats))
	else
	conn
	\|> put_status(404)
	\|> json([])
	end
	end

	def nick_gls_json(conn = %{assigns: %{account: account}}, params = %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	count = String.to_integer(Map.get(params, "days", "180"))
	if friend? do
	data = Nola.Plugins.Alcoolog.user_over_time_gl(profile_account, count)
	delay = count((24 60)*60)
	now = DateTime.utc_now()
	start_date = DateTime.utc_now()
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	\|> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
	\|> DateTime.to_date()
	\|> Date.to_erl()
	filled = (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(DateTime.utc_now \|> DateTime.to_date() \|> Date.to_erl))
	\|> Enum.to_list
	\|> Enum.map(&(:calendar.gregorian_days_to_date(&1)))
	\|> Enum.map(&Date.from_erl!(&1))
	\|> Enum.map(fn(date) ->
	%{date: date, gls: Map.get(data, date, 0)}
	end)
	\|> Enum.sort(&(Date.compare(&1.date, &2.date) != :gt))

	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(filled))
	else
	conn
	\|> put_status(404)
	\|> json([])
	end
	end



	def nick_volumes_json(conn = %{assigns: %{account: account}}, params = %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	count = String.to_integer(Map.get(params, "days", "180"))
	if friend? do
	data = Nola.Plugins.Alcoolog.user_over_time(profile_account, count)
	delay = count((24 60)*60)
	now = DateTime.utc_now()
	start_date = DateTime.utc_now()
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	\|> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
	\|> DateTime.to_date()
	\|> Date.to_erl()
	filled = (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(DateTime.utc_now \|> DateTime.to_date() \|> Date.to_erl))
	\|> Enum.to_list
	\|> Enum.map(&(:calendar.gregorian_days_to_date(&1)))
	\|> Enum.map(&Date.from_erl!(&1))
	\|> Enum.map(fn(date) ->
	%{date: date, volumes: Map.get(data, date, 0)}
	end)
	\|> Enum.sort(&(Date.compare(&1.date, &2.date) != :gt))

	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(filled))
	else
	conn
	\|> put_status(404)
	\|> json([])
	end
	end

	def nick_log_json(conn = %{assigns: %{account: account}}, %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	if friend? do
	history = for {{nick, ts}, points, active, cl, deg, type, descr, meta} <- Nola.Plugins.Alcoolog.nick_history(profile_account) do
	%{
	at: ts \|> DateTime.from_unix!(:millisecond) \|> DateTime.to_iso8601(),
	points: points,
	active: active,
	cl: cl,
	deg: deg,
	type: type,
	description: descr,
	meta: meta
	}
	end
	last = List.last(history)
	{_, active} = Nola.Plugins.Alcoolog.user_stats(profile_account)
	last = %{last \| active: active, at: DateTime.utc_now() \|> DateTime.to_iso8601()}
	history = history ++ [last]

	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(history))
	else
	conn
	\|> put_status(404)
	\|> json([])
	end
	end

	def nick_history_json(conn = %{assigns: %{account: account}}, %{"network" => network, "nick" => nick}) do
	profile_account = Nola.Account.find_always_by_nick(network, nick, nick)
	friend? = Enum.member?(Nola.Membership.friends(account), profile_account.id)
	if friend? do
	history = for {_, date, value} <- Nola.Plugs.AlcoologAnnouncer.log(profile_account) do
	%{date: DateTime.to_iso8601(date), value: value}
	end
	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(history))
	else
	conn
	\|> put_status(404)
	\|> json([])
	end
	end

	def index(conn = %{assigns: %{account: account}}, %{"network" => network, "chan" => channel}) do
	index(conn, account, network, NolaWeb.reformat_chan(channel))
	end

	def index(conn = %{assigns: %{account: account}}, _) do
	index(conn, account, nil, nil)
	end

	#def index(conn, params) do
	# network = Map.get(params, "network")
	# chan = if c = Map.get(params, "chan") do
	# NolaWeb.reformat_chan(c)
	# end
	# irc_conn = if network do
	- # IRC.Connection.get_network(network, chan)
	+ # Nola.Irc.Connection.get_network(network, chan)
	# end
	# bot = if(irc_conn, do: irc_conn.nick)#
	#
	# conn
	# \|> put_status(403)
	# \|> render("auth.html", network: network, channel: chan, irc_conn: conn, bot: bot)
	#end

	def index(conn, account, network, channel) do
	aday = ((24 * 60)*60)
	now = DateTime.utc_now()
	before7 = now
	\|> DateTime.add(-(7*aday), :second)
	\|> DateTime.to_unix(:millisecond)
	before15 = now
	\|> DateTime.add(-(15*aday), :second)
	\|> DateTime.to_unix(:millisecond)
	before31 = now
	\|> DateTime.add(-(31*aday), :second)
	\|> DateTime.to_unix(:millisecond)
	#match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end)
	match = [
	{{{:_, :"$1"}, :_, :_, :_, :_, :_, :_, :_},
	[
	{:>, :"$1", {:const, before15}},
	], [:"$_"]}
	]

	# tuple ets: {{nick, date}, volumes, current, nom, commentaire}
	members = Nola.Membership.expanded_members_or_friends(account, network, channel)
	members_ids = Enum.map(members, fn({account, _, nick}) -> account.id end)
	member_names = Enum.reduce(members, %{}, fn({account, _, nick}, acc) -> Map.put(acc, account.id, nick) end)
	drinks = :ets.select(Nola.Plugins.Alcoolog.ETS, match)
	\|> Enum.filter(fn({{account, _}, _vol, _cur, _cl, _deg, _name, _cmt, _meta}) -> Enum.member?(members_ids, account) end)
	\|> Enum.map(fn({{account, _}, _, _, _, _, _, _, _} = object) -> {object, Map.get(member_names, account)} end)
	\|> Enum.sort_by(fn({{{_, ts}, _, _, _, _, _, _, _}, _}) -> ts end, &>/2)

	stats = Nola.Plugins.Alcoolog.get_channel_statistics(account, network, channel)

	top = Enum.reduce(drinks, %{}, fn({{{account_id, _}, vol, _, _, _, _, _, _}, _}, acc) ->
	nick = Map.get(member_names, account_id)
	all = Map.get(acc, nick, 0)
	Map.put(acc, nick, all + vol)
	end)
	\|> Enum.sort_by(fn({_nick, count}) -> count end, &>/2)
	# {date, single_peak}
	#
	conn
	\|> assign(:title, "alcoolog")
	\|> render("index.html", network: network, channel: channel, drinks: drinks, top: top, stats: stats)
	end

	def index_gls_json(conn = %{assigns: %{account: account}}, %{"network" => network, "chan" => channel}) do
	count = 30
	channel = NolaWeb.reformat_chan(channel)
	members = Nola.Membership.expanded_members_or_friends(account, network, channel)
	members_ids = Enum.map(members, fn({account, _, nick}) -> account.id end)
	member_names = Enum.reduce(members, %{}, fn({account, _, nick}, acc) -> Map.put(acc, account.id, nick) end)
	delay = count((24 60)*60)
	now = DateTime.utc_now()
	start_date = DateTime.utc_now()
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	\|> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
	\|> DateTime.to_date()
	\|> Date.to_erl()
	filled = (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(DateTime.utc_now \|> DateTime.to_date() \|> Date.to_erl))
	\|> Enum.to_list
	\|> Enum.map(&(:calendar.gregorian_days_to_date(&1)))
	\|> Enum.map(&Date.from_erl!(&1))
	\|> Enum.map(fn(date) ->
	{date, (for {a, _, _} <- members, into: Map.new, do: {Map.get(member_names, a.id, a.id), 0})}
	end)
	\|> Enum.into(Map.new)

	gls = Enum.reduce(members, filled, fn({account, _, _}, gls) ->
	Enum.reduce(Nola.Plugins.Alcoolog.user_over_time_gl(account, count), gls, fn({date, gl}, gls) ->
	u = Map.get(gls, date, %{})
	\|> Map.put(Map.get(member_names, account.id, account.id), gl)
	Map.put(gls, date, u)
	end)
	end)

	dates = (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(DateTime.utc_now \|> DateTime.to_date() \|> Date.to_erl))
	\|> Enum.to_list
	\|> Enum.map(&(:calendar.gregorian_days_to_date(&1)))
	\|> Enum.map(&Date.from_erl!(&1))

	filled2 = Enum.map(member_names, fn({_, name}) ->
	history = (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(DateTime.utc_now \|> DateTime.to_date() \|> Date.to_erl))
	\|> Enum.to_list
	\|> Enum.map(&(:calendar.gregorian_days_to_date(&1)))
	\|> Enum.map(&Date.from_erl!(&1))
	\|> Enum.map(fn(date) ->
	get_in(gls, [date, name]) #%{date: date, gl: get_in(gls, [date, name])}
	end)
	if Enum.all?(history, fn(x) -> x == 0 end) do
	nil
	else
	%{name: name, history: history}
	end
	end)
	\|> Enum.filter(fn(x) -> x end)

	conn
	\|> put_resp_content_type("application/json")
	\|> text(Jason.encode!(%{labels: dates, data: filled2}))
	end

	def minisync(conn, %{"user_id" => user_id, "key" => key, "value" => value}) do
	account = Nola.Account.get(user_id)
	if account do
	ds = Nola.Plugins.Alcoolog.data_state()
	meta = Nola.Plugins.Alcoolog.get_user_meta(ds, account.id)
	case Float.parse(value) do
	{val, _} ->
	new_meta = Map.put(meta, String.to_existing_atom(key), val)
	Nola.Plugins.Alcoolog.put_user_meta(ds, account.id, new_meta)
	_ ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> text("invalid value")
	end
	else
	conn
	\|> put_status(:not_found)
	\|> text("not found")
	end
	end

	end
	diff --git a/lib/web/live/chat_live.ex b/lib/web/live/chat_live.ex
	index 3f126f2..f8bab7d 100644
	--- a/lib/web/live/chat_live.ex
	+++ b/lib/web/live/chat_live.ex
	@@ -1,120 +1,120 @@
	defmodule NolaWeb.ChatLive do
	use Phoenix.LiveView
	use Phoenix.HTML
	require Logger

	def mount(%{"network" => network, "chan" => chan}, %{"account" => account_id}, socket) do
	chan = NolaWeb.reformat_chan(chan)
	- connection = IRC.Connection.get_network(network, chan)
	+ connection = Nola.Irc.Connection.get_network(network, chan)
	account = Nola.Account.get(account_id)
	membership = Nola.Membership.of_account(Nola.Account.get("DRgpD4fLf8PDJMLp8Dtb"))
	if account && connection && Enum.member?(membership, {connection.network, chan}) do
	{:ok, _} = Registry.register(Nola.PubSub, "#{connection.network}:events", plugin: __MODULE__)
	for t <- ["messages", "triggers", "outputs", "events"] do
	{:ok, _} = Registry.register(Nola.PubSub, "#{connection.network}/#{chan}:#{t}", plugin: __MODULE__)
	end

	- IRC.PuppetConnection.start(account, connection)
	+ Nola.Irc.PuppetConnection.start(account, connection)

	users = Nola.UserTrack.channel(connection.network, chan)
	\|> Enum.map(fn(tuple) -> Nola.UserTrack.User.from_tuple(tuple) end)
	\|> Enum.reduce(Map.new, fn(user = %{id: id}, acc) ->
	Map.put(acc, id, user)
	end)

	backlog = case Nola.IRC.Buffer.select_buffer(connection.network, chan) do
	{backlog, _} ->
	{backlog, _} = Enum.reduce(backlog, {backlog, nil}, &reduce_contextual_event/2)
	Enum.reverse(backlog)
	_ -> []
	end

	socket = socket
	\|> assign(:connection_id, connection.id)
	\|> assign(:network, connection.network)
	\|> assign(:chan, chan)
	\|> assign(:title, "live")
	\|> assign(:channel, chan)
	\|> assign(:account_id, account.id)
	\|> assign(:backlog, backlog)
	\|> assign(:users, users)
	\|> assign(:counter, 0)

	{:ok, socket}
	else
	{:ok, redirect(socket, to: "/")}
	end
	end

	def handle_event("send", %{"message" => %{"text" => text}}, socket) do
	account = Nola.Account.get(socket.assigns.account_id)
	IRC.send_message_as(account, socket.assigns.network, socket.assigns.channel, text, true)
	{:noreply, assign(socket, :counter, socket.assigns.counter + 1)}
	end

	def handle_info({:irc, :event, event = %{type: :join, user_id: id}}, socket) do
	if user = Nola.UserTrack.lookup(id) do
	socket = socket
	\|> assign(:users, Map.put(socket.assigns.users, id, user))
	\|> append_to_backlog(event)
	{:noreply, socket}
	else
	{:noreply, socket}
	end
	end

	def handle_info({:irc, :event, event = %{type: :nick, user_id: id, nick: nick}}, socket) do
	socket = socket
	\|> assign(:users, update_in(socket.assigns.users, [id, :nick], nick))
	\|> append_to_backlog(event)
	{:noreply, socket}
	end

	def handle_info({:irc, :event, event = %{type: :quit, user_id: id}}, socket) do
	socket = socket
	\|> assign(:users, Map.delete(socket.assigns.users, id))
	\|> append_to_backlog(event)
	{:noreply, socket}
	end

	def handle_info({:irc, :event, event = %{type: :part, user_id: id}}, socket) do
	socket = socket
	\|> assign(:users, Map.delete(socket.assigns.users, id))
	\|> append_to_backlog(event)
	{:noreply, socket}
	end

	def handle_info({:irc, :trigger, _, message}, socket) do
	handle_info({:irc, nil, message}, socket)
	end

	def handle_info({:irc, :text, message}, socket) do
	IO.inspect({:live_message, message})
	socket = socket
	\|> append_to_backlog(message)
	{:noreply, socket}
	end

	def handle_info(info, socket) do
	Logger.debug("Unhandled info: #{inspect info}")
	{:noreply, socket}
	end

	defp append_to_backlog(socket, line) do
	{add, _} = reduce_contextual_event(line, {[], List.last(socket.assigns.backlog)})
	assign(socket, :backlog, socket.assigns.backlog ++ add)
	end

	defp reduce_contextual_event(line, {acc, nil}) do
	{[line \| acc], line}
	end
	defp reduce_contextual_event(line, {acc, last}) do
	if NaiveDateTime.to_date(last.at) != NaiveDateTime.to_date(line.at) do
	{[%{type: :day_changed, date: NaiveDateTime.to_date(line.at), at: nil}, line \| acc], line}
	else
	{[line \| acc], line}
	end

	end

	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 4:44 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 33610
Default Alt Text: (164 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions