Chapter 4 Publishing Sensor Data (47)

Adding PostgreSQL to the Stack
    Starting off we need to create a new phoenix weather_tracker app we will use the command
        mix phx.new weather_tracker \
            --binary-id --no-webpack --no-html --no-gettext --no-dashboard

    With this being said you will need to have the right generator installed so if that doesn't work be sure to run this command within you linux console
        mix archive.install hex phx_new 1.5.8

    Once that is all setup we need to created the yml file and get into the proper location
        cd weather_tracker && touch docker-compose.yml

    Okay so now we can populate the file with
        version: '3.3'
            services:
                postgres:
                    image: timescale/timescaledb:2.1.0-pg13
                    ports:
                    - '5432:5432'
                    volumes:
                    - postgres-data:/var/lib/postgresql/data
                    environment:
                    POSTGRES_PASSWORD: postgres
                    POSTGRES_USER: postgres
            volumes:
                postgres-data: {}

    Starting the Docker Compose Stack
        docker-compose up

        With that we will have the docker container up and running we will need to do some work to it so leave it up if you need to close it you can just crtl+calculated

Creating the Phoenix Application
    We will need to run some migrations so that we can persist the data from the sensors
        mix ecto.gen.migration set_up_weather_data_table

    We can now setup the migrations for that data table with the following. It should have created a file with a time stamp and the file name appended to the time stamp.
        defmodule WeatherTracker.Repo.Migrations.SetUpWeatherDataTable do
            use Ecto.Migration

            def up do
                execute("CREATE EXTENSION IF NOT EXISTS timescaledb")

                create table(:weather_conditions, primary_key: false) do
                add :timestamp, :naive_datetime, null: false
                add :temperature_c, :decimal, null: false
                add :pressure_pa, :decimal, null: false
                add :humidity_rh, :decimal, null: false
                add :light_lumens, :decimal, null: false
                add :voc_index, :decimal, null: false
                add :uv_index, :decimal, null: false
                add :als_lux, :decimal, null: false
                end

                execute("SELECT create_hypertable('weather_conditions', 'timestamp')")
            end

            def down do
                drop table(:weather_conditions)
                execute("DROP EXTENSION IF EXISTS timescaledb")
            end
        end

    This will setup the data table with the correct :atoms as names and will say what to do when we rool forward or what happens when we want to roll the database backwards. This will also make sure that we are running the timescale DB as the data table type.
        mix ecto.setup

    This is where I ran into issues with the timescale not being installed so I went to this website and then followed all the instructions
        https://docs.tigerdata.com/self-hosted/latest/install/installation-linux/

Creating our Ecto Schema
    Now we need to set the way in which we add the correct values to the database. It will be in and called: 
        sensor_hub_poncho/weather_tracker/lib/weather_tracker/weather_conditions/weather_condition.ex

    defmodule WeatherTracker.WeatherConditions.WeatherCondition do
        use Ecto.Schema
        import Ecto.Changeset

        @allowed_fields [
            :temperature_c,
            :pressure_pa,
            :humidity_rh,
            :light_lumens,
            :voc_index,
            :uv_index,
            :als_lux
        ]

        @derive {Jason.Encoder, only: @allowed_fields}
        @primary_key false

        schema "weather_conditions" do
            field :timestamp, :naive_datetime
            field :temperature_c, :decimal
            field :pressure_pa, :decimal
            field :humidity_rh, :decimal
            field :light_lumens, :decimal
            field :voc_index, :decimal
            field :uv_index, :decimal
            field :als_lux, :decimal
        end

        def create_changset(weather_condition = %__MODULE__{}, attrs) do
            timestamp =
            NaiveDateTime.utc_now()
            |> NaiveDateTime.truncate(:second)

            weather_condition
            |> cast(attrs, @allowed_fields)
            |> validate_required(@allowed_fields)
            |> put_change(:timestamp, timestamp)
        end
    end

Creating the Phoenix Context Module
    Now we need the commands and code to instert any data to the database. This will be at: lib/weather_tracker/weather_conditions.ex and will be very simple as we don't need much from it. 
    defmodule WeatherTracker.WeatherConditions do
        alias WeatherTracker.{WeatherConditions.WeatherCondition, Repo}

        def create_weather_condition(attrs) do
            %WeatherCondition{}
            |> WeatherCondition.create_changeset(attrs)
            |> Repo.insert()
        end
    end