stay_commerce 0.1.0

data/app/channels/chat_channel.rb

@@ -0,0 +1,13 @@
+class ChatChannel < ApplicationCable::Channel
+  def subscribed
+    user = params[:user]
+    stream_from "ChatChannel"
+    ActionCable.server.broadcast("chat_channel", { message: "Hello, world!", user: user })
+  end
+
+  def received(data)
+  end
+
+  def unsubscribed
+  end
+end

data/app/controllers/concerns/stay/booking_validations.rb

@@ -0,0 +1,86 @@
+module Stay
+  module BookingValidations
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :validate_booking_params, only: :create
+    end
+
+    private
+
+    def validate_booking_params
+      property = Stay::Property.friendly.find_by(slug: booking_params[:property_id])
+
+      return render_error("Property not found.", :not_found) unless property
+
+      return render_error("Property Host not active.", :not_found) unless property.user
+
+      return render_error("You cannot create a booking for your own property.", :unprocessable_entity) if property.user == current_devise_api_user
+
+      return render_error("Hosts cannot create bookings for properties.", :unprocessable_entity) if current_devise_api_user.stay_host?
+
+      if booking_params[:check_in_date].nil? || booking_params[:check_out_date].nil?
+        return render_error("Please select both check-in and check-out dates.", :unprocessable_entity)
+      end
+
+      return render_error("Please select the guest count.", :unprocessable_entity) if booking_params[:number_of_guests].nil?
+
+      if property.shared_property && booking_params[:line_items_attributes].nil?
+        return render_error("Please select a room for the shared property.", :unprocessable_entity)
+      end
+
+      validate_shared_property_room(property) if property.shared_property
+      validate_guest_limit(property)
+      validate_property_availability(property)
+    end
+
+    def validate_shared_property_room(property)
+      line_item = booking_params[:line_items_attributes][0]
+      return unless line_item
+
+      room_id = line_item[:room_id]
+      check_in_date = booking_params[:check_in_date].to_date
+      check_out_date = booking_params[:check_out_date].to_date
+      room = Stay::Room.find_by(id: room_id)
+
+      if room.nil?
+        render_error("Room not found.", :not_found)
+      elsif room.property_id != property.id
+        render_error("Room not found in the property.", :not_found)
+      elsif room.status == "inactive"
+        render_error("Room is inactive.", :unprocessable_entity)
+      elsif !property.allow_extra_guest && booking_params[:number_of_guests] > room.max_guests
+        render_error("No extra guests allowed. Maximum guest limit for this room is #{room.max_guests || 1}.", :unprocessable_entity)
+      elsif check_in_date < room.booking_start.to_date
+        render_error("Room not available on your check-in date.", :unprocessable_entity)
+      elsif check_out_date > room.booking_end.to_date
+        render_error("Room not available on your check-out date.", :unprocessable_entity)
+      end
+    end
+
+    def validate_guest_limit(property)
+      if !property.shared_property && !property.allow_extra_guest && booking_params[:number_of_guests] > property.guest_number
+        render_error("No extra guests allowed. Maximum guest limit for this property is #{property.guest_number || 1}.", :unprocessable_entity)
+      end
+    end
+
+    def validate_property_availability(property)
+      check_in_date = booking_params[:check_in_date].to_date
+      check_out_date = booking_params[:check_out_date].to_date
+
+      if property.unlimited_availability
+        if check_in_date < property.availability_start.to_date
+          render_error("Property not available on your check-in date.", :unprocessable_entity)
+        elsif check_in_date > check_out_date
+          render_error("Check-out date cannot be earlier than check-in date.", :unprocessable_entity)
+        end
+      else
+        if check_in_date < property.availability_start.to_date
+          render_error("Property not available on your check-in date.", :unprocessable_entity)
+        elsif check_out_date > property.availability_end.to_date
+          render_error("Property not available on your check-out date.", :unprocessable_entity)
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/stay/stripe_concern.rb

@@ -0,0 +1,72 @@
+module Stay
+    module StripeConcern
+        extend ActiveSupport::Concern
+        def user
+            current_devise_api_user || current_user
+        end
+
+        def create_payment_method
+            Stripe::PaymentMethod.create({
+                type: params[:payment_method_type],
+                card: {
+                    number: params[:number],
+                    exp_month: params[:exp_month],
+                    exp_year: params[:exp_year],
+                    cvc: params[:cvc],
+                },
+            })
+        end
+        def create_customer
+            Stripe::Customer.create({
+                email: user.email,
+                name: "#{user.first_name} #{user.last_name}",
+                address: {
+                    city: user.addresses.last&.city,
+                    state: user.addresses.last&.state.name,
+                    country: user.addresses.last&.country.name,
+                    line1: user.addresses.last&.address1,
+                    line2: user.addresses.last&.address2,
+                    postal_code: user.addresses.last&.zipcode
+                },
+                metadata: { order_id: user.id }
+            })
+        end
+
+        def create_or_retrieve_customer
+            customers = Stripe::Customer.list(email: user.email).data
+            if customers.empty?
+                create_customer
+            else
+                customers.first
+            end
+        end
+
+        def create_payment_intent 
+            Stripe::PaymentIntent.create(
+                amount: @booking.total.to_i* 100,
+                description: @booking.user.email,
+                currency: params[:currency] || 'INR',
+                payment_method: params[:payment_method_id],
+                automatic_payment_methods: { enabled: true },
+                receipt_email: user.email,
+                customer: @customer,
+                confirm: params[:confirm],
+                return_url: params[:redirect_url]
+            )
+        end
+        
+        def get_payment_intent
+            Stripe::PaymentIntent.retrieve(@booking.payment_intent_id)
+        end
+
+        def confirm_payment_intent
+            Stripe::PaymentIntent.confirm(
+            params[:payment_intent_id],
+            {
+                payment_method: params[:payment_method_id], 
+                return_url: params[redirect_url],
+            })
+        end    
+                        
+    end
+end

data/app/controllers/stay/admin/addresses_controller.rb

@@ -0,0 +1,76 @@
+module Stay
+  module Admin
+    class AddressesController < Stay::Admin::BaseController
+      before_action :set_address, only: %i[show edit update destroy]
+
+      # GET /Stay/admin/addresses
+      # GET /Stay/admin/addresses.json
+      def index
+        @addresses = Stay::Address.page(params[:page])
+      end
+
+      # GET /Stay/admin/addresses/1
+      # GET /Stay/admin/addresses/1.json
+      def show
+      end
+
+      # GET /Stay/admin/addresses/new
+      def new
+        @address = Stay::Address.new
+      end
+
+      # GET /Stay/admin/addresses/1/edit
+      def edit
+      end
+
+      # POST /Stay/admin/addresses
+      # POST /Stay/admin/addresses.json
+      def create
+        @address = Stay::Address.new(address_params)
+
+        respond_to do |format|
+          if @address.save
+            format.html { redirect_to [:admin, @address], notice: 'Address was successfully created.' }
+            format.json { render :show, status: :created, location: @address }
+          else
+            format.html { render :new }
+            format.json { render json: @address.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # PATCH/PUT /Stay/admin/addresses/1
+      # PATCH/PUT /Stay/admin/addresses/1.json
+      def update
+        respond_to do |format|
+          if @address.update(address_params)
+            format.html { redirect_to [:admin, @address], notice: 'Address was successfully updated.' }
+            format.json { render :show, status: :ok, location: @address }
+          else
+            format.html { render :edit }
+            format.json { render json: @address.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /Stay/admin/addresses/1
+      # DELETE /Stay/admin/addresses/1.json
+      def destroy
+        @address.destroy
+        respond_to do |format|
+          format.html { redirect_to admin_addresses_url, notice: 'Address was successfully destroyed.' }
+          format.json { head :no_content }
+        end
+      end
+
+      private
+        def set_address
+          @address = Stay::Address.find(params[:id])
+        end
+
+        def address_params
+          params.require(:address).permit(:address1, :address2, :city, :state, :country, :zipcode)
+        end
+    end
+  end
+end

data/app/controllers/stay/admin/amenities_controller.rb

@@ -0,0 +1,52 @@
+module Stay
+    class Admin::AmenitiesController < Stay::Admin::BaseController
+    before_action :set_amenity, only: %i[ show edit update destroy ]
+
+    def index
+      @amenities = Stay::Amenity.page(params[:page])
+    end
+
+    def show
+    end
+
+    def new
+      @amenity = Stay::Amenity.new
+    end
+
+    def edit
+    end
+
+    def create
+      @amenity = Stay::Amenity.new(amenity_params)
+
+      if @amenity.save
+        redirect_to admin_amenity_path(@amenity), notice: "Amenity was successfully created."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if @amenity.update(amenity_params)
+        redirect_to admin_amenity_path(@amenity), notice: "Amenity was successfully updated.", status: :see_other
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @amenity.destroy!
+      redirect_to admin_amenities_url, notice: "Amenity was successfully destroyed.", status: :see_other
+    end
+
+    private
+
+    def set_amenity
+      @amenity = Stay::Amenity.find(params[:id])
+    end
+
+    def amenity_params
+      params.require(:amenity).permit(:name, :amenity_type)
+    end
+    end
+end

data/app/controllers/stay/admin/amenity_categories_controller.rb

@@ -0,0 +1,52 @@
+module Stay
+    class Admin::AmenityCategoriesController < Stay::Admin::BaseController
+    before_action :set_amenity_category, only: %i[ show edit update destroy ]
+
+    def index
+      @amenity_categories = Stay::AmenityCategory.page(params[:page])
+    end
+
+    def show
+    end
+
+    def new
+      @amenity_category = Stay::AmenityCategory.new
+    end
+
+    def edit
+    end
+
+    def create
+      @amenity_category = Stay::AmenityCategory.new(amenity_category_params)
+
+      if @amenity_category.save
+        redirect_to admin_amenity_category_path(@amenity_category), notice: "Amenity was successfully created."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if @amenity_category.update(amenity_category_params)
+        redirect_to admin_amenity_category_path(@amenity_category), notice: "Amenity was successfully updated.", status: :see_other
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @amenity_category.destroy!
+      redirect_to admin_amenity_categories_url, notice: "Amenity was successfully destroyed.", status: :see_other
+    end
+
+    private
+
+    def set_amenity_category
+      @amenity_category = Stay::AmenityCategory.find(params[:id])
+    end
+
+    def amenity_category_params
+      params.require(:amenity_category).permit(:name)
+    end
+  end
+end

data/app/controllers/stay/admin/base_controller.rb

@@ -0,0 +1,38 @@
+module Stay
+  module Admin
+    class BaseController < ApplicationController
+      include Stay::ControllerHelpers::Currency
+      include Stay::ControllerHelpers::Store
+      layout "stay/admin"
+      before_action :authenticate_user!
+      before_action :ensure_admin
+      before_action :load_stores
+
+      def stores_scope
+        Stay::Store.includes(:translations)
+      end
+
+      def load_stores
+        @stores = stores_scope.order(default: :desc)
+      end
+
+      def set_current_store
+        return if @object.nil?
+
+        ensure_current_store(@object)
+      end
+
+      def set_currency
+        return if @object.nil?
+
+        @object.currency = current_currency if model_class.method_defined?(:currency=)
+      end
+
+      private
+
+      def ensure_admin
+        redirect_to root_path, alert: "Access denied!" unless current_user.stay_admin?
+      end
+    end
+  end
+end

data/app/controllers/stay/admin/bed_types_controller.rb

@@ -0,0 +1,51 @@
+module Stay
+  class Admin::BedTypesController < Stay::Admin::BaseController
+    before_action :set_bed_type, only: %i[show edit update destroy]
+
+    def index
+      @bed_types = Stay::BedType.page(params[:page])
+    end
+
+    def new
+      @bed_type = Stay::BedType.new
+    end
+
+    def create
+      @bed_type = Stay::BedType.new(bed_type_params)
+      if @bed_type.save
+        redirect_to admin_bed_types_path, notice: 'Bed type was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def update
+      if @bed_type.update(bed_type_params)
+        redirect_to admin_bed_types_path, notice: 'Bed type was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @bed_type.destroy
+      redirect_to admin_bed_types_path, notice: 'Bed type was successfully deleted.'
+    end
+
+    private
+
+    def set_bed_type
+      @bed_type = Stay::BedType.find(params[:id])
+    end
+
+    def bed_type_params
+      params.require(:bed_type).permit(:name)
+    end
+  end
+end

data/app/controllers/stay/admin/bookings_controller.rb

@@ -0,0 +1,54 @@
+module Stay
+  module Admin
+    class BookingsController < Stay::Admin::BaseController
+      before_action :set_booking, only: %i[show edit update destroy]
+
+      def index
+        @q = current_store.bookings.ransack(params[:q])
+        @bookings = @q.result.order(created_at: :desc).page(params[:page])
+      end
+
+      def show
+      end
+
+      def new
+        @booking = current_store.bookings.build
+      end
+
+      def create
+        @booking = current_store.bookings.build(booking_params)
+        if @booking.save
+          redirect_to admin_booking_path(@booking), notice: 'Booking was successfully created.'
+        else
+          render :new
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @booking.update(booking_params)
+          redirect_to admin_booking_path(@booking), notice: 'Booking was successfully updated.'
+        else
+          render :edit
+        end
+      end
+
+      def destroy
+        @booking.destroy
+        redirect_to admin_bookings_url, notice: 'Booking was successfully destroyed.'
+      end
+
+      private
+
+      def set_booking
+        @booking = current_store.bookings.find_by(id: params[:id])
+      end
+
+      def booking_params
+        params.require(:booking).permit(:user_id, :check_in_date, :check_out_date, :number_of_guests, :status)
+      end
+    end
+  end
+end

data/app/controllers/stay/admin/cancellation_policies_controller.rb

@@ -0,0 +1,51 @@
+module Stay
+  class Admin::CancellationPoliciesController < Stay::Admin::BaseController
+    before_action :set_policy_type, only: %i[show edit update destroy]
+
+    def index
+      @policies = Stay::CancellationPolicy.page(params[:page])
+    end
+
+    def new
+      @policy = Stay::CancellationPolicy.new
+    end
+
+    def create
+      @policy = Stay::CancellationPolicy.new(policy_params)
+      if @policy.save
+        redirect_to admin_cancellation_policies_path, notice: "Policy successfully created."
+      else
+        render :new
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def update
+      if @policy.update(policy_params)
+        redirect_to admin_cancellation_policies_path, notice: "Policy was successfully updated."
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @policy.destroy
+      redirect_to admin_cancellation_policies_path, notice: "Policy was successfully deleted."
+    end
+
+    private
+
+    def set_policy_type
+      @policy = Stay::CancellationPolicy.find(params[:id])
+    end
+
+    def policy_params
+      params.require(:cancellation_policy).permit(:name, :description)
+    end
+  end
+end

data/app/controllers/stay/admin/chats_controller.rb

@@ -0,0 +1,53 @@
+module Stay
+  module Admin
+    class ChatsController < Stay::Admin::BaseController
+      before_action :set_chat, only: %i[show edit update destroy]
+
+      def index
+        @chats = Stay::Chat.all
+      end
+
+      def show
+      end
+
+      def new
+        @chat = Stay::Chat.new
+      end
+
+      def create
+        @chat = Stay::Chat.new(chat_params)
+        if @chat.save
+          redirect_to admin_chat_path(@chat), notice: 'Chat was successfully created.'
+        else
+          render :new
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @chat.update(chat_params)
+          redirect_to admin_chat_path(@chat), notice: 'Chat was successfully updated.'
+        else
+          render :edit
+        end
+      end
+
+      def destroy
+        @chat.destroy
+        redirect_to admin_chats_path, notice: 'Chat was successfully destroyed.'
+      end
+
+      private
+
+      def set_chat
+        @chat = Stay::Chat.find(params[:id])
+      end
+
+      def chat_params
+        params.require(:chat).permit(:sender_id, :receiver_id, :property_id)
+      end
+    end
+  end
+end

data/app/controllers/stay/admin/cities_controller.rb

@@ -0,0 +1,66 @@
+module Stay
+  class Admin::CitiesController < Stay::Admin::BaseController
+    before_action :set_state
+    before_action :set_city, only: [:edit, :update, :destroy]
+
+    def index
+      @cities = @state.cities
+      respond_to do |format|
+      format.html
+      format.json { render json: @cities }
+    end
+
+    end
+
+    def new
+      @city = @state.cities.new
+    end
+
+    def create
+      @city = @state.cities.new(city_params)
+      if @city.save
+        redirect_to admin_state_cities_path(@state), notice: 'City was successfully created.'
+      else
+        flash.now[:alert] = @city.errors.full_messages.join(', ')
+        render :new
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      if @city.update(city_params)
+        redirect_to admin_state_cities_path(@state), notice: 'City was successfully updated.'
+      else
+        flash.now[:alert] = @city.errors.full_messages.join(', ')
+        render :edit
+      end
+    end
+
+    def destroy
+     if @city.destroy
+        flash[:alert] = "City was successfully deleted."
+        redirect_to admin_state_cities_path(@state)
+      else
+        flash[:alert] = @city.errors.full_messages.join(', ')
+        redirect_to admin_state_cities_path(@state)
+      end
+    end
+
+    private
+
+
+    def set_state
+      @state = Stay::State.find(params[:state_id])
+    end
+
+    def set_city
+      @city = @state.cities.find(params[:id])
+    end
+
+    def city_params
+      params.require(:city).permit(:name)
+    end
+  end
+end

data/app/controllers/stay/admin/confirmations_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Stay::Admin::ConfirmationsController < Devise::ConfirmationsController
+  # GET /resource/confirmation/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/confirmation
+  # def create
+  #   super
+  # end
+
+  # GET /resource/confirmation?confirmation_token=abcdef
+  # def show
+  #   super
+  # end
+
+  # protected
+
+  # The path used after resending confirmation instructions.
+  # def after_resending_confirmation_instructions_path_for(resource_name)
+  #   super(resource_name)
+  # end
+
+  # The path used after confirmation.
+  # def after_confirmation_path_for(resource_name, resource)
+  #   super(resource_name, resource)
+  # end
+end