1
            

            

            class ApplicationController < ActionController::API
          
        
      
        

          

            1
            

            

              ACTIVE_RECORD_EXS = [ActiveRecord::RecordInvalid, ActiveRecord::RecordNotFound]
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class CustomersController < ApplicationController
          
        
      
        

          

            1
            

            

              SUPPORTED_SORTS = %w[full_name vehicle_type]
          
        
      
        

          

            1
            

            

              CUSTOMER_EXS = [CustomerError]
          
        
      
        

          

            1
            

            

              RETURNABLE_EXS = ACTIVE_RECORD_EXS + CUSTOMER_EXS
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            5
            

            

                sort_params = params.permit(:sort_by, :order)
          
        
      
        

          

            5
            

            

                sort_by     = sort_params[:sort_by]
          
        
      
        

          

            5
            

            

                order       = sort_params[:order]&.upcase || 'ASC'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                if SUPPORTED_SORTS.include?(sort_by)
          
        
      
        

          

            4
            

            

                  validated_sort(order, sort_by)
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            1
            

            

                  render json: Customer.all
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue *CUSTOMER_EXS => e
          
        
      
        

          

            
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def show
          
        
      
        

          

            2
            

            

                customer = Customer.find(params[:id])
          
        
      
        

          

            1
            

            

                render json: customer
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue ActiveRecord::RecordNotFound => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def create
          
        
      
        

          

            2
            

            

                file = params.permit(:file)[:file]
          
        
      
        

          

            2
            

            

                if file && File.file?(file)
          
        
      
        

          

            1
            

            

                  emails = Customer.file_create(file)
          
        
      
        

          

            1
            

            

                  customers = Customer.where(email: emails)
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            1
            

            

                  customers = Customer.create!(customer_params)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            2
            

            

                render json: customers
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue *RETURNABLE_EXS => e
          
        
      
        

          

            
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def update
          
        
      
        

          

            2
            

            

                customer = Customer.find(params[:id])
          
        
      
        

          

            1
            

            

                customer.update!(customer_params)
          
        
      
        

          

            1
            

            

                render json: customer.reload
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue *RETURNABLE_EXS => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def destroy
          
        
      
        

          

            2
            

            

                customer = Customer.find(params[:id])
          
        
      
        

          

            1
            

            

                customer.delete
          
        
      
        

          

            1
            

            

                render json: customer
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue ActiveRecord::RecordNotFound => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def validated_sort(order, sort_by)
          
        
      
        

          

            4
            

            

                case sort_by
          
        
      
        

          

            
            

            

                when 'full_name'
          
        
      
        

          

            2
            

            

                  sort_criteria = "first_name #{order}, last_name #{order}"
          
        
      
        

          

            2
            

            

                  render json: Customer.order(sort_criteria)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                when 'vehicle_type'
          
        
      
        

          

            2
            

            

                  sort_criteria = ['vehicles.vehicle_type', order].compact.join(' ')
          
        
      
        

          

            2
            

            

                  render json: Customer
          
        
      
        

          

            
            

            

                   .joins(:vehicles)
          
        
      
        

          

            
            

            

                   .where('vehicles.primary = true')
          
        
      
        

          

            
            

            

                   .order(sort_criteria)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  raise CustomerError, 'Input invalid: invalid sort criteria'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def customer_params
          
        
      
        

          

            2
            

            

                params.require(:customer).permit(
          
        
      
        

          

            
            

            

                  :first_name,
          
        
      
        

          

            
            

            

                  :last_name,
          
        
      
        

          

            
            

            

                  :full_name,
          
        
      
        

          

            
            

            

                  :email
          
        
      
        

          

            
            

            

                )
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class VehiclesController < ApplicationController
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            1
            

            

                render json: Vehicle.all
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def show
          
        
      
        

          

            2
            

            

                render json: Vehicle.find(params[:id])
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue ActiveRecord::RecordNotFound => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def create
          
        
      
        

          

            1
            

            

                render json: Vehicle.create!(vehicle_params)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue ActiveRecord::RecordInvalid => e
          
        
      
        

          

            
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def update
          
        
      
        

          

            2
            

            

                vehicle = Vehicle.find(params[:id])
          
        
      
        

          

            1
            

            

                vehicle.update!(vehicle_params)
          
        
      
        

          

            1
            

            

                render json: vehicle.reload
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue *ACTIVE_RECORD_EXS => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def destroy
          
        
      
        

          

            2
            

            

                vehicle = Vehicle.find(params[:id])
          
        
      
        

          

            1
            

            

                vehicle.delete
          
        
      
        

          

            1
            

            

                render json: vehicle
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              rescue ActiveRecord::RecordNotFound => e
          
        
      
        

          

            1
            

            

                render json: { "error" => e.message }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def vehicle_params
          
        
      
        

          

            2
            

            

                params.require(:vehicle).permit(
          
        
      
        

          

            
            

            

                  :type,
          
        
      
        

          

            
            

            

                  :name,
          
        
      
        

          

            
            

            

                  :length,
          
        
      
        

          

            
            

            

                  :customer_id
          
        
      
        

          

            
            

            

                )
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class CustomerError < StandardError; end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ApplicationRecord < ActiveRecord::Base
          
        
      
        

          

            1
            

            

              self.abstract_class = true
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Customer < ApplicationRecord
          
        
      
        

          

            1
            

            

              attribute :id,         :integer
          
        
      
        

          

            1
            

            

              attribute :first_name, :string
          
        
      
        

          

            1
            

            

              attribute :last_name,  :string
          
        
      
        

          

            1
            

            

              attribute :full_name,  :string
          
        
      
        

          

            1
            

            

              attribute :email,      :string
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              validates :email, presence: true, uniqueness: true
          
        
      
        

          

            1
            

            

              validate  :name_is_present
          
        
      
        

          

            1
            

            

              has_many  :vehicles
          
        
      
        

          

            52
            

            

              has_one   :vehicle, -> { where(primary: true) }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def attributes
          
        
      
        

          

            
            

            

                {
          
        
      
        

          

            42
            

            

                  id:         id,
          
        
      
        

          

            
            

            

                  full_name:  full_name,
          
        
      
        

          

            
            

            

                  email:      email,
          
        
      
        

          

            
            

            

                  created_at: created_at,
          
        
      
        

          

            
            

            

                  updated_at: updated_at,
          
        
      
        

          

            
            

            

                  vehicle:    vehicle
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def full_name
          
        
      
        

          

            94
            

            

                [first_name, last_name].compact.join(' ')
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def full_name=(value)
          
        
      
        

          

            9
            

            

                params = value.split(' ')
          
        
      
        

          

            9
            

            

                assign_attributes first_name: params[0], last_name: params[1]
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def name_is_present
          
        
      
        

          

            303
            

            

                unless (first_name && last_name) || full_name
          
        
      
        

          

            
            

            

                  errors.add(base: 'Validation failed: must have both first & last OR full_name present')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              alias :name :full_name
          
        
      
        

          

            1
            

            

              class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # file_create creates both customers
          
        
      
        

          

            
            

            

                # and a single associated vehicle from the given format
          
        
      
        

          

            1
            

            

                def file_create(file)
          
        
      
        

          

            25
            

            

                  processed = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            25
            

            

                  lines = if file.respond_to? :tempfile
          
        
      
        

          

            24
            

            

                            File.read(file.tempfile)
          
        
      
        

          

            1
            

            

                          elsif file.is_a? String
          
        
      
        

          

            1
            

            

                            File.read(file)
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            25
            

            

                  lines.split("\n").each do |line|
          
        
      
        

          

            98
            

            

                    processed << parse_customer(line)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            25
            

            

                  processed
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                SPLIT_CRITERIA = /[|,]/
          
        
      
        

          

            1
            

            

                HEADER = {
          
        
      
        

          

            
            

            

                  first_name: 0,
          
        
      
        

          

            
            

            

                  last_name:  1,
          
        
      
        

          

            
            

            

                  email:      2,
          
        
      
        

          

            
            

            

                  type:       3,
          
        
      
        

          

            
            

            

                  name:       4,
          
        
      
        

          

            
            

            

                  length:     5
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def parse_customer(line)
          
        
      
        

          

            98
            

            

                  params   = line.split(SPLIT_CRITERIA)
          
        
      
        

          

            98
            

            

                  customer = Customer.find_by(email: params[HEADER[:email]])
          
        
      
        

          

            98
            

            

                  primary  = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            98
            

            

                  unless customer
          
        
      
        

          

            98
            

            

                    customer = Customer.create customer_file_params(params)
          
        
      
        

          

            98
            

            

                    primary  = true
          
        
      
        

          

            98
            

            

                    customer.save
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            98
            

            

                  if customer.valid?
          
        
      
        

          

            97
            

            

                    vehicle = Vehicle.create vehicle_file_params(params, customer, primary)
          
        
      
        

          

            97
            

            

                    vehicle.save
          
        
      
        

          

            97
            

            

                    customer.email
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def customer_file_params(params)
          
        
      
        

          

            
            

            

                  {
          
        
      
        

          

            98
            

            

                    first_name: params[HEADER[:first_name]],
          
        
      
        

          

            
            

            

                    last_name:  params[HEADER[:last_name]],
          
        
      
        

          

            
            

            

                    email:      params[HEADER[:email]],
          
        
      
        

          

            
            

            

                  }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def vehicle_file_params(params, customer, primary)
          
        
      
        

          

            
            

            

                  {
          
        
      
        

          

            97
            

            

                    type:        params[HEADER[:type]],
          
        
      
        

          

            
            

            

                    name:        params[HEADER[:name]],
          
        
      
        

          

            
            

            

                    length:      params[HEADER[:length]],
          
        
      
        

          

            
            

            

                    customer_id: customer.id,
          
        
      
        

          

            
            

            

                    primary:     primary
          
        
      
        

          

            
            

            

                  }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Vehicle < ApplicationRecord
          
        
      
        

          

            1
            

            

              attribute :id,           :integer
          
        
      
        

          

            1
            

            

              attribute :vehicle_type, :string
          
        
      
        

          

            1
            

            

              attribute :name,         :string
          
        
      
        

          

            1
            

            

              attribute :length,       :integer
          
        
      
        

          

            1
            

            

              attribute :primary,      :boolean
          
        
      
        

          

            1
            

            

              attribute :customer_id,  :integer
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              alias_attribute :type, :vehicle_type
          
        
      
        

          

            1
            

            

              validates  :vehicle_type, :name, :length, :customer_id, presence: true
          
        
      
        

          

            1
            

            

              belongs_to :customer
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def attributes
          
        
      
        

          

            
            

            

                {
          
        
      
        

          

            55
            

            

                  id: id,
          
        
      
        

          

            
            

            

                  type: type,
          
        
      
        

          

            
            

            

                  name: name,
          
        
      
        

          

            
            

            

                  length: length,
          
        
      
        

          

            
            

            

                  created_at: created_at,
          
        
      
        

          

            
            

            

                  updated_at: updated_at,
          
        
      
        

          

            
            

            

                  customer_id: customer_id
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def initialize(params)
          
        
      
        

          

            102
            

            

                params[:vehicle_type] = params[:type].downcase
          
        
      
        

          

            102
            

            

                params[:name]         = params[:name].titleize
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            102
            

            

                if Customer.find(params[:customer_id]).vehicles.size == 0
          
        
      
        

          

            100
            

            

                  params[:primary] = true
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            102
            

            

                super(params.except(:type))
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end