No OneTemporary
Actions

Size

79 KB

Subscribers

None

View Options

	diff --git a/lib/irc.ex b/lib/irc.ex
	index 3898068..0fa1b79 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 = 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)
	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
	+ 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

	Nola.Irc.Connection.setup()

	[
	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")
	Nola.Irc.Connection.start_all()
	end

	end
	diff --git a/lib/irc/admin_handler.ex b/lib/irc/admin_handler.ex
	index a462789..cb953db 100644
	--- a/lib/irc/admin_handler.ex
	+++ b/lib/irc/admin_handler.ex
	@@ -1,41 +1,41 @@
	defmodule Nola.Irc.AdminHandler do
	@moduledoc """
	# admin

	!op
	op; requiert admin
	"""

	def irc_doc, do: nil

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

	def init([client]) do
	ExIRC.Client.add_handler client, self
	- :ok = IRC.register("op")
	+ {:ok, _} = Registry.register(Nola.PubSub, "op", [])
	{:ok, client}
	end

	def handle_info({:irc, :trigger, "op", m = %Nola.Message{trigger: %Nola.Trigger{type: :bang}, sender: sender}}, client) do
	- if IRC.admin?(sender) do
	+ if Nola.Irc.admin?(sender) do
	m.replyfun.({:mode, "+o"})
	else
	m.replyfun.({:kick, "non"})
	end
	{:noreply, client}
	end

	def handle_info({:joined, chan, sender}, client) do
	- if IRC.admin?(sender) do
	+ if Nola.Irc.admin?(sender) do
	ExIRC.Client.mode(client, chan, "+o", sender.nick)
	end
	{:noreply, client}
	end

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

	end
	diff --git a/lib/matrix/room.ex b/lib/matrix/room.ex
	index 299d7cc..e2965a5 100644
	--- a/lib/matrix/room.ex
	+++ b/lib/matrix/room.ex
	@@ -1,196 +1,196 @@
	defmodule Nola.Matrix.Room do
	require Logger
	alias Nola.Matrix
	alias Polyjuice.Client
	import Matrix, only: [client: 0, client: 1, user_name: 1, myself?: 1]

	defmodule Supervisor do
	use DynamicSupervisor

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

	def start_child(room_id) do
	spec = %{id: room_id, start: {Nola.Matrix.Room, :start_link, [room_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 start(room_id) do
	__MODULE__.Supervisor.start_child(room_id)
	end

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

	def start_and_send_matrix_event(room_id, event) do
	pid = if pid = whereis(room_id) do
	pid
	else
	case __MODULE__.start(room_id) do
	{:ok, pid} -> pid
	{:error, {:already_started, pid}} -> pid
	:ignore -> nil
	end
	end
	if(pid, do: send(pid, {:matrix_event, event}))
	end

	def whereis(room_id) do
	{:global, name} = name(room_id)
	case :global.whereis_name(name) do
	:undefined -> nil
	pid -> pid
	end
	end

	def name(room_id) do
	{:global, {__MODULE__, room_id}}
	end

	def init([room_id]) do
	case Matrix.lookup_room(room_id) do
	{:ok, state} ->
	Logger.metadata(matrix_room: room_id)

	{:ok, _} = Registry.register(Nola.PubSub, "#{state.network}:events", plugin: __MODULE__)
	for t <- ["messages", "triggers", "outputs", "events"] do
	{:ok, _} = Registry.register(Nola.PubSub, "#{state.network}/#{state.channel}:#{t}", plugin: __MODULE__)
	end

	state = state
	\|> Map.put(:id, room_id)
	Logger.info("Started Matrix room #{room_id}")
	{:ok, state, {:continue, :update_state}}
	error ->
	Logger.info("Received event for nonexistent room #{inspect room_id}: #{inspect error}")
	:ignore
	end
	end

	def handle_continue(:update_state, state) do
	{:ok, s} = Client.Room.get_state(client(), state.id)
	members = Enum.reduce(s, [], fn(s, acc) ->
	if s["type"] == "m.room.member" do
	if s["content"]["membership"] == "join" do
	[s["user_id"] \| acc]
	else
	# XXX: The user left, remove from Nola.Memberships ?
	acc
	end
	else
	acc
	end
	end)
	\|> Enum.filter(& &1)

	for m <- members, do: Nola.UserTrack.joined(state.id, %{network: "matrix", nick: m, user: m, host: "matrix."}, [], true)

	accounts = Nola.UserTrack.channel(state.network, state.channel)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn(tuple) -> Nola.UserTrack.User.from_tuple(tuple).account end)
	\|> Enum.uniq()
	\|> Enum.each(fn(account_id) ->
	introduce_irc_account(account_id, state)
	end)

	{:noreply, state}
	end

	def handle_info({:irc, :text, message}, state), do: handle_irc(message, state)
	def handle_info({:irc, :out, message}, state), do: handle_irc(message, state)
	def handle_info({:irc, :trigger, _, message}, state), do: handle_irc(message, state)
	def handle_info({:irc, :event, event}, state), do: handle_irc(event, state)
	def handle_info({:matrix_event, event}, state) do
	if myself?(event.user_id) do
	{:noreply, state}
	else
	handle_matrix(event, state)
	end
	end

	def handle_irc(message = %Nola.Message{account: account}, state) do
	unless Map.get(message.meta, :puppet) && Map.get(message.meta, :from) == self() do
	opts = if Map.get(message.meta, :self) \|\| is_nil(account) do
	[]
	else
	mxid = Matrix.get_or_create_matrix_user(account.id)
	[user_id: mxid]
	end
	Client.Room.send_message(client(opts),state.id, message.text)
	end
	{:noreply, state}
	end

	def handle_irc(%{type: :join, account_id: account_id}, state) do
	introduce_irc_account(account_id, state)
	{:noreply, state}
	end

	def handle_irc(%{type: quit_or_part, account_id: account_id}, state) when quit_or_part in [:quit, :part] do
	mxid = Matrix.get_or_create_matrix_user(account_id)
	Client.Room.leave(client(user_id: mxid), state.id)
	{:noreply, state}
	end


	def handle_irc(event, state) do
	Logger.warn("Skipped irc event #{inspect event}")
	{:noreply, state}
	end

	def handle_matrix(event = %{type: "m.room.member", user_id: user_id, content: %{"membership" => "join"}}, state) do
	_account = get_account(event, state)
	Nola.UserTrack.joined(state.id, %{network: "matrix", nick: user_id, user: user_id, host: "matrix."}, [], true)
	{:noreply, state}
	end

	def handle_matrix(event = %{type: "m.room.member", user_id: user_id, content: %{"membership" => "leave"}}, state) do
	Nola.UserTrack.parted(state.id, %{network: "matrix", nick: user_id})
	{:noreply, state}
	end

	def handle_matrix(event = %{type: "m.room.message", user_id: user_id, content: %{"msgtype" => "m.text", "body" => text}}, state) do
	- IRC.send_message_as(get_account(event, state), state.network, state.channel, text, true)
	+ Nola.Irc.send_message_as(get_account(event, state), state.network, state.channel, text, true)
	{:noreply, state}
	end

	def handle_matrix(event, state) do
	Logger.warn("Skipped matrix event #{inspect event}")
	{:noreply, state}
	end

	def get_account(%{user_id: user_id}, %{id: id}) do
	Nola.Account.find_by_nick("matrix", user_id)
	end

	defp introduce_irc_account(account_id, state) do
	mxid = Matrix.get_or_create_matrix_user(account_id)
	account = Nola.Account.get(account_id)
	user = Nola.UserTrack.find_by_account(state.network, account)
	base_nick = if(user, do: user.nick, else: account.name)
	case Client.Profile.put_displayname(client(user_id: mxid), base_nick) do
	:ok -> :ok
	error ->
	Logger.warn("Failed to update profile for #{mxid}: #{inspect error}")
	end
	case Client.Room.join(client(user_id: mxid), state.id) do
	{:ok, _} -> :ok
	error ->
	Logger.warn("Failed to join room for #{mxid}: #{inspect error}")
	end
	:ok
	end

	end
	diff --git a/lib/nola/user_track.ex b/lib/nola/user_track.ex
	index f6a02ae..c1218b0 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

	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 = if Nola.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)

	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
	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))
	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))
	Nola.Irc.Connection.publish_event({network, channel}, %{type: :part, user_id: user.id, account_id: user.account, reason: nil})
	else
	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
	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/account.ex b/lib/plugins/account.ex
	index 20abab7..242b290 100644
	--- a/lib/plugins/account.ex
	+++ b/lib/plugins/account.ex
	@@ -1,188 +1,188 @@
	defmodule Nola.Plugins.Account do
	@moduledoc """
	# Account

	* account Get current account id and token
	* auth `<account-id>` `<token>` Authenticate and link the current nickname to an account
	* auth list authentications methods
	* whoami list currently authenticated users
	* web get a one-time login link to web
	* enable-telegram Link a Telegram account
	* enable-sms Link a SMS number
	* enable-untappd Link a Untappd account
	* set-name set account name
	* setusermeta puppet-nick `<nick>` Set puppet IRC nickname
	"""

	def irc_doc, do: @moduledoc
	def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)
	def init(_) do
	{:ok, _} = Registry.register(Nola.PubSub, "messages:private", [])
	{:ok, nil}
	end

	def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "help"}}, state) do
	text = [
	"account: show current account and auth token",
	"auth: show authentications methods",
	"whoami: list authenticated users",
	"set-name <name>: set account name",
	"web: login to web",
	"enable-sms \| disable-sms: enable/change or disable sms",
	"enable-telegram: link/change telegram",
	"enable-untappd: link untappd account",
	"getmeta: show meta datas",
	"setusermeta: set user meta",
	]
	m.replyfun.(text)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "auth"}}, state) do
	spec = [{{:"$1", :"$2"}, [{:==, :"$2", {:const, account.id}}], [:"$1"]}]
	predicates = :dets.select(Nola.Account.file("predicates"), spec)
	text = for {net, {key, value}} <- predicates, do: "#{net}: #{to_string(key)}: #{value}"
	m.replyfun.(text)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "whoami"}}, state) do
	users = for user <- Nola.UserTrack.find_by_account(m.account) do
	chans = Enum.map(user.privileges, fn({chan, _}) -> chan end)
	\|> Enum.join(" ")
	"#{user.network} - #{user.nick}!#{user.username}@#{user.host} - #{chans}"
	end
	m.replyfun.(users)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "account"}}, state) do
	account = Nola.Account.lookup(m.sender)
	text = ["Account Id: #{account.id}",
	"Authenticate to this account from another network: \"auth #{account.id} #{account.token}\" to the other bot!"]
	m.replyfun.(text)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{sender: sender, text: "auth"<>_}}, state) do
	#account = Nola.Account.lookup(m.sender)
	case String.split(m.text, " ") do
	["auth", id, token] ->
	join_account(m, id, token)
	_ ->
	m.replyfun.("Invalid parameters")
	end
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{account: account, text: "set-name "<>name}}, state) do
	Nola.Account.update_account_name(account, name)
	m.replyfun.("Name changed: #{name}")
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "disable-sms"}}, state) do
	if Nola.Account.get_meta(m.account, "sms-number") do
	Nola.Account.delete_meta(m.account, "sms-number")
	m.replfyun.("SMS disabled.")
	else
	m.replyfun.("SMS already disabled.")
	end
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "web"}}, state) do
	auth_url = Untappd.auth_url()
	login_url = Nola.AuthToken.new_url(m.account.id, nil)
	m.replyfun.("-> " <> login_url)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "enable-sms"}}, state) do
	code = String.downcase(EntropyString.small_id())
	Nola.Account.put_meta(m.account, "sms-validation-code", code)
	Nola.Account.put_meta(m.account, "sms-validation-target", m.network)
	- number = Nola.IRC.Sms.my_number()
	+ number = Nola.Plugin.Sms.my_number()
	text = "To enable or change your number for SMS messaging, please send:"
	<> " \"enable #{code}\" to #{number}"
	m.replyfun.(text)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "enable-telegram"}}, state) do
	code = String.downcase(EntropyString.small_id())
	Nola.Account.delete_meta(m.account, "telegram-id")
	Nola.Account.put_meta(m.account, "telegram-validation-code", code)
	Nola.Account.put_meta(m.account, "telegram-validation-target", m.network)
	text = "To enable or change your number for telegram messaging, please open #{Nola.Telegram.my_path()} and send:"
	<> " \"/enable #{code}\""
	m.replyfun.(text)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "enable-untappd"}}, state) do
	auth_url = Untappd.auth_url()
	login_url = Nola.AuthToken.new_url(m.account.id, {:external_redirect, auth_url})
	m.replyfun.(["To link your Untappd account, open this URL:", login_url])
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "getmeta"<>_}}, state) do
	result = case String.split(m.text, " ") do
	["getmeta"] ->
	for {k, v} <- Nola.Account.get_all_meta(m.account) do
	case k do
	"u:"<>key -> "(user) #{key}: #{v}"
	key -> "#{key}: #{v}"
	end
	end
	["getmeta", key] ->
	value = Nola.Account.get_meta(m.account, key)
	text = if value do
	"#{key}: #{value}"
	else
	"#{key} is not defined"
	end
	_ ->
	"usage: getmeta [key]"
	end
	m.replyfun.(result)
	{:noreply, state}
	end

	def handle_info({:irc, :text, m = %Nola.Message{text: "setusermeta"<>_}}, state) do
	result = case String.split(m.text, " ") do
	["setusermeta", key, value] ->
	Nola.Account.put_user_meta(m.account, key, value)
	"ok"
	_ ->
	"usage: setusermeta <key> <value>"
	end
	m.replyfun.(result)
	{:noreply, state}
	end

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

	defp join_account(m, id, token) do
	old_account = Nola.Account.lookup(m.sender)
	new_account = Nola.Account.get(id)
	if new_account && token == new_account.token do
	case Nola.Account.merge_account(old_account.id, new_account.id) do
	:ok ->
	if old_account.id == new_account.id do
	m.replyfun.("Already authenticated, but hello")
	else
	m.replyfun.("Accounts merged!")
	end
	_ -> m.replyfun.("Something failed :(")
	end
	else
	m.replyfun.("Invalid token")
	end
	end

	end

	diff --git a/lib/plugins/base.ex b/lib/plugins/base.ex
	index 3188495..0f2c7e5 100644
	--- a/lib/plugins/base.ex
	+++ b/lib/plugins/base.ex
	@@ -1,132 +1,132 @@
	defmodule Nola.Plugins.Base do

	def irc_doc, do: nil

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

	def init([]) do
	regopts = [plugin: __MODULE__]
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:version", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:help", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:liquidrender", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:plugin", regopts)
	{:ok, _} = Registry.register(Nola.PubSub, "trigger:plugins", regopts)
	{:ok, nil}
	end

	def handle_info({:irc, :trigger, "plugins", msg = %{trigger: %{type: :bang, args: []}}}, _) do
	enabled_string = Nola.Plugins.enabled()
	\|> Enum.map(fn(mod) ->
	mod
	\|> Macro.underscore()
	\|> String.split("/", parts: :infinity)
	\|> List.last()
	\|> Enum.sort()
	end)
	\|> Enum.join(", ")
	msg.replyfun.("Enabled plugins: #{enabled_string}")
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :query, args: [plugin]}} = m}, _) do
	module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
	with true <- Code.ensure_loaded?(module),
	pid when is_pid(pid) <- GenServer.whereis(module)
	do
	m.replyfun.("loaded, active: #{inspect(pid)}")
	else
	false -> m.replyfun.("not loaded")
	nil ->
	msg = case Nola.Plugins.get(module) do
	:disabled -> "disabled"
	{_, false, _} -> "disabled"
	_ -> "not active"
	end
	m.replyfun.(msg)
	end
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :plus, args: [plugin]}} = m}, _) do
	module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
	with true <- Code.ensure_loaded?(module),
	Nola.Plugins.switch(module, true),
	{:ok, pid} <- Nola.Plugins.start(module)
	do
	m.replyfun.("started: #{inspect(pid)}")
	else
	false -> m.replyfun.("not loaded")
	:ignore -> m.replyfun.("disabled or throttled")
	{:error, _} -> m.replyfun.("start error")
	end
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :tilde, args: [plugin]}} = m}, _) do
	module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
	with true <- Code.ensure_loaded?(module),
	pid when is_pid(pid) <- GenServer.whereis(module),
	:ok <- GenServer.stop(pid),
	{:ok, pid} <- Nola.Plugins.start(module)
	do
	m.replyfun.("restarted: #{inspect(pid)}")
	else
	false -> m.replyfun.("not loaded")
	nil -> m.replyfun.("not active")
	end
	{:noreply, nil}
	end


	def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :minus, args: [plugin]}} = m}, _) do
	module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
	with true <- Code.ensure_loaded?(module),
	pid when is_pid(pid) <- GenServer.whereis(module),
	:ok <- GenServer.stop(pid)
	do
	- IRC.Plugin.switch(module, false)
	+ Nola.Plugins.switch(module, false)
	m.replyfun.("stopped: #{inspect(pid)}")
	else
	false -> m.replyfun.("not loaded")
	nil -> m.replyfun.("not active")
	end
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "liquidrender", m = %{trigger: %{args: args}}}, _) do
	template = Enum.join(args, " ")
	m.replyfun.(Tmpl.render(template, m))
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "help", m = %{trigger: %{type: :bang}}}, _) do
	url = NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel))
	m.replyfun.("-> #{url}")
	{:noreply, nil}
	end

	def handle_info({:irc, :trigger, "version", message = %{trigger: %{type: :bang}}}, _) do
	{:ok, vsn} = :application.get_key(:nola, :vsn)
	ver = List.to_string(vsn)
	url = NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :index)
	elixir_ver = Application.started_applications() \|> List.keyfind(:elixir, 0) \|> elem(2) \|> to_string()
	otp_ver = :erlang.system_info(:system_version) \|> to_string() \|> String.trim()
	system = :erlang.system_info(:system_architecture) \|> to_string()
	brand = Nola.brand(:name)
	owner = "#{Nola.brand(:owner)} <#{Nola.brand(:owner_email)}>"
	message.replyfun.([
	<<"🤖 I am a robot running", 2, "#{brand}, version #{ver}", 2, " — source: #{Nola.source_url()}">>,
	"🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}",
	"👷‍♀️ Owner: h#{owner}",
	"🌍 Web interface: #{url}"
	])
	{:noreply, nil}
	end

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

	end
	diff --git a/lib/plugins/say.ex b/lib/plugins/say.ex
	index 3df3ac8..114ca64 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)
	+ Nola.Irc.send_message_as(account, net, chan, text)
	else
	Nola.Irc.Connection.broadcast_message(net, chan, text)
	end
	end
	end
	end

	end
	diff --git a/lib/plugins/txt.ex b/lib/plugins/txt.ex
	index 4f9a803..3b431e9 100644
	--- a/lib/plugins/txt.ex
	+++ b/lib/plugins/txt.ex
	@@ -1,556 +1,556 @@
	defmodule Nola.Plugins.Txt do
	alias Nola.UserTrack
	require Logger

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

	* .txt: liste des fichiers et statistiques.
	Les fichiers avec une `*` sont vérrouillés.
	[Voir sur le web]({{context_path}}/txt).

	* !txt: lis aléatoirement une ligne dans tous les fichiers.
	* !txt `<recherche>`: recherche une ligne dans tous les fichiers.

	* ~txt: essaie de générer une phrase (markov).
	* ~txt `<début>`: essaie de générer une phrase commencant par `<debut>`.

	* !`FICHIER`: lis aléatoirement une ligne du fichier `FICHIER`.
	* !`FICHIER` `<chiffre>`: lis la ligne `<chiffre>` du fichier `FICHIER`.
	* !`FICHIER` `<recherche>`: recherche une ligne contenant `<recherche>` dans `FICHIER`.

	* +txt `<file`>: crée le fichier `<file>`.
	* +`FICHIER` `<texte>`: ajoute une ligne `<texte>` dans le fichier `FICHIER`.
	* -`FICHIER` `<chiffre>`: supprime la ligne `<chiffre>` du fichier `FICHIER`.

	* -txtrw, +txtrw. op seulement. active/désactive le mode lecture seule.
	* +txtlock `<fichier>`, -txtlock `<fichier>`. op seulement. active/désactive le verrouillage d'un fichier.

	Insérez `\\\\` pour faire un saut de ligne.
	"""

	def short_irc_doc, do: "!txt https://sys.115ans.net/irc/txt "
	def irc_doc, do: @moduledoc

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

	defstruct triggers: %{}, rw: true, locks: nil, markov_handler: nil, markov: nil

	def random(file) do
	GenServer.call(__MODULE__, {:random, file})
	end

	def reply_random(message, file) do
	if line = random(file) do
	line
	\|> format_line(nil, message)
	\|> message.replyfun.()

	line
	end
	end

	def init([]) do
	dets_locks_filename = (Nola.data_path() <> "/" <> "txtlocks.dets") \|> String.to_charlist
	{:ok, locks} = :dets.open_file(dets_locks_filename, [])
	markov_handler = Keyword.get(Application.get_env(:nola, __MODULE__, []), :markov_handler, Nola.Plugins.Txt.Markov.Native)
	{:ok, markov} = markov_handler.start_link()
	{:ok, _} = Registry.register(Nola.PubSub, "triggers", [plugin: __MODULE__])
	{:ok, %__MODULE__{locks: locks, markov_handler: markov_handler, markov: markov, triggers: load()}}
	end

	def handle_info({:received, "!reload", _, chan}, state) do
	{:noreply, %__MODULE__{state \| triggers: load()}}
	end

	#
	# ADMIN: RW/RO
	#

	def handle_info({:irc, :trigger, "txtrw", msg = %{channel: channel, trigger: %{type: :plus}}}, state = %{rw: false}) do
	if channel && UserTrack.operator?(msg.network, channel, msg.sender.nick) do
	msg.replyfun.("txt: écriture réactivée")
	{:noreply, %__MODULE__{state \| rw: true}}
	else
	{:noreply, state}
	end
	end

	def handle_info({:irc, :trigger, "txtrw", msg = %{channel: channel, trigger: %{type: :minus}}}, state = %{rw: true}) do
	if channel && UserTrack.operator?(msg.network, channel, msg.sender.nick) do
	msg.replyfun.("txt: écriture désactivée")
	{:noreply, %__MODULE__{state \| rw: false}}
	else
	{:noreply, state}
	end
	end

	#
	# ADMIN: LOCKS
	#

	def handle_info({:irc, :trigger, "txtlock", msg = %{trigger: %{type: :plus, args: [trigger]}}}, state) do
	with \
	{trigger, _} <- clean_trigger(trigger),
	true <- UserTrack.operator?(msg.network, msg.channel, msg.sender.nick)
	do
	:dets.insert(state.locks, {trigger})
	msg.replyfun.("txt: #{trigger} verrouillé")
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "txtlock", msg = %{trigger: %{type: :minus, args: [trigger]}}}, state) do
	with \
	{trigger, _} <- clean_trigger(trigger),
	true <- UserTrack.operator?(msg.network, msg.channel, msg.sender.nick),
	true <- :dets.member(state.locks, trigger)
	do
	:dets.delete(state.locks, trigger)
	msg.replyfun.("txt: #{trigger} déverrouillé")
	end
	{:noreply, state}
	end

	#
	# FILE LIST
	#

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :dot}}}, state) do
	map = Enum.map(state.triggers, fn({key, data}) ->
	ignore? = String.contains?(key, ".")
	locked? = case :dets.lookup(state.locks, key) do
	[{trigger}] -> "*"
	_ -> ""
	end

	unless ignore?, do: "#{key}: #{to_string(Enum.count(data))}#{locked?}"
	end)
	\|> Enum.filter(& &1)
	total = Enum.reduce(state.triggers, 0, fn({_, data}, acc) ->
	acc + Enum.count(data)
	end)
	detail = Enum.join(map, ", ")
	total = ". total: #{Enum.count(state.triggers)} fichiers, #{to_string(total)} lignes. Détail: https://sys.115ans.net/irc/txt"

	ro = if !state.rw, do: " (lecture seule activée)", else: ""

	(detail<>total<>ro)
	\|> msg.replyfun.()
	{:noreply, state}
	end

	#
	# GLOBAL: RANDOM
	#

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :bang, args: []}}}, state) do
	result = Enum.reduce(state.triggers, [], fn({trigger, data}, acc) ->
	Enum.reduce(data, acc, fn({l, _}, acc) ->
	[{trigger, l} \| acc]
	end)
	end)
	\|> Enum.shuffle()

	if !Enum.empty?(result) do
	{source, line} = Enum.random(result)
	msg.replyfun.(format_line(line, "#{source}: ", msg))
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :bang, args: args}}}, state) do
	grep = Enum.join(args, " ")
	\|> String.downcase
	\|> :unicode.characters_to_nfd_binary()

	result = with_stateful_results(msg, {:bang,"txt",msg.network,msg.channel,grep}, fn() ->
	Enum.reduce(state.triggers, [], fn({trigger, data}, acc) ->
	if !String.contains?(trigger, ".") do
	Enum.reduce(data, acc, fn({l, _}, acc) ->
	[{trigger, l} \| acc]
	end)
	else
	acc
	end
	end)
	\|> Enum.filter(fn({_, line}) ->
	line
	\|> String.downcase()
	\|> :unicode.characters_to_nfd_binary()
	\|> String.contains?(grep)
	end)
	\|> Enum.shuffle()
	end)

	if result do
	{source, line} = result
	msg.replyfun.(["#{source}: " \| line])
	end
	{:noreply, state}
	end

	def with_stateful_results(msg, key, initfun) do
	me = self()
	scope = {msg.network, msg.channel \|\| msg.sender.nick}
	key = {__MODULE__, me, scope, key}
	with_stateful_results(key, initfun)
	end

	def with_stateful_results(key, initfun) do
	pid = case :global.whereis_name(key) do
	:undefined ->
	start_stateful_results(key, initfun.())
	pid -> pid
	end
	if pid, do: wait_stateful_results(key, initfun, pid)
	end

	def start_stateful_results(key, []) do
	nil
	end

	def start_stateful_results(key, list) do
	me = self()
	{pid, _} = spawn_monitor(fn() ->
	Process.monitor(me)
	stateful_results(me, list)
	end)
	:yes = :global.register_name(key, pid)
	pid
	end

	def wait_stateful_results(key, initfun, pid) do
	send(pid, :get)
	receive do
	{:stateful_results, line} ->
	line
	{:DOWN, _ref, :process, ^pid, reason} ->
	with_stateful_results(key, initfun)
	after
	5000 ->
	nil
	end
	end

	defp stateful_results(owner, []) do
	send(owner, :empty)
	:ok
	end

	@stateful_results_expire :timer.minutes(30)
	defp stateful_results(owner, [line \| rest] = acc) do
	receive do
	:get ->
	send(owner, {:stateful_results, line})
	stateful_results(owner, rest)
	{:DOWN, _ref, :process, ^owner, _} ->
	:ok
	after
	@stateful_results_expire -> :ok
	end
	end

	#
	# GLOBAL: MARKOV
	#

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :tilde, args: []}}}, state) do
	case state.markov_handler.sentence(state.markov) do
	{:ok, line} ->
	msg.replyfun.(line)
	error ->
	Logger.error "Txt Markov error: "<>inspect error
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :tilde, args: complete}}}, state) do
	complete = Enum.join(complete, " ")
	case state.markov_handler.complete_sentence(complete, state.markov) do
	{:ok, line} ->
	msg.replyfun.(line)
	error ->
	Logger.error "Txt Markov error: "<>inspect error
	end
	{:noreply, state}
	end

	#
	# TXT CREATE
	#

	def handle_info({:irc, :trigger, "txt", msg = %{trigger: %{type: :plus, args: [trigger]}}}, state) do
	with \
	{trigger, _} <- clean_trigger(trigger),
	true <- can_write?(state, msg, trigger),
	:ok <- create_file(trigger)
	do
	msg.replyfun.("#{trigger}.txt créé. Ajouter: `+#{trigger} …` ; Lire: `!#{trigger}`")
	{:noreply, %__MODULE__{state \| triggers: load()}}
	else
	_ -> {:noreply, state}
	end
	end

	#
	# TXT: RANDOM
	#

	def handle_info({:irc, :trigger, trigger, m = %{trigger: %{type: :query, args: opts}}}, state) do
	{trigger, _} = clean_trigger(trigger)
	if Map.get(state.triggers, trigger) do
	url = if m.channel do
	NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :txt, m.network, NolaWeb.format_chan(m.channel), trigger)
	else
	NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :txt, trigger)
	end
	m.replyfun.("-> #{url}")
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, trigger, msg = %{trigger: %{type: :bang, args: opts}}}, state) do
	{trigger, _} = clean_trigger(trigger)
	line = get_random(msg, state.triggers, trigger, String.trim(Enum.join(opts, " ")))
	if line do
	msg.replyfun.(format_line(line, nil, msg))
	end
	{:noreply, state}
	end

	#
	# TXT: ADD
	#

	def handle_info({:irc, :trigger, trigger, msg = %{trigger: %{type: :plus, args: content}}}, state) do
	with \
	true <- can_write?(state, msg, trigger),
	{:ok, idx} <- add(state.triggers, msg.text)
	do
	msg.replyfun.("#{msg.sender.nick}: ajouté à #{trigger}. (#{idx})")
	{:noreply, %__MODULE__{state \| triggers: load()}}
	else
	{:error, {:jaro, string, idx}} ->
	msg.replyfun.("#{msg.sender.nick}: doublon #{trigger}##{idx}: #{string}")
	error ->
	Logger.debug("txt add failed: #{inspect error}")
	{:noreply, state}
	end
	end

	#
	# TXT: DELETE
	#

	def handle_info({:irc, :trigger, trigger, msg = %{trigger: %{type: :minus, args: [id]}}}, state) do
	with \
	true <- can_write?(state, msg, trigger),
	data <- Map.get(state.triggers, trigger),
	{id, ""} <- Integer.parse(id),
	{text, _id} <- Enum.find(data, fn({_, idx}) -> id-1 == idx end)
	do
	data = data \|> Enum.into(Map.new)
	data = Map.delete(data, text)
	msg.replyfun.("#{msg.sender.nick}: #{trigger}.txt##{id} supprimée: #{text}")
	dump(trigger, data)
	{:noreply, %__MODULE__{state \| triggers: load()}}
	else
	_ ->
	{:noreply, state}
	end
	end

	def handle_info(:reload_markov, state=%__MODULE__{triggers: triggers, markov: markov}) do
	state.markov_handler.reload(state.triggers, state.markov)
	{:noreply, state}
	end

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

	def handle_call({:random, file}, _from, state) do
	random = get_random(nil, state.triggers, file, [])
	{:reply, random, state}
	end

	def terminate(_reason, state) do
	if state.locks do
	:dets.sync(state.locks)
	:dets.close(state.locks)
	end
	:ok
	end

	# Load/Reloads text files from disk
	defp load() do
	triggers = Path.wildcard(directory() <> "/*.txt")
	\|> Enum.reduce(%{}, fn(path, m) ->
	file = Path.basename(path)
	key = String.replace(file, ".txt", "")
	data = directory() <> file
	\|> File.read!
	\|> String.split("\n")
	\|> Enum.reject(fn(line) ->
	cond do
	line == "" -> true
	!line -> true
	true -> false
	end
	end)
	\|> Enum.with_index
	Map.put(m, key, data)
	end)
	\|> Enum.sort
	\|> Enum.into(Map.new)

	send(self(), :reload_markov)
	triggers
	end

	defp dump(trigger, data) do
	data = data
	\|> Enum.sort_by(fn({_, idx}) -> idx end)
	\|> Enum.map(fn({text, _}) -> text end)
	\|> Enum.join("\n")
	File.write!(directory() <> "/" <> trigger <> ".txt", data<>"\n", [])
	end

	defp get_random(msg, triggers, trigger, []) do
	if data = Map.get(triggers, trigger) do
	{data, _idx} = Enum.random(data)
	data
	else
	nil
	end
	end

	defp get_random(msg, triggers, trigger, opt) do
	arg = case Integer.parse(opt) do
	{pos, ""} -> {:index, pos}
	{_pos, _some_string} -> {:grep, opt}
	_error -> {:grep, opt}
	end
	get_with_param(msg, triggers, trigger, arg)
	end

	defp get_with_param(msg, triggers, trigger, {:index, pos}) do
	data = Map.get(triggers, trigger, %{})
	case Enum.find(data, fn({_, index}) -> index+1 == pos end) do
	{text, _} -> text
	_ -> nil
	end
	end

	defp get_with_param(msg, triggers, trigger, {:grep, query}) do
	out = with_stateful_results(msg, {:grep, trigger, query}, fn() ->
	data = Map.get(triggers, trigger, %{})
	regex = Regex.compile!("#{query}", "i")
	Enum.filter(data, fn({txt, _}) -> Regex.match?(regex, txt) end)
	\|> Enum.map(fn({txt, _}) -> txt end)
	\|> Enum.shuffle()
	end)
	if out, do: out
	end

	defp create_file(name) do
	File.touch!(directory() <> "/" <> name <> ".txt")
	:ok
	end

	defp add(triggers, trigger_and_content) do
	case String.split(trigger_and_content, " ", parts: 2) do
	[trigger, content] ->
	{trigger, _} = clean_trigger(trigger)


	if Map.has_key?(triggers, trigger) do
	jaro = Enum.find(triggers[trigger], fn({string, idx}) -> String.jaro_distance(content, string) > 0.9 end)

	if jaro do
	{string, idx} = jaro
	{:error, {:jaro, string, idx}}
	else
	File.write!(directory() <> "/" <> trigger <> ".txt", content<>"\n", [:append])
	idx = Enum.count(triggers[trigger])+1
	{:ok, idx}
	end
	else
	{:error, :notxt}
	end
	_ -> {:error, :badarg}
	end
	end

	# fixme: this is definitely the ugliest thing i've ever done
	defp clean_trigger(trigger) do
	[trigger \| opts] = trigger
	\|> String.strip
	\|> String.split(" ", parts: 2)

	trigger = trigger
	\|> String.downcase
	\|> :unicode.characters_to_nfd_binary()
	\|> String.replace(~r/[^a-z0-9._]/, "")
	\|> String.trim(".")
	\|> String.trim("_")

	{trigger, opts}
	end

	def format_line(line, prefix, msg) do
	prefix = unless(prefix, do: "", else: prefix)
	prefix <> line
	\|> String.split("\\\\")
	\|> Enum.map(fn(line) ->
	String.split(line, "\\\\\\\\")
	end)
	\|> List.flatten()
	\|> Enum.map(fn(line) ->
	String.trim(line)
	\|> Tmpl.render(msg)
	end)
	end

	def directory() do
	Application.get_env(:nola, :data_path) <> "/irc.txt/"
	end

	defp can_write?(%{rw: rw?, locks: locks}, msg = %{channel: nil, sender: sender}, trigger) do
	- admin? = IRC.admin?(sender)
	+ admin? = Nola.Irc.admin?(sender)
	locked? = case :dets.lookup(locks, trigger) do
	[{trigger}] -> true
	_ -> false
	end
	unlocked? = if rw? == false, do: false, else: !locked?

	can? = unlocked? \|\| admin?

	if !can? do
	reason = if !rw?, do: "lecture seule", else: "fichier vérrouillé"
	msg.replyfun.("#{sender.nick}: permission refusée (#{reason})")
	end
	can?
	end

	defp can_write?(state = %__MODULE__{rw: rw?, locks: locks}, msg = %{channel: channel, sender: sender}, trigger) do
	- admin? = IRC.admin?(sender)
	+ admin? = Nola.Irc.admin?(sender)
	operator? = Nola.UserTrack.operator?(msg.network, channel, sender.nick)
	locked? = case :dets.lookup(locks, trigger) do
	[{trigger}] -> true
	_ -> false
	end
	unlocked? = if rw? == false, do: false, else: !locked?
	can? = admin? \|\| operator? \|\| unlocked?

	if !can? do
	reason = if !rw?, do: "lecture seule", else: "fichier vérrouillé"
	msg.replyfun.("#{sender.nick}: permission refusée (#{reason})")
	end
	can?
	end

	end
	diff --git a/lib/telegram.ex b/lib/telegram.ex
	index dcd8b1f..f2c9eca 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")
	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)
	+ Nola.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?(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: Nola.Irc.Connection.extract_trigger(trigger_text),
	at: nil
	}
	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 f3c3715..ede939e 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 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 = Nola.Irc.Connection.get_network(state.net)
	- IRC.send_message_as(account, state.net, state.chan, text, true)
	+ Nola.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 = Nola.Irc.Connection.get_network(state.net)
	- IRC.send_message_as(account, state.net, state.chan, "@ #{lat}, #{lon}", true)
	+ Nola.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 = Nola.Irc.Connection.get_network(state.net)
	- IRC.send_message_as(account, state.net, state.chan, txt, true)
	+ Nola.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/controllers/irc_controller.ex b/lib/web/controllers/irc_controller.ex
	index d2ba04a..e87382b 100644
	--- a/lib/web/controllers/irc_controller.ex
	+++ b/lib/web/controllers/irc_controller.ex
	@@ -1,101 +1,101 @@
	defmodule NolaWeb.IrcController do
	use NolaWeb, :controller

	plug NolaWeb.ContextPlug

	def index(conn, params) do
	network = Map.get(params, "network")
	channel = if c = Map.get(params, "chan"), do: NolaWeb.reformat_chan(c)
	commands = for mod <- Enum.uniq([Nola.Plugins.Account] ++ Nola.Plugins.enabled()) do
	if is_atom(mod) do
	identifier = Module.split(mod) \|> List.last \|> Macro.underscore
	{identifier, mod.irc_doc()}
	end
	end
	\|> Enum.filter(& &1)
	\|> Enum.filter(fn({_, doc}) -> doc end)
	members = cond do
	network && channel -> Enum.map(Nola.UserTrack.channel(network, channel), fn(tuple) -> Nola.UserTrack.User.from_tuple(tuple) end)
	true ->
	Nola.Membership.of_account(conn.assigns.account)
	end
	render conn, "index.html", network: network, commands: commands, channel: channel, members: members
	end

	def txt(conn, %{"name" => name}) do
	if String.contains?(name, ".txt") do
	name = String.replace(name, ".txt", "")
	data = data()
	if Map.has_key?(data, name) do
	lines = Enum.join(data[name], "\n")
	text(conn, lines)
	else
	conn
	\|> put_status(404)
	\|> text("Not found")
	end
	else
	do_txt(conn, name)
	end
	end
	def txt(conn, _), do: do_txt(conn, nil)


	defp do_txt(conn, nil) do
	- doc = Nola.IRC.Txt.irc_doc()
	+ doc = Nola.Plugins.Txt.irc_doc()
	data = data()
	main = Enum.filter(data, fn({trigger, _}) -> !String.contains?(trigger, ".") end) \|> Enum.into(Map.new)
	system = Enum.filter(data, fn({trigger, _}) -> String.contains?(trigger, ".") end) \|> Enum.into(Map.new)
	lines = Enum.reduce(main, 0, fn({_, lines}, acc) -> acc + Enum.count(lines) end)
	conn
	\|> assign(:title, "txt")
	\|> render("txts.html", data: main, doc: doc, files: Enum.count(main), lines: lines, system: system)
	end

	defp do_txt(conn, txt) do
	data = data()
	base_url = cond do
	conn.assigns[:chan] -> "/#{conn.assigns.network}/#{NolaWeb.format_chan(conn.assigns.chan)}"
	true -> "/-"
	end
	if lines = Map.get(data, txt) do
	lines = Enum.map(lines, fn(line) ->
	line
	\|> String.split("\\\\")
	\|> Enum.intersperse(Phoenix.HTML.Tag.tag(:br))
	end)
	conn
	\|> assign(:breadcrumbs, [{"txt", "#{base_url}/txt"}])
	\|> assign(:title, "#{txt}.txt")
	\|> render("txt.html", name: txt, data: lines, doc: nil)
	else
	conn
	\|> put_status(404)
	\|> text("Not found")
	end
	end

	defp data() do
	dir = Application.get_env(:nola, :data_path) <> "/irc.txt/"
	Path.wildcard(dir <> "/*.txt")
	\|> Enum.reduce(%{}, fn(path, m) ->
	path = String.split(path, "/")
	file = List.last(path)
	key = String.replace(file, ".txt", "")
	data = dir <> file
	\|> File.read!
	\|> String.split("\n")
	\|> Enum.reject(fn(line) ->
	cond do
	line == "" -> true
	!line -> true
	true -> false
	end
	end)
	Map.put(m, key, data)
	end)
	\|> Enum.sort
	\|> Enum.into(Map.new)
	end

	end
	diff --git a/lib/web/controllers/page_controller.ex b/lib/web/controllers/page_controller.ex
	index bf79413..cb46b8f 100644
	--- a/lib/web/controllers/page_controller.ex
	+++ b/lib/web/controllers/page_controller.ex
	@@ -1,53 +1,53 @@
	defmodule NolaWeb.PageController do
	use NolaWeb, :controller

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

	def token(conn, %{"token" => token}) do
	with \
	{:ok, account, perks} <- Nola.AuthToken.lookup(token)
	do
	IO.puts("Authenticated account #{inspect account}")
	conn = put_session(conn, :account, account)
	case perks do
	nil -> redirect(conn, to: "/")
	{:redirect, path} -> redirect(conn, to: path)
	{:external_redirect, url} -> redirect(conn, external: url)
	end
	else
	z ->
	IO.inspect(z)
	text(conn, "Error: invalid or expired token")
	end
	end

	def index(conn = %{assigns: %{account: account}}, _) do
	memberships = Nola.Membership.of_account(account)
	users = Nola.UserTrack.find_by_account(account)
	metas = Nola.Account.get_all_meta(account)
	predicates = Nola.Account.get_predicates(account)
	conn
	\|> assign(:title, account.name)
	\|> render("user.html", users: users, memberships: memberships, metas: metas, predicates: predicates)
	end

	def irc(conn, _) do
	- bot_helps = for mod <- Nola.IRC.env(:handlers) do
	+ bot_helps = for mod <- Nola.Irc.env(:handlers) do
	mod.irc_doc()
	end
	render conn, "irc.html", bot_helps: bot_helps
	end

	def authenticate(conn, _) do
	with \
	{:account, account_id} when is_binary(account_id) <- {:account, get_session(conn, :account)},
	{:account, account} when not is_nil(account) <- {:account, Nola.Account.get(account_id)}
	do
	assign(conn, :account, account)
	else
	_ -> conn
	end
	end

	end
	diff --git a/lib/web/live/chat_live.ex b/lib/web/live/chat_live.ex
	index f8bab7d..8a9f6f2 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 = 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

	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 = case Nola.Plugins.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)
	+ Nola.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:20 PM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 33597
Default Alt Text: (79 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions