stay_commerce 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21d65148be51476482fe86e79472e2e0bf311f49f9def7ee1be0d94cc908484e
-  data.tar.gz: d930047ffebe22e514475ee2a965c840ec7961265d2e3dd48126ac27551b01ef
+  metadata.gz: ea9bf5bd2ce5586107d49503bcbbab44973eb929e6cf58fbe762892444a437ec
+  data.tar.gz: f32e5da8fb4d2b3840efc4115ca06ebcde81cbf9bc95b8c8cb505a845a9a384a
 SHA512:
-  metadata.gz: f4edf72e5d17bd18491b58f3b84b945ea297c01c7a0eb85e309a6899ed69a99cd92f96f81b121d387f22082fed143fe08ccc505fd9210849293f43fde2b5a405
-  data.tar.gz: 5fa10e530142899cffc424179a44001aabd2eb4e6897c836a76537b1c3323540005ba646212c74f9867f6c10740329396eedfa389fa19da0689018f96599294f
+  metadata.gz: 7f48289085a2aa3f9156d871ae5d6e76631a2c1dd25f90ca735bf84f51fe9f21cdfdd4d71cc959b23a85f18de45bef2a27130db01268967cd4c826fec3bbd4dc
+  data.tar.gz: 9eee63d5b3ed3c65c4a672e3ad97c2c7a43828de56b4b6a855497f803ad4445768bdfd75a7521d9b7728b10374b3fa55f4b96b5edf1d31cefce5808ca0e38b5f

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

@@ -1,72 +1,107 @@
+require "openssl"
+require "base64"
+require "dotenv/load"
 module Stay
     module StripeConcern
-        extend ActiveSupport::Concern
-        def user
-            current_devise_api_user || current_user
-        end
+      extend ActiveSupport::Concern
 
-        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
+      included do
+       Stripe.api_key = ENV["STRIPE_SECRECT_KEY"]
+      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 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
+       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 }
+        })
+        user.update(stripe_customer_id: customer.id)
+      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]
-            )
+      def create_or_retrieve_customer
+        if user.stripe_customer_id.present?
+          @customer  = Stripe::Customer.retrieve(user.stripe_customer_id)
+        else
+          @customer =  create_customer
         end
+      end
+
+      def create_payment_intent
+        payment_method_id = params[:payment_method_id]
+        payment_intent = Stripe::PaymentIntent.create(
+          amount: (@booking.total_amount * 100).to_i,
+          description: @booking.user.email,
+          currency: params[:currency] || "usd",
+          payment_method: payment_method_id,
+          receipt_email: user.email,
+          customer: @customer,
+          confirm: false
+        )
+        if payment_intent.status == "requires_confirmation"
+          payment_intent = confirm_payment_intent(payment_intent.id, payment_method_id)
+        end      
+      end
+
+      def get_payment_intent
+        Stripe::PaymentIntent.retrieve(@booking.payment_intent_id)
+      end
+
+      def attach_payment_method_to_customer(payment_method_token, customer_id)
+        Stripe::PaymentMethod.attach(
+          payment_method_token,{ customer: customer_id }
+        )
+      end
+
+      def create_payment_method_from_token(token)
+        payment_method = Stripe::PaymentMethod.create({
+            type: "card",
+            card: { token: token }  
+        })
         
-        def get_payment_intent
-            Stripe::PaymentIntent.retrieve(@booking.payment_intent_id)
-        end
+        attach_payment_method_to_customer( payment_method.id, current_devise_api_user.stripe_customer_id)
+        payment_method.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
+      def confirm_payment_intent(payment_intent_id, payment_method_id)
+        Stripe::PaymentIntent.confirm(
+          payment_intent_id,
+        {
+            payment_method: payment_method_id,
+            # return_url: params[redirect_url]
+        })
+      end
+      
+      def destroy_payment_method(payment_method_token)
+        begin
+          Stripe::PaymentMethod.detach(payment_method_token)
+        rescue Stripe::InvalidRequestError => e
+          raise "Failed to detach payment method: #{e.message}"
+        end
+      end
+      
+  end
+end

data/app/controllers/stay/api/v1/bookings_controller.rb

@@ -43,40 +43,36 @@ class Stay::Api::V1::BookingsController < Stay::BaseApiController
   end
 
   def host_booking
-    begin
-      page = params[:page].to_i > 0 ? params[:page].to_i : 1
-      per_page = params[:per_page].to_i > 0 ? params[:per_page].to_i : 10
-
-      cumulative_per_page = page * per_page
-      @request =  Stay::Booking.joins(:property).where(stay_properties: { user_id: current_devise_api_user&.id }).confirmed
-      @bookings = @request.order(created_at: :desc).limit(cumulative_per_page)
-
-      total_count = @request.count
-      total_pages = (total_count.to_f / per_page).ceil
-
-      if @bookings.empty?
-        return render json: { error: "No bookings found", bookings: [], success: false }, status: :ok
-      end
-
-      render json: {
-        data: "Bookings Found",
-        bookings: ActiveModelSerializers::SerializableResource.new(@bookings, each_serializer: BookingSerializer),
-        success: true,
-        meta: {
-          total_pages: total_pages,
-          current_page: page,
-          next_page: page < total_pages ? page + 1 : nil,
-          prev_page: page > 1 ? page - 1 : nil,
-          total_count: total_count
-        }
-      }, status: :ok
-    rescue ActiveRecord::RecordNotFound => e
-      render json: { success: false, error: "Bookings not found", message: e.message }, status: :not_found
-    rescue ArgumentError => e
-      render json: { success: false, error: "Invalid pagination parameters", message: e.message }, status: :bad_request
-    rescue StandardError => e
-      render json: { success: false, error: "Internal server error", message: e.message }, status: :internal_server_error
-    end
+          begin
+            page = params[:page].to_i > 0 ? params[:page].to_i : 1
+
+            @bookings =  Stay::Booking.current_host_booking(current_devise_api_user).confirmed
+            @bookings = @bookings.joins(:property).where("stay_properties.title ILIKE ?", "%#{params[:q]}%") if params[:q].present?
+            @bookings = @bookings.order(updated_at: :desc).page(page).per(10)
+
+            if @bookings.empty?
+              return render json: { error: "No bookings found", bookings: [], success: false }, status: :ok
+            end
+
+            render json: {
+              data: "Bookings Found",
+              bookings: ActiveModelSerializers::SerializableResource.new(@bookings, each_serializer: BookingListingSerializer),
+              success: true,
+              meta: {
+                total_pages: @bookings.total_pages,
+                current_page: @bookings.current_page,
+                next_page: @bookings.next_page,
+                prev_page: @bookings.prev_page,
+                total_count: @bookings.total_count
+              }
+            }, status: :ok
+          rescue ActiveRecord::RecordNotFound => e
+            render json: { success: false, error: "Bookings not found", message: e.message }, status: :not_found
+          rescue ArgumentError => e
+            render json: { success: false, error: "Invalid pagination parameters", message: e.message }, status: :bad_request
+          rescue StandardError => e
+            render json: { success: false, error: "Internal server error", message: e.message }, status: :internal_server_error
+          end
   end
 
   def host_request
@@ -97,7 +93,7 @@ class Stay::Api::V1::BookingsController < Stay::BaseApiController
 
       render json: {
         data: "Bookings Found",
-        bookings: ActiveModelSerializers::SerializableResource.new(@bookings, each_serializer: BookingSerializer),
+        bookings: ActiveModelSerializers::SerializableResource.new(@bookings, each_serializer: BookingListingSerializer),
         success: true,
         meta: {
           total_pages: total_pages,

data/app/controllers/stay/api/v1/credit_cards_controller.rb

@@ -1,6 +1,7 @@
 class Stay::Api::V1::CreditCardsController < Stay::BaseApiController
   before_action :authenticate_devise_api_token!
-  before_action :set_credit_card, only: %i[show edit update]
+  before_action :set_credit_card, only: %i[show edit update destroy]
+  include Stay::StripeConcern
 
   def index
     @credit_cards = current_devise_api_user.credit_cards
@@ -25,11 +26,17 @@ class Stay::Api::V1::CreditCardsController < Stay::BaseApiController
   end
 
   def create
-    @credit_card = current_devise_api_user.credit_cards.build(credit_card_params)
-    if @credit_card.save
-      render json: { message: "Credit card saved successfully", data: CreditCardSerializer.new(@credit_card), success: true }, status: :ok
-    else
-      render json: { error: "Credit card not saved", success: false, errors: @credit_card.errors.full_messages }, status: :unprocessable_entity
+    begin
+      token = create_payment_method_from_token(credit_card_params[:card_token])
+      @credit_card = current_devise_api_user.credit_cards.build(credit_card_params.merge(payment_method_token: token))
+
+      if @credit_card.save
+        render json: { message: "Credit card saved successfully", data: CreditCardSerializer.new(@credit_card), success: true }, status: :ok
+      else
+        render json: { error: "Credit card not saved", success: false, errors: @credit_card.errors.full_messages }, status: :unprocessable_entity
+      end
+    rescue Stripe::InvalidRequestError => e
+      render json: { error: e.message, success: false }, status: :unprocessable_entity
     end
   end
 
@@ -38,17 +45,31 @@ class Stay::Api::V1::CreditCardsController < Stay::BaseApiController
   end
 
   def update
-    if @credit_card.update(credit_card_params)
+    if @credit_card.update(credit_card_params.except(:card_token))
       render json: { message: "Credit card updated successfully", data: CreditCardSerializer.new(@credit_card), success: true }, status: :ok
     else
       render json: { error: "Credit card not updated", success: false, errors: @credit_card.errors.full_messages }, status: :unprocessable_entity
     end
   end
 
-  # def destroy
-  #   @credit_card.destroy
-  #   render json: { message: "Credit card successfully deleted", success: true }, status: :ok
-  # end
+  def destroy
+    begin
+      destroy_payment_method(@credit_card.payment_method_token)
+
+      if @credit_card.destroy
+        render json: { message: "Credit card successfully deleted", success: true }, status: :ok
+      else
+        render json: { error: "Failed to delete credit card", success: false, errors: @credit_card.errors.full_messages }, status: :unprocessable_entity
+      end
+    rescue Stripe::InvalidRequestError => e
+      render json: { error: "Stripe error: #{e.message}", success: false }, status: :unprocessable_entity
+    rescue ActiveRecord::RecordNotFound
+      render json: { error: "Credit card not found", success: false }, status: :not_found
+    rescue StandardError => e
+      render json: { error: "An unexpected error occurred: #{e.message}", success: false }, status: :internal_server_error
+    end
+  end
+
 
   private
 
@@ -57,6 +78,6 @@ class Stay::Api::V1::CreditCardsController < Stay::BaseApiController
   end
 
   def credit_card_params
-    params.require(:credit_card).permit(:month, :year, :cc_number, :cc_type, :name)
+    params.require(:credit_card).permit(:month, :year, :cc_number, :cc_type, :name, :card_token, :payment_method_token)
   end
 end

data/app/controllers/stay/api/v1/messages_controller.rb

@@ -19,22 +19,26 @@ class Stay::Api::V1::MessagesController < Stay::BaseApiController
       total_pages = (total_count.to_f / per_page).ceil
 
       messages = @chat.messages
-                     .order(created_at: :asc)
-                     .limit(cumulative_limit)
+                      .order(created_at: :desc)
+                      .limit(cumulative_limit)
 
-      chat_json = ChatSerializer.new(
-        @chat,
-        scope: { current_user: current_devise_api_user }
-      ).as_json
+      grouped_messages = messages
+                           .select("DATE(created_at) as message_date, stay_messages.*")
+                           .group_by { |message| message.created_at.to_date }
 
-      messages_json = messages.map do |message|
-        MessageSerializer.new(message, scope: current_devise_api_user).as_json
+      grouped_messages_json = grouped_messages.transform_keys(&:to_s).map do |date, msgs|
+        {
+          date: formatted_date(date.to_date),
+          messages: ActiveModelSerializers::SerializableResource.new(msgs, each_serializer: MessageSerializer)
+        }
       end
 
+      serialized_chat = ActiveModelSerializers::SerializableResource.new(@chat, serializer: ChatSerializer, scope: { current_user: current_devise_api_user })
+
       render json: {
         data: "Messages Found",
-        chat: chat_json,
-        message: messages_json,
+        chat: serialized_chat,
+        message: grouped_messages_json,
         success: true,
         meta: {
           total_pages: total_pages,
@@ -48,6 +52,7 @@ class Stay::Api::V1::MessagesController < Stay::BaseApiController
       render json: { error: e.message, success: false }, status: :internal_server_error
     end
   end
+
   def new
     @message = @chat.messages.new
     render json: { data: "Message form loaded", message: @message, success: true }, status: :ok

data/app/controllers/stay/api/v1/payments_controller.rb

@@ -1,5 +1,5 @@
 class Stay::Api::V1::PaymentsController < Stay::BaseApiController
-  include Stay::StripeConcern 
+  include Stay::StripeConcern
 
     before_action :set_booking, except: :payment_method
     before_action :authenticate_devise_api_token!
@@ -13,33 +13,80 @@ class Stay::Api::V1::PaymentsController < Stay::BaseApiController
         render json: { error: "no method found", success: false }, status: :unprocessable_entity
       end
     end
-    
+
+    def create_payment_method
+      payment_method = create_payment_method(payment_method_params)
+      attach_payment_method(payment_method.id)
+      render json: { message: "Payment method created and attached successfully.", payment_method: payment_method }
+    rescue Stripe::StripeError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    end
+
+    def list_payment_methods
+      payment_methods = list_payment_methods
+      render json: { payment_methods: payment_methods.data }
+    rescue Stripe::StripeError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    end
+
     def create
-        begin
-            customer = create_or_retrieve_customer
-            payment_intent = @booking.payment_intent_id ? get_payment_intent : create_payment_intent.tap { |pi| @booking.update(payment_intent_id: pi.id) }
-            if params[:confirm]
-                if payment_intent.status == 'succeeded'
-                    render json: { message: "Payment successful", payment_intent: payment_intent }, status: :ok
-                elsif payment_intent.status == 'requires_action'
-                    render json: { message: "Payment requires further action", client_secret: payment_intent.client_secret, payment_intent_id: payment_intent["id"] }, status: :ok
-                else
-                    render json: { message: "Payment failed", error: payment_intent.last_payment_error }, status: :unprocessable_entity
-                end
-            else 
-                render json: {payment_intent: payment_intent, client_secret: payment_intent.client_secret}, status: :ok
-            end
-        rescue Stripe::CardError => e
-          render json: { error: e.message }, status: :unprocessable_entity
-        rescue => e
-          render json: { error: "Something went wrong" }, status: :internal_server_error
+      begin
+        customer = create_or_retrieve_customer
+    
+        payment_intent = if @booking.payment_intent_id && @booking.payment_state == "confirmed"
+                           get_payment_intent
+                         else
+                           create_payment_intent
+                         end
+    
+        payment_status = case payment_intent.status
+                         when "succeeded"
+                           "confirmed"
+                         when "requires_action"
+                           "pending"
+                         else
+                           "failed"
+                         end
+        create_payment(payment_intent, payment_status, @booking)
+        @booking.update(payment_intent_id: payment_intent.id, payment_state:payment_status)
+    
+        if payment_intent.status == "requires_action"
+          render json: {
+            message: "Payment requires further action",
+            client_secret: payment_intent.client_secret,
+            payment_intent_id: payment_intent.id
+          }, status: :ok
+        elsif payment_intent.status == "succeeded"
+          render json: {
+            message: "Payment successful",
+            payment_intent: payment_intent
+          }, status: :ok
+        else
+          render json: {
+            message: "Payment failed",
+            error: payment_intent.last_payment_error
+          }, status: :unprocessable_entity
         end
+      rescue Stripe::CardError => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      rescue => e
+        render json: { error: e.message }, status: :internal_server_error
+      end
+    end
+    
+    def create_payment(payment_intent, status, booking)
+      Stay::Payment.create!(
+        booking: booking,
+        payment_method: Stay::PaymentMethod.last,
+        amount: booking.total_amount,
+        state: status,
+      )
     end
-  
+
     def confirm
       payment_intent = get_payment_intent
-      if payment_intent.status == 'succeeded'
-        @booking.update(status: 'completed')
+      if payment_intent.status == "succeeded"
+        @booking.update(status: "completed")
         render json: { success: true, redirect_url: params[:redirect_url] }
       else
         render json: { error: payment_intent.last_payment_error.message }, status: 422
@@ -48,14 +95,12 @@ class Stay::Api::V1::PaymentsController < Stay::BaseApiController
 
     private
 
-  
+
     def payment_params
       params.require(:payment).permit(:amount, :currency, :payment_method_id, :description, :customer_email)
     end
-    
+
     def set_booking
       @booking = Stay::Booking.find(params[:booking_id])
     end
-
-  end
-
+end

data/app/controllers/stay/api/v1/profiles_controller.rb

@@ -21,7 +21,7 @@ class Stay::Api::V1::ProfilesController < Stay::BaseApiController
     end
 
     def profile_params
-      params.require(:profile).permit(:first_name, :last_name, :phone, :date_of_birth, :gender, :profile_image )
+      params.require(:profile).permit(:first_name, :last_name, :phone, :date_of_birth, :gender, :profile_image, :about_me )
     end
     
 end

data/app/controllers/stay/api/v1/properties_controller.rb

@@ -200,7 +200,7 @@ class Stay::Api::V1::PropertiesController < Stay::BaseApiController
                                         property_house_rules_attributes: [ :id, :house_rule_id, :value, :_destroy ],
                                         property_amenities_attributes: [ :id, :amenity_id, :_destroy ],
                                         property_features_attributes: [ :id, :name, :feature_id, :_destroy ],
-                                        rooms_attributes: [ :id, :max_guests, :price_per_month, :status, :booking_start, :booking_end, :description, :size, :bed_type_id, :room_type_id,  :_destroy, room_images: [],
+                                        rooms_attributes: [ :id, :name, :max_guests, :price_per_month, :status, :booking_start, :booking_end, :description, :size, :bed_type_id, :room_type_id,  :_destroy, room_images: [],
                                           room_features_attributes: [ :id, :feature_id, :_destroy ],
                                           room_amenities_attributes: [ :id, :amenity_id, :_destroy ]
                                         ],

data/app/controllers/stay/payments_controller.rb

@@ -1,11 +1,11 @@
 class Stay::PaymentsController < ApplicationController
   include Stay::StripeConcern
-
-  before_action :authenticate_user!
+  skip_before_action :verify_authenticity_token
+  before_action :authenticate_devise_api_token!
   before_action :set_property_and_booking
-  
+
   def new
-    render layout: 'stay/application'
+    render layout: "stay/application"
   end
 
   def create
@@ -13,28 +13,28 @@ class Stay::PaymentsController < ApplicationController
         @customer = create_or_retrieve_customer
         payment_intent = @booking.payment_intent_id ? get_payment_intent : create_payment_intent.tap { |pi| @booking.update(payment_intent_id: pi.id) }
         if params[:confirm]
-            if payment_intent.status == 'succeeded'
+            if payment_intent.status == "succeeded"
                 render json: { success: true, redirect_url: params[:redirect_url] }, status: :ok
-            elsif payment_intent.status == 'requires_action'
+            elsif payment_intent.status == "requires_action"
                 render json: { message: "Payment requires further action", client_secret: payment_intent.client_secret }, status: :ok
             else
                 render json: { message: "Payment failed", error: payment_intent.last_payment_error }, status: :unprocessable_entity
             end
-        else 
-            render json: {payment_intent: payment_intent, client_secret: payment_intent.client_secret}, status: :ok
+        else
+            render json: { payment_intent: payment_intent, client_secret: payment_intent.client_secret }, status: :ok
         end
     rescue Stripe::CardError => e
       render json: { error: e.message }, status: :unprocessable_entity
     rescue => e
-      render json: { error: e.message}, status: :internal_server_error
+      render json: { error: e.message }, status: :internal_server_error
     end
   end
 
   def confirm
       payment_intent = get_payment_intent
-      if payment_intent.status == 'succeeded'
-        @booking.update(status: 'completed')
-        flash[:notice] = 'Payment Completed Successfully'
+      if payment_intent.status == "succeeded"
+        @booking.update(status: "completed")
+        flash[:notice] = "Payment Completed Successfully"
         render json: { success: true, redirect_url: params[:redirect_url] }
       else
         flash[:alert] = payment_intent.last_payment_error.message
@@ -47,4 +47,4 @@ class Stay::PaymentsController < ApplicationController
     @property = Stay::Property.find(params[:property_id])
     @booking = Stay::Booking.find(params[:booking_id])
   end
-end
+end

data/app/models/stay/amenity.rb

@@ -1,11 +1,11 @@
 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 :property_amenities, class_name: "Stay::PropertyAmenity", dependent: :destroy
     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 :room_amenities, class_name: "Stay::RoomAmenity", dependent: :destroy
     has_many :rooms, through: :room_amenities, class_name: "Stay::Room"
   end
 end

data/app/models/stay/booking.rb

@@ -19,6 +19,9 @@ module Stay
     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") }
+    scope :current_host_booking, ->(host)  {
+          joins(:property).where(stay_properties: { user: host })
+        }
 
     after_commit :booking_completed_at
     before_create :link_by_email, :generate_number

data/app/models/stay/feature.rb

@@ -1,8 +1,8 @@
 module Stay
   class Feature < ApplicationRecord
-    has_many :property_features, class_name: "Stay::PropertyFeature"
+    has_many :property_features, class_name: "Stay::PropertyFeature", dependent: :destroy
     has_many :properties, through: :property_features, class_name: "Stay::Property"
-    has_many :room_features, class_name: "Stay::RoomFeature"
+    has_many :room_features, class_name: "Stay::RoomFeature", dependent: :destroy
     has_many :rooms, through: :room_features, class_name: "Stay::Room"
 
     enum :feature_type, { property: 0, room: 1 }

data/app/models/stay/user.rb

@@ -5,6 +5,9 @@ module Stay
     devise :database_authenticatable, :registerable,
            :recoverable, :rememberable, :validatable, :api
 
+
+    Stripe.api_key = ENV["STRIPES_SECRECT_KEY"]
+
     has_many :role_users, class_name: "Stay::RoleUser", dependent: :destroy
     has_many :stay_roles, through: :role_users, class_name: "Stay::Role", source: :role
     has_many :bookings
@@ -35,8 +38,7 @@ module Stay
 
     # callbacks
     after_create :welcome_email
-    # after_create :assign_default_role
-    # after_create :admin_host_email
+    after_create :create_stripe_account
 
     attr_accessor :updating_password
 
@@ -106,5 +108,23 @@ module Stay
     def assign_default_role
       Stay::RoleUser.create(user: self, role: Stay::Role.where(name: Stay::Role::USER).first_or_create) unless stay_roles.exists?
     end
+
+    def create_stripe_account
+      user = self
+      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
+          },
+        })
+        user.update(stripe_customer_id: customer.id)
+      
+    end
   end
 end

data/app/serializers/booking_listing_serializer.rb

@@ -0,0 +1,64 @@
+class BookingListingSerializer < ActiveModel::Serializer
+  attributes :id, :number, :total, :total_amount, :check_in_date, :check_out_date, :item_total, :is_shared_property, :booked_room, :room_images,
+  :number_of_guests, :payment_state, :status, :request_by, :invoice_no, :calculate_cleaning_fee, :calculate_city_fee, :extra_guest_amount, :property
+
+
+  def total
+    object.total_amount
+  end
+
+  def property
+    property =  object.property
+
+    {
+      id: property.id,
+      title: property.title,
+      price_per_month: property.price_per_month,
+      city: property.city,
+      state: property.state,
+      slug: property.slug,
+      rooms_count:property.rooms.count,
+    }
+  end
+
+  def room_images
+    object.rooms.last.room_images.map(&:url).compact
+  end
+
+  def is_shared_property
+    object.property&.shared_property
+  end
+
+  def booked_room
+    object.line_items.any? ?  object.line_items.last.room&.name : nil
+  end
+
+  def calculate_cleaning_fee
+    nil #  object.property.cleaning_fee
+  end
+
+  def calculate_city_fee
+   nil # object.property.city_fee
+  end
+
+  def extra_guest_amount
+    object.extra_guest_amount
+  end
+
+  def check_in_date
+    object.check_in_date.strftime("%B %d, %Y")
+  end
+
+  def check_out_date
+    object.check_out_date.strftime("%B %d, %Y")
+  end
+
+  def request_by
+    object.user&.full_name || nil
+  end
+
+  def invoice_no
+    object.invoice ? object.invoice.id : nil
+  end
+
+end

data/app/serializers/booking_serializer.rb

@@ -1,6 +1,6 @@
 class BookingSerializer < ActiveModel::Serializer
   attributes  :id, :number, :calculate_totals, :tax_total, :total, :total_amount, :item_total, :room_count, :check_in_date, :check_out_date,
-              :number_of_guests, :completed_at, :payment_state, :calculate_city_fee, :calculate_cleaning_fee, :status, :invoice_total, :extra_guest_amount, :last_five_messages
+              :number_of_guests, :completed_at, :payment_state, :calculate_city_fee, :calculate_cleaning_fee, :status, :invoice_total, :extra_guest_amount, :last_five_messages , :property_user
   belongs_to :property, serializer: PropertyListingSerializer
   belongs_to :user,  serializer: UserListingSerializer
   has_many :line_items, serializer: LineItemSerializer
@@ -40,6 +40,10 @@ class BookingSerializer < ActiveModel::Serializer
     object.extra_guest_amount
   end
 
+  def property_user
+    object.property.user.present? ? UserListingSerializer.new(object.property.user) : nil
+  end
+
   def invoice_total
     object.invoice&.total
   end

data/app/serializers/credit_card_serializer.rb

@@ -1,7 +1,3 @@
 class CreditCardSerializer < ActiveModel::Serializer
-  attributes :id, :month, :year, :cc_number, :cc_type, :name, :user
-  belongs_to :user
-  # def user
-  #   UserSerializer.new(object.user)
-  # end
+  attributes :id, :month, :year, :cc_number, :cc_type, :name, :payment_method_token, :card_token
 end

data/app/serializers/property_listing_serializer.rb

@@ -1,7 +1,7 @@
 class PropertyListingSerializer < ActiveModel::Serializer
   attributes :id, :title, :price_per_month, :place_images, :total_rooms,
               :availability_end, :availability_start, :extra_guest, :latitude,
-              :longitude, :address, :city, :state, :country, :active, :property_state, :slug
+              :longitude, :address, :city, :state, :country, :active, :property_state, :slug ,:description
 
   belongs_to :property_category, Serializer: :PropertyCategorySerializer
   belongs_to :property_type, Serializer: :PropertyTypeSerializer

data/config/initializers/stripe.rb

@@ -1,8 +1,8 @@
-# API_CONFIG = YAML.load_file(Rails.root.join('config', 'api_config.yml'))[Rails.env]
+require "dotenv/load"
 
-# Rails.configuration.stripe = {
-#   publishable_key: API_CONFIG['stripe_publishable_key'],
-#   secret_key: API_CONFIG['stripe_secret_key']
-# }
+Rails.configuration.stripe = {
+  publishable_key: ENV["PUBLISHABLE_KEY"],
+  secret_key: ENV["SECRET_KEY"]
+}
 
-# Stripe.api_key = Rails.configuration.stripe[:secret_key]
+Stripe.api_key = Rails.configuration.stripe[:secret_key]

data/config/routes.rb

@@ -27,7 +27,11 @@ Stay::Engine.routes.draw do
     resources :rooms
     resources :bookings
     resources :payment_methods
-    resources :payments
+    resources :payments do
+      collection do
+        post :create_payment_method
+      end
+    end
     resources :reviews
     resources :chats
     resources :messages

data/db/migrate/20250123053039_add_stripe_customer_id_to_stay_users.rb

@@ -0,0 +1,5 @@
+class AddStripeCustomerIdToStayUsers < ActiveRecord::Migration[8.0]
+  def change
+    add_column :stay_users, :stripe_customer_id, :string
+  end
+end

data/db/migrate/20250123112636_add_payment_method_id_to_credit_cards.rb

@@ -0,0 +1,6 @@
+class AddPaymentMethodIdToCreditCards < ActiveRecord::Migration[8.0]
+  def change
+    add_column :stay_credit_cards, :payment_method_token, :string, null: true
+    add_column :stay_credit_cards, :card_token, :string, null: true
+  end
+end

data/lib/stay/version.rb

@@ -1,3 +1,3 @@
 module Stay
-  VERSION = "0.1.14"
+  VERSION = "0.1.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stay_commerce
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.16
 platform: ruby
 authors:
 - w3villa-vikaspal
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-28 00:00:00.000000000 Z
+date: 2025-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -422,20 +422,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: letter_opener
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
 description: Description of Stay.
 email:
 - vikas.pal@w3villa.com
@@ -606,6 +620,7 @@ files:
 - app/serializers/amenity_category_serializer.rb
 - app/serializers/amenity_serializer.rb
 - app/serializers/bed_type_serializer.rb
+- app/serializers/booking_listing_serializer.rb
 - app/serializers/booking_query_serializer.rb
 - app/serializers/booking_serializer.rb
 - app/serializers/cancellation_policy_serializer.rb
@@ -936,6 +951,8 @@ files:
 - db/migrate/20241205092943_create_friendly_id_slugs.rb
 - db/migrate/20241217044817_add_deleted_atto_stay_property.rb
 - db/migrate/20241230064432_modify_property_category_on_properties.rb
+- db/migrate/20250123053039_add_stripe_customer_id_to_stay_users.rb
+- db/migrate/20250123112636_add_payment_method_id_to_credit_cards.rb
 - db/migrate/20250407101335_add_field_to_stay_users.rb
 - db/seeds.rb
 - lib/stay.rb