Structuring Contexts and Channels in a Real Time Weather App

After reading the documentation on Contexts, I’m wondering how to best structure contexts for a realtime weather app that broadcasts temperature readings via channels from either Agent or GenServer (streaming CSV or JSON files), or using Postgres LISTEN/NOTIFY.

Any feedback is highly appreciated!


schema "city" do
field :city_name, :string
has_many :temp, App.Temperature
has_many :precipitation, App.Temperature


schema "temperature" do
field :temp, :float
field :precipitation, :float
belongs_to :city, App.City

---- city.ex
---- temperature.ex
---- temperature_socket.ex

1 Like

One important thing to notice: it’s better to use contexts to separate concerns on your system and not just grouping schemas by itself. So I would do something like:

  • lib
    • my_app/weather
      • city.ex
      • temperature.ex
    • my_app_web/channels
      • temperature_channels.ex

Maybe, once your system grows with more and more schemas, you could separate the city on another context called “locations” or something like that, but I would not do that on the beginning because it would just make your system more complex needlessly.

Thank you for your input.

In your example, “weather” is the context and city and temperature are the schemas?

Do you think it’s a good idea to then have the following setup? My concern is with channels. Specifically, I want to broadcast temperature updates in real time but separating each city to its own lobby/room so I can broadcast updates for each city individually. I don’t know if it’s better to create a JSON api that will trigger (e.g when there’s a new temperature update) a broadcast event for the channel, or to rely on Postgres listen/notify feature (hence the brief excerpt of the simple associations below)

2 tables:
city (parent) and temperature (child)

City has many temperatures.
Temperature belongs to City.

city_id is the foreign key in Temperature.

1 Like


Well, I would do this:

  • lib
    • my_app/weather
      • city.ex # schema
      • temperature.ex # schema
      • weather.ex # context
    • my_app_web/channels
      • user_socket.ex # socket
      • city_channel.ex # channel

Then in my_app_web/channels/user_socket.ex:

defmodule MyAppWeb.UserSocket do
  use Phoenix.Socket

  ## Channels
  channel "city:*", MyAppWeb.CityChannel

  # ...

And in my_app_web/channels/city_channel.ex:

defmodule MyAppWeb.DashboardChannel do
  use MyAppWeb, :channel

  alias MyApp.Weather

  def join("city:" <> id, _payload, socket) do
    {:ok, Socket.assign(socket, :city_id, id)}

  def handle_in("update_temperature", params, socket) do
    case Weather.update_temperature(socket.assigns[:city_id], params) do
      {:ok, temperature} -> broadcast! socket, "update_temperature", %{body: temperature}
      {:error, cs} -> # handle your error
    {:noreply, socket}