1527 lines
32 KiB
Elixir
1527 lines
32 KiB
Elixir
defmodule Mobilizon.Events do
|
|
@moduledoc """
|
|
The Events context.
|
|
"""
|
|
|
|
import Ecto.Query
|
|
import EctoEnum
|
|
|
|
import Mobilizon.Storage.Ecto
|
|
|
|
alias Mobilizon.Actors.Actor
|
|
alias Mobilizon.Addresses.Address
|
|
alias Mobilizon.Events.{Event, Comment, Participant}
|
|
alias Mobilizon.Storage.{Page, Repo}
|
|
alias Mobilizon.Users.User
|
|
|
|
defenum(EventVisibility, :event_visibility, [
|
|
:public,
|
|
:unlisted,
|
|
:restricted,
|
|
:private
|
|
])
|
|
|
|
defenum(JoinOptions, :join_options, [
|
|
:free,
|
|
:restricted,
|
|
:invite
|
|
])
|
|
|
|
defenum(EventStatus, :event_status, [
|
|
:tentative,
|
|
:confirmed,
|
|
:cancelled
|
|
])
|
|
|
|
defenum(EventCategory, :event_category, [
|
|
:business,
|
|
:conference,
|
|
:birthday,
|
|
:demonstration,
|
|
:meeting
|
|
])
|
|
|
|
defenum(CommentVisibility, :comment_visibility, [
|
|
:public,
|
|
:unlisted,
|
|
:private,
|
|
:moderated,
|
|
:invite
|
|
])
|
|
|
|
defenum(CommentModeration, :comment_moderation, [
|
|
:allow_all,
|
|
:moderated,
|
|
:closed
|
|
])
|
|
|
|
defenum(ParticipantRole, :participant_role, [
|
|
:not_approved,
|
|
:participant,
|
|
:moderator,
|
|
:administrator,
|
|
:creator
|
|
])
|
|
|
|
@doc false
|
|
@spec data :: Dataloader.Ecto.t()
|
|
def data, do: Dataloader.Ecto.new(Repo, query: &query/2)
|
|
|
|
@doc false
|
|
@spec query(Ecto.Query.t(), map) :: Ecto.Query.t()
|
|
def query(queryable, _params), do: queryable
|
|
|
|
def get_public_events_for_actor(%Actor{id: actor_id} = _actor, page \\ nil, limit \\ nil) do
|
|
query =
|
|
from(
|
|
e in Event,
|
|
where: e.organizer_actor_id == ^actor_id and e.visibility in [^:public, ^:unlisted],
|
|
order_by: [desc: :id],
|
|
preload: [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address,
|
|
:picture
|
|
]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
|
|
events = Repo.all(query)
|
|
|
|
count_events =
|
|
Repo.one(from(e in Event, select: count(e.id), where: e.organizer_actor_id == ^actor_id))
|
|
|
|
{:ok, events, count_events}
|
|
end
|
|
|
|
@doc """
|
|
Get an actor's eventual upcoming public event
|
|
"""
|
|
@spec get_actor_upcoming_public_event(Actor.t(), String.t()) :: Event.t() | nil
|
|
def get_actor_upcoming_public_event(%Actor{id: actor_id} = _actor, not_event_uuid \\ nil) do
|
|
query =
|
|
from(
|
|
e in Event,
|
|
where:
|
|
e.organizer_actor_id == ^actor_id and e.visibility in [^:public, ^:unlisted] and
|
|
e.begins_on > ^DateTime.utc_now(),
|
|
order_by: [asc: :begins_on],
|
|
limit: 1,
|
|
preload: [
|
|
:organizer_actor,
|
|
:tags,
|
|
:participants,
|
|
:physical_address
|
|
]
|
|
)
|
|
|
|
query =
|
|
if is_nil(not_event_uuid),
|
|
do: query,
|
|
else: from(q in query, where: q.uuid != ^not_event_uuid)
|
|
|
|
Repo.one(query)
|
|
end
|
|
|
|
def count_local_events do
|
|
Repo.one(
|
|
from(
|
|
e in Event,
|
|
select: count(e.id),
|
|
where: e.local == ^true and e.visibility in [^:public, ^:unlisted]
|
|
)
|
|
)
|
|
end
|
|
|
|
def count_local_comments do
|
|
Repo.one(
|
|
from(
|
|
c in Comment,
|
|
select: count(c.id),
|
|
where: c.local == ^true and c.visibility in [^:public, ^:unlisted]
|
|
)
|
|
)
|
|
end
|
|
|
|
import Geo.PostGIS
|
|
|
|
@doc """
|
|
Find close events to coordinates
|
|
|
|
Radius is in meters and defaults to 50km.
|
|
"""
|
|
@spec find_close_events(number(), number(), number(), number()) :: list(Event.t())
|
|
def find_close_events(lon, lat, radius \\ 50_000, srid \\ 4326) do
|
|
with {:ok, point} <- Geo.WKT.decode("SRID=#{srid};POINT(#{lon} #{lat})") do
|
|
Repo.all(
|
|
from(
|
|
e in Event,
|
|
join: a in Address,
|
|
on: a.id == e.physical_address_id,
|
|
where: e.visibility == ^:public and st_dwithin_in_meters(^point, a.geom, ^radius),
|
|
preload: :organizer_actor
|
|
)
|
|
)
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Gets a single event.
|
|
|
|
Raises `Ecto.NoResultsError` if the Event does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_event!(123)
|
|
%Event{}
|
|
|
|
iex> get_event!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_event!(id), do: Repo.get!(Event, id)
|
|
|
|
@doc """
|
|
Gets a single event.
|
|
"""
|
|
def get_event(id) do
|
|
case Repo.get(Event, id) do
|
|
nil -> {:error, :event_not_found}
|
|
event -> {:ok, event}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Gets an event by it's URL
|
|
"""
|
|
def get_event_by_url(url) do
|
|
Repo.get_by(Event, url: url)
|
|
end
|
|
|
|
@doc """
|
|
Gets an event by it's URL
|
|
"""
|
|
def get_event_by_url!(url) do
|
|
Repo.get_by!(Event, url: url)
|
|
end
|
|
|
|
# @doc """
|
|
# Gets an event by it's UUID
|
|
# """
|
|
# @depreciated "Use get_event_full_by_uuid/3 instead"
|
|
# def get_event_by_uuid(uuid) do
|
|
# Repo.get_by(Event, uuid: uuid)
|
|
# end
|
|
|
|
@doc """
|
|
Gets a full event by it's UUID
|
|
"""
|
|
@spec get_event_full_by_uuid(String.t()) :: Event.t()
|
|
def get_event_full_by_uuid(uuid) do
|
|
from(
|
|
e in Event,
|
|
where: e.uuid == ^uuid and e.visibility in [^:public, ^:unlisted],
|
|
preload: [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address,
|
|
:picture
|
|
]
|
|
)
|
|
|> Repo.one()
|
|
end
|
|
|
|
def get_cached_event_full_by_uuid(uuid) do
|
|
Cachex.fetch(:activity_pub, "event_" <> uuid, fn "event_" <> uuid ->
|
|
case get_event_full_by_uuid(uuid) do
|
|
%Event{} = event ->
|
|
{:commit, event}
|
|
|
|
_ ->
|
|
{:ignore, nil}
|
|
end
|
|
end)
|
|
end
|
|
|
|
@doc """
|
|
Gets a single event, with all associations loaded.
|
|
"""
|
|
def get_event_full!(id) do
|
|
event = Repo.get!(Event, id)
|
|
|
|
Repo.preload(event, [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address
|
|
])
|
|
end
|
|
|
|
@doc """
|
|
Gets a single event, with all associations loaded.
|
|
"""
|
|
def get_event_full(id) do
|
|
case Repo.get(Event, id) do
|
|
%Event{} = event ->
|
|
{:ok,
|
|
Repo.preload(event, [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address,
|
|
:picture
|
|
])}
|
|
|
|
_err ->
|
|
{:error, :event_not_found}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Gets an event by it's URL
|
|
"""
|
|
def get_event_full_by_url(url) do
|
|
case Repo.one(
|
|
from(e in Event,
|
|
where: e.url == ^url and e.visibility in [^:public, ^:unlisted],
|
|
preload: [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address
|
|
]
|
|
)
|
|
) do
|
|
nil -> {:error, :event_not_found}
|
|
event -> {:ok, event}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Gets an event by it's URL
|
|
"""
|
|
def get_event_full_by_url!(url) do
|
|
Repo.one(
|
|
from(e in Event,
|
|
where: e.url == ^url and e.visibility in [^:public, ^:unlisted],
|
|
preload: [
|
|
:organizer_actor,
|
|
:sessions,
|
|
:tracks,
|
|
:tags,
|
|
:participants,
|
|
:physical_address,
|
|
:picture
|
|
]
|
|
)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of events.
|
|
|
|
## Examples
|
|
|
|
iex> list_events()
|
|
[%Event{}, ...]
|
|
|
|
"""
|
|
@spec list_events(integer(), integer(), atom(), atom()) :: list(Event.t())
|
|
def list_events(
|
|
page \\ nil,
|
|
limit \\ nil,
|
|
sort \\ :begins_on,
|
|
direction \\ :asc,
|
|
unlisted \\ false,
|
|
future \\ true
|
|
) do
|
|
query =
|
|
from(
|
|
e in Event,
|
|
preload: [:organizer_actor, :participants]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
|> sort(sort, direction)
|
|
|> restrict_future_events(future)
|
|
|> allow_unlisted(unlisted)
|
|
|
|
Repo.all(query)
|
|
end
|
|
|
|
# Make sure we only show future events
|
|
@spec restrict_future_events(Ecto.Query.t(), boolean()) :: Ecto.Query.t()
|
|
defp restrict_future_events(query, true),
|
|
do: from(q in query, where: q.begins_on > ^DateTime.utc_now())
|
|
|
|
defp restrict_future_events(query, false), do: query
|
|
|
|
# Make sure unlisted events don't show up where they're not allowed
|
|
@spec allow_unlisted(Ecto.Query.t(), boolean()) :: Ecto.Query.t()
|
|
defp allow_unlisted(query, true),
|
|
do: from(q in query, where: q.visibility in [^:public, ^:unlisted])
|
|
|
|
defp allow_unlisted(query, false), do: from(q in query, where: q.visibility == ^:public)
|
|
|
|
@doc """
|
|
Find events by name
|
|
"""
|
|
def find_and_count_events_by_name(name, page \\ nil, limit \\ nil)
|
|
|
|
def find_and_count_events_by_name(name, page, limit) do
|
|
name = String.trim(name)
|
|
|
|
query =
|
|
from(e in Event,
|
|
where:
|
|
e.visibility == ^:public and
|
|
fragment(
|
|
"f_unaccent(?) %> f_unaccent(?)",
|
|
e.title,
|
|
^name
|
|
),
|
|
order_by:
|
|
fragment(
|
|
"word_similarity(?, ?) desc",
|
|
e.title,
|
|
^name
|
|
),
|
|
preload: [:organizer_actor]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
|
|
total = Task.async(fn -> Repo.aggregate(query, :count, :id) end)
|
|
elements = Task.async(fn -> Repo.all(query) end)
|
|
|
|
%{total: Task.await(total), elements: Task.await(elements)}
|
|
end
|
|
|
|
@doc """
|
|
Find events with the same tags
|
|
"""
|
|
@spec find_similar_events_by_common_tags(list(), integer()) :: {:ok, list(Event.t())}
|
|
def find_similar_events_by_common_tags(tags, limit \\ 2) do
|
|
tags_ids = Enum.map(tags, & &1.id)
|
|
|
|
query =
|
|
from(e in Event,
|
|
distinct: e.uuid,
|
|
join: te in "events_tags",
|
|
on: e.id == te.event_id,
|
|
where: e.begins_on > ^DateTime.utc_now(),
|
|
where: e.visibility in [^:public, ^:unlisted],
|
|
where: te.tag_id in ^tags_ids,
|
|
order_by: [asc: e.begins_on],
|
|
limit: ^limit
|
|
)
|
|
|
|
Repo.all(query)
|
|
end
|
|
|
|
@doc """
|
|
Creates a event.
|
|
|
|
## Examples
|
|
|
|
iex> create_event(%{field: value})
|
|
{:ok, %Event{}}
|
|
|
|
iex> create_event(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_event(attrs \\ %{}) do
|
|
with %Event{} = event <- do_create_event(attrs),
|
|
{:ok, %Participant{} = _participant} <-
|
|
%Participant{}
|
|
|> Participant.changeset(%{
|
|
actor_id: event.organizer_actor_id,
|
|
role: :creator,
|
|
event_id: event.id
|
|
})
|
|
|> Repo.insert() do
|
|
{:ok, event}
|
|
end
|
|
end
|
|
|
|
defp do_create_event(attrs) do
|
|
with {:ok, %Event{} = event} <- %Event{} |> Event.changeset(attrs) |> Repo.insert(),
|
|
%Event{} = event <-
|
|
event |> Repo.preload([:tags, :organizer_actor, :physical_address, :picture]),
|
|
{:has_tags, true, _} <- {:has_tags, Map.has_key?(attrs, "tags"), event} do
|
|
event
|
|
|> Ecto.Changeset.change()
|
|
|> Ecto.Changeset.put_assoc(:tags, attrs["tags"])
|
|
|> Repo.update()
|
|
else
|
|
{:has_tags, false, event} ->
|
|
event
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Updates a event.
|
|
|
|
## Examples
|
|
|
|
iex> update_event(event, %{field: new_value})
|
|
{:ok, %Event{}}
|
|
|
|
iex> update_event(event, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_event(%Event{} = event, attrs) do
|
|
event
|
|
|> Repo.preload(:tags)
|
|
|> Event.update_changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Event.
|
|
|
|
## Examples
|
|
|
|
iex> delete_event(event)
|
|
{:ok, %Event{}}
|
|
|
|
iex> delete_event(event)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_event(%Event{} = event) do
|
|
Repo.delete(event)
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Event.
|
|
|
|
Raises an exception if it fails.
|
|
"""
|
|
def delete_event!(%Event{} = event) do
|
|
Repo.delete!(event)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking event changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_event(event)
|
|
%Ecto.Changeset{source: %Event{}}
|
|
|
|
"""
|
|
def change_event(%Event{} = event) do
|
|
Event.changeset(event, %{})
|
|
end
|
|
|
|
alias Mobilizon.Events.Tag
|
|
|
|
@doc """
|
|
Returns the list of tags.
|
|
|
|
## Examples
|
|
|
|
iex> list_tags()
|
|
[%Tag{}, ...]
|
|
|
|
"""
|
|
def list_tags(page \\ nil, limit \\ nil) do
|
|
Repo.all(
|
|
Tag
|
|
|> Page.paginate(page, limit)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of tags for an event.
|
|
|
|
## Examples
|
|
|
|
iex> list_tags_for_event(id)
|
|
[%Participant{}, ...]
|
|
|
|
"""
|
|
def list_tags_for_event(id, page \\ nil, limit \\ nil) do
|
|
Repo.all(
|
|
from(
|
|
t in Tag,
|
|
join: e in "events_tags",
|
|
on: t.id == e.tag_id,
|
|
where: e.event_id == ^id
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Gets a single tag.
|
|
|
|
Raises `Ecto.NoResultsError` if the Tag does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_tag!(123)
|
|
%Tag{}
|
|
|
|
iex> get_tag!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_tag!(id), do: Repo.get!(Tag, id)
|
|
|
|
def get_tag(id), do: Repo.get(Tag, id)
|
|
|
|
def get_tag_by_slug(slug) do
|
|
query =
|
|
from(
|
|
t in Tag,
|
|
where: t.slug == ^slug
|
|
)
|
|
|
|
Repo.one(query)
|
|
end
|
|
|
|
@doc """
|
|
Get an existing tag or create one
|
|
"""
|
|
@spec get_or_create_tag(map()) :: {:ok, Tag.t()} | {:error, any()}
|
|
def get_or_create_tag(tag) do
|
|
"#" <> title = tag["name"]
|
|
|
|
case Repo.get_by(Tag, title: title) do
|
|
%Tag{} = tag ->
|
|
{:ok, tag}
|
|
|
|
nil ->
|
|
create_tag(%{"title" => title})
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Creates a tag.
|
|
|
|
## Examples
|
|
|
|
iex> create_tag(%{field: value})
|
|
{:ok, %Tag{}}
|
|
|
|
iex> create_tag(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_tag(attrs \\ %{}) do
|
|
%Tag{}
|
|
|> Tag.changeset(attrs)
|
|
|> Repo.insert()
|
|
end
|
|
|
|
@doc """
|
|
Updates a tag.
|
|
|
|
## Examples
|
|
|
|
iex> update_tag(tag, %{field: new_value})
|
|
{:ok, %Tag{}}
|
|
|
|
iex> update_tag(tag, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_tag(%Tag{} = tag, attrs) do
|
|
tag
|
|
|> Tag.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Tag.
|
|
|
|
## Examples
|
|
|
|
iex> delete_tag(tag)
|
|
{:ok, %Tag{}}
|
|
|
|
iex> delete_tag(tag)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_tag(%Tag{} = tag) do
|
|
Repo.delete(tag)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking tag changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_tag(tag)
|
|
%Ecto.Changeset{source: %Tag{}}
|
|
|
|
"""
|
|
def change_tag(%Tag{} = tag) do
|
|
Tag.changeset(tag, %{})
|
|
end
|
|
|
|
alias Mobilizon.Events.TagRelation
|
|
|
|
@doc """
|
|
Create a relation between two tags
|
|
"""
|
|
@spec create_tag_relation(map()) :: {:ok, TagRelation.t()} | {:error, Ecto.Changeset.t()}
|
|
def create_tag_relation(attrs \\ {}) do
|
|
%TagRelation{}
|
|
|> TagRelation.changeset(attrs)
|
|
|> Repo.insert(conflict_target: [:tag_id, :link_id], on_conflict: [inc: [weight: 1]])
|
|
end
|
|
|
|
@doc """
|
|
Remove a tag relation
|
|
"""
|
|
def delete_tag_relation(%TagRelation{} = tag_relation) do
|
|
Repo.delete(tag_relation)
|
|
end
|
|
|
|
@doc """
|
|
Returns whether two tags are linked or not
|
|
"""
|
|
def are_tags_linked(%Tag{id: tag1_id}, %Tag{id: tag2_id}) do
|
|
case from(tr in TagRelation,
|
|
where: tr.tag_id == ^min(tag1_id, tag2_id) and tr.link_id == ^max(tag1_id, tag2_id)
|
|
)
|
|
|> Repo.one() do
|
|
%TagRelation{} -> true
|
|
_ -> false
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Returns the tags neighbors for a given tag
|
|
|
|
We can't rely on the single many_to_many relation since we also want tags that link to our tag, not just tags linked by this one
|
|
|
|
The SQL query looks like this:
|
|
```sql
|
|
SELECT * FROM tags t
|
|
RIGHT JOIN (
|
|
SELECT weight, link_id AS id
|
|
FROM tag_relations t2
|
|
WHERE tag_id = 1
|
|
UNION ALL
|
|
SELECT tag_id AS id, weight
|
|
FROM tag_relations t2
|
|
WHERE link_id = 1
|
|
) tr
|
|
ON t.id = tr.id
|
|
ORDER BY tr.weight
|
|
DESC;
|
|
```
|
|
"""
|
|
def tag_neighbors(%Tag{id: id}, relation_minimum \\ 1, limit \\ 10) do
|
|
query2 =
|
|
from(tr in TagRelation,
|
|
select: %{id: tr.tag_id, weight: tr.weight},
|
|
where: tr.link_id == ^id
|
|
)
|
|
|
|
query =
|
|
from(tr in TagRelation,
|
|
select: %{id: tr.link_id, weight: tr.weight},
|
|
union_all: ^query2,
|
|
where: tr.tag_id == ^id
|
|
)
|
|
|
|
final_query =
|
|
from(t in Tag,
|
|
right_join: q in subquery(query),
|
|
on: [id: t.id],
|
|
where: q.weight >= ^relation_minimum,
|
|
limit: ^limit,
|
|
order_by: [desc: q.weight]
|
|
)
|
|
|
|
Repo.all(final_query)
|
|
end
|
|
|
|
alias Mobilizon.Events.Participant
|
|
|
|
@doc """
|
|
Returns the list of participants.
|
|
|
|
## Examples
|
|
|
|
iex> list_participants()
|
|
[%Participant{}, ...]
|
|
|
|
"""
|
|
def list_participants do
|
|
Repo.all(Participant)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of participants for an event.
|
|
|
|
Default behaviour is to not return :not_approved participants
|
|
|
|
## Examples
|
|
|
|
iex> list_participants_for_event(some_uuid)
|
|
[%Participant{}, ...]
|
|
|
|
"""
|
|
def list_participants_for_event(uuid, page \\ nil, limit \\ nil, include_not_improved \\ false)
|
|
|
|
def list_participants_for_event(uuid, page, limit, false) do
|
|
query = do_list_participants_for_event(uuid, page, limit)
|
|
query = from(p in query, where: p.role != ^:not_approved)
|
|
Repo.all(query)
|
|
end
|
|
|
|
def list_participants_for_event(uuid, page, limit, true) do
|
|
query = do_list_participants_for_event(uuid, page, limit)
|
|
Repo.all(query)
|
|
end
|
|
|
|
defp do_list_participants_for_event(uuid, page, limit) do
|
|
from(
|
|
p in Participant,
|
|
join: e in Event,
|
|
on: p.event_id == e.id,
|
|
where: e.uuid == ^uuid,
|
|
preload: [:actor]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of participations for an actor.
|
|
|
|
Default behaviour is to not return :not_approved participants
|
|
|
|
## Examples
|
|
|
|
iex> list_participants_for_actor(%Actor{})
|
|
[%Participant{}, ...]
|
|
|
|
"""
|
|
def list_event_participations_for_actor(%Actor{id: id}, page \\ nil, limit \\ nil) do
|
|
Repo.all(
|
|
from(
|
|
e in Event,
|
|
join: p in Participant,
|
|
join: a in Actor,
|
|
on: p.actor_id == a.id,
|
|
on: p.event_id == e.id,
|
|
where: a.id == ^id and p.role != ^:not_approved,
|
|
preload: [:picture, :tags]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of organizers participants for an event.
|
|
|
|
## Examples
|
|
|
|
iex> list_organizers_participants_for_event(id)
|
|
[%Participant{role: :creator}, ...]
|
|
|
|
"""
|
|
def list_organizers_participants_for_event(id, page \\ nil, limit \\ nil) do
|
|
Repo.all(
|
|
from(
|
|
p in Participant,
|
|
where: p.event_id == ^id and p.role == ^:creator,
|
|
preload: [:actor]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Gets a single participant.
|
|
|
|
Raises `Ecto.NoResultsError` if the Participant does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_participant!(123)
|
|
%Participant{}
|
|
|
|
iex> get_participant!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_participant!(event_id, actor_id) do
|
|
Repo.get_by!(Participant, event_id: event_id, actor_id: actor_id)
|
|
end
|
|
|
|
@doc """
|
|
Get a single participant
|
|
"""
|
|
def get_participant(event_id, actor_id) do
|
|
case Repo.get_by(Participant, event_id: event_id, actor_id: actor_id) do
|
|
nil -> {:error, :participant_not_found}
|
|
participant -> {:ok, participant}
|
|
end
|
|
end
|
|
|
|
def get_participant_by_url(url) do
|
|
Repo.one(
|
|
from(p in Participant,
|
|
where: p.url == ^url,
|
|
preload: [:actor, :event]
|
|
)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Creates a participant.
|
|
|
|
## Examples
|
|
|
|
iex> create_participant(%{field: value})
|
|
{:ok, %Participant{}}
|
|
|
|
iex> create_participant(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_participant(attrs \\ %{}) do
|
|
with {:ok, %Participant{} = participant} <-
|
|
%Participant{} |> Participant.changeset(attrs) |> Repo.insert() do
|
|
{:ok, Repo.preload(participant, [:event, :actor])}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Updates a participant.
|
|
|
|
## Examples
|
|
|
|
iex> update_participant(participant, %{field: new_value})
|
|
{:ok, %Participant{}}
|
|
|
|
iex> update_participant(participant, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_participant(%Participant{} = participant, attrs) do
|
|
participant
|
|
|> Participant.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Participant.
|
|
|
|
## Examples
|
|
|
|
iex> delete_participant(participant)
|
|
{:ok, %Participant{}}
|
|
|
|
iex> delete_participant(participant)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_participant(%Participant{} = participant) do
|
|
Repo.delete(participant)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking participant changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_participant(participant)
|
|
%Ecto.Changeset{source: %Participant{}}
|
|
|
|
"""
|
|
def change_participant(%Participant{} = participant) do
|
|
Participant.changeset(participant, %{})
|
|
end
|
|
|
|
@doc """
|
|
Get the default participant role depending on the event join options
|
|
"""
|
|
def get_default_participant_role(%Event{} = event) do
|
|
case event.join_options do
|
|
# Participant
|
|
:free -> :participant
|
|
# Not approved
|
|
_ -> :not_approved
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
List event participation requests for an actor
|
|
"""
|
|
@spec list_requests_for_actor(Actor.t()) :: list(Participant.t())
|
|
def list_requests_for_actor(%Actor{id: actor_id}) do
|
|
Repo.all(from(p in Participant, where: p.actor_id == ^actor_id and p.role == ^:not_approved))
|
|
end
|
|
|
|
alias Mobilizon.Events.Session
|
|
|
|
@doc """
|
|
Returns the list of sessions.
|
|
|
|
## Examples
|
|
|
|
iex> list_sessions()
|
|
[%Session{}, ...]
|
|
|
|
"""
|
|
def list_sessions do
|
|
Repo.all(Session)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of sessions for an event
|
|
"""
|
|
@spec list_sessions_for_event(Event.t()) :: list(Session.t())
|
|
def list_sessions_for_event(%Event{id: event_id}) do
|
|
Repo.all(
|
|
from(
|
|
s in Session,
|
|
join: e in Event,
|
|
on: s.event_id == e.id,
|
|
where: e.id == ^event_id
|
|
)
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Gets a single session.
|
|
|
|
Raises `Ecto.NoResultsError` if the Session does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_session!(123)
|
|
%Session{}
|
|
|
|
iex> get_session!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_session!(id), do: Repo.get!(Session, id)
|
|
|
|
@doc """
|
|
Creates a session.
|
|
|
|
## Examples
|
|
|
|
iex> create_session(%{field: value})
|
|
{:ok, %Session{}}
|
|
|
|
iex> create_session(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_session(attrs \\ %{}) do
|
|
%Session{}
|
|
|> Session.changeset(attrs)
|
|
|> Repo.insert()
|
|
end
|
|
|
|
@doc """
|
|
Updates a session.
|
|
|
|
## Examples
|
|
|
|
iex> update_session(session, %{field: new_value})
|
|
{:ok, %Session{}}
|
|
|
|
iex> update_session(session, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_session(%Session{} = session, attrs) do
|
|
session
|
|
|> Session.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Session.
|
|
|
|
## Examples
|
|
|
|
iex> delete_session(session)
|
|
{:ok, %Session{}}
|
|
|
|
iex> delete_session(session)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_session(%Session{} = session) do
|
|
Repo.delete(session)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking session changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_session(session)
|
|
%Ecto.Changeset{source: %Session{}}
|
|
|
|
"""
|
|
def change_session(%Session{} = session) do
|
|
Session.changeset(session, %{})
|
|
end
|
|
|
|
alias Mobilizon.Events.Track
|
|
|
|
@doc """
|
|
Returns the list of tracks.
|
|
|
|
## Examples
|
|
|
|
iex> list_tracks()
|
|
[%Track{}, ...]
|
|
|
|
"""
|
|
def list_tracks do
|
|
Repo.all(Track)
|
|
end
|
|
|
|
@doc """
|
|
Returns the list of sessions for a track
|
|
"""
|
|
@spec list_sessions_for_track(Track.t()) :: list(Session.t())
|
|
def list_sessions_for_track(%Track{id: track_id}) do
|
|
Repo.all(from(s in Session, where: s.track_id == ^track_id))
|
|
end
|
|
|
|
@doc """
|
|
Gets a single track.
|
|
|
|
Raises `Ecto.NoResultsError` if the Track does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_track!(123)
|
|
%Track{}
|
|
|
|
iex> get_track!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_track!(id), do: Repo.get!(Track, id)
|
|
|
|
@doc """
|
|
Creates a track.
|
|
|
|
## Examples
|
|
|
|
iex> create_track(%{field: value})
|
|
{:ok, %Track{}}
|
|
|
|
iex> create_track(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_track(attrs \\ %{}) do
|
|
%Track{}
|
|
|> Track.changeset(attrs)
|
|
|> Repo.insert()
|
|
end
|
|
|
|
@doc """
|
|
Updates a track.
|
|
|
|
## Examples
|
|
|
|
iex> update_track(track, %{field: new_value})
|
|
{:ok, %Track{}}
|
|
|
|
iex> update_track(track, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_track(%Track{} = track, attrs) do
|
|
track
|
|
|> Track.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Track.
|
|
|
|
## Examples
|
|
|
|
iex> delete_track(track)
|
|
{:ok, %Track{}}
|
|
|
|
iex> delete_track(track)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_track(%Track{} = track) do
|
|
Repo.delete(track)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking track changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_track(track)
|
|
%Ecto.Changeset{source: %Track{}}
|
|
|
|
"""
|
|
def change_track(%Track{} = track) do
|
|
Track.changeset(track, %{})
|
|
end
|
|
|
|
alias Mobilizon.Events.Comment
|
|
|
|
@doc """
|
|
Returns the list of public comments.
|
|
|
|
## Examples
|
|
|
|
iex> list_comments()
|
|
[%Comment{}, ...]
|
|
|
|
"""
|
|
def list_comments do
|
|
Repo.all(from(c in Comment, where: c.visibility == ^:public))
|
|
end
|
|
|
|
def get_public_comments_for_actor(%Actor{id: actor_id}, page \\ nil, limit \\ nil) do
|
|
query =
|
|
from(
|
|
c in Comment,
|
|
where: c.actor_id == ^actor_id and c.visibility in [^:public, ^:unlisted],
|
|
order_by: [desc: :id],
|
|
preload: [
|
|
:actor,
|
|
:in_reply_to_comment,
|
|
:origin_comment,
|
|
:event
|
|
]
|
|
)
|
|
|> Page.paginate(page, limit)
|
|
|
|
comments = Repo.all(query)
|
|
|
|
count_comments =
|
|
Repo.one(from(c in Comment, select: count(c.id), where: c.actor_id == ^actor_id))
|
|
|
|
{:ok, comments, count_comments}
|
|
end
|
|
|
|
@doc """
|
|
Gets a single comment.
|
|
|
|
Raises `Ecto.NoResultsError` if the Comment does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_comment!(123)
|
|
%Comment{}
|
|
|
|
iex> get_comment!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_comment!(id), do: Repo.get!(Comment, id)
|
|
|
|
# @doc """
|
|
# Gets a single comment from it's UUID
|
|
|
|
# """
|
|
# @spec get_comment_from_uuid(String.t) :: {:ok, Comment.t} | {:error, nil}
|
|
# def get_comment_from_uuid(uuid), do: Repo.get_by(Comment, uuid: uuid)
|
|
|
|
# @doc """
|
|
# Gets a single comment by it's UUID.
|
|
|
|
# Raises `Ecto.NoResultsError` if the Comment does not exist.
|
|
|
|
# ## Examples
|
|
|
|
# iex> get_comment_from_uuid!("123AFV13")
|
|
# %Comment{}
|
|
|
|
# iex> get_comment_from_uuid!("20R9HKDJHF")
|
|
# ** (Ecto.NoResultsError)
|
|
|
|
# """
|
|
# @spec get_comment_from_uuid(String.t) :: Comment.t
|
|
# def get_comment_from_uuid!(uuid), do: Repo.get_by!(Comment, uuid: uuid)
|
|
|
|
def get_comment_full_from_uuid(uuid) do
|
|
with %Comment{} = comment <- Repo.get_by!(Comment, uuid: uuid) do
|
|
Repo.preload(comment, [:actor, :attributed_to, :in_reply_to_comment])
|
|
end
|
|
end
|
|
|
|
def get_cached_comment_full_by_uuid(uuid) do
|
|
Cachex.fetch(:activity_pub, "comment_" <> uuid, fn "comment_" <> uuid ->
|
|
case get_comment_full_from_uuid(uuid) do
|
|
%Comment{} = comment ->
|
|
{:commit, comment}
|
|
|
|
_ ->
|
|
{:ignore, nil}
|
|
end
|
|
end)
|
|
end
|
|
|
|
def get_comment_from_url(url), do: Repo.get_by(Comment, url: url)
|
|
|
|
def get_comment_from_url!(url), do: Repo.get_by!(Comment, url: url)
|
|
|
|
def get_comment_full_from_url(url) do
|
|
case Repo.one(
|
|
from(c in Comment, where: c.url == ^url, preload: [:actor, :in_reply_to_comment])
|
|
) do
|
|
nil -> {:error, :comment_not_found}
|
|
comment -> {:ok, comment}
|
|
end
|
|
end
|
|
|
|
def get_comment_full_from_url!(url) do
|
|
with %Comment{} = comment <- Repo.get_by!(Comment, url: url) do
|
|
Repo.preload(comment, [:actor, :in_reply_to_comment])
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Get all comments by an actor and a list of ids
|
|
"""
|
|
def get_all_comments_by_actor_and_ids(actor_id, comment_ids \\ [])
|
|
def get_all_comments_by_actor_and_ids(_actor_id, []), do: []
|
|
|
|
def get_all_comments_by_actor_and_ids(actor_id, comment_ids) do
|
|
Comment
|
|
|> where([c], c.id in ^comment_ids)
|
|
|> where([c], c.actor_id == ^actor_id)
|
|
|> Repo.all()
|
|
end
|
|
|
|
@doc """
|
|
Creates a comment.
|
|
|
|
## Examples
|
|
|
|
iex> create_comment(%{field: value})
|
|
{:ok, %Comment{}}
|
|
|
|
iex> create_comment(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_comment(attrs \\ %{}) do
|
|
with {:ok, %Comment{} = comment} <-
|
|
%Comment{}
|
|
|> Comment.changeset(attrs)
|
|
|> Repo.insert(),
|
|
%Comment{} = comment <- Repo.preload(comment, [:actor, :in_reply_to_comment]) do
|
|
{:ok, comment}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Updates a comment.
|
|
|
|
## Examples
|
|
|
|
iex> update_comment(comment, %{field: new_value})
|
|
{:ok, %Comment{}}
|
|
|
|
iex> update_comment(comment, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_comment(%Comment{} = comment, attrs) do
|
|
comment
|
|
|> Comment.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Comment.
|
|
|
|
## Examples
|
|
|
|
iex> delete_comment(comment)
|
|
{:ok, %Comment{}}
|
|
|
|
iex> delete_comment(comment)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_comment(%Comment{} = comment) do
|
|
Repo.delete(comment)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking comment changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_comment(comment)
|
|
%Ecto.Changeset{source: %Comment{}}
|
|
|
|
"""
|
|
def change_comment(%Comment{} = comment) do
|
|
Comment.changeset(comment, %{})
|
|
end
|
|
|
|
alias Mobilizon.Events.FeedToken
|
|
|
|
@doc """
|
|
Gets a single feed token.
|
|
|
|
## Examples
|
|
|
|
iex> get_feed_token("123")
|
|
{:ok, %FeedToken{}}
|
|
|
|
iex> get_feed_token("456")
|
|
{:error, nil}
|
|
|
|
"""
|
|
def get_feed_token(token) do
|
|
from(ftk in FeedToken, where: ftk.token == ^token, preload: [:actor, :user])
|
|
|> Repo.one()
|
|
end
|
|
|
|
@doc """
|
|
Gets a single feed token.
|
|
|
|
Raises `Ecto.NoResultsError` if the FeedToken does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_feed_token!(123)
|
|
%FeedToken{}
|
|
|
|
iex> get_feed_token!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_feed_token!(token) do
|
|
from(
|
|
tk in FeedToken,
|
|
where: tk.token == ^token,
|
|
preload: [:actor, :user]
|
|
)
|
|
|> Repo.one!()
|
|
end
|
|
|
|
@doc """
|
|
Get feed tokens for an user
|
|
"""
|
|
@spec get_feed_tokens(User.t()) :: list(FeedTokens.t())
|
|
def get_feed_tokens(%User{id: id}) do
|
|
from(
|
|
tk in FeedToken,
|
|
where: tk.user_id == ^id,
|
|
preload: [:actor, :user]
|
|
)
|
|
|> Repo.all()
|
|
end
|
|
|
|
@doc """
|
|
Get feed tokens for an actor
|
|
"""
|
|
@spec get_feed_tokens(Actor.t()) :: list(FeedTokens.t())
|
|
def get_feed_tokens(%Actor{id: id, domain: nil}) do
|
|
from(
|
|
tk in FeedToken,
|
|
where: tk.actor_id == ^id,
|
|
preload: [:actor, :user]
|
|
)
|
|
|> Repo.all()
|
|
end
|
|
|
|
@doc """
|
|
Creates a feed token.
|
|
|
|
## Examples
|
|
|
|
iex> create_feed_token(%{field: value})
|
|
{:ok, %FeedToken{}}
|
|
|
|
iex> create_feed_token(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_feed_token(attrs \\ %{}) do
|
|
attrs = Map.put(attrs, "token", Ecto.UUID.generate())
|
|
|
|
%FeedToken{}
|
|
|> FeedToken.changeset(attrs)
|
|
|> Repo.insert()
|
|
end
|
|
|
|
@doc """
|
|
Updates a feed token.
|
|
|
|
## Examples
|
|
|
|
iex> update_feed_token(feed_token, %{field: new_value})
|
|
{:ok, %FeedToken{}}
|
|
|
|
iex> update_feed_token(feed_token, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_feed_token(%FeedToken{} = feed_token, attrs) do
|
|
feed_token
|
|
|> FeedToken.changeset(attrs)
|
|
|> Repo.update()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a FeedToken.
|
|
|
|
## Examples
|
|
|
|
iex> delete_feed_token(feed_token)
|
|
{:ok, %FeedToken{}}
|
|
|
|
iex> delete_feed_token(feed_token)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_feed_token(%FeedToken{} = feed_token) do
|
|
Repo.delete(feed_token)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking feed_token changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_feed_token(feed_token)
|
|
%Ecto.Changeset{source: %FeedToken{}}
|
|
|
|
"""
|
|
def change_feed_token(%FeedToken{} = feed_token) do
|
|
FeedToken.changeset(feed_token, %{})
|
|
end
|
|
end
|