diff options
Diffstat (limited to 'lib/nola_plugins')
42 files changed, 5882 insertions, 0 deletions
diff --git a/lib/nola_plugins/admin_handler.ex b/lib/nola_plugins/admin_handler.ex new file mode 100644 index 0000000..9a5d557 --- /dev/null +++ b/lib/nola_plugins/admin_handler.ex @@ -0,0 +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, client} + end + + def handle_info({:irc, :trigger, "op", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}, sender: sender}}, client) do + if 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 + 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/nola_plugins/alcolog_plugin.ex b/lib/nola_plugins/alcolog_plugin.ex new file mode 100644 index 0000000..145e4fc --- /dev/null +++ b/lib/nola_plugins/alcolog_plugin.ex @@ -0,0 +1,1229 @@ +defmodule Nola.IRC.AlcoologPlugin do + require Logger + + @moduledoc """ + # [alcoolog]({{context_path}}/alcoolog) + + * **!santai `<cl | (calc)>` `<degrés d'alcool> [annotation]`**: enregistre un nouveau verre de `montant` d'une boisson à `degrés d'alcool`. + * **!santai `<cl | (calc)>` `<beer name>`**: enregistre un nouveau verre de `cl` de la bière `beer name`, et checkin sur Untappd.com. + * **!moar `[cl]` : enregistre un verre équivalent au dernier !santai. + * **-santai**: annule la dernière entrée d'alcoolisme. + * **.alcoolisme**: état du channel en temps réel. + * **.alcoolisme `<semaine | Xj>`**: points par jour, sur X j. + * **!alcoolisme `[pseudo]`**: affiche les points d'alcoolisme. + * **!alcoolisme `[pseudo]` `<semaine | Xj>`**: affiche les points d'alcoolisme par jour sur X j. + * **+alcoolisme `<h|f>` `<poids en kg>` `[facteur de perte en mg/l (10, 15, 20, 25)]`**: Configure votre profil d'alcoolisme. + * **.sobre**: affiche quand la sobriété frappera sur le chan. + * **!sobre `[pseudo]`**: affiche quand la sobriété frappera pour `[pseudo]`. + * **!sobrepour `<date>`**: affiche tu pourras être sobre pour `<date>`, et si oui, combien de volumes d'alcool peuvent encore être consommés. + * **!alcoolog**: ([voir]({{context_path}}/alcoolog)) lien pour voir l'état/statistiques et historique de l'alcoolémie du channel. + * **!alcool `<cl>` `<degrés>`**: donne le nombre d'unités d'alcool dans `<cl>` à `<degrés>°`. + * **!soif**: c'est quand l'apéro ? + + 1 point = 1 volume d'alcool. + + Annotation: champ libre! + + --- + + ## `!txt`s + + * status utilisateur: `alcoolog.user_(sober|legal|legalhigh|high|toohigh|sick)(|_rising)` + * mauvaises boissons: `alcoolog.drink_(negative|zero|negative)` + * santo: `alcoolog.santo` + * santai: `alcoolog.santai` + * plus gros, moins gros: `alcoolog.(fatter|thinner)` + + """ + + def irc_doc, do: @moduledoc + + def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__) + + # tuple dets: {nick, date, volumes, current_alcohol_level, nom, commentaire} + # tuple ets: {{nick, date}, volumes, current, nom, commentaire} + # tuple meta dets: {nick, map} + # %{:weight => float, :sex => true(h),false(f)} + @pubsub ~w(account) + @pubsub_triggers ~w(santai moar again bis santo santeau alcoolog sobre sobrepour soif alcoolisme alcool) + @default_user_meta %{weight: 77.4, sex: true, loss_factor: 15} + + def data_state() do + dets_filename = (Nola.data_path() <> "/" <> "alcoolisme.dets") |> String.to_charlist + dets_meta_filename = (Nola.data_path() <> "/" <> "alcoolisme_meta.dets") |> String.to_charlist + %{dets: dets_filename, meta: dets_meta_filename, ets: __MODULE__.ETS} + end + + def init(_) do + triggers = for(t <- @pubsub_triggers, do: "trigger:"<>t) + for sub <- @pubsub ++ triggers do + {:ok, _} = Registry.register(IRC.PubSub, sub, plugin: __MODULE__) + end + dets_filename = (Nola.data_path() <> "/" <> "alcoolisme.dets") |> String.to_charlist + {:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}]) + ets = :ets.new(__MODULE__.ETS, [:ordered_set, :named_table, :protected, {:read_concurrency, true}]) + dets_meta_filename = (Nola.data_path() <> "/" <> "alcoolisme_meta.dets") |> String.to_charlist + {:ok, meta} = :dets.open_file(dets_meta_filename, [{:type,:set}]) + traverse_fun = fn(obj, dets) -> + case obj do + object = {nick, naive = %NaiveDateTime{}, volumes, active, cl, deg, name, comment} -> + date = naive + |> DateTime.from_naive!("Etc/UTC") + |> DateTime.to_unix() + new = {nick, date, volumes, active, cl, deg, name, comment, Map.new()} + :dets.delete_object(dets, object) + :dets.insert(dets, new) + :ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, Map.new()}) + dets + + object = {nick, naive = %NaiveDateTime{}, volumes, active, cl, deg, name, comment, meta} -> + date = naive + |> DateTime.from_naive!("Etc/UTC") + |> DateTime.to_unix() + new = {nick, date, volumes, active, cl, deg, name, comment, Map.new()} + :dets.delete_object(dets, object) + :dets.insert(dets, new) + :ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, Map.new()}) + dets + + object = {nick, date, volumes, active, cl, deg, name, comment, meta} -> + :ets.insert(ets, {{nick, date}, volumes, active, cl, deg, name, comment, meta}) + dets + + _ -> + dets + end + end + :dets.foldl(traverse_fun, dets, dets) + :dets.sync(dets) + state = %{dets: dets, meta: meta, ets: ets} + {:ok, state} + end + + @eau ["santo", "santeau"] + def handle_info({:irc, :trigger, santeau, m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) when santeau in @eau do + Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.santo") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "soif", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do + now = DateTime.utc_now() + |> Timex.Timezone.convert("Europe/Paris") + apero = format_duration_from_now(%DateTime{now | hour: 18, minute: 0, second: 0}, false) + day_of_week = Date.day_of_week(now) + {txt, apero?} = cond do + now.hour >= 0 && now.hour < 6 -> + {["apéro tardif ? Je dis OUI ! SANTAI !"], true} + now.hour >= 6 && now.hour < 12 -> + if day_of_week >= 6 do + {["de l'alcool pour le petit dej ? le week-end, pas de problème !"], true} + else + {["C'est quand même un peu tôt non ? Prochain apéro #{apero}"], false} + end + now.hour >= 12 && (now.hour < 14) -> + {["oui! c'est l'apéro de midi! (et apéro #{apero})", + "tu peux attendre #{apero} ou y aller, il est midi !" + ], true} + now.hour == 17 -> + {[ + "ÇA APPROCHE !!! Apéro #{apero}", + "BIENTÔT !!! Apéro #{apero}", + "achetez vite les teilles, apéro dans #{apero}!", + "préparez les teilles, apéro dans #{apero}!" + ], false} + now.hour >= 14 && now.hour < 18 -> + weekend = if day_of_week >= 6 do + " ... ou maintenant en fait, c'est le week-end!" + else + "" + end + {["tiens bon! apéro #{apero}#{weekend}", + "courage... apéro dans #{apero}#{weekend}", + "pas encore :'( apéro dans #{apero}#{weekend}" + ], false} + true -> + {[ + "C'EST L'HEURE DE L'APÉRO !!! SANTAIIIIIIIIIIII !!!!" + ], true} + end + + txt = txt + |> Enum.shuffle() + |> Enum.random() + + m.replyfun.(txt) + + stats = get_full_statistics(state, m.account.id) + if !apero? && stats.active > 0.1 do + m.replyfun.("(... ou continue en fait, je suis pas ta mère !)") + end + + {:noreply, state} + end + + def handle_info({:irc, :trigger, "sobrepour", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + args = Enum.join(args, " ") + {:ok, now} = DateTime.now("Europe/Paris", Tzdata.TimeZoneDatabase) + time = case args do + "demain " <> time -> + {h, m} = case String.split(time, [":", "h"]) do + [hour, ""] -> + IO.puts ("h #{inspect hour}") + {h, _} = Integer.parse(hour) + {h, 0} + [hour, min] when min != "" -> + {h, _} = Integer.parse(hour) + {m, _} = Integer.parse(min) + {h, m} + [hour] -> + IO.puts ("h #{inspect hour}") + {h, _} = Integer.parse(hour) + {h, 0} + _ -> {0, 0} + end + secs = ((60*60)*24) + day = DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase) + %DateTime{day | hour: h, minute: m, second: 0} + "après demain " <> time -> + secs = 2*((60*60)*24) + DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase) + datetime -> + case Timex.Parse.DateTime.Parser.parse(datetime, "{}") do + {:ok, dt} -> dt + _ -> nil + end + end + + if time do + meta = get_user_meta(state, m.account.id) + stats = get_full_statistics(state, m.account.id) + + duration = round(DateTime.diff(time, now)/60.0) + + IO.puts "diff #{inspect duration} sober in #{inspect stats.sober_in}" + + if duration < stats.sober_in do + int = stats.sober_in - duration + m.replyfun.("désolé, aucune chance! tu seras sobre #{format_minute_duration(int)} après!") + else + remaining = duration - stats.sober_in + if remaining < 30 do + m.replyfun.("moins de 30 minutes de sobriété, c'est impossible de boire plus") + else + loss_per_minute = ((meta.loss_factor/100)/60) + remaining_gl = (remaining-30)*loss_per_minute + m.replyfun.("marge de boisson: #{inspect remaining} minutes, #{remaining_gl} g/l") + end + end + + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do + {:ok, token} = Nola.Token.new({:alcoolog, :index, m.sender.network, m.channel}) + url = NolaWeb.Router.Helpers.alcoolog_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel), token) + m.replyfun.("-> #{url}") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :bang}}}, state) do + url = NolaWeb.Router.Helpers.alcoolog_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel)) + m.replyfun.("-> #{url}") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcool", m = %IRC.Message{trigger: %IRC.Trigger{args: args = [cl, deg], type: :bang}}}, state) do + {cl, _} = Util.float_paparse(cl) + {deg, _} = Util.float_paparse(deg) + points = Alcool.units(cl, deg) + meta = get_user_meta(state, m.account.id) + k = if meta.sex, do: 0.7, else: 0.6 + weight = meta.weight + gl = (10*points)/(k*weight) + duration = round(gl/((meta.loss_factor/100)/60))+30 + sober_in_s = if duration > 0 do + duration = Timex.Duration.from_minutes(duration) + Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized) + else + "" + end + + m.replyfun.("Il y a #{Float.round(points+0.0, 4)} unités d'alcool dans #{cl}cl à #{deg}° (#{Float.round(gl + 0.0, 4)} g/l, #{sober_in_s})") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: [cl, deg | comment], type: :bang}}}, state) do + santai(m, state, cl, deg, comment) + {:noreply, state} + end + + @moar [ + "{{message.sender.nick}}: la même donc ?", + "{{message.sender.nick}}: et voilà la petite sœur !" + ] + + def handle_info({:irc, :trigger, "bis", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + handle_info({:irc, :trigger, "moar", m}, state) + end + def handle_info({:irc, :trigger, "again", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + handle_info({:irc, :trigger, "moar", m}, state) + end + + def handle_info({:irc, :trigger, "moar", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + case get_statistics_for_nick(state, m.account.id) do + {_, obj = {_, _date, _points, _active, cl, deg, _name, comment, _meta}} -> + cl = case args do + [cls] -> + case Util.float_paparse(cls) do + {cl, _} -> cl + _ -> cl + end + _ -> cl + end + moar = @moar |> Enum.shuffle() |> Enum.random() |> Tmpl.render(m) |> m.replyfun.() + santai(m, state, cl, deg, comment, auto_set: true) + {_, obj = {_, date, points, _last_active, type, descr}} -> + case Regex.named_captures(~r/^(?<cl>\d+[.]\d+)cl\s+(?<deg>\d+[.]\d+)°$/, type) do + nil -> m.replyfun.("suce") + u -> + moar = @moar |> Enum.shuffle() |> Enum.random() |> Tmpl.render(m) |> m.replyfun.() + santai(m, state, u["cl"], u["deg"], descr, auto_set: true) + end + _ -> nil + end + {:noreply, state} + end + + defp santai(m, state, cl, deg, comment, options \\ []) do + comment = cond do + comment == [] -> nil + is_binary(comment) -> comment + comment == nil -> nil + true -> Enum.join(comment, " ") + end + + {cl, cl_extra} = case {Util.float_paparse(cl), cl} do + {{cl, extra}, _} -> {cl, extra} + {:error, "("<>_} -> + try do + {:ok, result} = Abacus.eval(cl) + {result, nil} + rescue + _ -> {nil, "cl: invalid calc expression"} + end + {:error, _} -> {nil, "cl: invalid value"} + end + + {deg, comment, auto_set, beer_id} = case Util.float_paparse(deg) do + {deg, _} -> {deg, comment, Keyword.get(options, :auto_set, false), nil} + :error -> + beername = if(comment, do: "#{deg} #{comment}", else: deg) + case Untappd.search_beer(beername, limit: 1) do + {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => [%{"beer" => beer, "brewery" => brewery} | _]}}}} -> + {Map.get(beer, "beer_abv"), "#{Map.get(brewery, "brewery_name")}: #{Map.get(beer, "beer_name")}", true, Map.get(beer, "bid")} + _ -> + {deg, "could not find beer", false, nil} + end + end + + cond do + cl == nil -> m.replyfun.(cl_extra) + deg == nil -> m.replyfun.(comment) + cl >= 500 || deg >= 100 -> Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.drink_toohuge") + cl == 0 || deg == 0 -> Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.drink_zero") + cl < 0 || deg < 0 -> Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.drink_negative") + true -> + points = Alcool.units(cl, deg) + now = m.at || DateTime.utc_now() + |> DateTime.to_unix(:millisecond) + user_meta = get_user_meta(state, m.account.id) + name = "#{cl}cl #{deg}°" + old_stats = get_full_statistics(state, m.account.id) + meta = %{} + meta = Map.put(meta, "timestamp", now) + meta = Map.put(meta, "weight", user_meta.weight) + meta = Map.put(meta, "sex", user_meta.sex) + :ok = :dets.insert(state.dets, {m.account.id, now, points, if(old_stats, do: old_stats.active, else: 0), cl, deg, name, comment, meta}) + true = :ets.insert(state.ets, {{m.account.id, now}, points, if(old_stats, do: old_stats.active, else: 0),cl, deg, name, comment, meta}) + #sante = @santai |> Enum.map(fn(s) -> String.trim(String.upcase(s)) end) |> Enum.shuffle() |> Enum.random() + sante = Nola.IRC.TxtPlugin.random("alcoolog.santai") + k = if user_meta.sex, do: 0.7, else: 0.6 + weight = user_meta.weight + peak = Float.round((10*points||0.0)/(k*weight), 4) + stats = get_full_statistics(state, m.account.id) + sober_add = if old_stats && Map.get(old_stats || %{}, :sober_in) do + mins = round(stats.sober_in - old_stats.sober_in) + " [+#{mins}m]" + else + "" + end + nonow = DateTime.utc_now() + sober = nonow |> DateTime.add(round(stats.sober_in*60), :second) + |> Timex.Timezone.convert("Europe/Paris") + at = if nonow.day == sober.day do + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr") + detail + else + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr") + detail + end + + up = if stats.active_drinks > 1 do + " " <> Enum.join(for(_ <- 1..stats.active_drinks, do: "▲")) <> "" + else + "" + end + + since_str = if stats.since && stats.since_min > 180 do + "(depuis: #{stats.since_s}) " + else + "" + end + + msg = fn(nick, extra) -> + "#{sante} #{nick} #{extra}#{up} #{format_points(points)} @#{stats.active}g/l [+#{peak} g/l]" + <> " (15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) #{since_str}(sobriété #{at} (dans #{stats.sober_in_s})#{sober_add}) !" + <> " (aujourd'hui #{stats.daily_volumes} points - #{stats.daily_gl} g/l)" + end + + meta = if beer_id do + Map.put(meta, "untappd:beer_id", beer_id) + else + meta + end + + if beer_id do + spawn(fn() -> + case Untappd.maybe_checkin(m.account, beer_id) do + {:ok, body} -> + badges = get_in(body, ["badges", "items"]) + if badges != [] do + badges_s = Enum.map(badges, fn(badge) -> Map.get(badge, "badge_name") end) + |> Enum.filter(fn(b) -> b end) + |> Enum.intersperse(", ") + |> Enum.join("") + badge = if(length(badges) > 1, do: "badges", else: "badge") + m.replyfun.("\\O/ Unlocked untappd #{badge}: #{badges_s}") + end + :ok + {:error, {:http_error, error}} when is_integer(error) -> m.replyfun.("Checkin to Untappd failed: #{to_string(error)}") + {:error, {:http_error, error}} -> m.replyfun.("Checkin to Untappd failed: #{inspect error}") + _ -> :error + end + end) + end + + local_extra = if auto_set do + if comment do + " #{comment} (#{cl}cl @ #{deg}°)" + else + "#{cl}cl @ #{deg}°" + end + else + "" + end + m.replyfun.(msg.(m.sender.nick, local_extra)) + notify = IRC.Membership.notify_channels(m.account) -- [{m.network,m.channel}] + for {net, chan} <- notify do + user = IRC.UserTrack.find_by_account(net, m.account) + nick = if(user, do: user.nick, else: m.account.name) + extra = " " <> present_type(name, comment) <> "" + IRC.Connection.broadcast_message(net, chan, msg.(nick, extra)) + end + + miss = cond do + points <= 0.6 -> :small + stats.active30m >= 2.9 && stats.active30m < 3 -> :miss3 + stats.active30m >= 1.9 && stats.active30m < 2 -> :miss2 + stats.active30m >= 0.9 && stats.active30m < 1 -> :miss1 + stats.active30m >= 0.45 && stats.active30m < 0.5 -> :miss05 + stats.active30m >= 0.20 && stats.active30m < 0.20 -> :miss025 + stats.active30m >= 3 && stats.active1h < 3.15 -> :small3 + stats.active30m >= 2 && stats.active1h < 2.15 -> :small2 + stats.active30m >= 1.5 && stats.active1h < 1.5 -> :small15 + stats.active30m >= 1 && stats.active1h < 1.15 -> :small1 + stats.active30m >= 0.5 && stats.active1h <= 0.51 -> :small05 + stats.active30m >= 0.25 && stats.active30m <= 0.255 -> :small025 + true -> nil + end + + if miss do + miss = Nola.IRC.TxtPlugin.random("alcoolog.#{to_string(miss)}") + if miss do + for {net, chan} <- IRC.Membership.notify_channels(m.account) do + user = IRC.UserTrack.find_by_account(net, m.account) + nick = if(user, do: user.nick, else: m.account.name) + IRC.Connection.broadcast_message(net, chan, "#{nick}: #{miss}") + end + end + end + end + end + + def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do + m.replyfun.("!santai <cl> <degrés> [commentaire]") + {:noreply, state} + end + + def get_all_stats() do + IRC.Account.all_accounts() + |> Enum.map(fn(account) -> {account.id, get_full_statistics(account.id)} end) + |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end) + |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2) + end + + def get_channel_statistics(account, network, nil) do + IRC.Membership.expanded_members_or_friends(account, network, nil) + |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end) + |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end) + |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2) + end + + def get_channel_statistics(_, network, channel), do: get_channel_statistics(network, channel) + + def get_channel_statistics(network, channel) do + IRC.Membership.expanded_members(network, channel) + |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end) + |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end) + |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2) + end + + @spec since() :: %{IRC.Account.id() => DateTime.t()} + @doc "Returns the last time the user was at 0 g/l" + def since() do + :ets.foldr(fn({{acct, timestamp_or_date}, _vol, current, _cl, _deg, _name, _comment, _m}, acc) -> + if !Map.get(acc, acct) && current == 0 do + date = Util.to_date_time(timestamp_or_date) + Map.put(acc, acct, date) + else + acc + end + end, %{}, __MODULE__.ETS) + end + + def get_full_statistics(nick) do + get_full_statistics(data_state(), nick) + end + + defp get_full_statistics(state, nick) do + case get_statistics_for_nick(state, nick) do + {count, {_, last_at, last_points, last_active, last_cl, last_deg, last_type, last_descr, _meta}} -> + {active, active_drinks} = current_alcohol_level(state, nick) + {_, m30} = alcohol_level_rising(state, nick) + {rising, m15} = alcohol_level_rising(state, nick, 15) + {_, m5} = alcohol_level_rising(state, nick, 5) + {_, h1} = alcohol_level_rising(state, nick, 60) + + trend = if rising do + "▲" + else + "▼" + end + user_state = cond do + active <= 0.0 -> :sober + active <= 0.25 -> :low + active <= 0.50 -> :legal + active <= 1.0 -> :legalhigh + active <= 2.5 -> :high + active < 3 -> :toohigh + true -> :sick + end + + rising_file_key = if rising, do: "_rising", else: "" + txt_file = "alcoolog." <> "user_" <> to_string(user_state) <> rising_file_key + user_status = Nola.IRC.TxtPlugin.random(txt_file) + + meta = get_user_meta(state, nick) + minutes_til_sober = h1/((meta.loss_factor/100)/60) + minutes_til_sober = cond do + active < 0 -> 0 + m15 < 0 -> 15 + m30 < 0 -> 30 + h1 < 0 -> 60 + minutes_til_sober > 0 -> + Float.round(minutes_til_sober+60) + true -> 0 + end + + duration = Timex.Duration.from_minutes(minutes_til_sober) + sober_in_s = if minutes_til_sober > 0 do + Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized) + else + nil + end + + since = if active > 0 do + since() + |> Map.get(nick) + end + + since_diff = if since, do: Timex.diff(DateTime.utc_now(), since, :minutes) + since_duration = if since, do: Timex.Duration.from_minutes(since_diff) + since_s = if since, do: Timex.Format.Duration.Formatter.lformat(since_duration, "fr", :humanized) + + {total_volumes, total_gl} = user_stats(state, nick) + + + %{active: active, last_at: last_at, last_cl: last_cl, last_deg: last_deg, last_points: last_points, last_type: last_type, last_descr: last_descr, + trend_symbol: trend, + active5m: m5, active15m: m15, active30m: m30, active1h: h1, + rising: rising, + active_drinks: active_drinks, + user_status: user_status, + daily_gl: total_gl, daily_volumes: total_volumes, + sober_in: minutes_til_sober, sober_in_s: sober_in_s, + since: since, since_min: since_diff, since_s: since_s, + } + _ -> + nil + end + end + + def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :dot}}}, state) do + nicks = IRC.Membership.expanded_members_or_friends(m.account, m.network, m.channel) + |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end) + |> Enum.filter(fn({_nick, status}) -> status && status.sober_in && status.sober_in > 0 end) + |> Enum.sort_by(fn({_, status}) -> status.sober_in end, &</2) + |> Enum.map(fn({nick, stats}) -> + now = DateTime.utc_now() + sober = now |> DateTime.add(round(stats.sober_in*60), :second) + |> Timex.Timezone.convert("Europe/Paris") + at = if now.day == sober.day do + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr") + detail + else + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr") + detail + end + "#{nick} sobre #{at} (dans #{stats.sober_in_s})" + end) + |> Enum.intersperse(", ") + |> Enum.join("") + |> (fn(line) -> + case line do + "" -> "tout le monde est sobre......." + line -> line + end + end).() + |> m.replyfun.() + {:noreply, state} + end + + def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + account = case args do + [nick] -> IRC.Account.find_always_by_nick(m.network, m.channel, nick) + [] -> m.account + end + + if account do + user = IRC.UserTrack.find_by_account(m.network, account) + nick = if(user, do: user.nick, else: account.name) + stats = get_full_statistics(state, account.id) + if stats && stats.sober_in > 0 do + now = DateTime.utc_now() + sober = now |> DateTime.add(round(stats.sober_in*60), :second) + |> Timex.Timezone.convert("Europe/Paris") + at = if now.day == sober.day do + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr") + detail + else + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr") + detail + end + m.replyfun.("#{nick} sera sobre #{at} (dans #{stats.sober_in_s})!") + else + m.replyfun.("#{nick} est déjà sobre. aidez le !") + end + else + m.replyfun.("inconnu") + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :dot}}}, state) do + nicks = IRC.Membership.expanded_members_or_friends(m.account, m.network, m.channel) + |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end) + |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end) + |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2) + |> Enum.map(fn({nick, status}) -> + trend_symbol = if status.active_drinks > 1 do + Enum.join(for(_ <- 1..status.active_drinks, do: status.trend_symbol)) + else + status.trend_symbol + end + since_str = if status.since_min > 180 do + "depuis: #{status.since_s} | " + else + "" + end + "#{nick} #{status.user_status} #{trend_symbol} #{Float.round(status.active, 4)} g/l [#{since_str}sobre dans: #{status.sober_in_s}]" + end) + |> Enum.intersperse(", ") + |> Enum.join("") + + msg = if nicks == "" do + "wtf?!?! personne n'a bu!" + else + nicks + end + + m.replyfun.(msg) + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [time], type: :dot}}}, state) do + time = case time do + "semaine" -> 7 + string -> + case Integer.parse(string) do + {time, "j"} -> time + {time, "J"} -> time + _ -> nil + end + end + + if time do + aday = time*((24 * 60)*60) + now = DateTime.utc_now() + before = now + |> DateTime.add(-aday, :second) + |> DateTime.to_unix(:millisecond) + over_time_stats(before, time, m, state) + else + m.replyfun.(".alcooolisme semaine|Xj") + end + {:noreply, state} + end + + def user_over_time(account, count) do + user_over_time(data_state(), account, count) + end + + def user_over_time(state, account, count) do + delay = count*((24 * 60)*60) + now = DateTime.utc_now() + before = DateTime.utc_now() + |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase) + |> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase) + |> DateTime.to_unix(:millisecond) + #[ +# {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, +# [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]} + #] + match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, + [{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]} + ] + :ets.select(state.ets, match) + |> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) -> + date = DateTime.from_unix!(ts, :millisecond) + |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase) + + date = if date.hour <= 8 do + DateTime.add(date, -(60*(60*(date.hour+1))), :second, Tzdata.TimeZoneDatabase) + else + date + end + |> DateTime.to_date() + + Map.put(acc, date, Map.get(acc, date, 0) + vol) + end) + end + + def user_over_time_gl(account, count) do + state = data_state() + meta = get_user_meta(state, account.id) + delay = count*((24 * 60)*60) + now = DateTime.utc_now() + before = DateTime.utc_now() + |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase) + |> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase) + |> DateTime.to_unix(:millisecond) + #[ +# {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, +# [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]} + #] + match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, + [{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]} + ] + :ets.select(state.ets, match) + |> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) -> + date = DateTime.from_unix!(ts, :millisecond) + |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase) + + date = if date.hour <= 8 do + DateTime.add(date, -(60*(60*(date.hour+1))), :second, Tzdata.TimeZoneDatabase) + else + date + end + |> DateTime.to_date() + weight = meta.weight + k = if meta.sex, do: 0.7, else: 0.6 + gl = (10*vol)/(k*weight) + + Map.put(acc, date, Map.get(acc, date, 0) + gl) + end) + end + + + + defp over_time_stats(before, j, m, state) do + #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _, _, _, _}) when date > before -> obj end) + match = [{{{:_, :"$1"}, :_, :_, :_, :_, :_, :_, :_}, + [{:>, :"$1", {:const, before}}], [:"$_"]} + ] + # tuple ets: {{nick, date}, volumes, current, nom, commentaire} + members = IRC.Membership.members_or_friends(m.account, m.network, m.channel) + drinks = :ets.select(state.ets, match) + |> Enum.filter(fn({{account, _}, _, _, _, _, _, _, _}) -> Enum.member?(members, account) end) + |> Enum.sort_by(fn({{_, ts}, _, _, _, _, _, _, _}) -> ts end, &>/2) + + top = Enum.reduce(drinks, %{}, fn({{nick, _}, vol, _, _, _, _, _, _}, acc) -> + all = Map.get(acc, nick, 0) + Map.put(acc, nick, all + vol) + end) + |> Enum.sort_by(fn({_nick, count}) -> count end, &>/2) + |> Enum.map(fn({nick, count}) -> + account = IRC.Account.get(nick) + user = IRC.UserTrack.find_by_account(m.network, account) + nick = if(user, do: user.nick, else: account.name) + "#{nick}: #{Float.round(count, 4)}" + end) + |> Enum.intersperse(", ") + + m.replyfun.("sur #{j} jours: #{top}") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do + meta = get_user_meta(state, m.account.id) + hf = if meta.sex, do: "h", else: "f" + m.replyfun.("+alcoolisme sexe: #{hf} poids: #{meta.weight} facteur de perte: #{meta.loss_factor}") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [h, weight | rest], type: :plus}}}, state) do + h = case h do + "h" -> true + "f" -> false + _ -> nil + end + + weight = case Util.float_paparse(weight) do + {weight, _} -> weight + _ -> nil + end + + {factor} = case rest do + [factor] -> + case Util.float_paparse(factor) do + {float, _} -> {float} + _ -> {@default_user_meta.loss_factor} + end + _ -> {@default_user_meta.loss_factor} + end + + if h == nil || weight == nil do + m.replyfun.("paramètres invalides") + else + old_meta = get_user_meta(state, m.account.id) + meta = Map.merge(@default_user_meta, %{sex: h, weight: weight, loss_factor: factor}) + put_user_meta(state, m.account.id, meta) + cond do + old_meta.weight < meta.weight -> + Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.fatter") + old_meta.weight == meta.weight -> + m.replyfun.("aucun changement!") + true -> + Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.thinner") + end + end + + {:noreply, state} + end + + def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :minus}}}, state) do + case get_statistics_for_nick(state, m.account.id) do + {_, obj = {_, date, points, _last_active, _cl, _deg, type, descr, _meta}} -> + :dets.delete_object(state.dets, obj) + :ets.delete(state.ets, {m.account.id, date}) + m.replyfun.("supprimé: #{m.sender.nick} #{points} #{type} #{descr}") + Nola.IRC.TxtPlugin.reply_random(m, "alcoolog.delete") + notify = IRC.Membership.notify_channels(m.account) -- [{m.network,m.channel}] + for {net, chan} <- notify do + user = IRC.UserTrack.find_by_account(net, m.account) + nick = if(user, do: user.nick, else: m.account.name) + IRC.Connection.broadcast_message(net, chan, "#{nick} -santai #{points} #{type} #{descr}") + end + {:noreply, state} + _ -> + {:noreply, state} + end + end + + + def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do + {account, duration} = case args do + [nick | rest] -> {IRC.Account.find_always_by_nick(m.network, m.channel, nick), rest} + [] -> {m.account, []} + end + if account do + duration = case duration do + ["semaine"] -> 7 + [j] -> + case Integer.parse(j) do + {j, "j"} -> j + _ -> nil + end + _ -> nil + end + user = IRC.UserTrack.find_by_account(m.network, account) + nick = if(user, do: user.nick, else: account.name) + if duration do + if duration > 90 do + m.replyfun.("trop gros, ça rentrera pas") + else + # duration stats + stats = user_over_time(state, account, duration) + |> Enum.sort_by(fn({k,_v}) -> k end, {:asc, Date}) + |> Enum.map(fn({date, count}) -> + "#{date.day}: #{Float.round(count, 2)}" + end) + |> Enum.intersperse(", ") + |> Enum.join("") + + if stats == "" do + m.replyfun.("alcoolisme a zéro sur #{duration}j :/") + else + m.replyfun.("alcoolisme de #{nick}, #{duration} derniers jours: #{stats}") + end + end + else + if stats = get_full_statistics(state, account.id) do + trend_symbol = if stats.active_drinks > 1 do + Enum.join(for(_ <- 1..stats.active_drinks, do: stats.trend_symbol)) + else + stats.trend_symbol + end + # TODO: Lookup nick for account_id + msg = "#{nick} #{stats.user_status} " + <> (if stats.active > 0 || stats.active15m > 0 || stats.active30m > 0 || stats.active1h > 0, do: ": #{trend_symbol} #{Float.round(stats.active, 4)}g/l ", else: "") + <> (if stats.active30m > 0 || stats.active1h > 0, do: "(15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) ", else: "") + <> (if stats.sober_in > 0, do: "— Sobre dans #{stats.sober_in_s} ", else: "") + <> (if stats.since && stats.since_min > 180, do: "— Paitai depuis #{stats.since_s} ", else: "") + <> "— Dernier verre: #{present_type(stats.last_type, stats.last_descr)} [#{Float.round(stats.last_points+0.0, 4)}] " + <> "#{format_duration_from_now(stats.last_at)} " + <> (if stats.daily_volumes > 0, do: "— Aujourd'hui: #{stats.daily_volumes} #{stats.daily_gl}g/l", else: "") + + m.replyfun.(msg) + else + m.replyfun.("honteux mais #{nick} n'a pas l'air alcoolique du tout. /kick") + end + end + else + m.replyfun.("je ne connais pas cet utilisateur") + end + {:noreply, state} + end + + + # Account merge + def handle_info({:account_change, old_id, new_id}, state) do + spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, old_id}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) -> + Logger.debug("alcolog/account_change:: merging #{old_id} -> #{new_id}") + rename_object_owner(table, state.ets, obj, old_id, new_id) + end) + case :dets.lookup(state.meta, {:meta, old_id}) do + [{_, meta}] -> + :dets.delete(state.meta, {:meta, old_id}) + :dets.insert(state.meta, {{:meta, new_id}, meta}) + _ -> + :ok + end + {:noreply, state} + end + + def terminate(_, state) do + for dets <- [state.dets, state.meta] do + :dets.sync(dets) + :dets.close(dets) + end + end + + defp rename_object_owner(table, ets, object = {old_id, date, volume, current, cl, deg, name, comment, meta}, old_id, new_id) do + :dets.delete_object(table, object) + :ets.delete(ets, {old_id, date}) + :dets.insert(table, {new_id, date, volume, current, cl, deg, name, comment, meta}) + :ets.insert(ets, {{new_id, date}, volume, current, cl, deg, name, comment, meta}) + end + + # Account: move from nick to account id + def handle_info({:accounts, accounts}, state) do + #for x={:account, _, _, _, _} <- accounts, do: handle_info(x, state) + #{:noreply, state} + mapping = Enum.reduce(accounts, Map.new, fn({:account, _net, _chan, nick, account_id}, acc) -> + Map.put(acc, String.downcase(nick), account_id) + end) + spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [], [:"$_"]}] + Logger.debug("accounts:: mappings #{inspect mapping}") + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj = {nick, _date, _vol, _cur, _cl, _deg, _name, _comment, _meta}) -> + #Logger.debug("accounts:: item #{inspect(obj)}") + if new_id = Map.get(mapping, nick) do + Logger.debug("alcolog/accounts:: merging #{nick} -> #{new_id}") + rename_object_owner(table, state.ets, obj, nick, new_id) + end + end) + {:noreply, state} + end + + def handle_info({:account, _net, _chan, nick, account_id}, state) do + nick = String.downcase(nick) + spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, nick}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) -> + Logger.debug("alcoolog/account:: merging #{nick} -> #{account_id}") + rename_object_owner(table, state.ets, obj, nick, account_id) + end) + case :dets.lookup(state.meta, {:meta, nick}) do + [{_, meta}] -> + :dets.delete(state.meta, {:meta, nick}) + :dets.insert(state.meta, {{:meta, account_id}, meta}) + _ -> + :ok + end + {:noreply, state} + end + + def handle_info(t, state) do + Logger.debug("AlcoologPlugin: unhandled info #{inspect t}") + {:noreply, state} + end + + def nick_history(account) do + spec = [ + {{{:"$1", :_}, :_, :_, :_, :_, :_, :_, :_}, + [{:==, :"$1", {:const, account.id}}], + [:"$_"]} + ] + :ets.select(data_state().ets, spec) + end + + defp get_statistics_for_nick(state, account_id) do + qvc = :dets.lookup(state.dets, account_id) + |> Enum.sort_by(fn({_, ts, _, _, _, _, _, _, _}) -> ts end, &</2) + count = Enum.reduce(qvc, 0, fn({_nick, _ts, points, _active, _cl, _deg, _type, _descr, _meta}, acc) -> acc + (points||0) end) + last = List.last(qvc) || nil + {count, last} + end + + def present_type(type, descr) when descr in [nil, ""], do: "#{type}" + def present_type(type, description), do: "#{type} (#{description})" + + def format_points(int) when is_integer(int) and int > 0 do + "+#{Integer.to_string(int)}" + end + def format_points(int) when is_integer(int) and int < 0 do + Integer.to_string(int) + end + def format_points(int) when is_float(int) and int > 0 do + "+#{Float.to_string(Float.round(int,4))}" + end + def format_points(int) when is_float(int) and int < 0 do + Float.to_string(Float.round(int,4)) + end + def format_points(0), do: "0" + def format_points(0.0), do: "0" + + defp format_relative_timestamp(timestamp) do + alias Timex.Format.DateTime.Formatters + alias Timex.Timezone + date = timestamp + |> DateTime.from_unix!(:millisecond) + |> Timezone.convert("Europe/Paris") + + {:ok, relative} = Formatters.Relative.relative_to(date, Timex.now("Europe/Paris"), "{relative}", "fr") + {:ok, detail} = Formatters.Default.lformat(date, " ({h24}:{m})", "fr") + + relative <> detail + end + + defp put_user_meta(state, account_id, meta) do + :dets.insert(state.meta, {{:meta, account_id}, meta}) + :ok + end + + defp get_user_meta(%{meta: meta}, account_id) do + case :dets.lookup(meta, {:meta, account_id}) do + [{{:meta, _}, meta}] -> + Map.merge(@default_user_meta, meta) + _ -> + @default_user_meta + end + end + # Calcul g/l actuel: + # 1. load user meta + # 2. foldr ets + # for each object + # get_current_alcohol + # ((object g/l) - 0,15/l/60)* minutes_since_drink + # if minutes_since_drink < 10, reduce g/l (?!) + # acc + current_alcohol + # stop folding when ? + # + + def user_stats(account) do + user_stats(data_state(), account.id) + end + + defp user_stats(state = %{ets: ets}, account_id) do + meta = get_user_meta(state, account_id) + aday = (10 * 60)*60 + now = DateTime.utc_now() + before = now + |> DateTime.add(-aday, :second) + |> DateTime.to_unix(:millisecond) + #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end) + match = [ + {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, + [ + {:>, :"$2", {:const, before}}, + {:"=:=", {:const, account_id}, :"$1"} + ], [:"$_"]} + ] + # tuple ets: {{nick, date}, volumes, current, nom, commentaire} + drinks = :ets.select(ets, match) + # {date, single_peak} + total_volume = Enum.reduce(drinks, 0.0, fn({{_, date}, volume, _, _, _, _, _, _}, acc) -> + acc + volume + end) + k = if meta.sex, do: 0.7, else: 0.6 + weight = meta.weight + gl = (10*total_volume)/(k*weight) + {Float.round(total_volume + 0.0, 4), Float.round(gl + 0.0, 4)} + end + + defp alcohol_level_rising(state, account_id, minutes \\ 30) do + {now, _} = current_alcohol_level(state, account_id) + soon_date = DateTime.utc_now + |> DateTime.add(minutes*60, :second) + {soon, _} = current_alcohol_level(state, account_id, soon_date) + soon = cond do + soon < 0 -> 0.0 + true -> soon + end + #IO.puts "soon #{soon_date} - #{inspect soon} #{inspect now}" + {soon > now, Float.round(soon+0.0, 4)} + end + + defp current_alcohol_level(state = %{ets: ets}, account_id, now \\ nil) do + meta = get_user_meta(state, account_id) + aday = ((24*7) * 60)*60 + now = if now do + now + else + DateTime.utc_now() + end + before = now + |> DateTime.add(-aday, :second) + |> DateTime.to_unix(:millisecond) + #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end) + match = [ + {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_}, + [ + {:>, :"$2", {:const, before}}, + {:"=:=", {:const, account_id}, :"$1"} + ], [:"$_"]} + ] + # tuple ets: {{nick, date}, volumes, current, nom, commentaire} + drinks = :ets.select(ets, match) + |> Enum.sort_by(fn({{_, date}, _, _, _, _, _, _, _}) -> date end, &</2) + # {date, single_peak} + {all, last_drink_at, gl, active_drinks} = Enum.reduce(drinks, {0.0, nil, [], 0}, fn({{_, date}, volume, _, _, _, _, _, _}, {all, last_at, acc, active_drinks}) -> + k = if meta.sex, do: 0.7, else: 0.6 + weight = meta.weight + peak = (10*volume)/(k*weight) + date = case date do + ts when is_integer(ts) -> DateTime.from_unix!(ts, :millisecond) + date = %NaiveDateTime{} -> DateTime.from_naive!(date, "Etc/UTC") + date = %DateTime{} -> date + end + last_at = last_at || date + mins_since = round(DateTime.diff(now, date)/60.0) + #IO.puts "Drink: #{inspect({date, volume})} - mins since: #{inspect mins_since} - last drink at #{inspect last_at}" + # Apply loss since `last_at` on `all` + # + all = if last_at do + mins_since_last = round(DateTime.diff(date, last_at)/60.0) + loss = ((meta.loss_factor/100)/60)*(mins_since_last) + #IO.puts "Applying last drink loss: from #{all}, loss of #{inspect loss} (mins since #{inspect mins_since_first})" + cond do + (all-loss) > 0 -> all - loss + true -> 0.0 + end + else + all + end + #IO.puts "Applying last drink current before drink: #{inspect all}" + if mins_since < 30 do + per_min = (peak)/30.0 + current = (per_min*mins_since) + #IO.puts "Applying current drink 30m: from #{peak}, loss of #{inspect per_min}/min (mins since #{inspect mins_since})" + {all + current, date, [{date, current} | acc], active_drinks + 1} + else + {all + peak, date, [{date, peak} | acc], active_drinks} + end + end) + #IO.puts "last drink #{inspect last_drink_at}" + mins_since_last = if last_drink_at do + round(DateTime.diff(now, last_drink_at)/60.0) + else + 0 + end + # Si on a déjà bu y'a déjà moins 15 minutes (big up le binge drinking), on applique plus de perte + level = if mins_since_last > 15 do + loss = ((meta.loss_factor/100)/60)*(mins_since_last) + Float.round(all - loss, 4) + else + all + end + #IO.puts "\n LEVEL #{inspect level}\n\n\n\n" + cond do + level < 0 -> {0.0, 0} + true -> {level, active_drinks} + end + end + + defp format_duration_from_now(date, with_detail \\ true) do + date = if is_integer(date) do + date = DateTime.from_unix!(date, :millisecond) + |> Timex.Timezone.convert("Europe/Paris") + else + Util.to_naive_date_time(date) + end + now = DateTime.utc_now() + |> Timex.Timezone.convert("Europe/Paris") + {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(date, "({h24}:{m})", "fr") + + mins_since = round(DateTime.diff(now, date)/60.0) + if ago = format_minute_duration(mins_since) do + word = if mins_since > 0 do + "il y a " + else + "dans " + end + word <> ago <> if(with_detail, do: " #{detail}", else: "") + else + "maintenant #{detail}" + end + end + + defp format_minute_duration(minutes) do + sober_in_s = if (minutes != 0) do + duration = Timex.Duration.from_minutes(minutes) + Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized) + else + nil + end + end + +end diff --git a/lib/nola_plugins/alcoolog_announcer_plugin.ex b/lib/nola_plugins/alcoolog_announcer_plugin.ex new file mode 100644 index 0000000..f90dc42 --- /dev/null +++ b/lib/nola_plugins/alcoolog_announcer_plugin.ex @@ -0,0 +1,272 @@ +defmodule Nola.IRC.AlcoologAnnouncerPlugin do + require Logger + + @moduledoc """ + Annonce changements d'alcoolog + """ + + @channel "#dmz" + + @seconds 30 + + @apero [ + "C'EST L'HEURE DE L'APÉRRROOOOOOOO !!", + "SAAAAANNNNNNNTTTTTTTTAAAAAAAAIIIIIIIIIIIIIIIIIIIIII", + "APÉRO ? APÉRO !", + {:timed, ["/!\\ à vos tires bouchons…", "… débouchez …", "… BUVEZ! SANTAIII!"]}, + "/!\\ ALERTE APÉRO /!\\", + "CED !!! VASE DE ROUGE !", + "DIDI UN PETIT RICARD™??!", + "ALLEZ GUIGUI UNE PETITE BIERE ?", + {:timed, ["/!\\ à vos tires bouchons…", "… débouchez …", "… BUVEZ! SANTAIII!"]}, + "APPPPAIIIRRREAAUUUUUUUUUUU" + ] + + def irc_doc, do: nil + + def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__) + + def log(account) do + dets_filename = (Nola.data_path() <> "/" <> "alcoologlog.dets") |> String.to_charlist + {:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}]) + from = ~U[2020-08-23 19:41:40.524154Z] + to = ~U[2020-08-24 19:41:40.524154Z] + select = [ + {{:"$1", :"$2", :_}, + [ + {:andalso, + {:andalso, {:==, :"$1", {:const, account.id}}, + {:>, :"$2", {:const, DateTime.to_unix(from)}}}, + {:<, :"$2", {:const, DateTime.to_unix(to)}}} + ], [:"$_"]} + ] + res = :dets.select(dets, select) + :dets.close(dets) + res + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "account", []) + stats = get_stats() + Process.send_after(self(), :stats, :timer.seconds(30)) + dets_filename = (Nola.data_path() <> "/" <> "alcoologlog.dets") |> String.to_charlist + {:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}]) + ets = nil # :ets.new(__MODULE__.ETS, [:ordered_set, :named_table, :protected, {:read_concurrency, true}]) + #:ok = Nola.IRC.SettingPlugin.declare("alcoolog.alerts", __MODULE__, true, :boolean) + #:ok = Nola.IRC.SettingPlugin.declare("alcoolog.aperoalert", __MODULE__, true, :boolean) + # + {:ok, {stats, now(), dets, ets}}#, {:continue, :traverse}} + end + + def handle_continue(:traverse, state = {_, _, dets, ets}) do + traverse_fun = fn(obj, dets) -> + case obj do + {nick, %DateTime{} = dt, active} -> + :dets.delete_object(dets, obj) + :dets.insert(dets, {nick, DateTime.to_unix(dt), active}) + IO.puts("ok #{inspect obj}") + dets + {nick, ts, value} -> + :ets.insert(ets, { {nick, ts}, value }) + dets + end + end + :dets.foldl(traverse_fun, dets, dets) + :dets.sync(dets) + IO.puts("alcoolog announcer fixed") + {:noreply, state} + end + + def alcohol_reached(old, new, level) do + (old.active < level && new.active >= level) && (new.active5m >= level) + end + + def alcohol_below(old, new, level) do + (old.active > level && new.active <= level) && (new.active5m <= level) + end + + + def handle_info(:stats, {old_stats, old_now, dets, ets}) do + stats = get_stats() + now = now() + + if old_now.hour < 18 && now.hour == 18 do + apero = Enum.shuffle(@apero) + |> Enum.random() + + case apero do + {:timed, list} -> + spawn(fn() -> + for line <- list do + IRC.Connection.broadcast_message("evolu.net", "#dmz", line) + :timer.sleep(:timer.seconds(5)) + end + end) + string -> + IRC.Connection.broadcast_message("evolu.net", "#dmz", string) + end + + end + + #IO.puts "newstats #{inspect stats}" + events = for {acct, old} <- old_stats do + new = Map.get(stats, acct, nil) + #IO.puts "#{acct}: #{inspect(old)} -> #{inspect(new)}" + + now = DateTime.to_unix(DateTime.utc_now()) + if new && new[:active] do + :dets.insert(dets, {acct, now, new[:active]}) + :ets.insert(ets, {{acct, now}, new[:active]}) + else + :dets.insert(dets, {acct, now, 0.0}) + :ets.insert(ets, {{acct, now}, new[:active]}) + end + + event = cond do + old == nil -> nil + (old.active > 0) && (new == nil) -> :sober + new == nil -> nil + alcohol_reached(old, new, 0.5) -> :stopconduire + alcohol_reached(old, new, 1.0) -> :g1 + alcohol_reached(old, new, 2.0) -> :g2 + alcohol_reached(old, new, 3.0) -> :g3 + alcohol_reached(old, new, 4.0) -> :g4 + alcohol_reached(old, new, 5.0) -> :g5 + alcohol_reached(old, new, 6.0) -> :g6 + alcohol_reached(old, new, 7.0) -> :g7 + alcohol_reached(old, new, 10.0) -> :g10 + alcohol_reached(old, new, 13.74) -> :record + alcohol_below(old, new, 0.5) -> :conduire + alcohol_below(old, new, 1.0) -> :fini1g + alcohol_below(old, new, 2.0) -> :fini2g + alcohol_below(old, new, 3.0) -> :fini3g + alcohol_below(old, new, 4.0) -> :fini4g + (old.rising) && (!new.rising) -> :lowering + true -> nil + end + {acct, event} + end + + for {acct, event} <- events do + message = case event do + :g1 -> [ + "[vigicuite jaune] LE GRAMME! LE GRAMME O/", + "début de vigicuite jaune ! LE GRAMME ! \\O/", + "waiiiiiiii le grammmeee", + "bourraiiiiiiiiiiide 1 grammeeeeeeeeeee", + ] + :g2 -> [ + "[vigicuite orange] \\o_YAY 2 GRAMMES ! _o/", + "PAITAIIIIIIIIII DEUX GRAMMEESSSSSSSSSSSSSSSSS", + "bourrrrrraiiiiiiiiiiiiiiiide 2 grammeeeeeeeeeees", + ] + :g3 -> [ + "et un ! et deux ! et TROIS GRAMMEEESSSSSSS", + "[vigicuite rouge] _o/ BOURRAIIDDDEEEE 3 GRAMMESSSSSSSSS \\o/ \\o/" + ] + :g4 -> [ + "[vigicuite écarlate] et un, et deux, et trois, ET QUATRES GRAMMEESSSSSSSSSSSSSSSSSSSssssss" + ] + :g5 -> "[vigicuite écarlate+] PUTAIN 5 GRAMMES !" + :g6 -> "[vigicuite écarlate++] 6 grammes ? Vous pouvez joindre Alcool info service au 0 980 980 930" + :g7 -> "[vigicuite c'est la merde] 7 grammes. Le SAMU, c'est le 15." + :g10 -> "BORDLE 10 GRAMMES" + :record -> "RECORD DU MONDE BATTU ! >13.74g/l !!" + :fini1g -> [ + "fin d'alerte vigicuite jaune, passage en vert (<1g/l)", + "/!\\ alerte moins de 1g/l /!\\" + ] + :fini2g -> [ + "t'as moins de 2 g/l, faut se reprendre là [vigicuite jaune]" + ] + :fini3g -> [ + "fin d'alerte vigicuite rouge, passage en orange (<3g/l)" + ] + :fini4g -> [ + "fin d'alerte vigicuite écarlate, passage en rouge (<4g/l)" + ] + :lowering -> [ + "attention ça baisse!", + "tu vas quand même pas en rester là ?", + "IL FAUT CONTINUER À BOIRE !", + "t'abandonnes déjà ?", + "!santai ?", + "faut pas en rester là", + "il faut se resservir", + "coucou faut reboire", + "encore un petit verre ?", + "abwaaaaaaaaaaaaarrrrrrrrrrrrrr", + "taux d'alcoolémie en chute ! agissez avant qu'il soit trop tard!", + "ÇA BAISSE !!" + ] + :stopconduire -> [ + "0.5g! bientot le gramme?", + "tu peux plus prendre la route... mais... tu peux prendre la route du gramme! !santai !", + "fini la conduite!", + "0.5! continues faut pas en rester là!", + "beau début, continues !", + "ça monte! 0.5g/l!" + ] + :conduire -> [ + "tu peux conduire, ou recommencer à boire! niveau critique!", + "!santai ?", + "tu peux reprendre la route, ou reprendre la route du gramme..", + "attention, niveau critique!", + "il faut boire !!", + "trop de sang dans ton alcool, c'est mauvais pour la santé", + "faut pas en rester là !", + ] + :sober -> [ + "sobre…", + "/!\\ alerte sobriété /!\\", + "... sobre?!?!", + "sobre :(", + "attention, t'es sobre :/", + "danger, alcoolémie à 0.0 !", + "sobre! c'était bien on recommence quand ?", + "sobre ? Faut recommencer...", + "T'es sobre. Ne te laisses pas abattre- ton caviste peut aider.", + "Vous êtes sobre ? Ceci n'est pas une fatalité - resservez vous vite !" + ] + _ -> nil + end + message = case message do + m when is_binary(m) -> m + m when is_list(m) -> m |> Enum.shuffle() |> Enum.random() + nil -> nil + end + if message do + #IO.puts("#{acct}: #{message}") + account = IRC.Account.get(acct) + for {net, chan} <- IRC.Membership.notify_channels(account) do + user = IRC.UserTrack.find_by_account(net, account) + nick = if(user, do: user.nick, else: account.name) + IRC.Connection.broadcast_message(net, chan, "#{nick}: #{message}") + end + end + end + + timer() + + #IO.puts "tick stats ok" + {:noreply, {stats,now,dets,ets}} + end + + def handle_info(_, state) do + {:noreply, state} + end + + defp now() do + DateTime.utc_now() + |> Timex.Timezone.convert("Europe/Paris") + end + + defp get_stats() do + Enum.into(Nola.IRC.AlcoologPlugin.get_all_stats(), %{}) + end + + defp timer() do + Process.send_after(self(), :stats, :timer.seconds(@seconds)) + end + +end diff --git a/lib/nola_plugins/base_plugin.ex b/lib/nola_plugins/base_plugin.ex new file mode 100644 index 0000000..a2b9ffb --- /dev/null +++ b/lib/nola_plugins/base_plugin.ex @@ -0,0 +1,131 @@ +defmodule Nola.IRC.BasePlugin do + + def irc_doc, do: nil + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:version", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:help", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:liquidrender", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:plugin", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:plugins", regopts) + {:ok, nil} + end + + def handle_info({:irc, :trigger, "plugins", msg = %{trigger: %{type: :bang, args: []}}}, _) do + enabled_string = IRC.Plugin.enabled() + |> Enum.map(fn(mod) -> + mod + |> Macro.underscore() + |> String.split("/", parts: :infinity) + |> List.last() + |> String.replace("_plugin", "") + |> Enum.sort() + end) + |> Enum.join(", ") + msg.replyfun.("Enabled plugins: #{enabled_string}") + {:noreply, nil} + end + + def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :query, args: [plugin]}} = m}, _) do + module = Module.concat([Nola.IRC, Macro.camelize(plugin<>"_plugin")]) + with true <- Code.ensure_loaded?(module), + pid when is_pid(pid) <- GenServer.whereis(module) + do + m.replyfun.("loaded, active: #{inspect(pid)}") + else + false -> m.replyfun.("not loaded") + nil -> + msg = case IRC.Plugin.get(module) do + :disabled -> "disabled" + {_, false, _} -> "disabled" + _ -> "not active" + end + m.replyfun.(msg) + end + {:noreply, nil} + end + + def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :plus, args: [plugin]}} = m}, _) do + module = Module.concat([Nola.IRC, Macro.camelize(plugin<>"_plugin")]) + with true <- Code.ensure_loaded?(module), + IRC.Plugin.switch(module, true), + {:ok, pid} <- IRC.Plugin.start(module) + do + m.replyfun.("started: #{inspect(pid)}") + else + false -> m.replyfun.("not loaded") + :ignore -> m.replyfun.("disabled or throttled") + {:error, _} -> m.replyfun.("start error") + end + {:noreply, nil} + end + + def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :tilde, args: [plugin]}} = m}, _) do + module = Module.concat([Nola.IRC, Macro.camelize(plugin<>"_plugin")]) + with true <- Code.ensure_loaded?(module), + pid when is_pid(pid) <- GenServer.whereis(module), + :ok <- GenServer.stop(pid), + {:ok, pid} <- IRC.Plugin.start(module) + do + m.replyfun.("restarted: #{inspect(pid)}") + else + false -> m.replyfun.("not loaded") + nil -> m.replyfun.("not active") + end + {:noreply, nil} + end + + + def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :minus, args: [plugin]}} = m}, _) do + module = Module.concat([Nola.IRC, Macro.camelize(plugin<>"_plugin")]) + with true <- Code.ensure_loaded?(module), + pid when is_pid(pid) <- GenServer.whereis(module), + :ok <- GenServer.stop(pid) + do + IRC.Plugin.switch(module, false) + m.replyfun.("stopped: #{inspect(pid)}") + else + false -> m.replyfun.("not loaded") + nil -> m.replyfun.("not active") + end + {:noreply, nil} + end + + def handle_info({:irc, :trigger, "liquidrender", m = %{trigger: %{args: args}}}, _) do + template = Enum.join(args, " ") + m.replyfun.(Tmpl.render(template, m)) + {:noreply, nil} + end + + def handle_info({:irc, :trigger, "help", m = %{trigger: %{type: :bang}}}, _) do + url = 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() + message.replyfun.([ + <<"🤖 I am a robot running", 2, "beautte, version #{ver}", 2, " — source: #{Nola.source_url()}">>, + "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}", + "👷♀️ Owner: href <href@random.sh>", + "🌍 Web interface: #{url}" + ]) + {:noreply, nil} + end + + def handle_info(msg, _) do + {:noreply, nil} + end + +end diff --git a/lib/nola_plugins/bourosama_plugin.ex b/lib/nola_plugins/bourosama_plugin.ex new file mode 100644 index 0000000..dd05144 --- /dev/null +++ b/lib/nola_plugins/bourosama_plugin.ex @@ -0,0 +1,58 @@ +defmodule Nola.IRC.BoursoramaPlugin do + + def irc_doc() do + """ + # bourses + + Un peu comme [finance](#finance), mais en un peu mieux, et un peu moins bien. + + Source: [boursorama.com](https://boursorama.com) + + * **!caca40** affiche l'état du cac40 + """ + end + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @cac40_url "https://www.boursorama.com/bourse/actions/palmares/france/?france_filter%5Bmarket%5D=1rPCAC&france_filter%5Bsector%5D=&france_filter%5Bvariation%5D=50002&france_filter%5Bperiod%5D=1&france_filter%5Bfilter%5D=" + + def init(_) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:cac40", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:caca40", regopts) + {:ok, nil} + end + + def handle_info({:irc, :trigger, cac, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) when cac in ["cac40", "caca40"] do + case HTTPoison.get(@cac40_url, [], []) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + html = Floki.parse(body) + board = Floki.find(body, "div.c-tradingboard") + + cac40 = Floki.find(board, ".c-tradingboard__main > .c-tradingboard__infos") + instrument = Floki.find(cac40, ".c-instrument") + last = Floki.find(instrument, "span[data-ist-last]") + |> Floki.text() + |> String.replace(" ", "") + variation = Floki.find(instrument, "span[data-ist-variation]") + |> Floki.text() + + sign = case variation do + "-"<>_ -> "▼" + "+" -> "▲" + _ -> "" + end + + m.replyfun.("caca40: #{sign} #{variation} #{last}") + + {:error, %HTTPoison.Response{status_code: code}} -> + m.replyfun.("caca40: erreur http #{code}") + + _ -> + m.replyfun.("caca40: erreur http") + end + end + +end diff --git a/lib/nola_plugins/buffer_plugin.ex b/lib/nola_plugins/buffer_plugin.ex new file mode 100644 index 0000000..eece34e --- /dev/null +++ b/lib/nola_plugins/buffer_plugin.ex @@ -0,0 +1,44 @@ +defmodule Nola.IRC.BufferPlugin do + @table __MODULE__.ETS + def irc_doc, do: nil + + def table(), do: @table + + def select_buffer(network, channel, limit \\ 50) do + import Ex2ms + spec = fun do {{n, c, _}, m} when n == ^network and (c == ^channel or is_nil(c)) -> m end + :ets.select(@table, spec, limit) + end + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + for e <- ~w(messages triggers events outputs) do + {:ok, _} = Registry.register(IRC.PubSub, e, plugin: __MODULE__) + end + {:ok, :ets.new(@table, [:named_table, :ordered_set, :protected])} + end + + def handle_info({:irc, :trigger, _, message}, ets), do: handle_message(message, ets) + def handle_info({:irc, :text, message}, ets), do: handle_message(message, ets) + def handle_info({:irc, :event, event}, ets), do: handle_message(event, ets) + + defp handle_message(message = %{network: network}, ets) do + key = {network, Map.get(message, :channel), ts(message.at)} + :ets.insert(ets, {key, message}) + {:noreply, ets} + end + + defp ts(nil), do: ts(NaiveDateTime.utc_now()) + + defp ts(naive = %NaiveDateTime{}) do + ts = naive + |> DateTime.from_naive!("Etc/UTC") + |> DateTime.to_unix() + + -ts + end + +end diff --git a/lib/nola_plugins/calc_plugin.ex b/lib/nola_plugins/calc_plugin.ex new file mode 100644 index 0000000..264370c --- /dev/null +++ b/lib/nola_plugins/calc_plugin.ex @@ -0,0 +1,37 @@ +defmodule Nola.IRC.CalcPlugin do + @moduledoc """ + # calc + + * **!calc `<expression>`**: évalue l'expression mathématique `<expression>`. + """ + + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:calc", [plugin: __MODULE__]) + {:ok, nil} + end + + def handle_info({:irc, :trigger, "calc", message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: expr_list}}}, state) do + expr = Enum.join(expr_list, " ") + result = try do + case Abacus.eval(expr) do + {:ok, result} -> result + error -> inspect(error) + end + rescue + error -> if(error[:message], do: "#{error.message}", else: "erreur") + end + message.replyfun.("#{message.sender.nick}: #{expr} = #{result}") + {:noreply, state} + end + + def handle_info(msg, state) do + {:noreply, state} + end + +end diff --git a/lib/nola_plugins/coronavirus_plugin.ex b/lib/nola_plugins/coronavirus_plugin.ex new file mode 100644 index 0000000..d04d8f9 --- /dev/null +++ b/lib/nola_plugins/coronavirus_plugin.ex @@ -0,0 +1,172 @@ +defmodule Nola.IRC.CoronavirusPlugin do + require Logger + NimbleCSV.define(CovidCsv, separator: ",", escape: "\"") + @moduledoc """ + # Corona Virus + + Données de [Johns Hopkins University](https://github.com/CSSEGISandData/COVID-19) et mises à jour a peu près tous les jours. + + * `!coronavirus [France | Country]`: :-) + * `!coronavirus`: top 10 confirmés et non guéris + * `!coronavirus confirmés`: top 10 confirmés + * `!coronavirus morts`: top 10 morts + * `!coronavirus soignés`: top 10 soignés + """ + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:coronavirus", [plugin: __MODULE__]) + {:ok, nil, {:continue, :init}} + :ignore + end + + def handle_continue(:init, _) do + date = Date.add(Date.utc_today(), -2) + {data, _} = fetch_data(%{}, date) + {data, next} = fetch_data(data) + :timer.send_after(next, :update) + {:noreply, %{data: data}} + end + + def handle_info(:update, state) do + {data, next} = fetch_data(state.data) + :timer.send_after(next, :update) + {:noreply, %{data: data}} + end + + def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :bang, args: args}}}, state) when args in [ + [], ["morts"], ["confirmés"], ["soignés"], ["malades"], ["n"], ["nmorts"], ["nsoignés"], ["nconfirmés"]] do + {field, name} = case args do + ["confirmés"] -> {:confirmed, "confirmés"} + ["morts"] -> {:deaths, "morts"} + ["soignés"] -> {:recovered, "soignés"} + ["nmorts"] -> {:new_deaths, "nouveaux morts"} + ["nconfirmés"] -> {:new_confirmed, "nouveaux confirmés"} + ["n"] -> {:new_current, "nouveaux malades"} + ["nsoignés"] -> {:new_recovered, "nouveaux soignés"} + _ -> {:current, "malades"} + end + IO.puts("FIELD #{inspect field}") + field_evol = String.to_atom("new_#{field}") + sorted = state.data + |> Enum.filter(fn({_, %{region: region}}) -> region == true end) + |> Enum.map(fn({location, data}) -> {location, Map.get(data, field, 0), Map.get(data, field_evol, 0)} end) + |> Enum.sort_by(fn({_,count,_}) -> count end, &>=/2) + |> Enum.take(10) + |> Enum.with_index() + |> Enum.map(fn({{location, count, evol}, index}) -> + ev = if String.starts_with?(name, "nouveaux") do + "" + else + " (#{Util.plusminus(evol)})" + end + "##{index+1}: #{location} #{count}#{ev}" + end) + |> Enum.intersperse(" - ") + |> Enum.join() + m.replyfun.("CORONAVIRUS TOP10 #{name}: " <> sorted) + {:noreply, state} + end + + def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :bang, args: location}}}, state) do + location = Enum.join(location, " ") |> String.downcase() + if data = Map.get(state.data, location) do + m.replyfun.("coronavirus: #{location}: " + <> "#{data.current} malades (#{Util.plusminus(data.new_current)}), " + <> "#{data.confirmed} confirmés (#{Util.plusminus(data.new_confirmed)}), " + <> "#{data.deaths} morts (#{Util.plusminus(data.new_deaths)}), " + <> "#{data.recovered} soignés (#{Util.plusminus(data.new_recovered)}) (@ #{data.update})") + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, "coronavirus", m = %IRC.Message{trigger: %{type: :query, args: location}}}, state) do + m.replyfun.("https://github.com/CSSEGISandData/COVID-19") + {:noreply, state} + end + + # 1. Try to fetch data for today + # 2. Fetch yesterday if no results + defp fetch_data(current_data, date \\ nil) do + now = Date.utc_today() + url = fn(date) -> + "https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_daily_reports/#{date}.csv" + end + request_date = date || now + Logger.debug("Coronavirus check date: #{inspect request_date}") + {:ok, date_s} = Timex.format({request_date.year, request_date.month, request_date.day}, "%m-%d-%Y", :strftime) + cur_url = url.(date_s) + Logger.debug "Fetching URL #{cur_url}" + case HTTPoison.get(cur_url, [], follow_redirect: true) do + {:ok, %HTTPoison.Response{status_code: 200, body: csv}} -> + # Parse CSV update data + data = csv + |> CovidCsv.parse_string() + |> Enum.reduce(%{}, fn(line, acc) -> + case line do + # FIPS,Admin2,Province_State,Country_Region,Last_Update,Lat,Long_,Confirmed,Deaths,Recovered,Active,Combined_Key + #0FIPS,Admin2,Province_State,Country_Region,Last_Update,Lat,Long_,Confirmed,Deaths,Recovered,Active,Combined_Key,Incidence_Rate,Case-Fatality_Ratio + [_, _, state, region, update, _lat, _lng, confirmed, deaths, recovered, _active, _combined_key, _incidence_rate, _fatality_ratio] -> + state = String.downcase(state) + region = String.downcase(region) + confirmed = String.to_integer(confirmed) + deaths = String.to_integer(deaths) + recovered = String.to_integer(recovered) + + current = (confirmed - recovered) - deaths + + entry = %{update: update, confirmed: confirmed, deaths: deaths, recovered: recovered, current: current, region: region} + + region_entry = Map.get(acc, region, %{update: nil, confirmed: 0, deaths: 0, recovered: 0, current: 0}) + region_entry = %{ + update: region_entry.update || update, + confirmed: region_entry.confirmed + confirmed, + deaths: region_entry.deaths + deaths, + current: region_entry.current + current, + recovered: region_entry.recovered + recovered, + region: true + } + + changes = if old = Map.get(current_data, region) do + %{ + new_confirmed: region_entry.confirmed - old.confirmed, + new_current: region_entry.current - old.current, + new_deaths: region_entry.deaths - old.deaths, + new_recovered: region_entry.recovered - old.recovered, + } + else + %{new_confirmed: 0, new_current: 0, new_deaths: 0, new_recovered: 0} + end + + region_entry = Map.merge(region_entry, changes) + + acc = Map.put(acc, region, region_entry) + + acc = if state && state != "" do + Map.put(acc, state, entry) + else + acc + end + + other -> + Logger.info("Coronavirus line failed: #{inspect line}") + acc + end + end) + Logger.info "Updated coronavirus database" + {data, :timer.minutes(60)} + {:ok, %HTTPoison.Response{status_code: 404}} -> + Logger.debug "Corona 404 #{cur_url}" + date = Date.add(date || now, -1) + fetch_data(current_data, date) + other -> + Logger.error "Coronavirus: Update failed #{inspect other}" + {current_data, :timer.minutes(5)} + end + end + +end diff --git a/lib/nola_plugins/correction_plugin.ex b/lib/nola_plugins/correction_plugin.ex new file mode 100644 index 0000000..5f9b278 --- /dev/null +++ b/lib/nola_plugins/correction_plugin.ex @@ -0,0 +1,59 @@ +defmodule Nola.IRC.CorrectionPlugin do + @moduledoc """ + # correction + + * `s/pattern/replace` replace `pattern` by `replace` in the last matching message + """ + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "messages", [plugin: __MODULE__]) + {:ok, _} = Registry.register(IRC.PubSub, "triggers", [plugin: __MODULE__]) + {:ok, %{}} + end + + # Trigger fallback + def handle_info({:irc, :trigger, _, m = %IRC.Message{}}, state) do + {:noreply, correction(m, state)} + end + + def handle_info({:irc, :text, m = %IRC.Message{}}, state) do + {:noreply, correction(m, state)} + end + + def correction(m, state) do + history = Map.get(state, key(m), []) + if String.starts_with?(m.text, "s/") do + case String.split(m.text, "/") do + ["s", match, replace | _] -> + case Regex.compile(match) do + {:ok, reg} -> + repl = Enum.find(history, fn(m) -> Regex.match?(reg, m.text) end) + if repl do + new_text = String.replace(repl.text, reg, replace) + m.replyfun.("correction: <#{repl.sender.nick}> #{new_text}") + end + _ -> + m.replyfun.("correction: invalid regex") + end + _ -> m.replyfun.("correction: invalid regex format") + end + state + else + history = if length(history) > 100 do + {_, history} = List.pop_at(history, 99) + [m | history] + else + [m | history] + end + Map.put(state, key(m), history) + end + end + + defp key(%{network: net, channel: chan}), do: "#{net}/#{chan}" + +end diff --git a/lib/nola_plugins/dice_plugin.ex b/lib/nola_plugins/dice_plugin.ex new file mode 100644 index 0000000..b5e7649 --- /dev/null +++ b/lib/nola_plugins/dice_plugin.ex @@ -0,0 +1,66 @@ +defmodule Nola.IRC.DicePlugin do + require Logger + + @moduledoc """ + # dice + + * **!dice `[1 | lancés]` `[6 | faces]`**: lance une ou plusieurs fois un dé de 6 ou autre faces + """ + + @default_faces 6 + @default_rolls 1 + @max_rolls 50 + + def short_irc_doc, do: "!dice (jeter un dé)" + defstruct client: nil, dets: nil + + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:dice", [plugin: __MODULE__]) + {:ok, %__MODULE__{}} + end + + def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: args}}}, state) do + to_integer = fn(string, default) -> + case Integer.parse(string) do + {int, _} -> int + _ -> default + end + end + + {rolls, faces} = case args do + [] -> {@default_rolls, @default_faces} + [faces, rolls] -> {to_integer.(rolls, @default_rolls), to_integer.(faces, @default_faces)} + [rolls] -> {to_integer.(rolls, @default_rolls), @default_faces} + end + + roll(state, message, faces, rolls) + + {:noreply, state} + end + + def handle_info(info, state) do + {:noreply, state} + end + + defp roll(state, message, faces, 1) when faces > 0 do + random = :crypto.rand_uniform(1, faces+1) + message.replyfun.("#{message.sender.nick} dice: #{random}") + end + defp roll(state, message, faces, rolls) when faces > 0 and rolls > 0 and rolls <= @max_rolls do + {results, acc} = Enum.map_reduce(Range.new(1, rolls), 0, fn(i, acc) -> + random = :crypto.rand_uniform(1, faces+1) + {random, acc + random} + end) + results = Enum.join(results, "; ") + message.replyfun.("#{message.sender.nick} dice: [#{acc}] #{results}") + end + + defp roll(_, _, _, _, _), do: nil + +end diff --git a/lib/nola_plugins/finance_plugin.ex b/lib/nola_plugins/finance_plugin.ex new file mode 100644 index 0000000..16d06ee --- /dev/null +++ b/lib/nola_plugins/finance_plugin.ex @@ -0,0 +1,190 @@ +defmodule Nola.IRC.FinancePlugin do + require Logger + + @moduledoc """ + # finance + + Données de [alphavantage.co](https://alphavantage.co). + + ## forex / monnaies / crypto-monnaies + + * **`!forex <MONNAIE1> [MONNAIE2]`**: taux de change entre deux monnaies. + * **`!forex <MONTANT> <MONNAIE1> <MONNAIE2>`**: converti `montant` entre deux monnaies + * **`?currency <recherche>`**: recherche une monnaie + + Utiliser le symbole des monnaies (EUR, USD, ...). + + ## bourses + + * **`!stocks <SYMBOLE>`** + * **`?stocks <recherche>`** cherche un symbole + + Pour les symboles non-US, ajouter le suffixe (RNO Paris: RNO.PAR). + + """ + + @currency_list "http://www.alphavantage.co/physical_currency_list/" + @crypto_list "http://www.alphavantage.co/digital_currency_list/" + + HTTPoison.start() + load_currency = fn(url) -> + resp = HTTPoison.get!(url) + resp.body + |> String.strip() + |> String.split("\n") + |> Enum.drop(1) + |> Enum.map(fn(line) -> + [symbol, name] = line + |> String.strip() + |> String.split(",", parts: 2) + {symbol, name} + end) + |> Enum.into(Map.new) + end + fiat = load_currency.(@currency_list) + crypto = load_currency.(@crypto_list) + @currencies Map.merge(fiat, crypto) + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:forex", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:currency", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:stocks", regopts) + {:ok, nil} + end + + + def handle_info({:irc, :trigger, "stocks", message = %{trigger: %{type: :query, args: args = search}}}, state) do + search = Enum.join(search, "%20") + url = "https://www.alphavantage.co/query?function=SYMBOL_SEARCH&keywords=#{search}&apikey=#{api_key()}" + case HTTPoison.get(url) do + {:ok, %HTTPoison.Response{status_code: 200, body: data}} -> + data = Poison.decode!(data) + if error = Map.get(data, "Error Message") do + Logger.error("AlphaVantage API invalid request #{url} - #{inspect error}") + message.replyfun.("stocks: requête invalide") + else + items = for item <- Map.get(data, "bestMatches") do + symbol = Map.get(item, "1. symbol") + name = Map.get(item, "2. name") + type = Map.get(item, "3. type") + region = Map.get(item, "4. region") + currency = Map.get(item, "8. currency") + "#{symbol}: #{name} (#{region}; #{currency}; #{type})" + end + |> Enum.join(", ") + items = if items == "" do + "no results!" + else + items + end + message.replyfun.(items) + end + {:ok, resp = %HTTPoison.Response{status_code: code}} -> + Logger.error "AlphaVantage API error: #{code} #{url} - #{inspect resp}" + message.replyfun.("forex: erreur (api #{code})") + {:error, %HTTPoison.Error{reason: error}} -> + Logger.error "AlphaVantage HTTP error: #{inspect error}" + message.replyfun.("forex: erreur (http #{inspect error})") + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, "stocks", message = %{trigger: %{type: :bang, args: args = [symbol]}}}, state) do + url = "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=#{symbol}&apikey=#{api_key()}" + case HTTPoison.get(url) do + {:ok, %HTTPoison.Response{status_code: 200, body: data}} -> + data = Poison.decode!(data) + if error = Map.get(data, "Error Message") do + Logger.error("AlphaVantage API invalid request #{url} - #{inspect error}") + message.replyfun.("stocks: requête invalide") + else + data = Map.get(data, "Global Quote") + open = Map.get(data, "02. open") + high = Map.get(data, "03. high") + low = Map.get(data, "04. low") + price = Map.get(data, "05. price") + volume = Map.get(data, "06. volume") + prev_close = Map.get(data, "08. previous close") + change = Map.get(data, "09. change") + change_pct = Map.get(data, "10. change percent") + + msg = "#{symbol}: #{price} #{change} [#{change_pct}] (high: #{high}, low: #{low}, open: #{open}, prev close: #{prev_close}) (volume: #{volume})" + message.replyfun.(msg) + end + {:ok, resp = %HTTPoison.Response{status_code: code}} -> + Logger.error "AlphaVantage API error: #{code} #{url} - #{inspect resp}" + message.replyfun.("stocks: erreur (api #{code})") + {:error, %HTTPoison.Error{reason: error}} -> + Logger.error "AlphaVantage HTTP error: #{inspect error}" + message.replyfun.("stocks: erreur (http #{inspect error})") + end + {:noreply, state} + end + + + def handle_info({:irc, :trigger, "forex", message = %{trigger: %{type: :bang, args: args = [_ | _]}}}, state) do + {amount, from, to} = case args do + [amount, from, to] -> + {amount, _} = Float.parse(amount) + {amount, from, to} + [from, to] -> + {1, from, to} + [from] -> + {1, from, "EUR"} + end + url = "https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency=#{from}&to_currency=#{to}&apikey=#{api_key()}" + case HTTPoison.get(url) do + {:ok, %HTTPoison.Response{status_code: 200, body: data}} -> + data = Poison.decode!(data) + if error = Map.get(data, "Error Message") do + Logger.error("AlphaVantage API invalid request #{url} - #{inspect error}") + message.replyfun.("forex: requête invalide") + else + data = Map.get(data, "Realtime Currency Exchange Rate") + from_name = Map.get(data, "2. From_Currency Name") + to_name = Map.get(data, "4. To_Currency Name") + rate = Map.get(data, "5. Exchange Rate") + {rate, _} = Float.parse(rate) + value = amount*rate + message.replyfun.("#{amount} #{from} (#{from_name}) -> #{value} #{to} (#{to_name}) (#{rate})") + end + {:ok, resp = %HTTPoison.Response{status_code: code}} -> + Logger.error "AlphaVantage API error: #{code} #{url} - #{inspect resp}" + message.replyfun.("forex: erreur (api #{code})") + {:error, %HTTPoison.Error{reason: error}} -> + Logger.error "AlphaVantage HTTP error: #{inspect error}" + message.replyfun.("forex: erreur (http #{inspect error})") + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, "currency", message = %{trigger: %{type: :query, args: args = search}}}, state) do + search = Enum.join(search, " ") + results = Enum.filter(@currencies, fn({symbol, name}) -> + String.contains?(String.downcase(name), String.downcase(search)) || String.contains?(String.downcase(symbol), String.downcase(search)) + end) + |> Enum.map(fn({symbol, name}) -> + "#{symbol}: #{name}" + end) + |> Enum.join(", ") + + if results == "" do + message.replyfun.("no results!") + else + message.replyfun.(results) + end + {:noreply, state} + end + + defp api_key() do + Application.get_env(:nola, :alphavantage, []) + |> Keyword.get(:api_key, "demo") + end + +end diff --git a/lib/nola_plugins/gpt_plugin.ex b/lib/nola_plugins/gpt_plugin.ex new file mode 100644 index 0000000..2c8f182 --- /dev/null +++ b/lib/nola_plugins/gpt_plugin.ex @@ -0,0 +1,259 @@ +defmodule Nola.IRC.GptPlugin do + require Logger + import Irc.Plugin.TempRef + + def irc_doc() do + """ + # OpenAI GPT + + Uses OpenAI's GPT-3 API to bring natural language prompts to your IRC channel. + + _prompts_ are pre-defined prompts and parameters defined in the bot' CouchDB. + + _Runs_ (results of the inference of a _prompt_) are also stored in CouchDB and + may be resumed. + + * **!gpt** list GPT prompts + * **!gpt `[prompt]` `<prompt or args>`** run a prompt + * **+gpt `[short ref|run id]` `<prompt or args>`** continue a prompt + * **?gpt offensive `<content>`** is content offensive ? + * **?gpt show `[short ref|run id]`** run information and web link + * **?gpt `[prompt]`** prompt information and web link + """ + end + + @couch_db "bot-plugin-openai-prompts" + @couch_run_db "bot-plugin-gpt-history" + @trigger "gpt" + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + defstruct [:temprefs] + + def get_result(id) do + Couch.get(@couch_run_db, id) + end + + def get_prompt(id) do + Couch.get(@couch_db, id) + end + + def init(_) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:#{@trigger}", regopts) + {:ok, %__MODULE__{temprefs: new_temp_refs()}} + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [prompt | args]}}}, state) do + case Couch.get(@couch_db, prompt) do + {:ok, prompt} -> {:noreply, prompt(m, prompt, Enum.join(args, " "), state)} + {:error, :not_found} -> + m.replyfun.("gpt: prompt '#{prompt}' does not exists") + {:noreply, state} + error -> + Logger.info("gpt: prompt load error: #{inspect error}") + m.replyfun.("gpt: database error") + {:noreply, state} + end + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do + case Couch.get(@couch_db, "_all_docs") do + {:ok, %{"rows" => []}} -> m.replyfun.("gpt: no prompts available") + {:ok, %{"rows" => prompts}} -> + prompts = prompts |> Enum.map(fn(prompt) -> Map.get(prompt, "id") end) |> Enum.join(", ") + m.replyfun.("gpt: prompts: #{prompts}") + error -> + Logger.info("gpt: prompt load error: #{inspect error}") + m.replyfun.("gpt: database error") + end + {:noreply, state} + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :plus, args: [ref_or_id | args]}}}, state) do + id = lookup_temp_ref(ref_or_id, state.temprefs, ref_or_id) + case Couch.get(@couch_run_db, id) do + {:ok, run} -> + Logger.debug("+gpt run: #{inspect run}") + {:noreply, continue_prompt(m, run, Enum.join(args, " "), state)} + {:error, :not_found} -> + m.replyfun.("gpt: ref or id not found or expired: #{inspect ref_or_id} (if using short ref, try using full id)") + {:noreply, state} + error -> + Logger.info("+gpt: run load error: #{inspect error}") + m.replyfun.("gpt: database error") + {:noreply, state} + end + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: ["offensive" | text]}}}, state) do + text = Enum.join(text, " ") + {moderate?, moderation} = moderation(text, m.account.id) + reply = cond do + moderate? -> "⚠️ #{Enum.join(moderation, ", ")}" + !moderate? && moderation -> "👍" + !moderate? -> "☠️ error" + end + m.replyfun.(reply) + {:noreply, state} + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: ["show", ref_or_id]}}}, state) do + id = lookup_temp_ref(ref_or_id, state.temprefs, ref_or_id) + url = if m.channel do + NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :result, m.network, NolaWeb.format_chan(m.channel), id) + else + NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :result, id) + end + m.replyfun.("→ #{url}") + {:noreply, state} + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :query, args: [prompt]}}}, state) do + url = if m.channel do + NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :prompt, m.network, NolaWeb.format_chan(m.channel), prompt) + else + NolaWeb.Router.Helpers.gpt_url(NolaWeb.Endpoint, :prompt, prompt) + end + m.replyfun.("→ #{url}") + {:noreply, state} + end + + def handle_info(info, state) do + Logger.debug("gpt: unhandled info: #{inspect info}") + {:noreply, state} + end + + defp continue_prompt(msg, run, content, state) do + prompt_id = Map.get(run, "prompt_id") + prompt_rev = Map.get(run, "prompt_rev") + + original_prompt = case Couch.get(@couch_db, prompt_id, rev: prompt_rev) do + {:ok, prompt} -> prompt + _ -> nil + end + + if original_prompt do + continue_prompt = %{"_id" => prompt_id, + "_rev" => prompt_rev, + "type" => Map.get(original_prompt, "type"), + "parent_run_id" => Map.get(run, "_id"), + "openai_params" => Map.get(run, "request") |> Map.delete("prompt")} + + continue_prompt = if prompt_string = Map.get(original_prompt, "continue_prompt") do + full_text = get_in(run, ~w(request prompt)) <> "\n" <> Map.get(run, "response") + continue_prompt + |> Map.put("prompt", prompt_string) + |> Map.put("prompt_format", "liquid") + |> Map.put("prompt_liquid_variables", %{"previous" => full_text}) + else + prompt_content_tag = if content != "", do: " {{content}}", else: "" + string = get_in(run, ~w(request prompt)) <> "\n" <> Map.get(run, "response") <> prompt_content_tag + continue_prompt + |> Map.put("prompt", string) + |> Map.put("prompt_format", "liquid") + end + + prompt(msg, continue_prompt, content, state) + else + msg.replyfun.("gpt: cannot continue this prompt: original prompt not found #{prompt_id}@v#{prompt_rev}") + state + end + end + + defp prompt(msg, prompt = %{"type" => "completions", "prompt" => prompt_template}, content, state) do + Logger.debug("gpt_plugin:prompt/4 #{inspect prompt}") + prompt_text = case Map.get(prompt, "prompt_format", "liquid") do + "liquid" -> Tmpl.render(prompt_template, msg, Map.merge(Map.get(prompt, "prompt_liquid_variables", %{}), %{"content" => content})) + "norender" -> prompt_template + end + + args = Map.get(prompt, "openai_params") + |> Map.put("prompt", prompt_text) + |> Map.put("user", msg.account.id) + + {moderate?, moderation} = moderation(content, msg.account.id) + if moderate?, do: msg.replyfun.("⚠️ offensive input: #{Enum.join(moderation, ", ")}") + + Logger.debug("GPT: request #{inspect args}") + case OpenAi.post("/v1/completions", args) do + {:ok, %{"choices" => [%{"text" => text, "finish_reason" => finish_reason} | _], "usage" => usage, "id" => gpt_id, "created" => created}} -> + text = String.trim(text) + {o_moderate?, o_moderation} = moderation(text, msg.account.id) + if o_moderate?, do: msg.replyfun.("🚨 offensive output: #{Enum.join(o_moderation, ", ")}") + msg.replyfun.(text) + doc = %{"id" => FlakeId.get(), + "prompt_id" => Map.get(prompt, "_id"), + "prompt_rev" => Map.get(prompt, "_rev"), + "network" => msg.network, + "channel" => msg.channel, + "nick" => msg.sender.nick, + "account_id" => (if msg.account, do: msg.account.id), + "request" => args, + "response" => text, + "message_at" => msg.at, + "reply_at" => DateTime.utc_now(), + "gpt_id" => gpt_id, + "gpt_at" => created, + "gpt_usage" => usage, + "type" => "completions", + "parent_run_id" => Map.get(prompt, "parent_run_id"), + "moderation" => %{"input" => %{flagged: moderate?, categories: moderation}, + "output" => %{flagged: o_moderate?, categories: o_moderation} + } + } + Logger.debug("Saving result to couch: #{inspect doc}") + {id, ref, temprefs} = case Couch.post(@couch_run_db, doc) do + {:ok, id, _rev} -> + {ref, temprefs} = put_temp_ref(id, state.temprefs) + {id, ref, temprefs} + error -> + Logger.error("Failed to save to Couch: #{inspect error}") + {nil, nil, state.temprefs} + end + stop = cond do + finish_reason == "stop" -> "" + finish_reason == "length" -> " — truncated" + true -> " — #{finish_reason}" + end + ref_and_prefix = if Map.get(usage, "completion_tokens", 0) == 0 do + "GPT had nothing else to say :( ↪ #{ref || "✗"}" + else + " ↪ #{ref || "✗"}" + end + msg.replyfun.(ref_and_prefix <> + stop <> + " — #{Map.get(usage, "total_tokens", 0)}" <> + " (#{Map.get(usage, "prompt_tokens", 0)}/#{Map.get(usage, "completion_tokens", 0)}) tokens" <> + " — #{id || "save failed"}") + %__MODULE__{state | temprefs: temprefs} + {:error, atom} when is_atom(atom) -> + Logger.error("gpt error: #{inspect atom}") + msg.replyfun.("gpt: ☠️ #{to_string(atom)}") + state + error -> + Logger.error("gpt error: #{inspect error}") + msg.replyfun.("gpt: ☠️ ") + state + end + end + + defp moderation(content, user_id) do + case OpenAi.post("/v1/moderations", %{"input" => content, "user" => user_id}) do + {:ok, %{"results" => [%{"flagged" => true, "categories" => categories} | _]}} -> + cat = categories + |> Enum.filter(fn({_key, value}) -> value end) + |> Enum.map(fn({key, _}) -> key end) + {true, cat} + {:ok, moderation} -> + Logger.debug("gpt: moderation: not flagged, #{inspect moderation}") + {false, true} + error -> + Logger.error("gpt: moderation error: #{inspect error}") + {false, false} + end + end + +end diff --git a/lib/nola_plugins/kick_roulette_plugin.ex b/lib/nola_plugins/kick_roulette_plugin.ex new file mode 100644 index 0000000..55b7da4 --- /dev/null +++ b/lib/nola_plugins/kick_roulette_plugin.ex @@ -0,0 +1,32 @@ +defmodule Nola.IRC.KickRoulettePlugin do + @moduledoc """ + # kick roulette + + * **!kick**, tentez votre chance… + """ + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:kick", [plugin: __MODULE__]) + {:ok, nil} + end + + def handle_info({:irc, :trigger, "kick", message = %{trigger: %{type: :bang, args: []}}}, _) do + if 5 == :crypto.rand_uniform(1, 6) do + spawn(fn() -> + :timer.sleep(:crypto.rand_uniform(200, 10_000)) + message.replyfun.({:kick, message.sender.nick, "perdu"}) + end) + end + {:noreply, nil} + end + + def handle_info(msg, _) do + {:noreply, nil} + end + +end diff --git a/lib/nola_plugins/last_fm_plugin.ex b/lib/nola_plugins/last_fm_plugin.ex new file mode 100644 index 0000000..03df675 --- /dev/null +++ b/lib/nola_plugins/last_fm_plugin.ex @@ -0,0 +1,187 @@ +defmodule Nola.IRC.LastFmPlugin 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(IRC.PubSub, t, type: __MODULE__) + 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 = IRC.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 = IRC.Account.get(nick_or_user) || IRC.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 = IRC.Account.get(id_or_user) do + user = IRC.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/nola_plugins/link_plugin.ex b/lib/nola_plugins/link_plugin.ex new file mode 100644 index 0000000..dee78e8 --- /dev/null +++ b/lib/nola_plugins/link_plugin.ex @@ -0,0 +1,271 @@ +defmodule Nola.IRC.LinkPlugin do + @moduledoc """ + # Link Previewer + + An extensible link previewer for IRC. + + To extend the supported sites, create a new handler implementing the callbacks. + + See `link_plugin/` directory for examples. The first in list handler that returns true to the `match/2` callback will be used, + and if the handler returns `:error` or crashes, will fallback to the default preview. + + Unsupported websites will use the default link preview method, which is for html document the title, otherwise it'll use + the mimetype and size. + + ## Configuration: + + ``` + config :nola, Nola.IRC.LinkPlugin, + handlers: [ + Nola.IRC.LinkPlugin.Youtube: [ + invidious: true + ], + Nola.IRC.LinkPlugin.Twitter: [], + Nola.IRC.LinkPlugin.Imgur: [], + ] + ``` + + """ + + @ircdoc """ + # Link preview + + Previews links (just post a link!). + + Announces real URL after redirections and provides extended support for YouTube, Twitter and Imgur. + """ + def short_irc_doc, do: false + def irc_doc, do: @ircdoc + require Logger + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @callback match(uri :: URI.t, options :: Keyword.t) :: {true, params :: Map.t} | false + @callback expand(uri :: URI.t, params :: Map.t, options :: Keyword.t) :: {:ok, lines :: [] | String.t} | :error + @callback post_match(uri :: URI.t, content_type :: binary, headers :: [], opts :: Keyword.t) :: {:body | :file, params :: Map.t} | false + @callback post_expand(uri :: URI.t, body :: binary() | Path.t, params :: Map.t, options :: Keyword.t) :: {:ok, lines :: [] | String.t} | :error + + @optional_callbacks [expand: 3, post_expand: 4] + + defstruct [:client] + + def init([]) do + {:ok, _} = Registry.register(IRC.PubSub, "messages", [plugin: __MODULE__]) + #{:ok, _} = Registry.register(IRC.PubSub, "messages:telegram", [plugin: __MODULE__]) + Logger.info("Link handler started") + {:ok, %__MODULE__{}} + end + + def handle_info({:irc, :text, message = %{text: text}}, state) do + String.split(text) + |> Enum.map(fn(word) -> + if String.starts_with?(word, "http://") || String.starts_with?(word, "https://") do + uri = URI.parse(word) + if uri.scheme && uri.host do + spawn(fn() -> + :timer.kill_after(:timer.seconds(30)) + case expand_link([uri]) do + {:ok, uris, text} -> + text = case uris do + [uri] -> text + [luri | _] -> + if luri.host == uri.host && luri.path == luri.path do + text + else + ["-> #{URI.to_string(luri)}", text] + end + end + if is_list(text) do + for line <- text, do: message.replyfun.(line) + else + message.replyfun.(text) + end + _ -> nil + end + end) + end + end + end) + {:noreply, state} + end + + def handle_info(msg, state) do + {:noreply, state} + end + + def terminate(_reason, state) do + :ok + end + + # 1. Match the first valid handler + # 2. Try to run the handler + # 3. If :error or crash, default link. + # If :skip, nothing + # 4. ? + + # Over five redirections: cancel. + def expand_link(acc = [_, _, _, _, _ | _]) do + {:ok, acc, "link redirects more than five times"} + end + + def expand_link(acc=[uri | _]) do + Logger.debug("link: expanding: #{inspect uri}") + handlers = Keyword.get(Application.get_env(:nola, __MODULE__, [handlers: []]), :handlers) + handler = Enum.reduce_while(handlers, nil, fn({module, opts}, acc) -> + Logger.debug("link: attempt expanding: #{inspect module} for #{inspect uri}") + module = Module.concat([module]) + case module.match(uri, opts) do + {true, params} -> {:halt, {module, params, opts}} + false -> {:cont, acc} + end + end) + run_expand(acc, handler) + end + + def run_expand(acc, nil) do + expand_default(acc) + end + + def run_expand(acc=[uri|_], {module, params, opts}) do + Logger.debug("link: expanding #{inspect uri} with #{inspect module}") + case module.expand(uri, params, opts) do + {:ok, data} -> {:ok, acc, data} + :error -> expand_default(acc) + :skip -> nil + end + rescue + e -> + Logger.error("link: rescued #{inspect uri} with #{inspect module}: #{inspect e}") + Logger.error(Exception.format(:error, e, __STACKTRACE__)) + expand_default(acc) + catch + e, b -> + Logger.error("link: catched #{inspect uri} with #{inspect module}: #{inspect {e, b}}") + expand_default(acc) + end + + defp get(url, headers \\ [], options \\ []) do + get_req(url, :hackney.get(url, headers, <<>>, options)) + end + + defp get_req(_, {:error, reason}) do + {:error, reason} + end + + defp get_req(url, {:ok, 200, headers, client}) do + headers = Enum.reduce(headers, %{}, fn({key, value}, acc) -> + Map.put(acc, String.downcase(key), value) + end) + content_type = Map.get(headers, "content-type", "application/octect-stream") + length = Map.get(headers, "content-length", "0") + {length, _} = Integer.parse(length) + + handlers = Keyword.get(Application.get_env(:nola, __MODULE__, [handlers: []]), :handlers) + handler = Enum.reduce_while(handlers, false, fn({module, opts}, acc) -> + module = Module.concat([module]) + try do + case module.post_match(url, content_type, headers, opts) do + {mode, params} when mode in [:body, :file] -> {:halt, {module, params, opts, mode}} + false -> {:cont, acc} + end + rescue + e -> + Logger.error(inspect(e)) + {:cont, false} + catch + e, b -> + Logger.error(inspect({b})) + {:cont, false} + end + end) + + cond do + handler != false and length <= 30_000_000 -> + case get_body(url, 30_000_000, client, handler, <<>>) do + {:ok, _} = ok -> ok + :error -> + {:ok, "file: #{content_type}, size: #{human_size(length)}"} + end + #String.starts_with?(content_type, "text/html") && length <= 30_000_000 -> + # get_body(url, 30_000_000, client, <<>>) + true -> + :hackney.close(client) + {:ok, "file: #{content_type}, size: #{human_size(length)}"} + end + end + + defp get_req(_, {:ok, redirect, headers, client}) when redirect in 300..399 do + headers = Enum.reduce(headers, %{}, fn({key, value}, acc) -> + Map.put(acc, String.downcase(key), value) + end) + location = Map.get(headers, "location") + + :hackney.close(client) + {:redirect, location} + end + + defp get_req(_, {:ok, status, headers, client}) do + :hackney.close(client) + {:error, status, headers} + end + + defp get_body(url, len, client, {handler, params, opts, mode} = h, acc) when len >= byte_size(acc) do + case :hackney.stream_body(client) do + {:ok, data} -> + get_body(url, len, client, h, << acc::binary, data::binary >>) + :done -> + body = case mode do + :body -> acc + :file -> + {:ok, tmpfile} = Plug.Upload.random_file("linkplugin") + File.write!(tmpfile, acc) + tmpfile + end + handler.post_expand(url, body, params, opts) + {:error, reason} -> + {:ok, "failed to fetch body: #{inspect reason}"} + end + end + + defp get_body(_, len, client, h, _acc) do + :hackney.close(client) + IO.inspect(h) + {:ok, "Error: file over 30"} + end + + def expand_default(acc = [uri = %URI{scheme: scheme} | _]) when scheme in ["http", "https"] do + Logger.debug("link: expanding #{uri} with default") + headers = [{"user-agent", "DmzBot (like TwitterBot)"}] + options = [follow_redirect: false, max_body_length: 30_000_000] + case get(URI.to_string(uri), headers, options) do + {:ok, text} -> + {:ok, acc, text} + {:redirect, link} -> + new_uri = URI.parse(link) + #new_uri = %URI{new_uri | scheme: scheme, authority: uri.authority, host: uri.host, port: uri.port} + expand_link([new_uri | acc]) + {:error, status, _headers} -> + text = Plug.Conn.Status.reason_phrase(status) + {:ok, acc, "Error: HTTP #{text} (#{status})"} + {:error, {:tls_alert, {:handshake_failure, err}}} -> + {:ok, acc, "TLS Error: #{to_string(err)}"} + {:error, reason} -> + {:ok, acc, "Error: #{to_string(reason)}"} + end + end + + # Unsupported scheme, came from a redirect. + def expand_default(acc = [uri | _]) do + {:ok, [uri], "-> #{URI.to_string(uri)}"} + end + + + defp human_size(bytes) do + bytes + |> FileSize.new(:b) + |> FileSize.scale() + |> FileSize.format() + end +end diff --git a/lib/nola_plugins/link_plugin/github.ex b/lib/nola_plugins/link_plugin/github.ex new file mode 100644 index 0000000..93e0892 --- /dev/null +++ b/lib/nola_plugins/link_plugin/github.ex @@ -0,0 +1,49 @@ +defmodule Nola.IRC.LinkPlugin.Github do + @behaviour Nola.IRC.LinkPlugin + + @impl true + def match(uri = %URI{host: "github.com", path: path}, _) do + case String.split(path, "/") do + ["", user, repo] -> + {true, %{user: user, repo: repo, path: "#{user}/#{repo}"}} + _ -> + false + end + end + + def match(_, _), do: false + + @impl true + def post_match(_, _, _, _), do: false + + @impl true + def expand(_uri, %{user: user, repo: repo}, _opts) do + case HTTPoison.get("https://api.github.com/repos/#{user}/#{repo}") do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + {:ok, json} = Jason.decode(body) + src = json["source"]["full_name"] + disabled = if(json["disabled"], do: " (disabled)", else: "") + archived = if(json["archived"], do: " (archived)", else: "") + fork = if src && src != json["full_name"] do + " (⑂ #{json["source"]["full_name"]})" + else + "" + end + start = "#{json["full_name"]}#{disabled}#{archived}#{fork} - #{json["description"]}" + tags = for(t <- json["topics"]||[], do: "##{t}") |> Enum.intersperse(", ") |> Enum.join("") + lang = if(json["language"], do: "#{json["language"]} - ", else: "") + issues = if(json["open_issues_count"], do: "#{json["open_issues_count"]} issues - ", else: "") + last_push = if at = json["pushed_at"] do + {:ok, date, _} = DateTime.from_iso8601(at) + " - last pushed #{DateTime.to_string(date)}" + else + "" + end + network = "#{lang}#{issues}#{json["stargazers_count"]} stars - #{json["subscribers_count"]} watchers - #{json["forks_count"]} forks#{last_push}" + {:ok, [start, tags, network]} + other -> + :error + end + end + +end diff --git a/lib/nola_plugins/link_plugin/html.ex b/lib/nola_plugins/link_plugin/html.ex new file mode 100644 index 0000000..56a8ceb --- /dev/null +++ b/lib/nola_plugins/link_plugin/html.ex @@ -0,0 +1,106 @@ +defmodule Nola.IRC.LinkPlugin.HTML do + @behaviour Nola.IRC.LinkPlugin + + @impl true + def match(_, _), do: false + + @impl true + def post_match(_url, "text/html"<>_, _header, _opts) do + {:body, nil} + end + def post_match(_, _, _, _), do: false + + @impl true + def post_expand(url, body, _params, _opts) do + html = Floki.parse(body) + title = collect_title(html) + opengraph = collect_open_graph(html) + itemprops = collect_itemprops(html) + text = if Map.has_key?(opengraph, "title") && Map.has_key?(opengraph, "description") do + sitename = if sn = Map.get(opengraph, "site_name") do + "#{sn}" + else + "" + end + paywall? = if Map.get(opengraph, "article:content_tier", Map.get(itemprops, "article:content_tier", "free")) == "free" do + "" + else + "[paywall] " + end + section = if section = Map.get(opengraph, "article:section", Map.get(itemprops, "article:section", nil)) do + ": #{section}" + else + "" + end + date = case DateTime.from_iso8601(Map.get(opengraph, "article:published_time", Map.get(itemprops, "article:published_time", ""))) do + {:ok, date, _} -> + "#{Timex.format!(date, "%d/%m/%y", :strftime)}. " + _ -> + "" + end + uri = URI.parse(url) + + prefix = "#{paywall?}#{Map.get(opengraph, "site_name", uri.host)}#{section}" + prefix = unless prefix == "" do + "#{prefix} — " + else + "" + end + [clean_text("#{prefix}#{Map.get(opengraph, "title")}")] ++ IRC.splitlong(clean_text("#{date}#{Map.get(opengraph, "description")}")) + else + clean_text(title) + end + {:ok, text} + end + + defp collect_title(html) do + case Floki.find(html, "title") do + [{"title", [], [title]} | _] -> + String.trim(title) + _ -> + nil + end + end + + defp collect_open_graph(html) do + Enum.reduce(Floki.find(html, "head meta"), %{}, fn(tag, acc) -> + case tag do + {"meta", values, []} -> + name = List.keyfind(values, "property", 0, {nil, nil}) |> elem(1) + content = List.keyfind(values, "content", 0, {nil, nil}) |> elem(1) + case name do + "og:" <> key -> + Map.put(acc, key, content) + "article:"<>_ -> + Map.put(acc, name, content) + _other -> acc + end + _other -> acc + end + end) + end + + defp collect_itemprops(html) do + Enum.reduce(Floki.find(html, "[itemprop]"), %{}, fn(tag, acc) -> + case tag do + {"meta", values, []} -> + name = List.keyfind(values, "itemprop", 0, {nil, nil}) |> elem(1) + content = List.keyfind(values, "content", 0, {nil, nil}) |> elem(1) + case name do + "article:" <> key -> + Map.put(acc, name, content) + _other -> acc + end + _other -> acc + end + end) + end + + defp clean_text(text) do + text + |> String.replace("\n", " ") + |> HtmlEntities.decode() + end + + +end diff --git a/lib/nola_plugins/link_plugin/imgur.ex b/lib/nola_plugins/link_plugin/imgur.ex new file mode 100644 index 0000000..5d74956 --- /dev/null +++ b/lib/nola_plugins/link_plugin/imgur.ex @@ -0,0 +1,96 @@ +defmodule Nola.IRC.LinkPlugin.Imgur do + @behaviour Nola.IRC.LinkPlugin + + @moduledoc """ + # Imgur link preview + + No options. + + Needs to have a Imgur API key configured: + + ``` + config :nola, :imgur, + client_id: "xxxxxxxx", + client_secret: "xxxxxxxxxxxxxxxxxxxx" + ``` + """ + + @impl true + def match(uri = %URI{host: "imgur.io"}, arg) do + match(%URI{uri | host: "imgur.com"}, arg) + end + def match(uri = %URI{host: "i.imgur.io"}, arg) do + match(%URI{uri | host: "i.imgur.com"}, arg) + end + def match(uri = %URI{host: "imgur.com", path: "/a/"<>album_id}, _) do + {true, %{album_id: album_id}} + end + def match(uri = %URI{host: "imgur.com", path: "/gallery/"<>album_id}, _) do + {true, %{album_id: album_id}} + end + def match(uri = %URI{host: "i.imgur.com", path: "/"<>image}, _) do + [hash, _] = String.split(image, ".", parts: 2) + {true, %{image_id: hash}} + end + def match(_, _), do: false + + @impl true + def post_match(_, _, _, _), do: false + + def expand(_uri, %{album_id: album_id}, opts) do + expand_imgur_album(album_id, opts) + end + + def expand(_uri, %{image_id: image_id}, opts) do + expand_imgur_image(image_id, opts) + end + + def expand_imgur_image(image_id, opts) do + client_id = Keyword.get(Application.get_env(:nola, :imgur, []), :client_id, "42") + headers = [{"Authorization", "Client-ID #{client_id}"}] + options = [] + case HTTPoison.get("https://api.imgur.com/3/image/#{image_id}", headers, options) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + {:ok, json} = Jason.decode(body) + data = json["data"] + title = String.slice(data["title"] || data["description"], 0, 180) + nsfw = if data["nsfw"], do: "(NSFW) - ", else: " " + height = Map.get(data, "height") + width = Map.get(data, "width") + size = Map.get(data, "size") + {:ok, "image, #{width}x#{height}, #{size} bytes #{nsfw}#{title}"} + other -> + :error + end + end + + def expand_imgur_album(album_id, opts) do + client_id = Keyword.get(Application.get_env(:nola, :imgur, []), :client_id, "42") + headers = [{"Authorization", "Client-ID #{client_id}"}] + options = [] + case HTTPoison.get("https://api.imgur.com/3/album/#{album_id}", headers, options) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + {:ok, json} = Jason.decode(body) + data = json["data"] + title = data["title"] + nsfw = data["nsfw"] + nsfw = if nsfw, do: "(NSFW) - ", else: "" + if data["images_count"] == 1 do + [image] = data["images"] + title = if title || data["title"] do + title = [title, data["title"]] |> Enum.filter(fn(x) -> x end) |> Enum.uniq() |> Enum.join(" — ") + "#{title} — " + else + "" + end + {:ok, "#{nsfw}#{title}#{image["link"]}"} + else + title = if title, do: title, else: "Untitled album" + {:ok, "#{nsfw}#{title} - #{data["images_count"]} images"} + end + other -> + :error + end + end + +end diff --git a/lib/nola_plugins/link_plugin/pdf.ex b/lib/nola_plugins/link_plugin/pdf.ex new file mode 100644 index 0000000..5f72ef5 --- /dev/null +++ b/lib/nola_plugins/link_plugin/pdf.ex @@ -0,0 +1,39 @@ +defmodule Nola.IRC.LinkPlugin.PDF do + require Logger + @behaviour Nola.IRC.LinkPlugin + + @impl true + def match(_, _), do: false + + @impl true + def post_match(_url, "application/pdf"<>_, _header, _opts) do + {:file, nil} + end + + def post_match(_, _, _, _), do: false + + @impl true + def post_expand(url, file, _, _) do + case System.cmd("pdftitle", ["-p", file]) do + {text, 0} -> + text = text + |> String.trim() + + if text == "" do + :error + else + basename = Path.basename(url, ".pdf") + text = "[#{basename}] " <> text + |> String.split("\n") + {:ok, text} + end + {_, 127} -> + Logger.error("dependency `pdftitle` is missing, please install it: `pip3 install pdftitle`.") + :error + {error, code} -> + Logger.warn("command `pdftitle` exited with status code #{code}:\n#{inspect error}") + :error + end + end + +end diff --git a/lib/nola_plugins/link_plugin/redacted.ex b/lib/nola_plugins/link_plugin/redacted.ex new file mode 100644 index 0000000..7a6229d --- /dev/null +++ b/lib/nola_plugins/link_plugin/redacted.ex @@ -0,0 +1,18 @@ +defmodule Nola.IRC.LinkPlugin.Redacted do + @behaviour Nola.IRC.LinkPlugin + + @impl true + def match(uri = %URI{host: "redacted.ch", path: "/torrent.php", query: query = "id="<>id}, _opts) do + %{"id" => id} = URI.decode_query(id) + {true, %{torrent: id}} + end + + def match(_, _), do: false + + @impl true + def post_match(_, _, _, _), do: false + + def expand(_uri, %{torrent: id}, _opts) do + end + +end diff --git a/lib/nola_plugins/link_plugin/reddit.ex b/lib/nola_plugins/link_plugin/reddit.ex new file mode 100644 index 0000000..79102e0 --- /dev/null +++ b/lib/nola_plugins/link_plugin/reddit.ex @@ -0,0 +1,119 @@ +defmodule Nola.IRC.LinkPlugin.Reddit do + @behaviour Nola.IRC.LinkPlugin + + @impl true + def match(uri = %URI{host: "reddit.com", path: path}, _) do + case String.split(path, "/") do + ["", "r", sub, "comments", post_id, _slug] -> + {true, %{mode: :post, path: path, sub: sub, post_id: post_id}} + ["", "r", sub, "comments", post_id, _slug, ""] -> + {true, %{mode: :post, path: path, sub: sub, post_id: post_id}} + ["", "r", sub, ""] -> + {true, %{mode: :sub, path: path, sub: sub}} + ["", "r", sub] -> + {true, %{mode: :sub, path: path, sub: sub}} +# ["", "u", user] -> +# {true, %{mode: :user, path: path, user: user}} + _ -> + false + end + end + + def match(uri = %URI{host: host, path: path}, opts) do + if String.ends_with?(host, ".reddit.com") do + match(%URI{uri | host: "reddit.com"}, opts) + else + false + end + end + + @impl true + def post_match(_, _, _, _), do: false + + @impl true + def expand(_, %{mode: :sub, sub: sub}, _opts) do + url = "https://api.reddit.com/r/#{sub}/about" + case HTTPoison.get(url) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + sr = Jason.decode!(body) + |> Map.get("data") + |> IO.inspect(limit: :infinity) + description = Map.get(sr, "public_description")||Map.get(sr, "description", "") + |> String.split("\n") + |> List.first() + name = if title = Map.get(sr, "title") do + Map.get(sr, "display_name_prefixed") <> ": " <> title + else + Map.get(sr, "display_name_prefixed") + end + nsfw = if Map.get(sr, "over18") do + "[NSFW] " + else + "" + end + quarantine = if Map.get(sr, "quarantine") do + "[Quarantined] " + else + "" + end + count = "#{Map.get(sr, "subscribers")} subscribers, #{Map.get(sr, "active_user_count")} active" + preview = "#{quarantine}#{nsfw}#{name} — #{description} (#{count})" + {:ok, preview} + _ -> + :error + end + end + + def expand(_uri, %{mode: :post, path: path, sub: sub, post_id: post_id}, _opts) do + case HTTPoison.get("https://api.reddit.com#{path}?sr_detail=true") do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + json = Jason.decode!(body) + op = List.first(json) + |> Map.get("data") + |> Map.get("children") + |> List.first() + |> Map.get("data") + |> IO.inspect(limit: :infinity) + sr = get_in(op, ["sr_detail", "display_name_prefixed"]) + {self?, url} = if Map.get(op, "selftext") == "" do + {false, Map.get(op, "url")} + else + {true, nil} + end + + self_str = if(self?, do: "text", else: url) + up = Map.get(op, "ups") + down = Map.get(op, "downs") + comments = Map.get(op, "num_comments") + nsfw = if Map.get(op, "over_18") do + "[NSFW] " + else + "" + end + state = cond do + Map.get(op, "hidden") -> "hidden" + Map.get(op, "archived") -> "archived" + Map.get(op, "locked") -> "locked" + Map.get(op, "quarantine") -> "quarantined" + Map.get(op, "removed_by") || Map.get(op, "removed_by_category") -> "removed" + Map.get(op, "banned_by") -> "banned" + Map.get(op, "pinned") -> "pinned" + Map.get(op, "stickied") -> "stickied" + true -> nil + end + flair = if flair = Map.get(op, "link_flair_text") do + "[#{flair}] " + else + "" + end + title = "#{nsfw}#{sr}: #{flair}#{Map.get(op, "title")}" + state_str = if(state, do: "#{state}, ") + content = "by u/#{Map.get(op, "author")} - #{state_str}#{up} up, #{down} down, #{comments} comments - #{self_str}" + + {:ok, [title, content]} + err -> + :error + end + end + +end diff --git a/lib/nola_plugins/link_plugin/twitter.ex b/lib/nola_plugins/link_plugin/twitter.ex new file mode 100644 index 0000000..640b193 --- /dev/null +++ b/lib/nola_plugins/link_plugin/twitter.ex @@ -0,0 +1,158 @@ +defmodule Nola.IRC.LinkPlugin.Twitter do + @behaviour Nola.IRC.LinkPlugin + + @moduledoc """ + # Twitter Link Preview + + Configuration: + + needs an API key and auth tokens: + + ``` + config :extwitter, :oauth, [ + consumer_key: "zzzzz", + consumer_secret: "xxxxxxx", + access_token: "yyyyyy", + access_token_secret: "ssshhhhhh" + ] + ``` + + options: + + * `expand_quoted`: Add the quoted tweet instead of its URL. Default: true. + """ + + def match(uri = %URI{host: twitter, path: path}, _opts) when twitter in ["twitter.com", "m.twitter.com", "mobile.twitter.com"] do + case String.split(path, "/", parts: 4) do + ["", _username, "status", status_id] -> + {status_id, _} = Integer.parse(status_id) + {true, %{status_id: status_id}} + _ -> false + end + end + + def match(_, _), do: false + + @impl true + def post_match(_, _, _, _), do: false + + def expand(_uri, %{status_id: status_id}, opts) do + expand_tweet(ExTwitter.show(status_id, tweet_mode: "extended"), opts) + end + + defp expand_tweet(nil, _opts) do + :error + end + + defp link_tweet(tweet_or_screen_id_tuple, opts, force_twitter_com \\ false) + + defp link_tweet({screen_name, id}, opts, force_twitter_com) do + path = "/#{screen_name}/status/#{id}" + nitter = Keyword.get(opts, :nitter) + host = if !force_twitter_com && nitter, do: nitter, else: "twitter.com" + "https://#{host}/#{screen_name}/status/#{id}" + end + + defp link_tweet(tweet, opts, force_twitter_com) do + link_tweet({tweet.user.screen_name, tweet.id}, opts, force_twitter_com) + end + + defp expand_tweet(tweet, opts) do + head = format_tweet_header(tweet, opts) + + # Format tweet text + text = expand_twitter_text(tweet, opts) + text = if tweet.quoted_status do + quote_url = link_tweet(tweet.quoted_status, opts, true) + String.replace(text, quote_url, "") + else + text + end + text = IRC.splitlong(text) + + reply_to = if tweet.in_reply_to_status_id do + reply_url = link_tweet({tweet.in_reply_to_screen_name, tweet.in_reply_to_status_id}, opts) + text = if tweet.in_reply_to_screen_name == tweet.user.screen_name, do: "continued from", else: "replying to" + <<3, 15, " ↪ ", text::binary, " ", reply_url::binary, 3>> + end + + quoted = if tweet.quoted_status do + full_text = tweet.quoted_status + |> expand_twitter_text(opts) + |> IRC.splitlong_with_prefix(">") + + head = format_tweet_header(tweet.quoted_status, opts, details: false, prefix: "↓ quoting") + + [head | full_text] + else + [] + end + + #<<2, "#{tweet.user.name} (@#{tweet.user.screen_name})", 2, " ", 3, 61, "#{foot} #{nitter_link}", 3>>, reply_to] ++ text ++ quoted + + text = [head, reply_to | text] ++ quoted + |> Enum.filter(& &1) + {:ok, text} + end + + defp expand_twitter_text(tweet, _opts) do + text = Enum.reduce(tweet.entities.urls, tweet.full_text, fn(entity, text) -> + String.replace(text, entity.url, entity.expanded_url) + end) + extended = tweet.extended_entities || %{media: []} + text = Enum.reduce(extended.media, text, fn(entity, text) -> + url = Enum.filter(extended.media, fn(e) -> entity.url == e.url end) + |> Enum.map(fn(e) -> + cond do + e.type == "video" -> e.expanded_url + true -> e.media_url_https + end + end) + |> Enum.join(" ") + String.replace(text, entity.url, url) + end) + |> HtmlEntities.decode() + end + + defp format_tweet_header(tweet, opts, format_opts \\ []) do + prefix = Keyword.get(format_opts, :prefix, nil) + details = Keyword.get(format_opts, :details, true) + + padded_prefix = if prefix, do: "#{prefix} ", else: "" + author = <<padded_prefix::binary, 2, "#{tweet.user.name} (@#{tweet.user.screen_name})", 2>> + + link = link_tweet(tweet, opts) + + {:ok, at} = Timex.parse(tweet.created_at, "%a %b %e %H:%M:%S %z %Y", :strftime) + {:ok, formatted_time} = Timex.format(at, "{relative}", :relative) + + nsfw = if tweet.possibly_sensitive, do: <<3, 52, "NSFW", 3>> + + rts = if tweet.retweet_count && tweet.retweet_count > 0, do: "#{tweet.retweet_count} RT" + likes = if tweet.favorite_count && tweet.favorite_count > 0, do: "#{tweet.favorite_count} ❤︎" + qrts = if tweet.quote_count && tweet.quote_count > 0, do: "#{tweet.quote_count} QRT" + replies = if tweet.reply_count && tweet.reply_count > 0, do: "#{tweet.reply_count} Reps" + + dmcad = if tweet.withheld_copyright, do: <<3, 52, "DMCA", 3>> + withheld_local = if tweet.withheld_in_countries && length(tweet.withheld_in_countries) > 0 do + "Withheld in #{length(tweet.withheld_in_countries)} countries" + end + + verified = if tweet.user.verified, do: <<3, 51, "✔", 3>> + + meta = if details do + [verified, nsfw, formatted_time, dmcad, withheld_local, rts, qrts, likes, replies] + else + [verified, nsfw, formatted_time, dmcad, withheld_local] + end + + meta = meta + |> Enum.filter(& &1) + |> Enum.join(" - ") + + meta = <<3, 15, meta::binary, " → #{link}", 3>> + + <<author::binary, " — ", meta::binary>> + end + +end diff --git a/lib/nola_plugins/link_plugin/youtube.ex b/lib/nola_plugins/link_plugin/youtube.ex new file mode 100644 index 0000000..f7c7541 --- /dev/null +++ b/lib/nola_plugins/link_plugin/youtube.ex @@ -0,0 +1,72 @@ +defmodule Nola.IRC.LinkPlugin.YouTube do + @behaviour Nola.IRC.LinkPlugin + + @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 + 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/nola_plugins/logger_plugin.ex b/lib/nola_plugins/logger_plugin.ex new file mode 100644 index 0000000..b13f33a --- /dev/null +++ b/lib/nola_plugins/logger_plugin.ex @@ -0,0 +1,70 @@ +defmodule Nola.IRC.LoggerPlugin do + require Logger + + @couch_db "bot-logs" + + def irc_doc(), do: nil + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "triggers", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "messages", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "irc:outputs", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "messages:private", regopts) + {:ok, nil} + end + + def handle_info({:irc, :trigger, _, m}, state) do + {:noreply, log(m, state)} + end + + def handle_info({:irc, :text, m}, state) do + {:noreply, log(m, state)} + end + + def handle_info(info, state) do + Logger.debug("logger_plugin: unhandled info: #{info}") + {:noreply, state} + end + + def log(entry, state) do + case Couch.post(@couch_db, format_to_db(entry)) do + {:ok, id, _rev} -> + Logger.debug("logger_plugin: saved: #{inspect id}") + state + error -> + Logger.error("logger_plugin: save failed: #{inspect error}") + end + rescue + e -> + Logger.error("logger_plugin: rescued processing for #{inspect entry}: #{inspect e}") + Logger.error(Exception.format(:error, e, __STACKTRACE__)) + state + catch + e, b -> + Logger.error("logger_plugin: catched processing for #{inspect entry}: #{inspect e}") + Logger.error(Exception.format(e, b, __STACKTRACE__)) + state + end + + def format_to_db(msg = %IRC.Message{id: id}) do + msg + |> Poison.encode!() + |> Map.drop("id") + + %{"_id" => id || FlakeId.get(), + "type" => "irc.message/v1", + "object" => msg} + end + + def format_to_db(anything) do + %{"_id" => FlakeId.get(), + "type" => "object", + "object" => anything} + end + +end diff --git a/lib/nola_plugins/outline_plugin.ex b/lib/nola_plugins/outline_plugin.ex new file mode 100644 index 0000000..820500e --- /dev/null +++ b/lib/nola_plugins/outline_plugin.ex @@ -0,0 +1,108 @@ +defmodule Nola.IRC.OutlinePlugin do + @moduledoc """ + # outline auto-link + + Envoie un lien vers Outline quand un lien est envoyé. + + * **!outline `<url>`** crée un lien outline pour `<url>`. + * **+outline `<host>`** active outline pour `<host>`. + * **-outline `<host>`** désactive outline pour `<host>`. + """ + def short_irc_doc, do: false + def irc_doc, do: @moduledoc + require Logger + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + defstruct [:file, :hosts] + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:outline", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "messages", regopts) + file = Path.join(Nola.data_path, "/outline.txt") + hosts = case File.read(file) do + {:error, :enoent} -> + [] + {:ok, lines} -> + String.split(lines, "\n", trim: true) + end + {:ok, %__MODULE__{file: file, hosts: hosts}} + end + + def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :plus, args: [host]}}}, state) do + state = %{state | hosts: [host | state.hosts]} + save(state) + message.replyfun.("ok") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :minus, args: [host]}}}, state) do + state = %{state | hosts: List.delete(state.hosts, host)} + save(state) + message.replyfun.("ok") + {:noreply, state} + end + + def handle_info({:irc, :trigger, "outline", message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [url]}}}, state) do + line = "-> #{outline(url)}" + message.replyfun.(line) + end + + def handle_info({:irc, :text, message = %IRC.Message{text: text}}, state) do + String.split(text) + |> Enum.map(fn(word) -> + if String.starts_with?(word, "http://") || String.starts_with?(word, "https://") do + uri = URI.parse(word) + if uri.scheme && uri.host do + if Enum.any?(state.hosts, fn(host) -> String.ends_with?(uri.host, host) end) do + outline_url = outline(word) + line = "-> #{outline_url}" + message.replyfun.(line) + end + end + end + end) + {:noreply, state} + end + + def handle_info(msg, state) do + {:noreply, state} + end + + def save(state = %{file: file, hosts: hosts}) do + string = Enum.join(hosts, "\n") + File.write(file, string) + end + + def outline(url) do + unexpanded = "https://outline.com/#{url}" + headers = [ + {"User-Agent", "Mozilla/5.0 (X11; Linux x86_64; rv:77.0) Gecko/20100101 Firefox/77.0"}, + {"Accept", "*/*"}, + {"Accept-Language", "en-US,en;q=0.5"}, + {"Origin", "https://outline.com"}, + {"DNT", "1"}, + {"Referer", unexpanded}, + {"Pragma", "no-cache"}, + {"Cache-Control", "no-cache"} + ] + params = %{"source_url" => url} + case HTTPoison.get("https://api.outline.com/v3/parse_article", headers, params: params) do + {:ok, %HTTPoison.Response{status_code: 200, body: json}} -> + body = Poison.decode!(json) + if Map.get(body, "success") do + code = get_in(body, ["data", "short_code"]) + "https://outline.com/#{code}" + else + unexpanded + end + error -> + Logger.info("outline.com error: #{inspect error}") + unexpanded + end + end + +end diff --git a/lib/nola_plugins/preums_plugin.ex b/lib/nola_plugins/preums_plugin.ex new file mode 100644 index 0000000..f250e85 --- /dev/null +++ b/lib/nola_plugins/preums_plugin.ex @@ -0,0 +1,276 @@ +defmodule Nola.IRC.PreumsPlugin do + @moduledoc """ + # preums !!! + + * `!preums`: affiche le preums du jour + * `.preums`: stats des preums + """ + + # WIP Scores + # L'idée c'est de donner un score pour mettre un peu de challenge en pénalisant les preums faciles. + # + # Un preums ne vaut pas 1 point, mais plutôt 0.10 ou 0.05, et on arrondi au plus proche. C'est un jeu sur le long + # terme. Un gros bonus pourrait apporter beaucoup de points. + # + # Il faudrait ces données: + # - moyenne des preums + # - activité récente du channel et par nb actifs d'utilisateurs + # (aggréger memberships+usertrack last_active ?) + # (faire des stats d'activité habituelle (un peu a la pisg) ?) + # - preums consécutifs + # + # Malus: + # - est proche de la moyenne en faible activité + # - trop consécutif de l'utilisateur sauf si activité + # + # Bonus: + # - plus le preums est éloigné de la moyenne + # - après 18h double + # - plus l'activité est élévée, exponentiel selon la moyenne + # - derns entre 4 et 6 (pourrait être adapté selon les stats d'activité) + # + # WIP Badges: + # - derns + # - streaks + # - faciles + # - ? + + require Logger + + @perfects [~r/preum(s|)/i] + + # dets {{chan, day = {yyyy, mm, dd}}, nick, now, perfect?, text} + + def all(dets) do + :dets.foldl(fn(i, acc) -> [i|acc] end, [], dets) + end + + def all(dets, channel) do + fun = fn({{chan, date}, account_id, time, perfect, text}, acc) -> + if channel == chan do + [%{date: date, account_id: account_id, time: time, perfect: perfect, text: text} | acc] + else + acc + end + end + :dets.foldl(fun, [], dets) + end + + def topnicks(dets, channel, options \\ []) do + sort_elem = case Keyword.get(options, :sort_by, :score) do + :score -> 1 + :count -> 0 + end + + fun = fn(x = {{chan, date}, account_id, time, perfect, text}, acc) -> + if (channel == nil and chan) or (channel == chan) do + {count, points} = Map.get(acc, account_id, {0, 0}) + score = score(chan, account_id, time, perfect, text) + Map.put(acc, account_id, {count + 1, points + score}) + else + acc + end + end + :dets.foldl(fun, %{}, dets) + |> Enum.sort_by(fn({_account_id, value}) -> elem(value, sort_elem) end, &>=/2) + end + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def dets do + (Nola.data_path() <> "/preums.dets") |> String.to_charlist() + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "account", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "messages", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "triggers", regopts) + {:ok, dets} = :dets.open_file(dets(), [{:repair, :force}]) + Util.ets_mutate_select_each(:dets, dets, [{:"$1", [], [:"$1"]}], fn(table, obj) -> + {key, nick, now, perfect, text} = obj + case key do + {{net, {bork,chan}}, date} -> + :dets.delete(table, key) + nick = if IRC.Account.get(nick) do + nick + else + if acct = IRC.Account.find_always_by_nick(net, nil, nick) do + acct.id + else + nick + end + end + :dets.insert(table, { { {net,chan}, date }, nick, now, perfect, text}) + {{_net, nil}, _} -> + :dets.delete(table, key) + {{net, chan}, date} -> + if !IRC.Account.get(nick) do + if acct = IRC.Account.find_always_by_nick(net, chan, nick) do + :dets.delete(table, key) + :dets.insert(table, { { {net,chan}, date }, acct.id, now, perfect, text}) + end + end + _ -> + Logger.debug("DID NOT FIX: #{inspect key}") + end + end) + {:ok, %{dets: dets}} + end + + # Latest + def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) do + channelkey = {m.network, m.channel} + state = handle_preums(m, state) + tz = timezone(channelkey) + {:ok, now} = DateTime.now(tz, Tzdata.TimeZoneDatabase) + date = {now.year, now.month, now.day} + key = {channelkey, date} + chan_cache = Map.get(state, channelkey, %{}) + item = if i = Map.get(chan_cache, date) do + i + else + case :dets.lookup(state.dets, key) do + [item = {^key, _account_id, _now, _perfect, _text}] -> item + _ -> nil + end + end + + if item do + {_, account_id, date, _perfect, text} = item + h = "#{date.hour}:#{date.minute}:#{date.second}" + account = IRC.Account.get(account_id) + user = IRC.UserTrack.find_by_account(m.network, account) + nick = if(user, do: user.nick, else: account.name) + m.replyfun.("preums: #{nick} à #{h}: “#{text}”") + end + {:noreply, state} + end + + # Stats + def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :dot}}}, state) do + channel = {m.network, m.channel} + state = handle_preums(m, state) + top = topnicks(state.dets, channel, sort_by: :score) + |> Enum.map(fn({account_id, {count, score}}) -> + account = IRC.Account.get(account_id) + user = IRC.UserTrack.find_by_account(m.network, account) + nick = if(user, do: user.nick, else: account.name) + "#{nick}: #{score} (#{count})" + end) + |> Enum.intersperse(", ") + |> Enum.join("") + msg = unless top == "" do + "top preums: #{top}" + else + "vous êtes tous nuls" + end + m.replyfun.(msg) + {:noreply, state} + end + + # Help + def handle_info({:irc, :trigger, "preums", m = %IRC.Message{trigger: %IRC.Trigger{type: :query}}}, state) do + state = handle_preums(m, state) + msg = "!preums - preums du jour, .preums top preumseurs" + m.replymsg.(msg) + {:noreply, state} + end + + # Trigger fallback + def handle_info({:irc, :trigger, _, m = %IRC.Message{}}, state) do + state = handle_preums(m, state) + {:noreply, state} + end + + # Message fallback + def handle_info({:irc, :text, m = %IRC.Message{}}, state) do + {:noreply, handle_preums(m, state)} + end + + # Account + def handle_info({:account_change, old_id, new_id}, state) do + spec = [{{:_, :"$1", :_, :_, :_}, [{:==, :"$1", {:const, old_id}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) -> + rename_object_owner(table, obj, new_id) + end) + {:noreply, state} + end + + # Account: move from nick to account id + # FIXME: Doesn't seem to work. + def handle_info({:accounts, accounts}, state) do + for x={:account, _net, _chan, _nick, _account_id} <- accounts do + handle_info(x, state) + end + {:noreply, state} + end + def handle_info({:account, _net, _chan, nick, account_id}, state) do + nick = String.downcase(nick) + spec = [{{:_, :"$1", :_, :_, :_}, [{:==, :"$1", {:const, nick}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) -> + Logger.debug("account:: merging #{nick} -> #{account_id}") + rename_object_owner(table, obj, account_id) + end) + {:noreply, state} + end + + def handle_info(_, dets) do + {:noreply, dets} + end + + + defp rename_object_owner(table, object = {key, _, now, perfect, time}, new_id) do + :dets.delete_object(table, key) + :dets.insert(table, {key, new_id, now, perfect, time}) + end + + defp timezone(channel) do + env = Application.get_env(:nola, Nola.IRC.PreumsPlugin, []) + channels = Keyword.get(env, :channels, %{}) + channel_settings = Map.get(channels, channel, []) + default = Keyword.get(env, :default_tz, "Europe/Paris") + Keyword.get(channel_settings, :tz, default) || default + end + + defp handle_preums(%IRC.Message{channel: nil}, state) do + state + end + + defp handle_preums(m = %IRC.Message{text: text, sender: sender}, state) do + channel = {m.network, m.channel} + tz = timezone(channel) + {:ok, now} = DateTime.now(tz, Tzdata.TimeZoneDatabase) + date = {now.year, now.month, now.day} + key = {channel, date} + chan_cache = Map.get(state, channel, %{}) + unless i = Map.get(chan_cache, date) do + case :dets.lookup(state.dets, key) do + [item = {^key, _nick, _now, _perfect, _text}] -> + # Preums lost, but wasn't cached + Map.put(state, channel, %{date => item}) + [] -> + # Preums won! + perfect? = Enum.any?(@perfects, fn(perfect) -> Regex.match?(perfect, text) end) + item = {key, m.account.id, now, perfect?, text} + :dets.insert(state.dets, item) + :dets.sync(state.dets) + Map.put(state, channel, %{date => item}) + {:error, _} = error -> + Logger.error("#{__MODULE__} dets lookup failed: #{inspect error}") + state + end + else + state + end + end + + def score(_chan, _account, _time, _perfect, _text) do + 1 + end + + +end diff --git a/lib/nola_plugins/quatre_cent_vingt_plugin.ex b/lib/nola_plugins/quatre_cent_vingt_plugin.ex new file mode 100644 index 0000000..8953ea3 --- /dev/null +++ b/lib/nola_plugins/quatre_cent_vingt_plugin.ex @@ -0,0 +1,149 @@ +defmodule Nola.IRC.QuatreCentVingtPlugin do + require Logger + + @moduledoc """ + # 420 + + * **!420**: recorde un nouveau 420. + * **!420*x**: recorde un nouveau 420*x (*2 = 840, ...) (à vous de faire la multiplication). + * **!420 pseudo**: stats du pseudo. + """ + + @achievements %{ + 1 => ["[le premier… il faut bien commencer un jour]"], + 10 => ["T'en es seulement à 10 ? ╭∩╮(Ο_Ο)╭∩╮"], + 42 => ["Bravo, et est-ce que autant de pétards t'on aidés à trouver la Réponse ? ٩(- ̮̮̃-̃)۶ [42]"], + 100 => ["°º¤ø,¸¸,ø¤º°`°º¤ø,¸,ø¤°º¤ø,¸¸,ø¤º°`°º¤ø,¸ 100 °º¤ø,¸¸,ø¤º°`°º¤ø,¸,ø¤°º¤ø,¸¸,ø¤º°`°º¤ø,¸"], + 115 => [" ۜ\(סּںסּَ` )/ۜ 115!!"] + } + + @emojis [ + "\\o/", + "~o~", + "~~o∞~~", + "*\\o/*", + "**\\o/**", + "*ô*", + ] + + @coeffs Range.new(1, 100) + + def irc_doc, do: @moduledoc + + def start_link, do: GenServer.start_link(__MODULE__, [], name: __MODULE__) + + def init(_) do + for coeff <- @coeffs do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:#{420*coeff}", [plugin: __MODULE__]) + end + {:ok, _} = Registry.register(IRC.PubSub, "account", [plugin: __MODULE__]) + dets_filename = (Nola.data_path() <> "/420.dets") |> String.to_charlist + {:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag},{:repair,:force}]) + {:ok, dets} + :ignore + end + + for coeff <- @coeffs do + qvc = to_string(420 * coeff) + def handle_info({:irc, :trigger, unquote(qvc), m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :bang}}}, dets) do + {count, last} = get_statistics_for_nick(dets, m.account.id) + count = count + unquote(coeff) + text = achievement_text(count) + now = DateTime.to_unix(DateTime.utc_now())-1 # this is ugly + for i <- Range.new(1, unquote(coeff)) do + :ok = :dets.insert(dets, {m.account.id, now+i}) + end + last_s = if last do + last_s = format_relative_timestamp(last) + " (le dernier était #{last_s})" + else + "" + end + m.replyfun.("#{m.sender.nick} 420 +#{unquote(coeff)} #{text}#{last_s}") + {:noreply, dets} + end + end + + def handle_info({:irc, :trigger, "420", m = %IRC.Message{trigger: %IRC.Trigger{args: [nick], type: :bang}}}, dets) do + account = IRC.Account.find_by_nick(m.network, nick) + if account do + text = case get_statistics_for_nick(dets, m.account.id) do + {0, _} -> "#{nick} n'a jamais !420 ... honte à lui." + {count, last} -> + last_s = format_relative_timestamp(last) + "#{nick} 420: total #{count}, le dernier #{last_s}" + end + m.replyfun.(text) + else + m.replyfun.("je connais pas de #{nick}") + end + {:noreply, dets} + end + + # Account + def handle_info({:account_change, old_id, new_id}, dets) do + spec = [{{:"$1", :_}, [{:==, :"$1", {:const, old_id}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, dets, spec, fn(table, obj) -> + rename_object_owner(table, obj, new_id) + end) + {:noreply, dets} + end + + # Account: move from nick to account id + def handle_info({:accounts, accounts}, dets) do + for x={:account, _net, _chan, _nick, _account_id} <- accounts do + handle_info(x, dets) + end + {:noreply, dets} + end + def handle_info({:account, _net, _chan, nick, account_id}, dets) do + nick = String.downcase(nick) + spec = [{{:"$1", :_}, [{:==, :"$1", {:const, nick}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, dets, spec, fn(table, obj) -> + Logger.debug("account:: merging #{nick} -> #{account_id}") + rename_object_owner(table, obj, account_id) + end) + {:noreply, dets} + end + + def handle_info(_, dets) do + {:noreply, dets} + end + + defp rename_object_owner(table, object = {_, at}, account_id) do + :dets.delete_object(table, object) + :dets.insert(table, {account_id, at}) + end + + + defp format_relative_timestamp(timestamp) do + alias Timex.Format.DateTime.Formatters + alias Timex.Timezone + date = timestamp + |> DateTime.from_unix! + |> Timezone.convert("Europe/Paris") + + {:ok, relative} = Formatters.Relative.relative_to(date, Timex.now("Europe/Paris"), "{relative}", "fr") + {:ok, detail} = Formatters.Default.lformat(date, " ({h24}:{m})", "fr") + + relative <> detail + end + + defp get_statistics_for_nick(dets, acct) do + qvc = :dets.lookup(dets, acct) |> Enum.sort + count = Enum.reduce(qvc, 0, fn(_, acc) -> acc + 1 end) + {_, last} = List.last(qvc) || {nil, nil} + {count, last} + end + + @achievements_keys Map.keys(@achievements) + defp achievement_text(count) when count in @achievements_keys do + Enum.random(Map.get(@achievements, count)) + end + + defp achievement_text(count) do + emoji = Enum.random(@emojis) + "#{emoji} [#{count}]" + end + +end diff --git a/lib/nola_plugins/radio_france_plugin.ex b/lib/nola_plugins/radio_france_plugin.ex new file mode 100644 index 0000000..c2e966f --- /dev/null +++ b/lib/nola_plugins/radio_france_plugin.ex @@ -0,0 +1,133 @@ +defmodule Nola.IRC.RadioFrancePlugin do + require Logger + + def irc_doc() do + """ + # radio france + + Qu'est ce qu'on écoute sur radio france ? + + * **!radiofrance `[station]`, !rf `[station]`** + * **!fip, !inter, !info, !bleu, !culture, !musique, !fip `[sous-station]`, !bleu `[région]`** + """ + end + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @trigger "radiofrance" + @shortcuts ~w(fip inter info bleu culture musique) + + def init(_) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "trigger:radiofrance", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:rf", regopts) + for s <- @shortcuts do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:#{s}", regopts) + end + {:ok, nil} + end + + def handle_info({:irc, :trigger, "rf", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang}}}, state) do + handle_info({:irc, :trigger, "radiofrance", m}, state) + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do + m.replyfun.("radiofrance: précisez la station!") + {:noreply, state} + end + + def handle_info({:irc, :trigger, @trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do + now(args_to_station(args), m) + {:noreply, state} + end + + def handle_info({:irc, :trigger, trigger, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) when trigger in @shortcuts do + now(args_to_station([trigger | args]), m) + {:noreply, state} + end + + defp args_to_station(args) do + args + |> Enum.map(&unalias/1) + |> Enum.map(&String.downcase/1) + |> Enum.join("_") + end + + def handle_info(info, state) do + Logger.debug("unhandled info: #{inspect info}") + {:noreply, state} + end + + defp now(station, m) when is_binary(station) do + case HTTPoison.get(np_url(station), [], []) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + json = Poison.decode!(body) + song? = !!get_in(json, ["now", "song"]) + station = reformat_station_name(get_in(json, ["now", "stationName"])) + now_title = get_in(json, ["now", "firstLine", "title"]) + now_subtitle = get_in(json, ["now", "secondLine", "title"]) + next_title = get_in(json, ["next", "firstLine", "title"]) + next_subtitle = get_in(json, ["next", "secondLine", "title"]) + next_song? = !!get_in(json, ["next", "song"]) + next_at = get_in(json, ["next", "startTime"]) + + now = format_title(song?, now_title, now_subtitle) + prefix = if song?, do: "🎶", else: "🎤" + m.replyfun.("#{prefix} #{station}: #{now}") + + next = format_title(song?, next_title, next_subtitle) + if next do + next_prefix = if next_at do + next_date = DateTime.from_unix!(next_at) + in_seconds = DateTime.diff(next_date, DateTime.utc_now()) + in_minutes = ceil(in_seconds / 60) + if in_minutes >= 5 do + if next_song?, do: "#{in_minutes}m 🔜", else: "dans #{in_minutes} minutes:" + else + if next_song?, do: "🔜", else: "suivi de:" + end + else + if next_song?, do: "🔜", else: "à suivre:" + end + m.replyfun.("#{next_prefix} #{next}") + end + + {:error, %HTTPoison.Response{status_code: 404}} -> + m.replyfun.("radiofrance: la radio \"#{station}\" n'existe pas") + + {:error, %HTTPoison.Response{status_code: code}} -> + m.replyfun.("radiofrance: erreur http #{code}") + + _ -> + m.replyfun.("radiofrance: ça n'a pas marché, rip") + end + end + + defp np_url(station), do: "https://www.radiofrance.fr/api/v2.0/stations/#{station}/live" + + defp unalias("inter"), do: "franceinter" + defp unalias("info"), do: "franceinfo" + defp unalias("bleu"), do: "francebleu" + defp unalias("culture"), do: "franceculture" + defp unalias("musique"), do: "francemusique" + defp unalias(station), do: station + + defp format_title(_, nil, nil) do + nil + end + defp format_title(true, title, artist) do + [artist, title] |> Enum.filter(& &1) |> Enum.join(" - ") + end + defp format_title(false, show, section) do + [show, section] |> Enum.filter(& &1) |> Enum.join(": ") + end + + defp reformat_station_name(station) do + station + |> String.replace("france", "france ") + |> String.replace("_", " ") + end + +end diff --git a/lib/nola_plugins/say_plugin.ex b/lib/nola_plugins/say_plugin.ex new file mode 100644 index 0000000..915b0f6 --- /dev/null +++ b/lib/nola_plugins/say_plugin.ex @@ -0,0 +1,73 @@ +defmodule Nola.IRC.SayPlugin 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(IRC.PubSub, "trigger:say", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:asay", regopts) + {:ok, _} = Registry.register(IRC.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} <- IRC.Membership.of_account(account) do + chan2 = String.replace(chan, "#", "") + if (target == "#{net}/#{chan}" || target == "#{net}/#{chan2}" || target == chan || target == chan2) do + if with_nick? do + IRC.send_message_as(account, net, chan, text) + else + IRC.Connection.broadcast_message(net, chan, text) + end + end + end + end + +end diff --git a/lib/nola_plugins/script_plugin.ex b/lib/nola_plugins/script_plugin.ex new file mode 100644 index 0000000..94d4edf --- /dev/null +++ b/lib/nola_plugins/script_plugin.ex @@ -0,0 +1,42 @@ +defmodule Nola.IRC.ScriptPlugin do + require Logger + + @moduledoc """ + Allows to run outside scripts. Scripts are expected to be long running and receive/send data as JSON over stdin/stdout. + + """ + + @ircdoc """ + # script + + Allows to run an outside script. + + * **+script `<name>` `[command]`** défini/lance un script + * **-script `<name>`** arrête un script + * **-script del `<name>`** supprime un script + """ + + def irc_doc, do: @ircdoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:script", [plugin: __MODULE__]) + dets_filename = (Nola.data_path() <> "/" <> "scripts.dets") |> String.to_charlist + {:ok, dets} = :dets.open_file(dets_filename, []) + {:ok, %{dets: dets}} + end + + def handle_info({:irc, :trigger, "script", m = %{trigger: %{type: :plus, args: [name | args]}}}, state) do + end + + def handle_info({:irc, :trigger, "script", m = %{trigger: %{type: :minus, args: args}}}, state) do + case args do + ["del", name] -> :ok #prout + [name] -> :ok#stop + end + end + +end diff --git a/lib/nola_plugins/seen_plugin.ex b/lib/nola_plugins/seen_plugin.ex new file mode 100644 index 0000000..2a4d0dd --- /dev/null +++ b/lib/nola_plugins/seen_plugin.ex @@ -0,0 +1,59 @@ +defmodule Nola.IRC.SeenPlugin do + @moduledoc """ + # seen + + * **!seen `<nick>`** + """ + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "triggers", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "messages", regopts) + dets_filename = (Nola.data_path() <> "/seen.dets") |> String.to_charlist() + {:ok, dets} = :dets.open_file(dets_filename, []) + {:ok, %{dets: dets}} + end + + def handle_info({:irc, :trigger, "seen", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [nick]}}}, state) do + witness(m, state) + m.replyfun.(last_seen(m.channel, nick, state)) + {:noreply, state} + end + + def handle_info({:irc, :trigger, _, m}, state) do + witness(m, state) + {:noreply, state} + end + + def handle_info({:irc, :text, m}, state) do + witness(m, state) + {:noreply, state} + end + + defp witness(%IRC.Message{channel: channel, text: text, sender: %{nick: nick}}, %{dets: dets}) do + :dets.insert(dets, {{channel, nick}, DateTime.utc_now(), text}) + :ok + end + + defp last_seen(channel, nick, %{dets: dets}) do + case :dets.lookup(dets, {channel, nick}) do + [{_, date, text}] -> + diff = round(DateTime.diff(DateTime.utc_now(), date)/60) + cond do + diff >= 30 -> + duration = Timex.Duration.from_minutes(diff) + format = Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized) + "#{nick} a parlé pour la dernière fois il y a #{format}: “#{text}”" + true -> "#{nick} est là..." + end + [] -> + "je ne connais pas de #{nick}" + end + end + +end diff --git a/lib/nola_plugins/sms_plugin.ex b/lib/nola_plugins/sms_plugin.ex new file mode 100644 index 0000000..d8f7387 --- /dev/null +++ b/lib/nola_plugins/sms_plugin.ex @@ -0,0 +1,165 @@ +defmodule Nola.IRC.SmsPlugin do + @moduledoc """ + ## sms + + * **!sms `<nick>` `<message>`** envoie un SMS. + """ + def short_irc_doc, do: false + def irc_doc, do: @moduledoc + require Logger + + def incoming(from, "enable "<>key) do + key = String.trim(key) + account = IRC.Account.find_meta_account("sms-validation-code", String.downcase(key)) + if account do + net = IRC.Account.get_meta(account, "sms-validation-target") + IRC.Account.put_meta(account, "sms-number", from) + IRC.Account.delete_meta(account, "sms-validation-code") + IRC.Account.delete_meta(account, "sms-validation-number") + IRC.Account.delete_meta(account, "sms-validation-target") + IRC.Connection.broadcast_message(net, account, "SMS Number #{from} added!") + send_sms(from, "Yay! Number linked to account #{account.name}") + end + end + + def incoming(from, message) do + account = IRC.Account.find_meta_account("sms-number", from) + if account do + reply_fun = fn(text) -> + send_sms(from, text) + end + trigger_text = if Enum.any?(IRC.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(message, trigger) end) do + message + else + "!"<>message + end + message = %IRC.Message{ + id: FlakeId.get(), + transport: :sms, + network: "sms", + channel: nil, + text: message, + account: account, + sender: %ExIRC.SenderInfo{nick: account.name}, + replyfun: reply_fun, + trigger: IRC.Connection.extract_trigger(trigger_text) + } + Logger.debug("converted sms to message: #{inspect message}") + IRC.Connection.publish(message, ["messages:sms"]) + message + end + end + + def my_number() do + Keyword.get(Application.get_env(:nola, :sms, []), :number, "+33000000000") + end + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def path() do + account = Keyword.get(Application.get_env(:nola, :sms), :account) + "https://eu.api.ovh.com/1.0/sms/#{account}" + end + + def path(rest) do + Path.join(path(), rest) + end + + def send_sms(number, text) do + url = path("/virtualNumbers/#{my_number()}/jobs") + body = %{ + "message" => text, + "receivers" => [number], + #"senderForResponse" => true, + #"noStopClause" => true, + "charset" => "UTF-8", + "coding" => "8bit" + } |> Poison.encode!() + headers = [{"content-type", "application/json"}] ++ sign("POST", url, body) + options = [] + case HTTPoison.post(url, body, headers, options) do + {:ok, %HTTPoison.Response{status_code: 200}} -> :ok + {:ok, %HTTPoison.Response{status_code: code} = resp} -> + Logger.error("SMS Error: #{inspect resp}") + {:error, code} + {:error, error} -> {:error, error} + end + end + + def init([]) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:sms", [plugin: __MODULE__]) + :ok = register_ovh_callback() + {:ok, %{}} + :ignore + end + + def handle_info({:irc, :trigger, "sms", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [nick | text]}}}, state) do + with \ + {:tree, false} <- {:tree, m.sender.nick == "Tree"}, + {_, %IRC.Account{} = account} <- {:account, IRC.Account.find_always_by_nick(m.network, m.channel, nick)}, + {_, number} when not is_nil(number) <- {:number, IRC.Account.get_meta(account, "sms-number")} + do + text = Enum.join(text, " ") + sender = if m.channel do + "#{m.channel} <#{m.sender.nick}> " + else + "<#{m.sender.nick}> " + end + case send_sms(number, sender<>text) do + :ok -> m.replyfun.("sent!") + {:error, error} -> m.replyfun.("not sent, error: #{inspect error}") + end + else + {:tree, _} -> m.replyfun.("Tree: va en enfer") + {:account, _} -> m.replyfun.("#{nick} not known") + {:number, _} -> m.replyfun.("#{nick} have not enabled sms") + end + {:noreply, state} + end + + def handle_info(msg, state) do + {:noreply, state} + end + + defp register_ovh_callback() do + url = path() + body = %{ + "callBack" =>NolaWeb.Router.Helpers.sms_url(NolaWeb.Endpoint, :ovh_callback), + "smsResponse" => %{ + "cgiUrl" => NolaWeb.Router.Helpers.sms_url(NolaWeb.Endpoint, :ovh_callback), + "responseType" => "cgi" + } + } |> Poison.encode!() + headers = [{"content-type", "application/json"}] ++ sign("PUT", url, body) + options = [] + case HTTPoison.put(url, body, headers, options) do + {:ok, %HTTPoison.Response{status_code: 200}} -> + :ok + error -> error + end + end + + defp sign(method, url, body) do + ts = DateTime.utc_now() |> DateTime.to_unix() + as = env(:app_secret) + ck = env(:consumer_key) + sign = Enum.join([as, ck, String.upcase(method), url, body, ts], "+") + sign_hex = :crypto.hash(:sha, sign) |> Base.encode16(case: :lower) + headers = [{"X-OVH-Application", env(:app_key)}, {"X-OVH-Timestamp", ts}, + {"X-OVH-Signature", "$1$"<>sign_hex}, {"X-Ovh-Consumer", ck}] + end + + def parse_number(num) do + {:error, :todo} + end + + defp env() do + Application.get_env(:nola, :sms) + end + + defp env(key) do + Keyword.get(env(), key) + end +end diff --git a/lib/nola_plugins/tell_plugin.ex b/lib/nola_plugins/tell_plugin.ex new file mode 100644 index 0000000..ecc98df --- /dev/null +++ b/lib/nola_plugins/tell_plugin.ex @@ -0,0 +1,106 @@ +defmodule Nola.IRC.TellPlugin do + use GenServer + + @moduledoc """ + # Tell + + * **!tell `<nick>` `<message>`**: tell `message` to `nick` when they reconnect. + """ + + def irc_doc, do: @moduledoc + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def dets do + (Nola.data_path() <> "/tell.dets") |> String.to_charlist() + end + + def tell(m, target, message) do + GenServer.cast(__MODULE__, {:tell, m, target, message}) + end + + def init([]) do + regopts = [plugin: __MODULE__] + {:ok, _} = Registry.register(IRC.PubSub, "account", regopts) + {:ok, _} = Registry.register(IRC.PubSub, "trigger:tell", regopts) + {:ok, dets} = :dets.open_file(dets(), [type: :bag]) + {:ok, %{dets: dets}} + end + + def handle_cast({:tell, m, target, message}, state) do + do_tell(state, m, target, message) + {:noreply, state} + end + + def handle_info({:irc, :trigger, "tell", m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: [target | message]}}}, state) do + do_tell(state, m, target, message) + {:noreply, state} + end + + def handle_info({:account, network, channel, nick, account_id}, state) do + messages = :dets.lookup(state.dets, {network, channel, account_id}) + if messages != [] do + strs = Enum.map(messages, fn({_, from, message, at}) -> + account = IRC.Account.get(from) + user = IRC.UserTrack.find_by_account(network, account) + fromnick = if user, do: user.nick, else: account.name + "#{nick}: <#{fromnick}> #{message}" + end) + Enum.each(strs, fn(s) -> IRC.Connection.broadcast_message(network, channel, s) end) + :dets.delete(state.dets, {network, channel, account_id}) + end + {:noreply, state} + end + + def handle_info({:account_change, old_id, new_id}, state) do + #:ets.fun2ms(fn({ {_net, _chan, target_id}, from_id, _, _} = obj) when (target_id == old_id) or (from_id == old_id) -> obj end) + spec = [{{{:"$1", :"$2", :"$3"}, :"$4", :_, :_}, [{:orelse, {:==, :"$3", {:const, old_id}}, {:==, :"$4", {:const, old_id}}}], [:"$_"]}] + Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) -> + case obj do + { {net, chan, ^old_id}, from_id, message, at } = obj -> + :dets.delete(obj) + :dets.insert(table, {{net, chan, new_id}, from_id, message, at}) + {key, ^old_id, message, at} = obj -> + :dets.delete(table, obj) + :dets.insert(table, {key, new_id, message, at}) + _ -> :ok + end + end) + {:noreply, state} + end + + + def handle_info(info, state) do + {:noreply, state} + end + + def terminate(_, state) do + :dets.close(state.dets) + :ok + end + + defp do_tell(state, m, nick_target, message) do + target = IRC.Account.find_always_by_nick(m.network, m.channel, nick_target) + message = Enum.join(message, " ") + with \ + {:target, %IRC.Account{} = target} <- {:target, target}, + {:same, false} <- {:same, target.id == m.account.id}, + target_user = IRC.UserTrack.find_by_account(m.network, target), + target_nick = if(target_user, do: target_user.nick, else: target.name), + present? = if(target_user, do: Map.has_key?(target_user.last_active, m.channel)), + {:absent, true, _} <- {:absent, !present?, target_nick}, + {:message, message} <- {:message, message} + do + obj = { {m.network, m.channel, target.id}, m.account.id, message, NaiveDateTime.utc_now()} + :dets.insert(state.dets, obj) + m.replyfun.("will tell to #{target_nick}") + else + {:same, _} -> m.replyfun.("are you so stupid that you need a bot to tell yourself things ?") + {:target, _} -> m.replyfun.("#{nick_target} unknown") + {:absent, _, nick} -> m.replyfun.("#{nick} is here, tell yourself!") + {:message, _} -> m.replyfun.("can't tell without a message") + end + end + +end diff --git a/lib/nola_plugins/txt_plugin.ex b/lib/nola_plugins/txt_plugin.ex new file mode 100644 index 0000000..cab912a --- /dev/null +++ b/lib/nola_plugins/txt_plugin.ex @@ -0,0 +1,556 @@ +defmodule Nola.IRC.TxtPlugin do + alias IRC.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.IRC.TxtPlugin.Markov.Native) + {:ok, markov} = markov_handler.start_link() + {:ok, _} = Registry.register(IRC.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) + 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) + operator? = IRC.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/nola_plugins/txt_plugin/markov.ex b/lib/nola_plugins/txt_plugin/markov.ex new file mode 100644 index 0000000..2e30dfa --- /dev/null +++ b/lib/nola_plugins/txt_plugin/markov.ex @@ -0,0 +1,9 @@ +defmodule Nola.IRC.TxtPlugin.Markov do + + @type state :: any() + @callback start_link() :: {:ok, state()} + @callback reload(content :: Map.t, state()) :: any() + @callback sentence(state()) :: {:ok, String.t} | {:error, String.t} + @callback complete_sentence(state()) :: {:ok, String.t} | {:error, String.t} + +end diff --git a/lib/nola_plugins/txt_plugin/markov_native.ex b/lib/nola_plugins/txt_plugin/markov_native.ex new file mode 100644 index 0000000..4c403c2 --- /dev/null +++ b/lib/nola_plugins/txt_plugin/markov_native.ex @@ -0,0 +1,33 @@ +defmodule Nola.IRC.TxtPlugin.MarkovNative do + @behaviour Nola.IRC.TxtPlugin.Markov + + def start_link() do + ExChain.MarkovModel.start_link() + end + + def reload(data, markov) do + data = data + |> Enum.map(fn({_, data}) -> + for {line, _idx} <- data, do: line + end) + |> List.flatten + + ExChain.MarkovModel.populate_model(markov, data) + :ok + end + + def sentence(markov) do + case ExChain.SentenceGenerator.create_filtered_sentence(markov) do + {:ok, line, _, _} -> {:ok, line} + error -> error + end + end + + def complete_sentence(sentence, markov) do + case ExChain.SentenceGenerator.complete_sentence(markov, sentence) do + {line, _} -> {:ok, line} + error -> error + end + end + +end diff --git a/lib/nola_plugins/txt_plugin/markov_py_markovify.ex b/lib/nola_plugins/txt_plugin/markov_py_markovify.ex new file mode 100644 index 0000000..b610ea8 --- /dev/null +++ b/lib/nola_plugins/txt_plugin/markov_py_markovify.ex @@ -0,0 +1,39 @@ +defmodule Nola.IRC.TxtPlugin.MarkovPyMarkovify do + + def start_link() do + {:ok, nil} + end + + def reload(_data, _markov) do + :ok + end + + def sentence(_) do + {:ok, run()} + end + + def complete_sentence(sentence, _) do + {:ok, run([sentence])} + end + + defp run(args \\ []) do + {binary, script} = script() + args = [script, Path.expand(Nola.IRC.TxtPlugin.directory()) | args] + IO.puts "Args #{inspect args}" + case MuonTrap.cmd(binary, args) do + {response, 0} -> response + {response, code} -> "error #{code}: #{response}" + end + end + + defp script() do + default_script = to_string(:code.priv_dir(:nola)) <> "/irc/txt/markovify.py" + env = Application.get_env(:nola, Nola.IRC.TxtPlugin, []) + |> Keyword.get(:py_markovify, []) + + {Keyword.get(env, :python, "python3"), Keyword.get(env, :script, default_script)} + end + + + +end diff --git a/lib/nola_plugins/untappd_plugin.ex b/lib/nola_plugins/untappd_plugin.ex new file mode 100644 index 0000000..50b0c4d --- /dev/null +++ b/lib/nola_plugins/untappd_plugin.ex @@ -0,0 +1,66 @@ +defmodule Nola.IRC.UntappdPlugin do + + def irc_doc() do + """ + # [Untappd](https://untappd.com) + + * `!beer <beer name>` Information about the first beer matching `<beer name>` + * `?beer <beer name>` List the 10 firsts beer matching `<beer name>` + + _Note_: The best way to search is always "Brewery Name + Beer Name", such as "Dogfish 60 Minute". + + Link your Untappd account to the bot (for automated checkins on [alcoolog](#alcoolog), ...) with the `enable-untappd` command, in private. + """ + end + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:beer", [plugin: __MODULE__]) + {:ok, %{}} + end + + def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %{type: :bang, args: args}}}, state) do + case Untappd.search_beer(Enum.join(args, " "), limit: 1) do + {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => [result | _]}}}} -> + %{"beer" => beer, "brewery" => brewery} = result + description = Map.get(beer, "beer_description") + |> String.replace("\n", " ") + |> String.replace("\r", " ") + |> String.trim() + beer_s = "#{Map.get(brewery, "brewery_name")}: #{Map.get(beer, "beer_name")} - #{Map.get(beer, "beer_abv")}°" + city = get_in(brewery, ["location", "brewery_city"]) + location = [Map.get(brewery, "brewery_type"), city, Map.get(brewery, "country_name")] + |> Enum.filter(fn(x) -> x end) + |> Enum.join(", ") + extra = "#{Map.get(beer, "beer_style")} - IBU: #{Map.get(beer, "beer_ibu")} - #{location}" + m.replyfun.([beer_s, extra, description]) + err -> + m.replyfun.("Error") + end + {:noreply, state} + end + + + def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %{type: :query, args: args}}}, state) do + case Untappd.search_beer(Enum.join(args, " ")) do + {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => results}}}} -> + beers = for %{"beer" => beer, "brewery" => brewery} <- results do + "#{Map.get(brewery, "brewery_name")}: #{Map.get(beer, "beer_name")} - #{Map.get(beer, "beer_abv")}°" + end + |> Enum.intersperse(", ") + |> Enum.join("") + m.replyfun.("#{count}. #{beers}") + err -> + m.replyfun.("Error") + end + {:noreply, state} + end + + def handle_info(info, state) do + {:noreply, state} + end + +end diff --git a/lib/nola_plugins/user_mention_plugin.ex b/lib/nola_plugins/user_mention_plugin.ex new file mode 100644 index 0000000..eb230fd --- /dev/null +++ b/lib/nola_plugins/user_mention_plugin.ex @@ -0,0 +1,52 @@ +defmodule Nola.IRC.UserMentionPlugin do + @moduledoc """ + # mention + + * **@`<nick>` `<message>`**: notifie si possible le nick immédiatement via Telegram, SMS, ou équivalent à `!tell`. + """ + + require Logger + + def short_irc_doc, do: false + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "triggers", plugin: __MODULE__) + {:ok, nil} + end + + def handle_info({:irc, :trigger, nick, message = %IRC.Message{sender: sender, account: account, network: network, channel: channel, trigger: %IRC.Trigger{type: :at, args: content}}}, state) do + nick = nick + |> String.trim(":") + |> String.trim(",") + target = IRC.Account.find_always_by_nick(network, channel, nick) + if target do + telegram = IRC.Account.get_meta(target, "telegram-id") + sms = IRC.Account.get_meta(target, "sms-number") + text = "#{channel} <#{sender.nick}> #{Enum.join(content, " ")}" + + cond do + telegram -> + Nola.Telegram.send_message(telegram, "`#{channel}` <**#{sender.nick}**> #{Enum.join(content, " ")}") + sms -> + case Nola.IRC.SmsPlugin.send_sms(sms, text) do + {:error, code} -> message.replyfun("#{sender.nick}: erreur #{code} (sms)") + end + true -> + Nola.IRC.TellPlugin.tell(message, nick, content) + end + else + message.replyfun.("#{nick} m'est inconnu") + end + {:noreply, state} + end + + def handle_info(_, state) do + {:noreply, state} + end + +end diff --git a/lib/nola_plugins/wikipedia_plugin.ex b/lib/nola_plugins/wikipedia_plugin.ex new file mode 100644 index 0000000..3202e13 --- /dev/null +++ b/lib/nola_plugins/wikipedia_plugin.ex @@ -0,0 +1,90 @@ +defmodule Nola.IRC.WikipediaPlugin do + require Logger + + @moduledoc """ + # wikipédia + + * **!wp `<recherche>`**: retourne le premier résultat de la `<recherche>` Wikipedia + * **!wp**: un article Wikipédia au hasard + """ + + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:wp", [plugin: __MODULE__]) + {:ok, nil} + end + + def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: []}}}, state) do + irc_random(message) + {:noreply, state} + end + def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do + irc_search(Enum.join(args, " "), message) + {:noreply, state} + end + + def handle_info(info, state) do + {:noreply, state} + end + + defp irc_search("", message), do: irc_random(message) + defp irc_search(query, message) do + params = %{ + "action" => "query", + "list" => "search", + "srsearch" => String.strip(query), + "srlimit" => 1, + } + case query_wikipedia(params) do + {:ok, %{"query" => %{"search" => [item | _]}}} -> + title = item["title"] + url = "https://fr.wikipedia.org/wiki/" <> String.replace(title, " ", "_") + msg = "Wikipédia: #{title} — #{url}" + message.replyfun.(msg) + _ -> + nil + end + end + + defp irc_random(message) do + params = %{ + "action" => "query", + "generator" => "random", + "grnnamespace" => 0, + "prop" => "info" + } + case query_wikipedia(params) do + {:ok, %{"query" => %{"pages" => map = %{}}}} -> + [{_, item}] = Map.to_list(map) + title = item["title"] + url = "https://fr.wikipedia.org/wiki/" <> String.replace(title, " ", "_") + msg = "Wikipédia: #{title} — #{url}" + message.replyfun.(msg) + _ -> + nil + end + end + + defp query_wikipedia(params) do + url = "https://fr.wikipedia.org/w/api.php" + params = params + |> Map.put("format", "json") + |> Map.put("utf8", "") + + case HTTPoison.get(url, [], params: params) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> Jason.decode(body) + {:ok, %HTTPoison.Response{status_code: 400, body: body}} -> + Logger.error "Wikipedia HTTP 400: #{inspect body}" + {:error, "http 400"} + error -> + Logger.error "Wikipedia http error: #{inspect error}" + {:error, "http client error"} + end + end + +end diff --git a/lib/nola_plugins/wolfram_alpha_plugin.ex b/lib/nola_plugins/wolfram_alpha_plugin.ex new file mode 100644 index 0000000..6ee06f0 --- /dev/null +++ b/lib/nola_plugins/wolfram_alpha_plugin.ex @@ -0,0 +1,47 @@ +defmodule Nola.IRC.WolframAlphaPlugin do + use GenServer + require Logger + + @moduledoc """ + # wolfram alpha + + * **`!wa <requête>`** lance `<requête>` sur WolframAlpha + """ + + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, _} = Registry.register(IRC.PubSub, "trigger:wa", [plugin: __MODULE__]) + {:ok, nil} + end + + def handle_info({:irc, :trigger, _, m = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: query}}}, state) do + query = Enum.join(query, " ") + params = %{ + "appid" => Keyword.get(Application.get_env(:nola, :wolframalpha, []), :app_id, "NO_APP_ID"), + "units" => "metric", + "i" => query + } + url = "https://www.wolframalpha.com/input/?i=" <> URI.encode(query) + case HTTPoison.get("http://api.wolframalpha.com/v1/result", [], [params: params]) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + m.replyfun.(["#{query} -> #{body}", url]) + {:ok, %HTTPoison.Response{status_code: code, body: body}} -> + error = case {code, body} do + {501, b} -> "input invalide: #{body}" + {code, error} -> "erreur #{code}: #{body || ""}" + end + m.replyfun.("wa: #{error}") + {:error, %HTTPoison.Error{reason: reason}} -> + m.replyfun.("wa: erreur http: #{to_string(reason)}") + _ -> + m.replyfun.("wa: erreur http") + end + {:noreply, state} + end + +end diff --git a/lib/nola_plugins/youtube_plugin.ex b/lib/nola_plugins/youtube_plugin.ex new file mode 100644 index 0000000..fb9bea2 --- /dev/null +++ b/lib/nola_plugins/youtube_plugin.ex @@ -0,0 +1,104 @@ +defmodule Nola.IRC.YouTubePlugin do + require Logger + + @moduledoc """ + # youtube + + * **!yt `<recherche>`**, !youtube `<recherche>`: retourne le premier résultat de la `<recherche>` YouTube + """ + + defstruct client: nil + + def irc_doc, do: @moduledoc + + def start_link() do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init([]) do + for t <- ["trigger:yt", "trigger:youtube"], do: {:ok, _} = Registry.register(IRC.PubSub, t, [plugin: __MODULE__]) + {:ok, %__MODULE__{}} + end + + def handle_info({:irc, :trigger, _, message = %IRC.Message{trigger: %IRC.Trigger{type: :bang, args: args}}}, state) do + irc_search(Enum.join(args, " "), message) + {:noreply, state} + end + + def handle_info(info, state) do + {:noreply, state} + end + + defp irc_search(query, message) do + case search(query) do + {:ok, %{"items" => [item | _]}} -> + url = "https://youtube.com/watch?v=" <> item["id"] + 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) + + info_line = "— #{duration} — uploaded by #{snippet["channelTitle"]} — #{date}" + <> " — #{item["statistics"]["viewCount"]} views, #{item["statistics"]["likeCount"]} likes," + <> " #{item["statistics"]["dislikeCount"]} dislikes" + message.replyfun.("#{snippet["title"]} — #{url}") + message.replyfun.(info_line) + {:error, error} -> + message.replyfun.("Erreur YouTube: "<>error) + _ -> + nil + end + end + + defp search(query) do + query = query + |> String.strip + key = Application.get_env(:nola, :youtube)[:api_key] + params = %{ + "key" => key, + "maxResults" => 1, + "part" => "id", + "safeSearch" => "none", + "type" => "video", + "q" => query, + } + url = "https://www.googleapis.com/youtube/v3/search" + case HTTPoison.get(url, [], params: params) do + {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> + {:ok, json} = Jason.decode(body) + item = List.first(json["items"]) + if item do + video_id = item["id"]["videoId"] + 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}} -> + Jason.decode(body) + {:ok, %HTTPoison.Response{status_code: code, body: body}} -> + Logger.error "YouTube HTTP #{code}: #{inspect body}" + {:error, "http #{code}"} + error -> + Logger.error "YouTube http error: #{inspect error}" + :error + end + else + :error + end + {:ok, %HTTPoison.Response{status_code: code, body: body}} -> + Logger.error "YouTube HTTP #{code}: #{inspect body}" + {:error, "http #{code}"} + error -> + Logger.error "YouTube http error: #{inspect error}" + :error + end + end + +end |