stay_commerce 0.1.0

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

@@ -0,0 +1,205 @@
+class Stay::Api::V1::BookingQueriesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+  before_action :set_property, except: [ :index, :show, :host_query ]
+  before_action :booking_availability, only: [ :create, :update ]
+  before_action :set_query, only: [ :update, :show ]
+  before_action :restrict_multiple_query, only: [ :create ]
+  before_action :check_booking_validation, only: [ :create ]
+
+  def index
+    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
+      query = current_devise_api_user.booking_queries.ongoing
+      @booking_queries = query.order(created_at: :desc).limit(cumulative_per_page)
+
+      total_count = query.count
+      total_pages = (total_count.to_f / per_page).ceil
+
+      return render json: { success: false, error: "Query not found" }, status: :not_found if @booking_queries.empty?
+
+      render json: {
+        success: true,
+        booking_queries: ActiveModelSerializers::SerializableResource.new(@booking_queries, each_serializer: BookingQuerySerializer),
+        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: "Query 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_query
+    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
+      query = Stay::BookingQuery.joins(:property).where(stay_properties: { user_id: current_devise_api_user&.id }).ongoing.order(created_at: :desc)
+      @booking_queries = query.limit(cumulative_per_page).uniq
+
+      total_count = query.count
+      total_pages = (total_count.to_f / per_page).ceil
+
+      return render json: { success: false, error: "Query not found" }, status: :not_found if @booking_queries.empty?
+
+      render json: {
+        success: true,
+        booking_queries: ActiveModelSerializers::SerializableResource.new(@booking_queries, each_serializer: BookingQuerySerializer),
+        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: "Query 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 create
+    ActiveRecord::Base.transaction do
+      return render json: { error: "you can not query for your own property", success: false }, status: :unprocessable_entity if current_devise_api_user == @property.user
+
+      chat = create_chat(current_devise_api_user, @property)
+      if chat.persisted?
+        booking_query = chat.build_booking_query(booking_query_params.merge(property: @property, user: current_devise_api_user))
+        if booking_query.save
+          Stay::Chat::QueryMessagingService.new(booking_query, current_devise_api_user).perform
+          render json: { success: true, booking_query: BookingQuerySerializer.new(booking_query) }, status: :created
+        else
+          raise ActiveRecord::Rollback
+        end
+      else
+        raise ActiveRecord::Rollback, "Failed to create chat"
+      end
+    end
+
+  rescue ActiveRecord::Rollback => e
+    render json: { success: false, errors: e.message || booking_query.errors.full_messages }, status: :unprocessable_entity
+  end
+
+  def show
+    last_five = @booking_query.chat&.messages.order(created_at: :desc).limit(5)
+    render json: {
+      success: true,
+      booking_query: BookingQuerySerializer.new(@booking_query),
+      booking: @booking_query.booking ? BookingSerializer.new(@booking_query.booking) : nil,
+      messages: ActiveModelSerializers::SerializableResource.new(last_five, each_serializer: MessageSerializer)
+    }, status: :ok
+  end
+
+
+  def update
+    if %w[request_change booking_invitation accepted rejected].include?(booking_query_params[:state])
+      @booking_query.update(state: booking_query_params[:state].to_sym)
+      Stay::Chat::QueryMessagingService.new(@booking_query, current_devise_api_user).perform
+    end
+
+    unless @booking_query.update(booking_query_params)
+      return render json: { success: false, errors: @booking_query.errors.full_messages }, status: :unprocessable_entity
+    end
+
+    last_five = @booking_query.chat&.messages.order(created_at: :desc).limit(5)
+
+    if @booking_query.accepted?
+      if @booking_query.booking.present?
+        render json: { success: false, message: "Booking already created for this query" }, status: :unprocessable_entity
+      else
+        result = Stay::Bookings::CreateBookingService.new(@booking_query).perform
+        if result[:success]
+          render json: {
+            message: "Booking created successfully",
+            success: true,
+            booking_query: BookingQuerySerializer.new(@booking_query),
+            booking: @booking_query.booking ? BookingSerializer.new(@booking_query.booking) : nil,
+            messages: ActiveModelSerializers::SerializableResource.new(last_five, each_serializer: MessageSerializer)
+          }, status: :ok
+        else
+          render json: { success: false, errors: result[:errors] }, status: :unprocessable_entity
+        end
+      end
+    else
+      render json: {
+        success: true,
+        booking_query: BookingQuerySerializer.new(@booking_query),
+        booking: @booking_query.booking ? BookingSerializer.new(@booking_query.booking) : nil,
+        messages: ActiveModelSerializers::SerializableResource.new(last_five, each_serializer: MessageSerializer)
+      }, status: :ok, status: :ok
+    end
+  end
+
+  private
+
+  def set_property
+    @property = Stay::Property.find_by(id: params[:property_id])
+    render json: { success: false, error: "Property not found" }, status: :not_found unless @property
+  end
+
+  def create_chat(user, property)
+    host = property.user
+    Stay::Chat.between(current_devise_api_user.id, host.id).create!(sender: user, receiver: host, property: property)
+  end
+
+  def set_query
+    begin
+      @booking_query = Stay::BookingQuery.find(params[:id])
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { success: false, error: "Query not found" }, status: :not_found
+    end
+  end
+
+  def booking_query_params
+    params.require(:booking_query).permit(:chat_id, :user_id, :check_in_date, :check_out_date, :query, :booking_id, :state, :guest_count, :property_id, query_for: {})
+  end
+
+  def booking_availability
+    if @property.user.nil?
+      render json: { success: false, error: "Property Host not active." }, status: :not_found
+    end
+  end
+
+  def check_booking_validation
+    check_in_date = booking_query_params[:check_in_date].to_date
+    check_out_date = booking_query_params[:check_out_date].to_date
+
+    month_diff = (check_in_date.year * 12 + check_in_date.month) - (check_out_date.to_date.year * 12 + check_out_date.to_date.month)
+    if   @property&.minimum_months_of_booking && month_diff > @property.minimum_months_of_booking
+      render json: { success: false, error: "minimum month for booking is #{@property.minimum_months_of_booking}" }, status: :unprocessable_entity
+    end
+  end
+
+  def restrict_multiple_query
+    existing_query = Stay::BookingQuery
+                     .joins(:property)
+                     .date_range(booking_query_params[:check_in_date], booking_query_params[:check_out_date])
+                     .without_booking
+                     .for_current_user(current_devise_api_user)
+                     .where(stay_properties: { id: @property.id })
+                     .exists?
+
+    if existing_query
+      render json: {
+        error: "You already raised a query for this property. Visit the booking query section for updates.",
+        success: false
+      }, status: :unprocessable_entity
+    end
+  end
+end

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

@@ -0,0 +1,299 @@
+class Stay::Api::V1::BookingsController < Stay::BaseApiController
+  before_action :set_booking, only: [ :show, :update, :delete_line_item, :booking_chat ]
+  before_action :authenticate_devise_api_token!
+  include Stay::BookingValidations
+
+  def index
+    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
+
+      @bookings = current_devise_api_user.bookings&.confirmed
+                  .order(created_at: :desc)
+                  .limit(cumulative_per_page)
+
+      total_count = current_devise_api_user.bookings&.confirmed.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
+  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
+  end
+
+  def host_request
+    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 }).where.not(status: "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
+  end
+
+  def create
+    booking = find_incomplete_booking
+
+    property = Stay::Property.friendly.find_by(slug: booking_params[:property_id])
+    return render json: { error: "property not found", success: false }, status: :unprocessable_entity if property.nil?
+    if booking.any?
+      handle_existing_booking(booking)
+    else
+      create_new_booking(property)
+    end
+  end
+
+  def my_reservation
+    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
+      @bookings = current_devise_api_user.bookings.incomplete
+                   .order(created_at: :desc)
+                   .limit(cumulative_per_page)
+
+      total_count = current_devise_api_user.bookings.incomplete&.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
+  end
+
+
+  def booking_chat
+    @chat = @booking.chat
+    if @chat.present? && @chat.messages.any?
+      @messages = @chat.messages.page(params[:page]).per(params[:per_page] || 10)
+      render json: {
+        booking: BookingSerializer.new(@booking),
+        chat: ChatSerializer.new(@booking.chat, scope: { current_user: current_devise_api_user }),
+        messages: ActiveModelSerializers::SerializableResource.new(@messages, each_serializer: MessageSerializer),
+        success: true,
+        meta: {
+          total_pages: @messages.total_pages,
+          current_page: @messages.current_page,
+          next_page: @messages.next_page,
+          prev_page: @messages.prev_page,
+          total_count: @messages.total_count
+        }
+      }, status: :ok
+    else
+      render json: { error: "no chat found", success: false }, status: :unprocessable_entity
+    end
+  end
+
+  def show
+      render json: { booking: BookingSerializer.new(@booking), booking_query: @booking&.booking_query.present? ? BookingQuerySerializer.new(@booking&.booking_query) : nil,  success: true }, status: :ok
+  end
+
+  def update
+    if @booking.payment_state == "failed" && params[:booking][:status] == "confirmed"
+      return render json: { error: "Booking cannot be confirmed due to failed payment." }, status: :unprocessable_entity
+    end
+    if @booking.update(booking_params)
+      if @booking.saved_change_to_status?
+        @booking.update_columns(canceler_id: current_devise_api_user.id, canceled_at: Time.current) if @booking.canceled?
+        Stay::Chat::ChatMessagingService.new(@booking).send_initial_messages
+      end
+      render json: { data: BookingSerializer.new(@booking, scope: { current_user: current_devise_api_user }), success: true }, status: :ok
+    else
+      render json: { error: @booking.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+  def delete_line_item
+    room = @booking.line_items.find_by(room_id: params[:room_id])
+    if room&.destroy
+      unless @booking.line_items.exists?
+        @booking.destroy
+        return render json: { message: "Booking deleted successfully", success: true }, status: :ok
+      end
+      render json: { message: "Room deleted successfully", data: BookingSerializer.new(@booking), success: true }, status: :ok
+    else
+      render json: { error: room ? room.errors.full_messages : "Room not found" }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def booking_params
+    params.require(:booking).permit(
+      :check_in_date, :check_out_date, :number_of_guests, :total_amount, :property_id, :status, :payment_intent_id,
+      line_items_attributes: [ :id, :room_id, :price, :quantity, :property_id ],
+      payments_attributes: [ :id, :payment_method_id, :amount, :state, :transaction_id, :intent_client_key ],
+      invoice_attributes: [
+        :id, :total, :invoice_period, :invoice_type, :billing_type, :status, :_destroy,
+        discounts_attributes: [ :id, :amount, :description,  :_destroy ],
+        expenses_attributes: [ :id, :amount, :category,  :_destroy ]
+      ]
+    )
+  end
+
+  def find_incomplete_booking
+    booking = current_devise_api_user.bookings.joins(:property).where(property: { slug: booking_params[:property_id] }).incomplete
+  end
+
+  def handle_existing_booking(booking)
+    @booking = booking.last
+    @booking.line_items.destroy_all if @booking.line_items
+    result = Stay::Bookings::ExistingBookingService.new(@booking, booking_params).perform
+    if result[:success]
+      if @booking.check_in_date != booking_params[:check_in_date].to_date &&  @booking.check_out_date != booking_params[:check_out_date].to_date
+        Stay::Chat::ChatMessagingService.new(@booking).send_initial_messages
+      end
+      render json: { data: BookingSerializer.new(@booking), success: true }, status: :ok
+    else
+    render json: { success: false, errors: result[:errors] }, status: :unprocessable_entity
+    end
+  end
+
+  def create_new_booking(property)
+    @booking = current_devise_api_user.bookings.new(booking_params)
+    unless property.shared_property
+      @booking.line_items = []
+      room_numbers = property.rooms.pluck(:id)
+      build_line_items(room_numbers, @booking)
+    end
+    @booking.property = property
+    if @booking.save
+      Stay::Chat::ChatMessagingService.new(@booking).send_initial_messages
+      @booking.calculate_totals
+      render json: {  data: BookingSerializer.new(@booking), success: true }, status: :created
+    else
+      render json: { error: @booking.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+
+  def build_line_items(room_numbers, booking)
+    room_numbers.map do |room_number|
+      room = Stay::Room.find_by(id: room_number)
+      next unless room
+      booking.line_items.new(
+        room: room,
+        price: room.price.to_s,
+        quantity: 1
+      )
+    end
+  end
+
+  def set_room
+    @room = Stay::Room.find(params[:room_id])
+  end
+
+  def render_error(message, status)
+    render json: { error: message, success: false }, status: status
+  end
+
+  def set_booking
+    @booking = Stay::Booking.find_by(id: params[:id])
+    render json: { error: "no booking found", success: false }, status: :unprocessable_entity if  @booking.nil?
+  end
+end

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

@@ -0,0 +1,10 @@
+class Stay::Api::V1::CancellationPoliciesController < Stay::BaseApiController
+  def index
+    policies = Stay::CancellationPolicy.all
+    render json: { data:ActiveModelSerializers::SerializableResource.new(policies, each_serializer: CancellationPolicySerializer), success: true }, status: :ok
+  rescue ActiveRecord::RecordNotFound
+    render json: { error: "Cancellation policies not found" }, status: :not_found
+  rescue StandardError => e
+    render json: { error: "An unexpected error occurred", details: e.message }, status: :internal_server_error
+  end
+end

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

@@ -0,0 +1,116 @@
+class Stay::Api::V1::ChatsController < ApplicationController
+  before_action :authenticate_devise_api_token!
+  before_action :check_admin_access, only: :index
+
+  def index
+    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 : 15
+      cumulative_per_page = page * per_page
+
+      chats = Stay::Chat.joins(:messages, :property).where(stay_properties: { user: current_devise_api_user })
+      chats = params[:unread].present? ? chats.get_unread_messages_chat : chats.get_all_messages
+      chats = chats.order_by_latest_messages
+      return render json: { error: "No chats found", success: false }, status: :unprocessable_entity if chats.empty?
+
+      total_count = chats.length
+      chats = chats.limit(cumulative_per_page)
+      total_pages = (total_count.to_f / per_page).ceil
+
+      data = {
+        message: "Chats Found",
+        chats: ActiveModelSerializers::SerializableResource.new(chats, each_serializer: ChatSerializer, scope: { current_user: current_devise_api_user }),
+        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
+        }
+      }
+      render json: { data: data }, status: :ok
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { success: false, error: "Properties 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 create
+    begin
+      @chat = Stay::Chat.between(current_devise_api_user&.id, params[:receiver_id]).create!(chat_params.merge(sender_id: current_devise_api_user&.id))
+      render json: {
+        data: "Chat Created",
+        chat: ActiveModelSerializers::SerializableResource.new(@chat, serializer: ChatSerializer, scope: { current_user: current_devise_api_user }),
+        success: true
+      }, status: :ok
+    rescue ActiveRecord::RecordInvalid => e
+      render json: { error: e.message, success: false }, status: :unprocessable_entity
+    rescue StandardError => e
+      render json: { error: "An error occurred: #{e.message}", success: false }, status: :internal_server_error
+    end
+  end
+
+  def user_chat
+    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 : 15
+
+      cumulative_per_page = page * per_page
+      @chats = Stay::Chat.for_user(current_devise_api_user)
+
+      @chats = params[:unread].present? ? @chats.get_unread_messages_chat : @chats.get_all_messages
+      @chats = @chats.order_by_latest_messages
+      return render json: { error: "No chats found", success: false }, status: :unprocessable_entity if @chats.empty?
+
+      total_count = @chats.length
+      @chats = @chats.limit(cumulative_per_page)
+      total_pages = (total_count.to_f / per_page).ceil
+
+      data = {
+        message: @chats.any? ? "Chats Found" : "No Chat Found",
+        chats: @chats.any? ? ActiveModelSerializers::SerializableResource.new(@chats, each_serializer: ChatSerializer, scope: { current_user: current_devise_api_user }) : [],
+        success: @chats.any? ? true : false,
+        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
+        }
+      }
+      render json: { data: data }, status: :ok
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { success: false, error: "Chat 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 chat_messages
+    begin
+      @chat = Stay::Chat.find(params[:id])
+      @messages = @chat.messages
+      render json: { messages: @messages, success: true }, status: :ok
+    rescue ActiveRecord::RecordNotFound
+      render json: { error: "Chat not found", success: false }, status: :not_found
+    rescue StandardError => e
+      render json: { error: e.message, success: false }, status: :internal_server_error
+    end
+  end
+
+  private
+
+  def check_admin_access
+    render json: { error: "not authorize to see this chat", success: false }, status: :unprocessable_entity unless current_devise_api_user.stay_host?
+  end
+
+  def chat_params
+    params.require(:chat).permit(:sender_id, :receiver_id, :property_id, :booking_id, :chat_event, :event_message)
+  end
+end

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

@@ -0,0 +1,62 @@
+class Stay::Api::V1::CreditCardsController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+  before_action :set_credit_card, only: %i[show edit update]
+
+  def index
+    @credit_cards = current_devise_api_user.credit_cards
+    if @credit_cards.any?
+      render json: {
+        message: "Credit cards found",
+        data: CreditCardSerializer.new(@credit_cards.last),
+        success: true },
+      status: :ok
+    else
+      render json: { error: "No credit cards found", success: false }, status: :unprocessable_entity
+    end
+  end
+
+  def show
+    render json: { data: CreditCardSerializer.new(@credit_card), success: true }, status: :ok
+  end
+
+  def new
+    @credit_card = current_devise_api_user.credit_cards.build
+    render json: { data: @credit_card, success: true }, status: :ok
+  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
+    end
+  end
+
+  def edit
+    render json: { data: @credit_card, success: true }, status: :ok
+  end
+
+  def update
+    if @credit_card.update(credit_card_params)
+      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
+
+  private
+
+  def set_credit_card
+    @credit_card = current_devise_api_user.credit_cards.find(params[:id])
+  end
+
+  def credit_card_params
+    params.require(:credit_card).permit(:month, :year, :cc_number, :cc_type, :name)
+  end
+end