Notesclub

created by hec & contributors

My calendar 0.0.1

livebooks/my_calendar_livebook.livemd

@peresvetjke

tn_elixir_dev_course

More notebooks

My calendar 0.0.1

alias MyCalendar.App

MyCalendar.App

Create or modify

Here’s our organizer:

{:ok, organizer} = App.create_user(%{login: "username", email: "username@example.com"})

[debug] QUERY OK db=2.4ms idle=1376.6ms
INSERT INTO "users" ("email","login","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" ["username@example.com", "username", ~N[2023-03-16 05:51:10], ~N[2023-03-16 05:51:10]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   id: 15,
   login: "username",
   email: "username@example.com",
   meetings: #Ecto.Association.NotLoaded,
   inserted_at: ~N[2023-03-16 05:51:10],
   updated_at: ~N[2023-03-16 05:51:10]
 }}

Let’create few users

{:ok, user1} = App.create_user(%{login: "username1", email: "username1@example.com"})
{:ok, user2} = App.create_user(%{login: "username2", email: "username2@example.com"})

[debug] QUERY OK db=2.7ms queue=0.5ms idle=1456.7ms
INSERT INTO "users" ("email","login","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" ["username1@example.com", "username1", ~N[2023-03-16 05:51:14], ~N[2023-03-16 05:51:14]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.4ms idle=1460.4ms
INSERT INTO "users" ("email","login","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" ["username2@example.com", "username2", ~N[2023-03-16 05:51:14], ~N[2023-03-16 05:51:14]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   id: 17,
   login: "username2",
   email: "username2@example.com",
   meetings: #Ecto.Association.NotLoaded,
   inserted_at: ~N[2023-03-16 05:51:14],
   updated_at: ~N[2023-03-16 05:51:14]
 }}

What is the point in calendar if we can’t create meetings?

attrs = %{
  date_time: ~U[2023-01-01 10:00:00Z],
  duration_minutes: 60
}

{:ok, meeting} = App.create_meeting(organizer, attrs, [user1, user2])

[debug] QUERY OK db=0.3ms idle=1877.9ms
begin []
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.8ms
INSERT INTO "meetings" ("date_time","duration_minutes","organizator_id","inserted_at","updated_at") VALUES ($1,$2,$3,$4,$5) RETURNING "id" [~U[2023-01-01 10:00:00Z], 60, 15, ~N[2023-03-16 05:51:19], ~N[2023-03-16 05:51:19]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.7ms
INSERT INTO "meetings_users" ("meeting_id","user_id","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" [3, 16, ~N[2023-03-16 05:51:19], ~N[2023-03-16 05:51:19]]
↳ anonymous fn/3 in Ecto.Adapters.SQL.checkout_or_transaction/4, at: lib/ecto/adapters/sql.ex:1203
[debug] QUERY OK db=0.4ms
INSERT INTO "meetings_users" ("meeting_id","user_id","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" [3, 17, ~N[2023-03-16 05:51:19], ~N[2023-03-16 05:51:19]]
↳ anonymous fn/3 in Ecto.Adapters.SQL.checkout_or_transaction/4, at: lib/ecto/adapters/sql.ex:1203
[debug] QUERY OK db=2.1ms
commit []
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.Meeting{
   __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
   id: 3,
   date_time: ~U[2023-01-01 10:00:00Z],
   duration_minutes: 60,
   organizator_id: 15,
   organizator: %MyCalendar.App.User{
     __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
     id: 15,
     login: "username",
     email: "username@example.com",
     meetings: #Ecto.Association.NotLoaded,
     inserted_at: ~N[2023-03-16 05:51:10],
     updated_at: ~N[2023-03-16 05:51:10]
   },
   users: [
     %MyCalendar.App.User{
       __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
       id: 16,
       login: "username1",
       email: "username1@example.com",
       meetings: #Ecto.Association.NotLoaded,
       inserted_at: ~N[2023-03-16 05:51:14],
       updated_at: ~N[2023-03-16 05:51:14]
     },
     %MyCalendar.App.User{
       __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
       id: 17,
       login: "username2",
       email: "username2@example.com",
       meetings: #Ecto.Association.NotLoaded,
       inserted_at: ~N[2023-03-16 05:51:14],
       updated_at: ~N[2023-03-16 05:51:14]
     }
   ],
   inserted_at: ~N[2023-03-16 05:51:19],
   updated_at: ~N[2023-03-16 05:51:19]
 }}

Stop! our organizer is just a username? He is not some casual user - solve it right now!

App.update_user(organizer, %{login: "organizer", email: "organizer@example.com"})

[debug] QUERY OK db=2.6ms queue=0.6ms idle=1082.0ms
UPDATE "users" SET "email" = $1, "login" = $2, "updated_at" = $3 WHERE "id" = $4 ["organizer@example.com", "organizer", ~N[2023-03-16 05:51:26], 15]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   id: 15,
   login: "organizer",
   email: "organizer@example.com",
   meetings: #Ecto.Association.NotLoaded,
   inserted_at: ~N[2023-03-16 05:51:10],
   updated_at: ~N[2023-03-16 05:51:26]
 }}

We will spend part of our meeting to get participants familiar with new email of organizer:

attrs = %{
  date_time: ~U[2023-01-01 10:00:00Z],
  duration_minutes: 120
}

{:ok, meeting} = App.update_meeting(meeting, attrs, [user1, user2])

[debug] QUERY OK db=2.7ms queue=0.5ms idle=1816.9ms
UPDATE "meetings" SET "duration_minutes" = $1, "updated_at" = $2 WHERE "id" = $3 [120, ~N[2023-03-16 05:51:32], 3]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.Meeting{
   __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
   id: 3,
   date_time: ~U[2023-01-01 10:00:00Z],
   duration_minutes: 120,
   organizator_id: 15,
   organizator: %MyCalendar.App.User{
     __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
     id: 15,
     login: "username",
     email: "username@example.com",
     meetings: #Ecto.Association.NotLoaded,
     inserted_at: ~N[2023-03-16 05:51:10],
     updated_at: ~N[2023-03-16 05:51:10]
   },
   users: [
     %MyCalendar.App.User{
       __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
       id: 16,
       login: "username1",
       email: "username1@example.com",
       meetings: #Ecto.Association.NotLoaded,
       inserted_at: ~N[2023-03-16 05:51:14],
       updated_at: ~N[2023-03-16 05:51:14]
     },
     %MyCalendar.App.User{
       __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
       id: 17,
       login: "username2",
       email: "username2@example.com",
       meetings: #Ecto.Association.NotLoaded,
       inserted_at: ~N[2023-03-16 05:51:14],
       updated_at: ~N[2023-03-16 05:51:14]
     }
   ],
   inserted_at: ~N[2023-03-16 05:51:19],
   updated_at: ~N[2023-03-16 05:51:32]
 }}

Fetch

Get meetings by date:

App.get_meetings_by_date(~D[2023-01-01])

[debug] QUERY OK source="meetings" db=1.1ms queue=0.1ms idle=1610.5ms
SELECT m0."id", m0."date_time", m0."duration_minutes", m0."organizator_id", m0."inserted_at", m0."updated_at" FROM "meetings" AS m0 WHERE (cast(m0."date_time" as date) = $1) [~D[2023-01-01]]
↳ MyCalendar.App.get_meetings_by_date/1, at: lib/my_calendar/app/app.ex:24
[debug] QUERY OK source="users" db=0.6ms queue=0.4ms idle=1612.2ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", u0."id" FROM "users" AS u0 WHERE (u0."id" = ANY($1)) [[15, 10]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK source="users" db=1.7ms idle=1612.0ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", m1."meeting_id"::bigint FROM "users" AS u0 INNER JOIN "meetings_users" AS m1 ON u0."id" = m1."user_id" WHERE (m1."meeting_id" = ANY($1)) ORDER BY m1."meeting_id"::bigint [[3, 1]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

[
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 1,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 10,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 10,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:28:45],
      updated_at: ~N[2023-03-16 05:42:24]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 11,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:28:47],
        updated_at: ~N[2023-03-16 05:28:47]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 12,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:28:47],
        updated_at: ~N[2023-03-16 05:28:47]
      }
    ],
    inserted_at: ~N[2023-03-16 05:28:49],
    updated_at: ~N[2023-03-16 05:45:33]
  },
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 3,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 15,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 15,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:10],
      updated_at: ~N[2023-03-16 05:51:26]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 16,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 17,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      }
    ],
    inserted_at: ~N[2023-03-16 05:51:19],
    updated_at: ~N[2023-03-16 05:51:32]
  }
]

Get meetings by organizer id:

App.get_meetings_by_organizator_id(organizer.id)

[debug] QUERY OK source="meetings" db=1.5ms queue=0.1ms idle=1392.4ms
SELECT m0."id", m0."date_time", m0."duration_minutes", m0."organizator_id", m0."inserted_at", m0."updated_at" FROM "meetings" AS m0 WHERE (m0."organizator_id" = $1) [15]
↳ MyCalendar.App.get_meetings_by_organizator_id/1, at: lib/my_calendar/app/app.ex:31
[debug] QUERY OK source="users" db=0.7ms idle=394.3ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", u0."id" FROM "users" AS u0 WHERE (u0."id" = $1) [15]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK source="users" db=1.8ms idle=394.3ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", m1."meeting_id"::bigint FROM "users" AS u0 INNER JOIN "meetings_users" AS m1 ON u0."id" = m1."user_id" WHERE (m1."meeting_id" = ANY($1)) ORDER BY m1."meeting_id"::bigint [[3]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

[
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 3,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 15,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 15,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:10],
      updated_at: ~N[2023-03-16 05:51:26]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 16,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 17,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      }
    ],
    inserted_at: ~N[2023-03-16 05:51:19],
    updated_at: ~N[2023-03-16 05:51:32]
  }
]

Cool! what if we want to get the list of meetings for a certain user?

App.get_meetings_by_user_id(user1.id)

[debug] QUERY OK source="meetings" db=1.2ms idle=1800.9ms
SELECT m0."id", m0."date_time", m0."duration_minutes", m0."organizator_id", m0."inserted_at", m0."updated_at" FROM "meetings" AS m0 INNER JOIN "meetings_users" AS m1 ON (m1."meeting_id" = m0."id") AND (m1."user_id" = $1) [16]
↳ MyCalendar.App.get_meetings_by_user_id/1, at: lib/my_calendar/app/app.ex:41
[debug] QUERY OK source="users" db=0.5ms idle=1802.6ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", u0."id" FROM "users" AS u0 WHERE (u0."id" = $1) [15]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK source="users" db=1.5ms idle=1802.6ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", m1."meeting_id"::bigint FROM "users" AS u0 INNER JOIN "meetings_users" AS m1 ON u0."id" = m1."user_id" WHERE (m1."meeting_id" = ANY($1)) ORDER BY m1."meeting_id"::bigint [[3]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

[
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 3,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 15,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 15,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:10],
      updated_at: ~N[2023-03-16 05:51:26]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 16,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 17,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      }
    ],
    inserted_at: ~N[2023-03-16 05:51:19],
    updated_at: ~N[2023-03-16 05:51:32]
  }
]

Get user or meeting by id or list them all!

App.get_user(user1.id)

[debug] QUERY OK source="users" db=1.0ms idle=1160.6ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at" FROM "users" AS u0 WHERE (u0."id" = $1) [16]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

%MyCalendar.App.User{
  __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
  id: 16,
  login: "username1",
  email: "username1@example.com",
  meetings: #Ecto.Association.NotLoaded,
  inserted_at: ~N[2023-03-16 05:51:14],
  updated_at: ~N[2023-03-16 05:51:14]
}

App.get_meeting(meeting.id)

[debug] QUERY OK source="meetings" db=0.6ms idle=1304.9ms
SELECT m0."id", m0."date_time", m0."duration_minutes", m0."organizator_id", m0."inserted_at", m0."updated_at" FROM "meetings" AS m0 WHERE (m0."id" = $1) [3]
↳ MyCalendar.App.get_meeting/1, at: lib/my_calendar/app/app.ex:17
[debug] QUERY OK source="users" db=0.4ms idle=1306.0ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", u0."id" FROM "users" AS u0 WHERE (u0."id" = $1) [15]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK source="users" db=0.6ms queue=0.1ms idle=1306.0ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", m1."meeting_id"::bigint FROM "users" AS u0 INNER JOIN "meetings_users" AS m1 ON u0."id" = m1."user_id" WHERE (m1."meeting_id" = ANY($1)) ORDER BY m1."meeting_id"::bigint [[3]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

%MyCalendar.App.Meeting{
  __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
  id: 3,
  date_time: ~U[2023-01-01 10:00:00Z],
  duration_minutes: 120,
  organizator_id: 15,
  organizator: %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 15,
    login: "organizer",
    email: "organizer@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:51:10],
    updated_at: ~N[2023-03-16 05:51:26]
  },
  users: [
    %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 16,
      login: "username1",
      email: "username1@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:14],
      updated_at: ~N[2023-03-16 05:51:14]
    },
    %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 17,
      login: "username2",
      email: "username2@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:14],
      updated_at: ~N[2023-03-16 05:51:14]
    }
  ],
  inserted_at: ~N[2023-03-16 05:51:19],
  updated_at: ~N[2023-03-16 05:51:32]
}

App.list_users()

[debug] QUERY OK source="users" db=1.0ms idle=1898.8ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at" FROM "users" AS u0 []
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

[
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 1,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-13 06:43:52],
    updated_at: ~N[2023-03-13 06:43:52]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 2,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:09:28],
    updated_at: ~N[2023-03-16 05:09:28]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 3,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:09:35],
    updated_at: ~N[2023-03-16 05:09:35]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 4,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:17:41],
    updated_at: ~N[2023-03-16 05:17:41]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 5,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:19:43],
    updated_at: ~N[2023-03-16 05:19:43]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 6,
    login: "username1",
    email: "username1@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:19:43],
    updated_at: ~N[2023-03-16 05:19:43]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 7,
    login: "username2",
    email: "username2@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:19:43],
    updated_at: ~N[2023-03-16 05:19:43]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 8,
    login: "username1",
    email: "username1@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:23:45],
    updated_at: ~N[2023-03-16 05:23:45]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 9,
    login: "username2",
    email: "username2@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:23:45],
    updated_at: ~N[2023-03-16 05:23:45]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 11,
    login: "username1",
    email: "username1@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:28:47],
    updated_at: ~N[2023-03-16 05:28:47]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 12,
    login: "username2",
    email: "username2@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:28:47],
    updated_at: ~N[2023-03-16 05:28:47]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 10,
    login: "organizer",
    email: "organizer@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:28:45],
    updated_at: ~N[2023-03-16 05:42:24]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 14,
    login: "username",
    email: "username@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:50:46],
    updated_at: ~N[2023-03-16 05:50:46]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 16,
    login: "username1",
    email: "username1@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:51:14],
    updated_at: ~N[2023-03-16 05:51:14]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 17,
    login: "username2",
    email: "username2@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:51:14],
    updated_at: ~N[2023-03-16 05:51:14]
  },
  %MyCalendar.App.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    id: 15,
    login: "organizer",
    email: "organizer@example.com",
    meetings: #Ecto.Association.NotLoaded,
    inserted_at: ~N[2023-03-16 05:51:10],
    updated_at: ~N[2023-03-16 05:51:26]
  }
]

App.list_meetings()

[debug] QUERY OK source="meetings" db=0.9ms idle=1005.0ms
SELECT m0."id", m0."date_time", m0."duration_minutes", m0."organizator_id", m0."inserted_at", m0."updated_at" FROM "meetings" AS m0 []
↳ MyCalendar.App.list_meetings/0, at: lib/my_calendar/app/app.ex:51
[debug] QUERY OK source="users" db=0.6ms idle=1006.4ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", m1."meeting_id"::bigint FROM "users" AS u0 INNER JOIN "meetings_users" AS m1 ON u0."id" = m1."user_id" WHERE (m1."meeting_id" = ANY($1)) ORDER BY m1."meeting_id"::bigint [[3, 1]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK source="users" db=0.8ms idle=1006.4ms
SELECT u0."id", u0."login", u0."email", u0."inserted_at", u0."updated_at", u0."id" FROM "users" AS u0 WHERE (u0."id" = ANY($1)) [[15, 10]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

[
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 1,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 10,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 10,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:28:45],
      updated_at: ~N[2023-03-16 05:42:24]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 11,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:28:47],
        updated_at: ~N[2023-03-16 05:28:47]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 12,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:28:47],
        updated_at: ~N[2023-03-16 05:28:47]
      }
    ],
    inserted_at: ~N[2023-03-16 05:28:49],
    updated_at: ~N[2023-03-16 05:45:33]
  },
  %MyCalendar.App.Meeting{
    __meta__: #Ecto.Schema.Metadata<:loaded, "meetings">,
    id: 3,
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 120,
    organizator_id: 15,
    organizator: %MyCalendar.App.User{
      __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
      id: 15,
      login: "organizer",
      email: "organizer@example.com",
      meetings: #Ecto.Association.NotLoaded,
      inserted_at: ~N[2023-03-16 05:51:10],
      updated_at: ~N[2023-03-16 05:51:26]
    },
    users: [
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 16,
        login: "username1",
        email: "username1@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      },
      %MyCalendar.App.User{
        __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
        id: 17,
        login: "username2",
        email: "username2@example.com",
        meetings: #Ecto.Association.NotLoaded,
        inserted_at: ~N[2023-03-16 05:51:14],
        updated_at: ~N[2023-03-16 05:51:14]
      }
    ],
    inserted_at: ~N[2023-03-16 05:51:19],
    updated_at: ~N[2023-03-16 05:51:32]
  }
]

Delete

Destroy users:

{:ok, user} = App.create_user(%{login: "username", email: "username@example.com"})
App.delete_user(user)

[debug] QUERY OK db=0.6ms idle=1619.9ms
INSERT INTO "users" ("email","login","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" ["username@example.com", "username", ~N[2023-03-16 05:52:05], ~N[2023-03-16 05:52:05]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.9ms idle=1620.7ms
DELETE FROM "users" WHERE "id" = $1 [18]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.User{
   __meta__: #Ecto.Schema.Metadata<:deleted, "users">,
   id: 18,
   login: "username",
   email: "username@example.com",
   meetings: #Ecto.Association.NotLoaded,
   inserted_at: ~N[2023-03-16 05:52:05],
   updated_at: ~N[2023-03-16 05:52:05]
 }}

Destroy meetings:

{:ok, organizer} = App.create_user(%{login: "username", email: "username@example.com"})

{:ok, meeting} =
  App.create_meeting(organizer, %{
    date_time: ~U[2023-01-01 10:00:00Z],
    duration_minutes: 60
  })

App.delete_meeting(meeting)

[debug] QUERY OK db=2.2ms idle=1185.4ms
INSERT INTO "users" ("email","login","inserted_at","updated_at") VALUES ($1,$2,$3,$4) RETURNING "id" ["username@example.com", "username", ~N[2023-03-16 05:52:08], ~N[2023-03-16 05:52:08]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.2ms idle=1187.9ms
begin []
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.6ms
INSERT INTO "meetings" ("date_time","duration_minutes","organizator_id","inserted_at","updated_at") VALUES ($1,$2,$3,$4,$5) RETURNING "id" [~U[2023-01-01 10:00:00Z], 60, 19, ~N[2023-03-16 05:52:08], ~N[2023-03-16 05:52:08]]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.3ms
commit []
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309
[debug] QUERY OK db=0.7ms queue=0.3ms idle=1189.9ms
DELETE FROM "meetings" WHERE "id" = $1 [4]
↳ anonymous fn/4 in :elixir.eval_external_handler/1, at: src/elixir.erl:309

{:ok,
 %MyCalendar.App.Meeting{
   __meta__: #Ecto.Schema.Metadata<:deleted, "meetings">,
   id: 4,
   date_time: ~U[2023-01-01 10:00:00Z],
   duration_minutes: 60,
   organizator_id: 19,
   organizator: %MyCalendar.App.User{
     __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
     id: 19,
     login: "username",
     email: "username@example.com",
     meetings: #Ecto.Association.NotLoaded,
     inserted_at: ~N[2023-03-16 05:52:08],
     updated_at: ~N[2023-03-16 05:52:08]
   },
   users: [],
   inserted_at: ~N[2023-03-16 05:52:08],
   updated_at: ~N[2023-03-16 05:52:08]
 }}

Back