No OneTemporary
Actions

Size

40 KB

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index e2d7db9..bf52838 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,54 +1,56 @@
	import Config

	config :logger, level: :debug
	config :logger, :console,
	format: "$date $time [$level] $metadata$message\n",
	metadata: :all

	config :phoenix, :json_library, Jason

	# General application configuration
	config :nola,
	namespace: Nola

	config :nola, :data_path, "priv"

	config :nola, :brand,
	name: "Nola",
	- source_url: "https://phab.random.sh/source/Nola/"
	+ source_url: "https://phab.random.sh/source/Nola/",
	+ owner: "Ashamed Owner",
	+ owner_email: "do@not.mail.him"

	config :ex_aws,
	region: "us-east-1",
	host: "s3.wasabisys.com",
	s3: [
	host: "s3.wasabisys.com",
	region: "us-east-1",
	scheme: "https://"
	]

	# Configures the endpoint
	config :nola, NolaWeb.Endpoint,
	url: [host: "localhost"],
	secret_key_base: "cAFb7x2p/D7PdV8/C6Os18uygoD0FVQh3efNEFc5+5L529q3dofZtZye/BG12MRZ",
	render_errors: [view: NolaWeb.ErrorView, accepts: ~w(html json)],
	server: true,
	live_view: [signing_salt: "CHANGE_ME_FFS"],
	pubsub: [name: NolaWeb.PubSub,
	adapter: Phoenix.PubSub.PG2]

	config :mime, :types, %{"text/event-stream" => ["sse"]}

	config :nola, :lastfm,
	api_key: "x",
	api_secret: "x"

	config :nola, :youtube,
	api_key: "x",
	invidious: "yewtu.be"

	config :mnesia,
	dir: '.mnesia/#{Mix.env}/#{node()}'

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env}.exs"
	diff --git a/lib/plugins/base.ex b/lib/plugins/base.ex
	index 1baf066..97aaa05 100644
	--- a/lib/plugins/base.ex
	+++ b/lib/plugins/base.ex
	@@ -1,136 +1,144 @@
	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(string_or_module) ->
	case string_or_module do
	string when is_binary(string) -> string
	module when is_atom(module) ->
	module
	\|> Macro.underscore()
	\|> String.split("/", parts: :infinity)
	\|> List.last()
	end
	end)
	\|> Enum.sort()
	\|> 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
	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}"
	- ])
	+
	+ if message.channel do
	+ message.replyfun.([
	+ <<"🤖 ", 2, "#{brand}", 2, " v", 2, "#{ver}", 2, "! My owner is #{Nola.brand(:owner)} and help is at #{url}">>,
	+ ])
	+ else
	+ message.replyfun.([
	+ <<"🤖 I am a robot running ", 2, "#{brand}", 2, " version ", 2, "#{ver}", 2, " — source: #{Nola.source_url()}">>,
	+ "Source code: #{Nola.source_url()}",
	+ "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}",
	+ "🙋🏻 Owner: #{owner}",
	+ "🌍 Web interface: #{url}"
	+ ])
	+ end
	{:noreply, nil}
	end

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

	end
	diff --git a/lib/plugins/last_fm.ex b/lib/plugins/last_fm.ex
	index 8e872ea..b7d0a92 100644
	--- a/lib/plugins/last_fm.ex
	+++ b/lib/plugins/last_fm.ex
	@@ -1,187 +1,187 @@
	defmodule Nola.Plugins.LastFm do
	require Logger

	@moduledoc """
	# last.fm

	* !lastfm\|np `[nick\|username]`
	* .lastfm\|np
	* +lastfm, -lastfm `<username last.fm>; ?lastfm` Configurer un nom d'utilisateur last.fm
	"""

	@single_trigger ~w(lastfm np)
	@pubsub_topics ~w(trigger:lastfm trigger:np)

	defstruct dets: nil

	def irc_doc, do: @moduledoc

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

	def init([]) do
	- regopts = [type: __MODULE__]
	- for t <- @pubsub_topics, do: {:ok, _} = Registry.register(Nola.PubSub, t, type: __MODULE__)
	+ regopts = [plugin: __MODULE__]
	+ for t <- @pubsub_topics, do: {:ok, _} = Registry.register(Nola.PubSub, t, regopts)
	dets_filename = (Nola.data_path() <> "/" <> "lastfm.dets") \|> String.to_charlist
	{:ok, dets} = :dets.open_file(dets_filename, [])
	{:ok, %__MODULE__{dets: dets}}
	end

	def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :plus, args: [username]}}}, state) do
	username = String.strip(username)
	:ok = :dets.insert(state.dets, {message.account.id, username})
	message.replyfun.("#{message.sender.nick}: nom d'utilisateur last.fm configuré: \"#{username}\".")
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :minus, args: []}}}, state) do
	text = case :dets.lookup(state.dets, message.account.id) do
	[{_nick, _username}] ->
	:dets.delete(state.dets, message.account.id)
	message.replyfun.("#{message.sender.nick}: nom d'utilisateur last.fm enlevé.")
	_ -> nil
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :query, args: []}}}, state) do
	text = case :dets.lookup(state.dets, message.account.id) do
	[{_nick, username}] ->
	message.replyfun.("#{message.sender.nick}: #{username}.")
	_ -> nil
	end
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: []}}}, state) do
	irc_now_playing(message.account.id, message, state)
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: [nick_or_user]}}}, state) do
	irc_now_playing(nick_or_user, message, state)
	{:noreply, state}
	end

	def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :dot}}}, state) do
	members = Nola.Membership.members(message.network, message.channel)
	foldfun = fn({nick, user}, acc) -> [{nick,user}\|acc] end
	usernames = :dets.foldl(foldfun, [], state.dets)
	\|> Enum.uniq()
	\|> Enum.filter(fn({acct,_}) -> Enum.member?(members, acct) end)
	\|> Enum.map(fn({_, u}) -> u end)
	for u <- usernames, do: irc_now_playing(u, message, state)
	{:noreply, state}
	end

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

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

	defp irc_now_playing(nick_or_user, message, state) do
	nick_or_user = String.strip(nick_or_user)

	id_or_user = if account = Nola.Account.get(nick_or_user) \|\| Nola.Account.find_always_by_nick(message.network, message.channel, nick_or_user) do
	account.id
	else
	nick_or_user
	end

	username = case :dets.lookup(state.dets, id_or_user) do
	[{_, username}] -> username
	_ -> id_or_user
	end

	case now_playing(username) do
	{:error, text} when is_binary(text) ->
	message.replyfun.(text)
	{:ok, map} when is_map(map) ->
	track = fetch_track(username, map)
	text = format_now_playing(map, track)
	user = if account = Nola.Account.get(id_or_user) do
	user = Nola.UserTrack.find_by_account(message.network, account)
	if(user, do: user.nick, else: account.name)
	else
	username
	end
	if user && text do
	message.replyfun.("#{user} #{text}")
	else
	message.replyfun.("#{username}: pas de résultat")
	end
	other ->
	message.replyfun.("erreur :(")
	end
	end

	defp now_playing(user) do
	api = Application.get_env(:nola, :lastfm)[:api_key]
	url = "http://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&format=json&limit=1&extended=1" <> "&api_key=" <> api <> "&user="<> user
	case HTTPoison.get(url) do
	{:ok, %HTTPoison.Response{status_code: 200, body: body}} -> Jason.decode(body)
	{:ok, %HTTPoison.Response{status_code: 404}} -> {:error, "last.fm: utilisateur \"#{user}\" inexistant"}
	{:ok, %HTTPoison.Response{status_code: code}} -> {:error, "last.fm: erreur #{to_string(code)}"}
	error ->
	Logger.error "Lastfm http error: #{inspect error}"
	:error
	end
	end
	defp fetch_track(user, %{"recenttracks" => %{"track" => [ t = %{"name" => name, "artist" => %{"name" => artist}} \| _]}}) do
	api = Application.get_env(:nola, :lastfm)[:api_key]
	url = "http://ws.audioscrobbler.com/2.0/?method=track.getInfo&format=json" <> "&api_key=" <> api <> "&username="<> user <> "&artist="<>URI.encode(artist)<>"&track="<>URI.encode(name)
	case HTTPoison.get(url) do
	{:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
	case Jason.decode(body) do
	{:ok, body} -> body["track"] \|\| %{}
	_ -> %{}
	end
	error ->
	Logger.error "Lastfm http error: #{inspect error}"
	:error
	end
	end

	defp format_now_playing(%{"recenttracks" => %{"track" => [track = %{"@attr" => %{"nowplaying" => "true"}} \| _]}}, et) do
	format_track(true, track, et)
	end

	defp format_now_playing(%{"recenttracks" => %{"track" => [track \| _]}}, et) do
	format_track(false, track, et)
	end

	defp format_now_playing(%{"error" => err, "message" => message}, _) do
	"last.fm error #{err}: #{message}"
	end

	defp format_now_playing(miss) do
	nil
	end

	defp format_track(np, track, extended) do
	artist = track["artist"]["name"]
	album = if track["album"]["#text"], do: " (" <> track["album"]["#text"] <> ")", else: ""
	name = track["name"] <> album
	action = if np, do: "écoute ", else: "a écouté"
	love = if track["loved"] != "0", do: "❤️"
	count = if x = extended["userplaycount"], do: "x#{x} #{love}"
	tags = (get_in(extended, ["toptags", "tag"]) \|\| [])
	\|> Enum.map(fn(tag) -> tag["name"] end)
	\|> Enum.filter(& &1)
	\|> Enum.join(", ")

	[action, artist, name, count, tags, track["url"]]
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.trim(&1))
	\|> Enum.join(" - ")
	end

	end
	diff --git a/lib/plugins/link/youtube.ex b/lib/plugins/link/youtube.ex
	index 1b14221..0114940 100644
	--- a/lib/plugins/link/youtube.ex
	+++ b/lib/plugins/link/youtube.ex
	@@ -1,72 +1,72 @@
	defmodule Nola.Plugins.Link.YouTube do
	@behaviour Nola.Plugins.Link

	@moduledoc """
	# YouTube link preview

	needs an API key:

	```
	config :nola, :youtube,
	api_key: "xxxxxxxxxxxxx"
	```

	options:

	* `invidious`: Add a link to invidious.
	"""

	@impl true
	def match(uri = %URI{host: yt, path: "/watch", query: "v="<>video_id}, _opts) when yt in ["youtube.com", "www.youtube.com"] do
	{true, %{video_id: video_id}}
	end

	def match(%URI{host: "youtu.be", path: "/"<>video_id}, _opts) do
	{true, %{video_id: video_id}}
	end

	def match(_, _), do: false

	@impl true
	def post_match(_, _, _, _), do: false

	@impl true
	- def expand(uri, %{video_id: video_id}, opts) do
	+ def expand(_uri, %{video_id: video_id}, opts) do
	key = Application.get_env(:nola, :youtube)[:api_key]
	params = %{
	"part" => "snippet,contentDetails,statistics",
	"id" => video_id,
	"key" => key
	}
	headers = []
	options = [params: params]
	case HTTPoison.get("https://www.googleapis.com/youtube/v3/videos", [], options) do
	{:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
	case Jason.decode(body) do
	{:ok, json} ->
	item = List.first(json["items"])
	if item do
	snippet = item["snippet"]
	duration = item["contentDetails"]["duration"] \|> String.replace("PT", "") \|> String.downcase
	date = snippet["publishedAt"]
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> Timex.format("{relative}", :relative)
	\|> elem(1)

	line = if host = Keyword.get(opts, :invidious) do
	["-> https://#{host}/watch?v=#{video_id}"]
	else
	[]
	end
	{:ok, line ++ ["#{snippet["title"]}", "— #{duration} — uploaded by #{snippet["channelTitle"]} — #{date}"
	<> " — #{item["statistics"]["viewCount"]} views, #{item["statistics"]["likeCount"]} likes"]}
	else
	:error
	end
	_ -> :error
	end
	end
	end

	end
	diff --git a/lib/telegram.ex b/lib/telegram.ex
	index f2c9eca..b161b63 100644
	--- a/lib/telegram.ex
	+++ b/lib/telegram.ex
	@@ -1,233 +1,236 @@
	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}}
	+ case Nola.TelegramRoom.init(chat_id) do
	+ {:ok, state} -> {:ok, %{room_state: state}}
	+ _ -> :ignore
	+ end
	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}"
	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 ede939e..7a8f427 100644
	--- a/lib/telegram/room.ex
	+++ b/lib/telegram/room.ex
	@@ -1,188 +1,194 @@
	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))
	+ {:ok, rooms} = rooms(:ids)
	+ for id <- rooms do
	+ spawn(fn() ->
	+ Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(Nola.Telegram, Integer.parse(id) \|> elem(0))
	+ end)
	+ end
	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
	+ tg_room = case room(to_string(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)
	+ _ = Couch.post(@couch, %{"_id" => id, "network" => net, "channel" => chan})
	+ {:ok, tg_room} = room(to_string(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
	+ :ignore
	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)
	+
	+ Nola.Account.put_meta(account, "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)
	+ #connection = Nola.Irc.Connection.get_network(state.net)
	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)
	+ #connection = Nola.Irc.Connection.get_network(state.net)
	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)
	+ #connection = Nola.Irc.Connection.get_network(state.net)
	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.ex b/lib/web.ex
	index 906e961..c1720a0 100644
	--- a/lib/web.ex
	+++ b/lib/web.ex
	@@ -1,99 +1,99 @@
	defmodule NolaWeb do
	@moduledoc """
	The entrypoint for defining your web interface, such
	as controllers, views, channels and so on.

	This can be used in your application as:

	use NolaWeb, :controller
	use NolaWeb, :view

	The definitions below will be executed for every view,
	controller, etc, so keep them short and clean, focused
	on imports, uses and aliases.

	Do NOT define functions inside the quoted expressions
	below. Instead, define any helper function in modules
	and import those modules here.
	"""

	def format_chan("##") do
	"♯♯"
	end

	def format_chan("#") do
	"♯"
	end

	def format_chan("#"<>chan) do
	chan
	end

	def format_chan(chan = "!"<>_), do: chan

	def reformat_chan("♯") do
	"#"
	end
	def reformat_chan("♯♯") do
	"##"
	end
	def reformat_chan(chan = "!"<>_), do: chan

	def reformat_chan(chan) do
	"#"<>chan
	end

	def controller do
	quote do
	use Phoenix.Controller, namespace: NolaWeb
	import Plug.Conn
	import NolaWeb.Router.Helpers
	import NolaWeb.Gettext
	alias NolaWeb.Router.Helpers, as: Routes
	end
	end

	def view do
	quote do
	- use Phoenix.View, root: "lib/nola_web/templates",
	+ use Phoenix.View, root: "lib/web/templates",
	namespace: NolaWeb

	# Import convenience functions from controllers
	import Phoenix.Controller, only: [get_flash: 2, view_module: 1]

	# Use all HTML functionality (forms, tags, etc)
	use Phoenix.HTML

	import NolaWeb.Router.Helpers
	import NolaWeb.ErrorHelpers
	import NolaWeb.Gettext

	import Phoenix.LiveView.Helpers

	alias NolaWeb.Router.Helpers, as: Routes
	end
	end

	def router do
	quote do
	use Phoenix.Router
	import Plug.Conn
	import Phoenix.Controller
	import Phoenix.LiveView.Router
	end
	end

	def channel do
	quote do
	use Phoenix.Channel
	import NolaWeb.Gettext
	end
	end

	@doc """
	When used, dispatch to the appropriate controller/view/etc.
	"""
	defmacro __using__(which) when is_atom(which) do
	apply(__MODULE__, which, [])
	end
	end
	diff --git a/lib/web/views/layout_view.ex b/lib/web/views/layout_view.ex
	index 2bffc6f..663eccf 100644
	--- a/lib/web/views/layout_view.ex
	+++ b/lib/web/views/layout_view.ex
	@@ -1,81 +1,81 @@
	defmodule NolaWeb.LayoutView do
	use NolaWeb, :view

	def liquid_markdown(conn, text) do
	context_path = cond do
	conn.assigns[:chan] -> "/#{conn.assigns[:network]}/#{NolaWeb.format_chan(conn.assigns[:chan])}"
	conn.assigns[:network] -> "/#{conn.assigns[:network]}/-"
	true -> "/-"
	end

	{:ok, ast} = Liquex.parse(text)
	context = Liquex.Context.new(%{
	"context_path" => context_path
	})
	{content, _} = Liquex.render(ast, context)
	content
	\|> to_string()
	\|> Earmark.as_html!()
	\|> raw()
	end

	def page_title(conn) do
	target = cond do
	conn.assigns[:chan] ->
	"#{conn.assigns.chan} @ #{conn.assigns.network}"
	conn.assigns[:network] -> conn.assigns.network
	- true -> Keyword.get(Nola.name())
	+ true -> Nola.name()
	end

	breadcrumb_title = Enum.map(Map.get(conn.assigns, :breadcrumbs)\|\|[], fn({title, _href}) -> title end)

	title = [conn.assigns[:title], breadcrumb_title, target]
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.filter(fn(x) -> x end)
	\|> Enum.intersperse(" / ")
	\|> Enum.join()

	content_tag(:title, title)
	end

	def format_time(date, with_relative \\ true) do
	alias Timex.Format.DateTime.Formatters
	alias Timex.Timezone
	date = if is_integer(date) do
	date
	\|> DateTime.from_unix!(:millisecond)
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	else
	date
	\|> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
	end

	now = DateTime.now!("Europe/Paris", Tzdata.TimeZoneDatabase)

	now_week = Timex.iso_week(now)
	date_week = Timex.iso_week(date)

	{y, w} = now_week
	now_last_week = {y, w-1}
	now_last_roll = 7-Timex.days_to_beginning_of_week(now)

	date_date = DateTime.to_date(date)
	now_date = DateTime.to_date(date)

	format = cond do
	date.year != now.year -> "{D}/{M}/{YYYY} {h24}:{m}"
	date_date == now_date -> "{h24}:{m}"
	(now_week == date_week) \|\| (date_week == now_last_week && (Date.day_of_week(date) >= now_last_roll)) -> "{WDfull} {h24}:{m}"
	(now.year == date.year && now.month == date.month) -> "{WDfull} {D} {h24}:{m}"
	true -> "{WDfull} {D} {M} {h24}:{m}"
	end

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

	content_tag(:time, if(with_relative, do: relative, else: detail), [title: full])
	end

	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 4:57 PM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 33625
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions