commit 154949f5174df7aa28a23b503bd302551682b5c7 · comet.sh/comet

+9

apps/backend/lib/comet/repo/comment.ex

···

       3
       3
        
         Schema containing information about a Comet comment.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "comments" do

     

       8
       9
        
           field :rkey, :string

     
···

       18
       19
        
           has_many :replies, __MODULE__, foreign_key: :reply_id

     

       19
       20
        
       

     

       20
       21
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       22
       22
       +
         end

     

       23
       23
       +
       

     

       24
       24
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       25
       25
       +
       

     

       26
       26
       +
         def changeset(struct, params \\ %{}) do

     

       27
       27
       +
           struct

     

       28
       28
       +
           |> cast(params, [:rkey, :did, :text, :facets, :subject_id, :subject_type, :langs, :created_at])

     

       29
       29
       +
           |> validate_required([:rkey, :text])

     

       21
       30
        
         end

     

       22
       31
        
       end

+8

apps/backend/lib/comet/repo/embed/facet.ex

···

       1
       1
        
       defmodule Comet.Repo.Embed.Facet do

     

       2
       2
        
         use Comet.Schema

     

       3
       3
       +
         import Ecto.Changeset

     

       3
       4
        
       

     

       4
       5
        
         @primary_key false

     

       5
       6
        
         embedded_schema do

     
···

       10
       11
        
       

     

       11
       12
        
           # Sadly Ecto doesn't support union types/embeds so this has to be generic, without doing weirdness in the database at least

     

       12
       13
        
           field :features, {:array, :map}

     

       14
       14
       +
         end

     

       15
       15
       +
       

     

       16
       16
       +
         def changeset(struct, params \\ %{}) do

     

       17
       17
       +
           struct

     

       18
       18
       +
           |> cast(params, [:features])

     

       19
       19
       +
           |> cast_embed(:index, required: true)

     

       20
       20
       +
           |> validate_required([:features])

     

       13
       21
        
         end

     

       14
       22
        
       end

+7

apps/backend/lib/comet/repo/embed/link.ex

···

       1
       1
        
       defmodule Comet.Repo.Embed.Link do

     

       2
       2
        
         use Comet.Schema

     

       3
       3
       +
         import Ecto.Changeset

     

       3
       4
        
       

     

       4
       5
        
         @primary_key false

     

       5
       6
        
         embedded_schema do

     

       6
       7
        
           field :type, :string

     

       7
       8
        
           field :value, :string

     

       9
       9
       +
         end

     

       10
       10
       +
       

     

       11
       11
       +
         def changeset(struct, params \\ %{}) do

     

       12
       12
       +
           struct

     

       13
       13
       +
           |> cast(params, [:type, :value])

     

       14
       14
       +
           |> validate_required([:type, :value])

     

       8
       15
        
         end

     

       9
       16
        
       end

+9 -1

apps/backend/lib/comet/repo/identity.ex

···

       3
       3
        
         Schema containing information about an ATProtocol identity.

     

       4
       4
        
         """

     

       5
       5
        
         use Ecto.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         @primary_key {:did, :string, autogenerate: false}

     

       8
       9
        
         @foreign_key_type :string

     
···

       10
       11
        
         schema "identity" do

     

       11
       12
        
           field :handle, :string

     

       12
       13
        
           field :active, :boolean

     

       13
       13
       -
           # TODO: see if it'd be possible to set this to an enum, if ecto allows open enums

     

       14
       14
        
           field :status, :string

     

       15
       15
        
       

     

       16
       16
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       17
       17
       +
         end

     

       18
       18
       +
       

     

       19
       19
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       20
       20
       +
       

     

       21
       21
       +
         def changeset(struct, params \\ %{}) do

     

       22
       22
       +
           struct

     

       23
       23
       +
           |> cast(params, [:did, :handle, :active, :status])

     

       24
       24
       +
           |> validate_required([:did, :active])

     

       17
       25
        
         end

     

       18
       26
        
       end

+9

apps/backend/lib/comet/repo/like.ex

···

       3
       3
        
         Schema containing information about a Comet like.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "likes" do

     

       8
       9
        
           field :rkey, :string

     
···

       13
       14
        
           belongs_to :identity, Repo.Identity, foreign_key: :did, references: :did

     

       14
       15
        
       

     

       15
       16
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       17
       17
       +
         end

     

       18
       18
       +
       

     

       19
       19
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       20
       20
       +
       

     

       21
       21
       +
         def changeset(struct, params \\ %{}) do

     

       22
       22
       +
           struct

     

       23
       23
       +
           |> cast(params, [:rkey, :did, :subject_id, :subject_type, :created_at])

     

       24
       24
       +
           |> validate_required([:rkey, :did, :subject_id, :subject_type, :created_at])

     

       16
       25
        
         end

     

       17
       26
        
       end

+13 -1

apps/backend/lib/comet/repo/playlist.ex

···

       1
       1
        
       defmodule Comet.Repo.Playlist do

     

       2
       2
        
         @moduledoc """

     

       3
       3
       -
         Schema containing information about a Comet playlist.

     

       3
       3
       +
         Sch ema containing information about a Comet playlist.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "playlists" do

     

       8
       9
        
           field :rkey, :string

     

       9
       10
        
           field :title, :string

     

       10
       11
        
           field :image, :string

     

       11
       12
        
           field :description, :string

     

       13
       13
       +
           # TODO: see how this looks with/without primary id

     

       12
       14
        
           embeds_one :description_facets, Repo.Embed.Facet, on_replace: :update

     

       13
       15
        
           field :type, :string

     

       14
       16
        
           field :tags, {:array, :string}

     
···

       19
       21
        
           has_many :tracks, Repo.Playlist

     

       20
       22
        
       

     

       21
       23
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       27
       27
       +
       

     

       28
       28
       +
         def changeset(struct, params \\ %{}) do

     

       29
       29
       +
           struct

     

       30
       30
       +
           |> cast(params, [:rkey, :did, :title, :image, :description, :type, :tags, :created_at])

     

       31
       31
       +
           |> cast_embed(:description_facets)

     

       32
       32
       +
           |> cast_embed(:link)

     

       33
       33
       +
           |> validate_required([:rkey, :did, :title, :type, :created_at])

     

       22
       34
        
         end

     

       23
       35
        
       end

+9

apps/backend/lib/comet/repo/playlist_track.ex

···

       3
       3
        
         Schema containing information about a track in a Comet playlist.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "playlist_tracks" do

     

       8
       9
        
           field :rkey, :string

     
···

       14
       15
        
           belongs_to :playlist, Repo.Playlist

     

       15
       16
        
       

     

       16
       17
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       18
       18
       +
         end

     

       19
       19
       +
       

     

       20
       20
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       21
       21
       +
       

     

       22
       22
       +
         def changeset(struct, params \\ %{}) do

     

       23
       23
       +
           struct

     

       24
       24
       +
           |> cast(params, [:rkey, :did, :position, :created_at, :track_id, :playlist_id])

     

       25
       25
       +
           |> validate_required([:rkey, :did, :position, :created_at, :track_id, :playlist_id])

     

       17
       26
        
         end

     

       18
       27
        
       end

+20

apps/backend/lib/comet/repo/profile.ex

···

       3
       3
        
         Schema containing information about a Comet profile.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       8
       8
       +
         # TODO: should probably keep track of CID so as to not do unnecessary writes

     

       7
       9
        
         schema "profiles" do

     

       8
       10
        
           field :rkey, :string, default: "self"

     

       9
       11
        
           field :display_name, :string

     
···

       17
       19
        
           belongs_to :identity, Repo.Identity, foreign_key: :did, references: :did

     

       18
       20
        
       

     

       19
       21
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       22
       22
       +
         end

     

       23
       23
       +
       

     

       24
       24
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       25
       25
       +
       

     

       26
       26
       +
         def changeset(struct, params \\ %{}) do

     

       27
       27
       +
           struct

     

       28
       28
       +
           |> cast(params, [

     

       29
       29
       +
             :rkey,

     

       30
       30
       +
             :did,

     

       31
       31
       +
             :display_name,

     

       32
       32
       +
             :description,

     

       33
       33
       +
             :avatar,

     

       34
       34
       +
             :banner,

     

       35
       35
       +
             :featured_items,

     

       36
       36
       +
             :created_at

     

       37
       37
       +
           ])

     

       38
       38
       +
           |> cast_embed(:description_facets)

     

       39
       39
       +
           |> validate_required([:rkey, :did])

     

       20
       40
        
         end

     

       21
       41
        
       end

+9

apps/backend/lib/comet/repo/repost.ex

···

       3
       3
        
         Schema containing information about a Comet repost.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "reposts" do

     

       8
       9
        
           field :rkey, :string

     
···

       13
       14
        
           belongs_to :identity, Repo.Identity, foreign_key: :did, references: :did

     

       14
       15
        
       

     

       15
       16
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       17
       17
       +
         end

     

       18
       18
       +
       

     

       19
       19
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       20
       20
       +
       

     

       21
       21
       +
         def changeset(struct, params \\ %{}) do

     

       22
       22
       +
           struct

     

       23
       23
       +
           |> cast(params, [:rkey, :did, :subject_id, :subject_type, :created_at])

     

       24
       24
       +
           |> validate_required([:rkey, :did, :subject_id, :subject_type, :created_at])

     

       16
       25
        
         end

     

       17
       26
        
       end

+22

apps/backend/lib/comet/repo/track.ex

···

       3
       3
        
         Schema containing information about a Comet track.

     

       4
       4
        
         """

     

       5
       5
        
         use Comet.Schema

     

       6
       6
       +
         import Ecto.Changeset

     

       6
       7
        
       

     

       7
       8
        
         schema "tracks" do

     

       8
       9
        
           field :rkey, :string

     
···

       20
       21
        
           belongs_to :identity, Repo.Identity, foreign_key: :did, references: :did

     

       21
       22
        
       

     

       22
       23
        
           timestamps(inserted_at: :indexed_at, updated_at: false)

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         def new(params \\ %{}), do: changeset(%__MODULE__{}, params)

     

       27
       27
       +
       

     

       28
       28
       +
         def changeset(struct, params \\ %{}) do

     

       29
       29
       +
           struct

     

       30
       30
       +
           |> cast(params, [

     

       31
       31
       +
             :rkey,

     

       32
       32
       +
             :did,

     

       33
       33
       +
             :title,

     

       34
       34
       +
             :audio,

     

       35
       35
       +
             :image,

     

       36
       36
       +
             :description,

     

       37
       37
       +
             :explicit,

     

       38
       38
       +
             :tags,

     

       39
       39
       +
             :created_at,

     

       40
       40
       +
             :released_at

     

       41
       41
       +
           ])

     

       42
       42
       +
           |> cast_embed(:description_facets)

     

       43
       43
       +
           |> cast_embed(:link)

     

       44
       44
       +
           |> validate_required([:rkey, :did, :audio, :title, :created_at])

     

       23
       45
        
         end

     

       24
       46
        
       end