Modify data layers and data access. Add more functionality including setup

.rubocop.yml

···
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.4
+  TargetRubyVersion: 3.4
+
+Style/CharacterLiteral:
+  Enabled: false

app.rb

···
 # frozen_string_literal: true
 
-require 'irb'
 require 'sinatra'
 
 require_relative 'lib/database'
 require_relative 'lib/data_access'
+require_relative 'lib/services'
 
 database = Database.new
 data_access = DataAccess.new database
+services = Services.new data_access
 
-get '/' do
-  erb :index
-end
+def simple_get(path, view)= get(path) { erb view.to_sym }
 
-get '/db-health-check' do
-  results = database.exec 'SELECT NOW() AS time'
-  results[0]['time']
+# Simple routes
+simple_get '/', :index
+simple_get '/plants', :plants
+get('/db-health-check') { database.healthcheck }
+
+post '/new-plant' do
+  redirect '/plants' if services.plant.new_plant user_id: params['user_id'],
+                                                 name: params['name'],
+                                                 plant_type: params['plant_type']
 end
 
 post '/sign-up' do
-  return data_access.users.sign_up! params['email'] if params.key?('email')
+  return services.user.sign_up! params['email'] if params.key?('email')
 
   status 400
   'No email provided!'
 end
 
 post '/validate-code' do
-  data_access.users.validate_code? ip: request.env['REMOTE_ADDR'],
-                                   email: params['email'],
-                                   code: params['validation-code']
+  redirect '/plants' if services.user.validate_code? ip: request.env['REMOTE_ADDR'],
+                                                     email: params['email'],
+                                                     code: params['validation-code']
 end
 
 post '/send-email' do

bin/setup

···
   gem install bundler
 fi
 
-bundle install
+psql -f "db/create_db.sql"
+
+for table in users validations plants; do
+  psql -d plant_reminder_development -f "db/create_$table.sql"
+done

config.ru

···
+# frozen_string_literal: true
+
 require_relative 'app'
 
 run Sinatra::Application

db/create_db.sql

···
+SELECT 'CREATE DATABASE plant_reminder_development'
+WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = 'plant_reminder_development')\gexec

db/create_plants.sql

···
+CREATE TABLE IF NOT EXISTS plant_types (
+    id SERIAL PRIMARY KEY NOT NULL,
+    name VARCHAR(100) NOT NULL,
+    watering_frequency_in_minutes INT
+);
+
+CREATE TABLE IF NOT EXISTS plants (
+    id SERIAL PRIMARY KEY NOT NULL,
+    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    name VARCHAR(200),
+    plant_type_id INT REFERENCES plant_types(id) ON DELETE SET NULL
+);

db/create_users.sql

···
+CREATE TABLE IF NOT EXISTS users (
+    id UUID PRIMARY KEY NOT NULL DEFAULT gen_random_uuid(),
+    email VARCHAR(100) UNIQUE NOT NULL,
+    access_code VARCHAR(20) UNIQUE
+);

db/create_validations.sql

···
+CREATE TABLE IF NOT EXISTS validations (
+    id SERIAL PRIMARY KEY NOT NULL,
+    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    ip_address CIDR,
+    validated_at TIMESTAMP NOT NULL DEFAULT NOW(),
+    validated BOOLEAN
+);

lib/data_access.rb

···
 # frozen_string_literal: true
 
 require_relative 'data_access/users_data_access'
+require_relative 'data_access/validations_data_access'
 
 # General class for all data_access classes
 class DataAccess
-  attr_reader :database, :users
+  attr_reader :users, :validations
 
   def initialize(database)
-    @database = database
     @users = UsersDataAccess.new database
+    @validations = ValidationsDataAccess.new database
   end
 end

lib/data_access/base_data_access.rb

···
+# frozen_string_literal: false
+
+# Base data access layer
+class BaseDataAccess
+  class << self
+    attr_accessor :table_name
+  end
+
+  def initialize(database)
+    @database = database
+  end
+
+  COLUMNS = [].freeze
+
+  def find_or_create(*, **params)
+    base_find(*, **params) do |result, params|
+      next result if result.one?
+
+      id = insert(**params)
+
+      params[:id] = id
+
+      find(*, **params)
+    end
+  end
+
+  # Do not pass block
+  def find(*, **params) = base_find(*, **params)
+
+  def insert(**params)
+    valid_params = params.select { |column| self.class::COLUMNS.include?(column) }
+    insert_statement = build_insert_statement(valid_params.keys)
+    database.exec(insert_statement, valid_params.values)[0]['id']
+  end
+
+  attr_reader :database
+
+  private
+
+  def base_find(choose: [:id], **params)
+    valid_choose = choose & self.class::COLUMNS # the intersection operator is great for things like this!
+    query_by = filter_params_by_columns params
+    query = build_find_query valid_choose, query_by
+    result = database.exec query, [*query_by.values]
+    return result unless block_given?
+
+    yield result, params
+  end
+
+  def build_insert_statement(columns)
+    "INSERT INTO #{self.class.table_name} (".tap do |sql|
+      sql << columns.join(', ')
+      sql << ') VALUES ('
+      sql << (1..columns.length).map { |pos| "$#{pos}" }.join(', ')
+      sql << ') RETURNING id'
+    end
+  end
+
+  def build_find_query(valid_choose, query_by)
+    'SELECT '.tap do |sql|
+      sql << valid_choose.join(', ')
+      sql << " FROM #{self.class.table_name} WHERE "
+      sql << query_by.map.with_index(1) { |(key), index| "#{key}=$#{index}" }.join(' AND ')
+    end
+  end
+
+  def filter_params_by_columns(params)
+    params.select { |column| self.class::COLUMNS.include?(column) }
+  end
+end

lib/data_access/plant_data_access.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_data_access'
+
+# Handles the data access for plants
+class PlantDataAccess < BaseDataAccess
+  self.table_name = 'plants'
+
+  COLUMNS = %i[id user_id name plant_type_id].freeze
+
+  def insert(user_id:, name:, plant_type_id:)
+    database.exec 'INSERT INTO plants (user_id, name, plant_type_id) VALUES ($1, $2, $3)',
+                  [user_id, name, plant_type_id]
+  end
+end

lib/data_access/plant_type_data_access.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_data_access'
+
+# Handles the data access for plant types
+class PlantTypeDataAccess < BaseDataAccess
+  self.table_name = 'plant_types'
+
+  COLUMNS = %i[id name watering_frequency_in_minutes].freeze
+end

lib/data_access/users_data_access.rb

···
 # frozen_string_literal: true
 
-require_relative '../databaseable'
+require_relative 'base_data_access'
 
 # Handles the data access for users
-class UsersDataAccess
-  include Databaseable
+class UsersDataAccess < BaseDataAccess
+  self.table_name = 'users'
 
-  COUNT_WITHIN_QUANTUM_SQL = <<~SQL
-    SELECT COUNT(*) from validations
-    WHERE user_id = $1 AND validated_at >= NOW() - INTERVAL '30 minutes' AND validated = false
-  SQL
+  COLUMNS = %i[id email access_code].freeze
 
-  def sign_up!(email)
-    raise 'Invalid email' unless /^[^@]+@[^.]+\.[^.]+$/.match? email
-
+  def insert(email:)
     database.exec 'INSERT INTO users (email) VALUES ($1)', [email]
-    'success'
-  rescue PG::UniqueViolation
-    "An account with the email #{email} already exists"
-  end
-
-  def validate_code?(code:, email:, ip:)
-    user_id = database.exec('SELECT id FROM users WHERE email = $1', [email])[0]['id']
-    count_within_quantum = database.exec(COUNT_WITHIN_QUANTUM_SQL, [user_id])
-    raise 'Too many requests' if count_within_quantum[0]['count'].to_i >= 10
-
-    database.exec 'INSERT INTO validations (user_id, ip_address) VALUES ($1, $2)', [user_id, ip]
-
-    results = database.exec 'SELECT access_code FROM users WHERE id = $1', [user_id]
-    results[0]['code'] == code
   end
 end

lib/data_access/validations_data_access.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_data_access'
+
+# Handles the data access for validations
+class ValidationsDataAccess < BaseDataAccess
+  self.table_name = 'validations'
+
+  COLUMNS = %i[id user_id ip_address validated_at validated].freeze
+
+  COUNT_WITHIN_QUANTUM_SQL = <<~SQL
+    SELECT COUNT(*) from validations
+    WHERE user_id = $1 AND validated_at >= NOW() - INTERVAL '30 minutes' AND validated = false
+  SQL
+
+  def validations_within_time_quantum_for_user_id(user_id)
+    database.exec COUNT_WITHIN_QUANTUM_SQL, [user_id]
+  end
+
+  def insert(user_id:, ip_address:)
+    database.exec 'INSERT INTO validations (user_id, ip_address) VALUES ($1, $2)', [user_id, ip_address]
+  end
+end

lib/database.rb

···
 
   def exec(...) = @pg_conn.exec(...)
 
+  def healthcheck
+    exec('SELECT NOW() AS time')[0]['time']
+  end
+
   private
 
   def connect!

lib/databaseable.rb

···
-module Databaseable
-  def initialize(database)
-    @database = database
-  end
-
-  protected
-
-  attr_reader :database
-end

lib/services.rb

···
+# frozen_string_literal: true
+
+require_relative 'services/user_service'
+require_relative 'services/validation_service'
+
+# General class for all service classes
+class Services
+  attr_reader :user, :validation
+
+  def initialize(data_access)
+    @user = UserService.new data_access
+    @validation = ValidationService.new data_access
+  end
+end

lib/services/base_service.rb

···
+# frozen_string_literal: true
+
+require 'sinatra'
+
+# Base services, initializes data access, services
+class BaseService
+  def initialize(data_access)
+    @data_access = data_access
+  end
+
+  protected
+
+  attr_reader :data_access
+
+  def error!(message)
+    halt 500, message
+  end
+end

lib/services/plant_service.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_service'
+
+# Dealing with plant actions
+class PlantService < BaseService
+  def new_plant(user_id:, name:, plant_type: nil)
+    plant_type_id = data_access.plant_types.find_or_create(name: plant_type) if plant_type
+    data_access.plants.insert user_id:, name:, plant_type_id:
+  end
+end

lib/services/user_service.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_service'
+
+# Dealing with user's actions
+class UserService < BaseService
+  # Signs a user up by email, returns a message to be sent back to the user
+  def sign_up!(email)
+    raise 'Invalid email' unless /^[^@]+@[^.]+\.[^.]+$/.match? email
+
+    data_access.users.insert email:
+  rescue PG::UniqueViolation
+    error! "An account with the email #{email} already exists"
+  end
+
+  # Validates a code to allow a user to sign in (or to check if a user can sign in) return true or false
+  def validate_code?(code:, email:, ip:)
+    user_id = find_id_from_email email
+    count_within_quantum = data_access.validations.validations_within_time_quantum_for_user_id(user_id)[0]['count'].to_i
+    raise 'Too many requests' if count_within_quantum >= 10
+
+    data_access.validations.insert(user_id:, ip:)
+
+    results = @data_access.users.find(choose: %i[access_code], id: user_id)
+    results[0]['access_code'] == code
+  end
+
+  private
+
+  def find_id_from_email(email)
+    data_access.users.find(choose: %i[id], email:)[0]['id']
+  end
+end

lib/services/validation_service.rb

···
+# frozen_string_literal: true
+
+require_relative 'base_service'
+
+# Dealing with validation actions
+class ValidationService < BaseService
+end

views/plants.erb

···
+<h1>Plants</h1>