stay_commerce 0.1.0

data/app/models/stay/payment.rb

@@ -0,0 +1,54 @@
+module Stay
+  class Payment < ApplicationRecord
+    PAYMENT_STATES = %w(failed paid)
+
+    belongs_to :booking, class_name: 'Stay::Booking'
+    belongs_to :payment_method, class_name: 'Stay::PaymentMethod'
+
+    validates :payment_method, presence: true
+    validates :amount, numericality: true
+
+    scope :with_state, ->(s) { where(state: s.to_s) }
+    scope :completed, -> { with_state('completed') }
+    scope :pending, -> { with_state('pending') }
+    scope :processing, -> { with_state('processing') }
+    scope :failed, -> { with_state('failed') }
+
+    # state_machine initial: :checkout do
+    #   # to complete
+    #   event :started_processing do
+    #     transition from: [:checkout, :pending, :completed, :processing], to: :processing
+    #   end
+    #   # When processing during checkout fails
+    #   event :failure do
+    #     transition from: [:pending, :processing], to: :failed
+    #   end
+    #   # With card payments this represents authorizing the payment
+    #   event :pend do
+    #     transition from: [:checkout, :processing], to: :pending
+    #   end
+    #   # With card payments this represents completing a purchase or capture transaction
+    #   event :complete do
+    #     transition from: [:processing, :pending, :checkout], to: :completed
+    #   end
+    #   after_transition to: :completed, do: :after_completed
+    #   event :void do
+    #     transition from: [:pending, :processing, :completed, :checkout], to: :void
+    #   end
+    #   after_transition to: :void, do: :after_void
+    #   # when the card brand isn't supported
+    #   event :invalidate do
+    #     transition from: [:checkout], to: :invalid
+    #   end
+
+    #   after_transition do |payment, transition|
+    #     payment.state_changes.create!(
+    #       previous_state: transition.from,
+    #       next_state: transition.to,
+    #       name: 'payment'
+    #     )
+    #   end
+    # end
+
+  end
+end

data/app/models/stay/payment_method.rb

@@ -0,0 +1,13 @@
+module Stay
+  class PaymentMethod < ApplicationRecord
+    DISPLAY = [ :both, :front_end, :back_end ].freeze
+
+    has_many :payments, class_name: "Stay::Payment", dependent: :destroy
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+
+    scope :active,                 -> { where(active: true).order(position: :asc) }
+    scope :available,              -> { active.where(display_on: [ :front_end, :back_end, :both ]) }
+    scope :available_on_front_end, -> { active.where(display_on: [ :front_end, :both ]) }
+    scope :available_on_back_end,  -> { active.where(display_on: [ :back_end, :both ]) }
+  end
+end

data/app/models/stay/price.rb

@@ -0,0 +1,18 @@
+module Stay
+  class Price < ApplicationRecord
+    MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
+
+    belongs_to :room, class_name: 'Stay::Room'
+    before_validation :ensure_currency
+    validates :amount, allow_nil: true, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }
+    
+    private
+
+    def ensure_currency
+      self.currency ||= Stay::Store.default.default_currency
+    end
+  end
+end

data/app/models/stay/property.rb

@@ -0,0 +1,243 @@
+module Stay
+  class Property < ApplicationRecord
+    ACTIVE_STATUS = "active".freeze
+    APPROVED = "approved".freeze
+    include Rails.application.routes.url_helpers
+    include CurrencyHelper
+    include Stay::ControllerHelpers::Currency
+    include Stay::ControllerHelpers::Store
+    extend FriendlyId
+    acts_as_paranoid
+
+    friendly_id :title, use: :slugged
+
+    validates :title, presence: true, uniqueness: { case_sensitive: false, error: "Title has already been taken" }
+    validate :availability_dates_are_valid
+    has_one :master, -> { where is_master: true }, class_name: "Stay::Room", dependent: :destroy
+    has_many :rooms, -> { where(status: ACTIVE_STATUS) }, class_name: "Stay::Room", dependent: :destroy
+    has_many :rooms_including_master,
+         inverse_of: :property,
+         class_name: "Stay::Room",
+         dependent: :destroy
+
+    belongs_to :cancellation_policy, class_name: "Stay::CancellationPolicy", optional: :true
+    has_many :chats, class_name: "Stay::Chat", dependent: :destroy
+
+    belongs_to :user, class_name: "Stay::User", optional: true
+    # belongs_to :address, class_name: 'Stay::Address', optional: true
+
+    has_many :prices, through: :rooms
+    has_many :line_items, through: :variants_including_master
+    has_many :bookings
+    belongs_to :property_category, class_name: "Stay::PropertyCategory", optional: true
+    belongs_to :property_type, class_name: "Stay::PropertyType"
+    has_many :property_amenities, class_name: "Stay::PropertyAmenity", dependent: :destroy
+    has_many :amenities, through: :property_amenities, class_name: "Stay::Amenity"
+    has_many :additional_rules, class_name: "Stay::AdditionalRule", dependent: :destroy
+    has_many :property_house_rules, class_name: "Stay::PropertyHouseRule", dependent: :destroy
+    has_many :house_rules, through: :property_house_rules, class_name: "Stay::HouseRule"
+    has_many :property_features, class_name: "Stay::PropertyFeature", dependent: :destroy
+    has_many :features, through: :property_features, class_name: "Stay::Feature"
+    has_many :property_taxes, class_name: "Stay::PropertyTax", dependent: :destroy
+    has_many :taxes, through: :property_taxes, class_name: "Stay::Tax"
+    has_many :store_properties, class_name: "Stay::StoreProperty", dependent: :destroy
+    has_many :stores, through: :store_properties, class_name: "Stay::Store"
+
+    # images
+    has_one_attached :cover_image
+    has_many_attached :place_images
+
+    # nested_attributes
+    accepts_nested_attributes_for :property_amenities, allow_destroy: true
+    accepts_nested_attributes_for :additional_rules, allow_destroy: true
+    accepts_nested_attributes_for :rooms, allow_destroy: true
+    accepts_nested_attributes_for :property_house_rules, allow_destroy: true
+    accepts_nested_attributes_for :property_features, allow_destroy: true
+    accepts_nested_attributes_for :property_taxes, allow_destroy: true
+
+    after_restore :restore_associated_rooms
+    after_restore :restore_active_storage_files
+    after_create :create_default_room
+    after_update :update_prices
+    after_create :create_store_property
+    geocoded_by :combine_address
+    after_validation :geocode
+
+    # scopes
+    scope :approved, -> { where(property_state: APPROVED) }
+    scope :active, -> { where(active: true) }
+    scope :similar_properties, ->(type_id, category_id, property_id) {
+      where(property_type_id: type_id, property_category_id: category_id)
+      .where.not(id: property_id)
+    }
+
+    scope :with_features, ->(feature_ids) {
+      joins(:features).where(stay_features: { id: feature_ids }).distinct
+    }
+
+    scope :with_amenities, ->(amenity_ids) {
+      joins(:amenities).where(stay_amenities: { id: amenity_ids }).distinct
+    }
+
+    scope :nearby, ->(latitude, longitude, distance) {
+      near([ latitude, longitude ], distance)
+    }
+
+    scope :by_property_type, ->(property_type_id) {
+      joins(:property_type).where(property_type: { id: property_type_id })
+    }
+
+    scope :price_filter, ->(min_price, max_price) {
+      joins(:rooms).where(stay_rooms: { price_per_month: min_price..max_price })
+    }
+
+    scope :by_property_category, ->(property_category_id) {
+      joins(:property_category).where(property_category: { id: property_category_id })
+    }
+
+    def id_with_title
+      [
+        truncated_title,
+        [ truncated_title, truncated_description ]
+      ]
+    end
+
+    def truncated_title
+      title.split[0..9].join(" ")
+    end
+
+    def truncated_description
+      description.split[0..5].join(" ")
+    end
+
+    def should_generate_new_friendly_id?
+      title_changed?
+    end
+
+    def combine_address
+      [ address, city, state, country ].compact.join(" ")
+    end
+
+    state_machine :property_state, initial: :waiting_for_approval do
+      state :waiting_for_approval
+      state :approved
+      state :rejected
+
+      event :approve do
+        transition waiting_for_approval: :approved
+      end
+
+      event :reject do
+        transition waiting_for_approval: :rejected
+      end
+
+      event :resubmit do
+        transition rejected: :waiting_for_approval
+      end
+    end
+
+    def self.ransackable_scopes(auth_object = nil)
+      %i[with_amenities nearby by_property_type]
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[active address availability_end availability_start title extra_guest total_rooms total_bathrooms latitude longitude total_bedrooms guest_number]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[rooms amenities property_type]
+    end
+
+    def shared_property
+      property_type.present? ? property_type.name.casecmp?("shared property") : false
+    end
+
+    def has_rooms?
+      rooms.any?
+    end
+
+    def deleted?
+      !!deleted_at
+    end
+
+    def average_rating
+      all_reviews = Stay::Review.joins(booking: { rooms: :property }).where(stay_properties: { id: self.id })
+
+      return 0 if all_reviews.empty?
+      total_rating = all_reviews.sum(:rating)
+      review_count = all_reviews.count
+
+      (total_rating.to_f / review_count).round(2)
+    end
+
+    def reviews_count
+      Stay::Review.joins(booking: { rooms: :property }).where(stay_properties: { id: self.id }).count
+    end
+
+    def default_room
+      master
+    end
+
+    def price
+      master&.price_per_month.to_f || 0
+    end
+
+    def place_images_urls
+      place_images.map { |image| image.url }
+    end
+
+    def cover_image_url
+      cover_image.attached? ? cover_image.url : nil
+    end
+
+    def approved
+      transaction do
+        approve!
+      end
+    end
+
+    def rejected
+      transaction do
+        reject!
+      end
+    end
+
+    def resubmited
+      transaction do
+        resubmit!
+      end
+    end
+
+    private
+
+    def restore_active_storage_files
+      place_images.each do |image|
+        Rails.logger.error "Missing file for #{image.filename}" unless File.exist?(ActiveStorage::Blob.service.path_for(image.blob.key))
+      end
+    end
+
+    def restore_associated_rooms
+      rooms.only_deleted.each(&:restore)
+    end
+
+    def availability_dates_are_valid
+      if availability_start && availability_end && availability_start >= availability_end
+        errors.add(:availability_end, "must be after availability start date")
+      end
+    end
+
+    def create_store_property
+      StoreProperty.create(store_id: current_store.id, property_id: self.id)
+    end
+
+    def create_default_room
+      return unless Stay::RoomType.first.present?
+      master_room = rooms.create!(is_master: true, property_id: self.id, max_guests: 2, price_per_month: price_per_month, room_type_id: Stay::RoomType.first&.id, status: "active")
+      master_room.prices.create(amount: master_room.price_per_month, currency: Stay::Store.default.default_currency)
+    end
+
+    def update_prices
+      master&.prices&.update(amount: master.price_per_month, currency: Stay::Store.default.default_currency)
+    end
+  end
+end

data/app/models/stay/property_amenity.rb

@@ -0,0 +1,6 @@
+module Stay
+  class PropertyAmenity < ApplicationRecord
+    belongs_to :property, class_name: "Stay::Property"
+    belongs_to :amenity, class_name: "Stay::Amenity"
+  end
+end

data/app/models/stay/property_category.rb

@@ -0,0 +1,6 @@
+module Stay
+  class PropertyCategory < ApplicationRecord
+    has_many :properties, class_name: "Stay::Property", dependent: :nullify
+    validates :name,  presence: true, uniqueness: { case_sensitive: false }, format: { without: /\s/, message: "must contain no spaces" }
+  end
+end

data/app/models/stay/property_feature.rb

@@ -0,0 +1,6 @@
+module Stay
+  class PropertyFeature < ApplicationRecord
+    belongs_to :property, class_name: "Stay::Property"
+    belongs_to :feature, class_name: "Stay::Feature"
+  end
+end

data/app/models/stay/property_house_rule.rb

@@ -0,0 +1,6 @@
+module Stay
+  class PropertyHouseRule < ApplicationRecord
+    belongs_to :property
+    belongs_to :house_rule
+  end
+end

data/app/models/stay/property_tax.rb

@@ -0,0 +1,6 @@
+module Stay
+  class PropertyTax < ApplicationRecord
+    belongs_to :tax, class_name: 'Stay::Tax', touch: true
+    belongs_to :property, class_name: 'Stay::Property', touch: true
+  end
+end

data/app/models/stay/property_type.rb

@@ -0,0 +1,15 @@
+module Stay
+  class PropertyType < ApplicationRecord
+    validates :name,  presence: true, uniqueness: { case_sensitive: false }, format: { without: /\s/, error: "must contain no spaces" }
+
+
+    has_many :properties
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id name created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      []
+    end
+  end
+end

data/app/models/stay/review.rb

@@ -0,0 +1,5 @@
+module Stay
+  class Review < ApplicationRecord
+     belongs_to :booking
+  end
+end

data/app/models/stay/role.rb

@@ -0,0 +1,11 @@
+module Stay
+  class Role < ApplicationRecord
+    has_many :role_users, class_name: "Stay::RoleUser", dependent: :destroy
+    has_many :users, through: :role_users, class_name: "Stay::User"
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+
+    USER = "student".freeze
+    ADMIN = "admin".freeze
+    HOST = "host".freeze
+  end
+end

data/app/models/stay/role_user.rb

@@ -0,0 +1,6 @@
+module Stay
+  class RoleUser < ApplicationRecord
+    belongs_to :user, class_name: 'Stay::User'
+    belongs_to :role, class_name: 'Stay::Role'
+  end
+end

data/app/models/stay/room.rb

@@ -0,0 +1,93 @@
+module Stay
+  class Room < ApplicationRecord
+    include CurrencyHelper
+    STATUSES = %w[active inactive].freeze
+    acts_as_paranoid
+    after_initialize :set_default_price, if: :new_record?
+
+    # validations
+    validates :status, presence: true, inclusion: { in: STATUSES, message: "%{value} is not a valid status" }
+    validate :booking_dates_are_valid
+    validate :room_count_limit, on: :create
+
+    # associations
+    belongs_to :property, class_name: "Stay::Property"
+    belongs_to :room_type, class_name: "Stay::RoomType"
+    belongs_to :bed_type, class_name: "Stay::BedType", optional: :true
+    has_many :bookings, class_name: "Stay::Booking"
+    has_many_attached :room_images
+    has_many :line_items, class_name: "Stay::LineItem"
+    has_many :prices,
+             class_name: "Stay::Price",
+             dependent: :destroy
+
+    has_many :room_features, class_name: "Stay::RoomFeature", dependent: :destroy
+    has_many :features, through: :room_features, class_name: "Stay::Feature"
+
+    has_many :room_amenities, class_name: "Stay::RoomAmenity", dependent: :destroy
+    has_many :amenities, through: :room_amenities, class_name: "Stay::Amenity"
+
+    # nested attributes
+    accepts_nested_attributes_for :room_features, allow_destroy: true
+    accepts_nested_attributes_for :room_amenities, allow_destroy: true
+
+    after_create :set_price
+    after_update :update_price, if: :saved_change_to_price_per_month?
+
+    # state_machine :status, initial: :active do
+    #   state :active
+    #   state :booked
+    #   state :inactive
+
+    #   event :book do
+    #     transition active: :booked
+    #   end
+
+    #   event :deactivate do
+    #     transition [:booked, :active] => :inactive
+    #   end
+
+    #   event :activate do
+    #     transition inactive: :active
+    #   end
+    # end
+
+
+    def price
+      price_per_month
+    end
+
+    def images_urls
+      room_images.map { |image| image.url }
+    end
+
+    def set_default_price
+      self.price_per_month ||= 0
+    end
+
+    private
+
+    def booking_dates_are_valid
+      if booking_start && booking_end && booking_start >= booking_end
+        errors.add(:booking_end, "must be after start date")
+      end
+    end
+
+    def room_count_limit
+      return if property.rooms.count == 0
+      if property.rooms.count >= property.total_rooms
+        errors.add(:base, "You cannot create more rooms than the property's total room count.")
+      end
+    end
+
+    def set_price
+      prices.create(amount: price_per_month, currency: Stay::Store.default.default_currency) if price_per_month.present? && !is_master
+    end
+
+    def update_price
+      price = prices.find_or_initialize_by(currency: Stay::Store.default.default_currency)
+      price.amount = price_per_month
+      price.save
+    end
+  end
+end

data/app/models/stay/room_amenity.rb

@@ -0,0 +1,6 @@
+module Stay
+  class RoomAmenity < ApplicationRecord
+    belongs_to :room, class_name: "Stay::Room"
+    belongs_to :amenity, class_name: "Stay::Amenity"
+  end
+end

data/app/models/stay/room_feature.rb

@@ -0,0 +1,6 @@
+module Stay
+  class RoomFeature < ApplicationRecord
+    belongs_to :room, class_name: "Stay::Room"
+    belongs_to :feature, class_name: "Stay::Feature"
+  end
+end

data/app/models/stay/room_type.rb

@@ -0,0 +1,7 @@
+module Stay
+  class RoomType < ApplicationRecord
+    has_many :rooms, class_name: "Stay::Room"
+
+    validates :name,  presence: true, uniqueness: { case_sensitive: false }, format: { without: /\s/, message: "must contain no spaces" }
+  end
+end

data/app/models/stay/state.rb

@@ -0,0 +1,13 @@
+module Stay
+  class State < ApplicationRecord
+    belongs_to :country, class_name: "Stay::Country"
+    has_many :cities, class_name: "Stay::City"
+    has_many :addresses, dependent: :destroy
+    validates :name, presence: true
+
+    def self.ransackable_attributes(auth_object = nil)
+      ["name"]
+    end
+
+  end
+end

data/app/models/stay/store.rb

@@ -0,0 +1,139 @@
+module Stay
+  class Store < ApplicationRecord
+    include TranslatableResource
+    # acts_as_paranoid
+
+    TRANSLATABLE_FIELDS = %i[meta_description meta_keywords seo_title facebook
+                             twitter instagram customer_support_email description
+                             address contact_phone new_order_notifications_email].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
+    self::Translation.class_eval do
+      acts_as_paranoid
+      # deleted translation values still need to be accessible - remove deleted_at scope
+      default_scope { unscope(where: :deleted_at) }
+    end
+
+    acts_as_paranoid
+
+    has_many :bookings, class_name: 'Stay::Booking'
+    has_many :line_items, through: :bookings, class_name: 'Stay::LineItem'
+    has_many :payments, through: :bookings, class_name: 'Stay::Payment'
+    has_many :store_properties, class_name: 'Stay::StoreProperty'
+    has_many :properties, through: :store_properties, class_name: 'Stay::Property'
+    has_many :rooms, through: :properties, class_name: 'Stay::Room', source: :rooms_including_master
+
+    validates :code, uniqueness: { case_sensitive: false, conditions: -> { with_deleted }}
+
+    default_scope { order(created_at: :asc) }
+
+    before_save :ensure_default_exists_and_is_unique
+    before_save :ensure_supported_currencies, :ensure_supported_locales
+    before_destroy :pass_default_flag_to_other_store
+
+    scope :by_url, ->(url) { where('url like ?', "%#{url}%") }
+
+    after_commit :clear_cache
+
+    alias_attribute :contact_email, :customer_support_email
+
+    def self.default
+      Rails.cache.fetch('default_store') do
+        if where(default: true).any?
+          where(default: true).first
+        else
+          new(default: true)
+        end
+      end
+    end
+
+    def self.available_locales
+      Rails.cache.fetch('stores_available_locales') do
+        Stay::Store.all.map(&:supported_locales_list).flatten.uniq
+      end
+    end
+
+    def unique_name
+      @unique_name ||= "#{name} (#{code})"
+    end
+
+    def formatted_url
+      return if url.blank?
+
+      @formatted_url ||= if url.match(/http:\/\/|https:\/\//)
+                           url
+                         else
+                           Rails.env.development? || Rails.env.test? ? "http://#{url}" : "https://#{url}"
+                         end
+    end
+
+    def supported_locales_list
+      @supported_locales_list ||= (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
+    end
+
+    def supported_currencies_list
+      @supported_currencies_list ||= (read_attribute(:supported_currencies).to_s.split(',') << default_currency).sort.map(&:to_s).map do |code|
+        ::Money::Currency.find(code.strip)
+      end.uniq.compact
+    end
+
+    def can_be_deleted?
+      self.class.where.not(id: id).any?
+    end
+
+    def seo_meta_description
+      if meta_description.present?
+        meta_description
+      elsif seo_title.present?
+        seo_title
+      else
+        name
+      end
+    end
+
+  private
+
+    def ensure_supported_locales
+      return unless attributes.keys.include?('supported_locales')
+      return if supported_locales.present?
+      return if default_locale.blank?
+
+      self.supported_locales = default_locale
+    end
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Store.where.not(id: id).update_all(default: false)
+      elsif Store.where(default: true).count.zero?
+        self.default = true
+      end
+    end
+
+    def ensure_supported_currencies
+      return unless attributes.keys.include?('supported_currencies')
+      return if supported_currencies.present?
+      return if default_currency.blank?
+
+      self.supported_currencies = default_currency
+    end
+
+    def validate_not_last
+      unless can_be_deleted?
+        errors.add(:base, :cannot_destroy_only_store)
+        throw(:abort)
+      end
+    end
+
+     def pass_default_flag_to_other_store
+      if default? && can_be_deleted?
+        self.class.where.not(id: id).first.update!(default: true)
+        self.default = false
+      end
+    end
+
+    def clear_cache
+      Rails.cache.delete('default_store')
+      Rails.cache.delete('stores_available_locales')
+    end
+  end
+end