stay_commerce 0.1.0

data/app/helpers/stay/locale_helper.rb

@@ -0,0 +1,107 @@
+module Stay
+  module LocaleHelper
+    def all_locales_options
+      supported_locales_for_all_stores.map { |locale| locale_presentation(locale) }
+    end
+
+    def available_locales_options
+      available_locales.map { |locale| locale_presentation(locale) }
+    end
+
+    def supported_locales_options
+      return if current_store.nil?
+
+      current_store.supported_locales_list.map { |locale| locale_presentation(locale) }
+    end
+
+    def supported_locales_for_all_stores
+      @supported_locales_for_all_stores ||= available_locales
+    end
+
+    def available_locales
+      locales_from_i18n = I18n.available_locales
+      locales =
+        if defined?(StayI18n)
+          (StayI18n::Locale.all << :en).map(&:to_sym)
+        else
+          [Rails.application.config.i18n.default_locale, I18n.locale, :en]
+        end
+
+      (locales + locales_from_i18n).uniq.compact
+    end
+
+    def locale_presentation(locale)
+      if I18n.exists?('stay.i18n.this_file_language', locale: locale, fallback: false)
+        [locale_full_name(locale), locale.to_s]
+      elsif defined?(StayI18n::Locale) && (language_name = StayI18n::Locale.local_language_name(locale))
+        ["#{language_name} (#{locale})", locale.to_s]
+      elsif locale.to_s == 'en'
+        ['English (US)', 'en']
+      else
+        [locale, locale.to_s]
+      end
+    end
+
+    def locale_full_name(locale)
+      I18n.t('i18n.this_file_language', locale: locale)
+    end
+
+    def should_render_locale_dropdown?
+      return false if current_store.nil?
+
+      current_store.supported_locales_list.size > 1
+    end
+
+    # New methods added from the controller
+    def current_locale
+      @current_locale ||= if user_locale?
+                            current_user.selected_locale
+                          elsif params_locale?
+                            params[:locale]
+                          elsif config_locale?
+                            config_locale
+                          else
+                            current_store&.default_locale || Rails.application.config.i18n.default_locale || I18n.default_locale
+                          end
+    end
+
+    def supported_locales
+      @supported_locales ||= current_store&.supported_locales_list
+    end
+
+    def supported_locale?(locale_code)
+      return false if supported_locales.nil?
+
+      supported_locales.include?(locale_code&.to_s)
+    end
+
+    def params_locale?
+      params[:locale].present? && supported_locale?(params[:locale])
+    end
+
+    def user_locale?
+      Stay::Config.use_user_locale && current_user && supported_locale?(current_user.selected_locale)
+    end
+
+    def config_locale?
+      respond_to?(:config_locale, true) && config_locale.present?
+    end
+
+    def locale_param
+      return if I18n.locale.to_s == current_store.default_locale || current_store.default_locale.nil?
+
+      I18n.locale.to_s
+    end
+
+    # Optionally, you can keep this as a helper method for views
+    def find_with_fallback_default_locale(&block)
+      result = begin
+        block.call
+      rescue ActiveRecord::RecordNotFound => _e
+        nil
+      end
+
+      result || Mobility.with_locale(current_store.default_locale) { block.call }
+    end
+  end
+end

data/app/jobs/stay/application_job.rb

@@ -0,0 +1,4 @@
+module Stay
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/stay/application_mailer.rb

@@ -0,0 +1,6 @@
+module Stay
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/mailers/stay/user_mailer.rb

@@ -0,0 +1,13 @@
+module Stay
+  class UserMailer < ApplicationMailer
+    def welcome_email(user)
+      @user = user
+      mail(to: @user.email, subject: "Welcome #{@user.full_name}")
+    end
+
+    def new_host_signup(user)
+      @user = user
+      mail(to: Stay::User.admin_emails, subject: "New Host Signup")
+    end
+  end
+end

data/app/models/concerns/stay/translatable_resource.rb

@@ -0,0 +1,25 @@
+module Stay
+  module TranslatableResource
+    extend ActiveSupport::Concern
+
+    included do
+      extend Mobility
+      default_scope { i18n }
+
+      def get_field_with_locale(locale, field_name, fallback: false)
+        # method will return nil if no translation is present due to fallback: false setting
+        public_send(field_name, locale: locale, fallback: fallback)
+      end
+    end
+
+    class_methods do
+      def translatable_fields
+        const_get(:TRANSLATABLE_FIELDS)
+      end
+
+      def translation_table_alias
+        "#{self::Translation.table_name}_#{Mobility.locale}"
+      end
+    end
+  end
+end

data/app/models/stay/additional_rule.rb

@@ -0,0 +1,5 @@
+module Stay
+  class AdditionalRule < ApplicationRecord
+    belongs_to :property, class_name: "Stay::Property"
+  end
+end

data/app/models/stay/address.rb

@@ -0,0 +1,40 @@
+module Stay
+  class Address < ApplicationRecord
+    belongs_to :state, class_name: 'Stay::State'
+    belongs_to :country, class_name: 'Stay::Country'
+    has_many :properties, class_name: 'Stay::Property'
+
+    belongs_to :user, class_name: 'Stay::Address', optional: true
+    validates :phone, format: { with: /\A\d{10}\z/, message: "number must be valid." }
+
+    # geocoded_by :full_address
+    # after_validation :geocode, if: ->(obj){ obj.address1.present? && obj.zipcode.present? }
+
+    
+    NO_ZIPCODE_ISO_CODES ||= [
+      'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
+      'CD', 'CK', 'CUW', 'CI', 'DJ', 'DM', 'GQ', 'ER', 'FJ', 'TF', 'GAB', 'GM', 'GH', 'GD', 'GN',
+      'GY', 'HK', 'IE', 'KI', 'KP', 'LY', 'MO', 'MW', 'ML', 'MR', 'NR', 'AN', 'NU', 'KP', 'PA',
+      'QA', 'RW', 'KN', 'LC', 'ST', 'SC', 'SL', 'SB', 'SO', 'SR', 'SY', 'TZ', 'TL', 'TK', 'TG',
+      'TO', 'TV', 'UG', 'AE', 'VU', 'YE', 'ZW'
+    ].freeze
+
+    # The required states listed below match those used by PayPal and Shopify.
+    STATES_REQUIRED = [
+      'AU', 'AE', 'BR', 'CA', 'CN', 'ES', 'HK', 'IE', 'IN',
+      'IT', 'MY', 'MX', 'NZ', 'PT', 'RO', 'TH', 'US', 'ZA'
+    ].freeze
+    
+    def self.ransackable_associations(auth_object = nil)
+      [ "properties", "user"]
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      ["address1", "address2", "city", "state", "country", "zipcode"]
+    end
+
+    def full_address
+      [address1, address2, city.try(:name), state.try(:name), country.try(:name), zipcode].compact.join(', ')
+    end
+  end
+end

data/app/models/stay/amenity.rb

@@ -0,0 +1,13 @@
+module Stay
+  class Amenity < ApplicationRecord
+    belongs_to :amenity_category, class_name: "Stay::AmenityCategory", optional: true
+    has_many :property_amenities, class_name: "Stay::PropertyAmenity"
+    has_many :properties, through: :property_amenities, class_name: "Stay::Property"
+    enum :amenity_type, { property: 0, room: 1 }
+
+    has_many :room_amenities, class_name: "Stay::RoomAmenity"
+    has_many :rooms, through: :room_amenities, class_name: "Stay::Room"
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+  end
+end

data/app/models/stay/amenity_category.rb

@@ -0,0 +1,6 @@
+module Stay
+  class AmenityCategory < ApplicationRecord
+    # has_many :amenities, class_name: "Stay::Amenity"
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+  end
+end

data/app/models/stay/application_record.rb

@@ -0,0 +1,5 @@
+module Stay
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/stay/bed_type.rb

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

data/app/models/stay/booking.rb

@@ -0,0 +1,199 @@
+module Stay
+  class Booking < ApplicationRecord
+    PAYMENT_STATES = %w[failed paid]
+    STATUSES = %w[booking_request invoice_sent confirmed canceled completed].freeze
+
+    belongs_to :user, class_name: "Stay::User"
+    belongs_to :canceler, class_name: "Stay::User", foreign_key: "canceler_id", optional: true
+    has_many :reviews, class_name: "Stay::Review", dependent: :destroy
+    has_many :payments, class_name: "Stay::Payment", dependent: :destroy
+    has_many :line_items, class_name: "Stay::LineItem", dependent: :destroy
+    has_many :rooms, through: :line_items
+    belongs_to :property, -> { with_deleted }, class_name: "Stay::Property", foreign_key: "property_id"
+    belongs_to :store, class_name: "Stay::Store"
+    has_one :chat, class_name: "Stay::Chat", dependent: :destroy
+    has_one :booking_query, class_name: "Stay::BookingQuery", dependent: :destroy
+    has_one :invoice, dependent: :destroy
+
+    scope :complete, -> { where.not(completed_at: nil).where(payment_state: "paid") }
+    scope :incomplete, -> { where(completed_at: nil).where(payment_state: [ "failed", nil ]).where.not(status: :canceled) }
+    scope :not_canceled, -> { where.not(status: "canceled") }
+    scope :confirmed, -> { where(status: "confirmed").where(payment_state: "paid") }
+
+    after_commit :booking_completed_at
+    before_create :link_by_email, :generate_number
+    before_validation :ensure_store_presence
+    after_commit :booking_completed_at, if: :booking_completed?
+    after_commit :update_payment_status, on: [ :update ]
+    after_create :booking_room_count
+
+    accepts_nested_attributes_for :line_items, allow_destroy: true
+    accepts_nested_attributes_for :payments, allow_destroy: true
+    accepts_nested_attributes_for :invoice, allow_destroy: true
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :number, uniqueness: true
+
+    state_machine :status, initial: :booking_request do
+      state :booking_request
+      state :invoice_sent
+      state :confirmed
+      state :canceled
+      state :completed
+
+      event :send_invoice do
+        transition booking_request: :invoice_sent
+        transition invoice_sent: :booking_request, if: :invoice_deleted?
+      end
+
+      event :confirm do
+        transition invoice_sent: :confirmed
+      end
+
+      event :cancel do
+        transition [ :booking_request, :confirmed ] => :canceled
+      end
+
+      event :complete do
+        transition confirmed: :completed
+      end
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[number]
+    end
+
+    def self.ransackable_association(auth_object = nil)
+      %w[user]
+    end
+
+    def update_payment_status
+      update_columns(payment_state: "paid") if payments.exists?(state: "paid")
+    end
+
+    def invoice_deleted?
+      invoice.nil?
+    end
+
+    def canceled_by(user)
+      transaction do
+        cancel!
+        update_columns(
+          canceler_id: user.id,
+          canceled_at: Time.current
+        )
+      end
+    end
+
+    def booking_completed?
+      completed?
+    end
+
+    def booking_completed_at
+      update_columns(completed_at: Time.current)
+    end
+
+    def after_cancel
+      payments.completed.each(&:cancel!)
+      send_cancel_email
+      update(status: "canceled", canceled_at: Time.current)
+    end
+
+    # Associates the specified user with the booking.
+    def associate_user!(user, override_email = true)
+      self.user           = user
+      self.email          = user.email if override_email
+      self.created_by   ||= user
+      changes = slice(:user_id, :email, :created_by_id)
+
+      # immediately persist the changes we just made, but don't use save
+      # since we might have an invalid address associated
+      self.class.unscoped.where(id: self).update_all(changes)
+    end
+
+    def generate_number
+      loop do
+        numeric_part = rand.to_s[2..11]
+        self.number = "S#{numeric_part}"
+        break unless self.class.exists?(number: number)
+      end
+    end
+
+    def add_rooms_and_calculate(selected_rooms, booking_params, property)
+      total_price = 0
+      total_guests = 0
+
+      selected_rooms.each do |room_id|
+        room = property.rooms.find(room_id.to_i)
+        number_of_guests = booking_params[:bookings][room_id][:number_of_guests].to_i
+        price = room.price_per_month * (check_out_date - check_in_date).to_i
+
+        line_items.build(room: room, quantity: number_of_guests, price: price)
+
+        total_price += price
+        total_guests += number_of_guests
+      end
+
+      self.total = total_price
+      self.number_of_guests = total_guests
+    end
+
+    def ensure_store_presence
+      self.store ||= Stay::Store.default
+    end
+
+    def extra_guest_amount
+      return 0 unless property&.allow_extra_guest
+      return 0 unless property&.guest_number
+      return 0 unless property.allow_extra_guest && number_of_guests > property.guest_number
+
+      extra_guest = number_of_guests - property.guest_number
+      property.per_extra_guest_amount.to_f * extra_guest
+    end
+
+    def calculate_item_total
+      property.shared_property ? line_items.sum(:price) : property.price_per_month
+    end
+
+    def calculate_tax_total
+      property.property_taxes
+              .uniq { |property_tax| property_tax.tax_id }
+              .sum(&:value)
+    end
+
+    def calculate_cleaning_fee
+      property.cleaning_fee || 0
+    end
+
+    def calculate_city_fee
+      property.city_fee || 0
+    end
+
+    def calculate_totals
+      item_total = calculate_item_total || 0
+      invoice_total = invoice&.total || 0
+      tax_total = calculate_tax_total
+      extra_guest_total = extra_guest_amount
+      cleaning_fee = calculate_cleaning_fee
+      city_fee = calculate_city_fee
+      total_amount = item_total + invoice_total + tax_total  + extra_guest_total + cleaning_fee + city_fee
+
+      update_columns(
+        item_total: item_total,
+        total: invoice_total,
+        total_amount: total_amount
+      ) if item_total != self.item_total || invoice_total != self.total || total_amount != self.total_amount
+    end
+
+
+    def booking_room_count
+      self.update_column(:room_count, self.rooms.count)
+    end
+
+    private
+
+    def link_by_email
+      self.email = user.email if user
+    end
+  end
+end

data/app/models/stay/booking_query.rb

@@ -0,0 +1,23 @@
+module Stay
+  class BookingQuery < ApplicationRecord
+    ACCEPTED = "accepted".freeze
+    belongs_to :chat
+    belongs_to :booking, optional: true
+    belongs_to :property
+    belongs_to :user
+    enum :state, { send_message: 0, request_change: 1, booking_invitation: 2, accepted: 3, rejected: 4 }
+    after_initialize :set_default_state, if: :new_record?
+    scope :ongoing, -> { where.not(state: ACCEPTED) }
+    scope :date_range, ->(check_in, check_out) { where(check_in_date: check_in, check_out_date: check_out) }
+    scope :without_booking, -> { where(booking_id: nil) }
+    scope :for_current_user, ->(user) { where(user: user) }
+
+    def set_default_state
+      self.state ||= :send_message
+    end
+
+    def check_date_change
+      self.state = :request_change if check_in_date_changed? || check_out_date_changed?
+    end
+  end
+end

data/app/models/stay/cancellation_policy.rb

@@ -0,0 +1,6 @@
+module Stay
+  class CancellationPolicy < ApplicationRecord
+    has_many :properties, class_name: "Stay::Property", dependent: :nullify
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+  end
+end

data/app/models/stay/chat.rb

@@ -0,0 +1,23 @@
+module Stay
+  class Chat < ApplicationRecord
+    belongs_to :sender, class_name: "Stay::User", foreign_key: "sender_id"
+    belongs_to :receiver, class_name: "Stay::User", foreign_key: "receiver_id"
+    has_many :messages, class_name: "Stay::Message", dependent: :destroy
+    has_one :booking_query, dependent: :destroy
+    belongs_to :property, class_name: "Stay::Property"
+    belongs_to :booking, class_name: "Stay::Booking", optional: true
+    scope :for_user, ->(user) { where(sender: user).or(where(receiver: user)) }
+    scope :get_all_messages, -> { joins(:messages) }
+    scope :order_by_latest_messages, -> { group("stay_chats.id").order("MAX(stay_messages.created_at) DESC") }
+    scope :get_unread_messages_chat, -> { joins(:messages).where(stay_messages: { read_at: nil }) }
+    enum :chat_event, { booking_request: 0, booking_accept: 1, booking_reject: 2, booking_request_change: 3 }
+
+    scope :between, ->(sender_id, receiver_id) do
+      where("(sender_id = ? AND
+          receiver_id =?) OR
+          (sender_id = ? AND receiver_id =?)",
+          sender_id, receiver_id, receiver_id, sender_id
+      )
+    end
+  end
+end

data/app/models/stay/city.rb

@@ -0,0 +1,9 @@
+module Stay
+  class City < ApplicationRecord   
+    belongs_to :state, class_name: 'Stay::State', foreign_key: 'state_id'
+
+    def self.ransackable_attributes(auth_object = nil)
+      ["name"]
+    end
+  end
+end

data/app/models/stay/country.rb

@@ -0,0 +1,23 @@
+module Stay
+  class Country < ApplicationRecord
+    has_many :addresses
+    has_many :states, class_name: 'Stay::State', dependent: :destroy
+    validates :name, presence: true
+    
+    def self.ransackable_attributes(auth_object = nil)
+      ["name"]
+    end
+
+    def self.default(store = nil)
+      store ||= Stay::Store.default
+      country_id = store.default_country_id
+      default = find_by(id: country_id) if country_id.present?
+      default || find_by(iso: 'US') || first
+    end
+
+    def default?(store = nil)
+      store ||= Stay::Store.default
+      self == store.default_country
+    end
+  end
+end

data/app/models/stay/credit_card.rb

@@ -0,0 +1,6 @@
+module Stay
+  class CreditCard < ApplicationRecord
+    belongs_to :user, class_name: "Stay::User"
+    belongs_to :payment_method, class_name: "Stay::PaymentMethod", optional: :true
+  end
+end

data/app/models/stay/discount.rb

@@ -0,0 +1,4 @@
+module Stay
+  class Discount < ApplicationRecord
+  end
+end

data/app/models/stay/expense.rb

@@ -0,0 +1,4 @@
+module Stay
+  class Expense < ApplicationRecord
+  end
+end

data/app/models/stay/feature.rb

@@ -0,0 +1,11 @@
+module Stay
+  class Feature < ApplicationRecord
+    has_many :property_features, class_name: "Stay::PropertyFeature"
+    has_many :properties, through: :property_features, class_name: "Stay::Property"
+    has_many :room_features, class_name: "Stay::RoomFeature"
+    has_many :rooms, through: :room_features, class_name: "Stay::Room"
+
+    enum :feature_type, { property: 0, room: 1 }
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+  end
+end

data/app/models/stay/house_rule.rb

@@ -0,0 +1,4 @@
+module Stay
+  class HouseRule < ApplicationRecord
+  end
+end

data/app/models/stay/invoice.rb

@@ -0,0 +1,23 @@
+module Stay
+  class Invoice < ApplicationRecord
+    belongs_to :booking
+    has_many :expenses, dependent: :destroy
+    has_many :discounts, dependent: :destroy
+    after_commit :calculate_totals, on: [:create, :update]
+
+    accepts_nested_attributes_for :expenses, allow_destroy: true
+    accepts_nested_attributes_for :discounts, allow_destroy: true
+
+    private
+
+    def calculate_totals
+      subtotal = expenses.any? ? expenses.pluck(:amount).sum : 0
+      discount_amount = discounts.any? ? discounts.pluck(:amount).sum : 0
+      total = subtotal - discount_amount
+
+      if subtotal != self.subtotal || discount_amount != self.discount_amount || total != self.total
+        update_columns(subtotal: subtotal, discount_amount: discount_amount, total: total)
+      end
+    end
+  end
+end

data/app/models/stay/line_item.rb

@@ -0,0 +1,7 @@
+module Stay
+  class LineItem < ApplicationRecord
+    belongs_to :booking, class_name: "Stay::Booking"
+    belongs_to :room, class_name: "Stay::Room"
+    has_one :property, through: :room
+  end
+end

data/app/models/stay/message.rb

@@ -0,0 +1,30 @@
+module Stay
+  class Message < ApplicationRecord
+    belongs_to :sender, foreign_key: :sender_id, class_name: "Stay::User", optional: true
+    belongs_to :receiver, foreign_key: :receiver_id, class_name: "Stay::User", optional: true
+    belongs_to :chat, class_name: "Stay::Chat"
+    has_many_attached :attachments
+    enum :event_for, { host: 0, student: 1, both: 2 }
+    after_initialize :set_default_event_for, if: :new_record?
+
+    def read?
+      read_at.present?
+    end
+
+    def host_messages
+      where(event_for: [ "host", "both" ])
+    end
+
+    def student_messages
+      where(event_for: [ "student", "both" ])
+    end
+
+    def attachments_urls
+      attachments.map { |image| image.url }
+    end
+
+    def set_default_event_for
+      self.event_for ||= :both
+    end
+  end
+end