How to Build a Booking Engine Similar to Booking.com with Ruby on Rails 6 and ElasticSearch 7

class Property < ApplicationRecord  include PropertyElastic  has_many :rooms, dependent: :destroy  has_many :booking_rooms, through: :rooms  has_and_belongs_to_many :property_options, dependent: :destroyend

class Room < ApplicationRecord  belongs_to :property  has_and_belongs_to_many :room_options  has_many :booking_rooms, dependent: :destroyend

class BookingRoom < ApplicationRecord  belongs_to :room  has_many :booking_room_availabilities, dependent: :destroy  enum status: %i[published draft]end

class BookingRoomAvailability < ApplicationRecord  belongs_to :booking_room  enum status: %i[available closed booked]  validates_uniqueness_of :booking_room, scope: %i[day]end

class CreateBookingRoomAvailabilities < ActiveRecord::Migration[5.2]  def change    create_table :booking_room_availabilities do |t|      t.references :booking_room      t.date :day      t.integer :price      t.integer :status      t.timestamps    end  endend

gem 'elasticsearch-model', '7.1.1'gem 'elasticsearch-rails', '7.1.1'

require 'elasticsearch/model'module PropertyElastic  extend ActiveSupport::Concern  included do    include Elasticsearch::Model    include Elasticsearch::Model::Callbacks    settings index: { number_of_shards: 1 } do      mappings dynamic: 'false' do        indexes :id        indexes :search_body, analyzer: 'snowball'        indexes :property_options        indexes :rooms, type: 'nested', properties: {          'name' => {'type' => 'text'},          'id' => {'type' => 'long'},          'room_options' => {'type' => 'keyword'},          'guests' => { 'type' => 'long'},          'availability' => { 'type' => 'nested', properties: {            'day' => { 'type' => 'date' },            'id' => { 'type' => 'long' },            'price' => {'type' => 'long'},            'status' => { 'type' => 'keyword' },            'booking_room_id' => { 'type' => 'long'}          } }        }      end    end  end  def as_indexed_json(_options = {})    as_json(      only: %i[id updated_at]    ).merge({      property_options: property_options.pluck(:id),      search_body: title,      rooms: availabilities,      })  end  def availabilities    if booking_rooms.any?      booking_rooms.map do |br|        {          name: br.title,          id: br.id,          room_options: br.room.room_options.pluck(:id).uniq,          guests: br.guests,          availability: br.booking_room_availabilities.where("day >= ? AND day < ?", Date.today, Date.today + 6.months).map do |s|            {day: s.day.to_s, price: s.price, status: s.status, room_id: br.id, id: s.id}          end        }      end    else      rooms.map do |r|        {          name: r.title,          id: r.id,          room_options: r.room_options.pluck(:id).uniq,        }      end    end  endend

class BookingSearch  def self.perform(params, page = 1)    @page = page || 1    @per_page = params[:per_page]    @query = params[:q]&.strip    @params = params    search  end  def self.search    salt = @params[:salt] || "salt"    terms = {      sort: {        _script: {          script: "(doc['_id'] + '#{salt}').hashCode()",          type: "number",          order: "asc"        }      },      query: {        bool: {          must: search_terms,          filter:  {            bool: {              must: generate_term + generate_nested_term            }          }        }      },      size: @per_page,      from: (@page.to_i - 1) * @per_page    }    Property.__elasticsearch__.search(terms)  end  def self.generate_nested_term    terms_all = []    terms = []    if @params[:room_options]      @params[:room_options].split(",")&.map(&:to_i)&.each do |ro|        terms.push({terms: { "rooms.room_options" => [ro] }})      end    end    terms.push({range: { "rooms.guests" => {'gte' => @params[:guests].to_i}}})    n = {nested: {      path: "rooms",      query: {        bool: {          must: terms        }      },      inner_hits: { name: 'room' }    }}    terms_all.push(n)    Date.parse(@params[:from]).upto(Date.parse(@params[:to]) - 1.day) do |d|      terms = []      terms.push(match: { "rooms.availability.status" => 'available' })      terms.push(match: { "rooms.availability.day" => d.to_s })      n = {nested: {        path: "rooms.availability",        query: {          bool: {            must: terms          }        },        inner_hits: { name: d.to_s }      }      }      terms_all.push(n)    end    terms_all  end  def self.generate_term    terms = []    if @params[:property_options].present?      @params[:property_options].split(',').each do |lo|        terms.push(term: { property_options: lo })      end    end    terms  end  def self.search_terms    match = [@query.blank? ? { match_all: {} } : { multi_match: { query: @query, fields: %w[search_body], operator: 'and' } }]    match.push( { ids: { values: @params[:ids] } }) if @params[:ids]    match  endend

class DataDemo  PROPERTIES = ['White', 'Blue', 'Yellow', 'Red', 'Green']  PROPERTY_OPTIONS = ['WiFi', 'Parking', 'Swimming Pool', 'Playground']  ROOM_OPTIONS = ['Kitchen', 'Kettle', 'Work table', 'TV']  ROOM_TYPES = ['Standard', 'Comfort']  def self.search    params = {}    from_search = Date.today + rand(20).days    params[:from] = from_search.to_s    params[:to] = (from_search + 3.days).to_s    params[:per_page] = 10    property_options = PROPERTY_OPTIONS.sample(1).map{|po| PropertyOption.find_by title: "po}"    room_options = ROOM_OPTIONS.sample(1).map{|ro| RoomOption.find_by title: "ro}"    params[:property_options] = property_options.map(&:id).join(',')    params[:room_options] = room_options.map(&:id).join(',')    params[:guests] = 2    res = BookingSearch.perform(params)    puts "Search for dates: #{params[:from]}..#{params[:to]}"    puts "Property options: #{property_options.map(&:title).to_sentence}"    puts "Room options: #{room_options.map(&:title).to_sentence}"    res.response.hits.hits.each do |hit|      puts "Property: #{hit._source.search_body}"      available_rooms = {}      # dive into inner hits to get detailed search data      # here we transform search result into more structured way         hit.inner_hits.each do |key, inner_hit|        if key != 'room'          inner_hit.hits.hits.each do |v|            available_rooms[v._source.room_id.to_s] ||= []            available_rooms[v._source.room_id.to_s] << { day: v._source.day, price: v._source.price }          end        else          puts "Rooms: #{inner_hit.hits.hits.count}"        end      end      # printing results      available_rooms.each do |key, ar|        booking_room = BookingRoom.find key        puts "Room: #{booking_room.room.title} / #{booking_room.title}"        total_price = 0        ar.each do |day|          puts "#{day[:day]}: $#{day[:price]}/night"          total_price += day[:price]        end        puts "Total price for #{ar.count} #{'night'.pluralize(ar.count)}: $#{total_price}"        puts "----------------------------
"      end    end    res.response.hits["total"].value  end  def self.delete    Property.destroy_all    PropertyOption.destroy_all    RoomOption.destroy_all  end  def self.run    delete    PROPERTY_OPTIONS.each { |po| PropertyOption.create(title: po) }    ROOM_OPTIONS.each { |ro| RoomOption.create(title: ro) }    5.times do |i|      p = Property.create(title: PROPERTIES[i])      rooms = rand(2) + 1      p.property_options = PROPERTY_OPTIONS.sample(2).map{ |po| PropertyOption.find_by title: po }      rooms.times do |j|        room = p.rooms.create({title: "#{ROOM_TYPES[rand(2)]} #{j}" })        room.room_options = ROOM_OPTIONS.sample(2).map{ |po| RoomOption.find_by title: po }        (rand(2) + 1).times do |k|          booking_room = room.booking_rooms.create title: "Room #{k+1}", status: :published, guests: rand(4) + 1          30.times do |d|            booking_room.booking_room_availabilities.create day: Date.today + d.days, status: :available, price: [100, 200, 300][rand(3)]          end        end      end    end    Property.__elasticsearch__.delete_index!    Property.__elasticsearch__.create_index!    Property.__elasticsearch__.import  endend

DataDemo.run

DataDemo.search