stay_commerce 0.1.0

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

@@ -0,0 +1,21 @@
+class Stay::Api::V1::FeaturesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+
+  def property
+    features = Stay::Feature.property
+    if features.any?
+    render json: { data:ActiveModelSerializers::SerializableResource.new(features, each_serializer: PropertyFeatureSerializer) ,success: true }, status: :ok
+    else
+      render json: { error:"no feature found", success: false }, status: :unprocessable_entity
+    end
+  end
+
+  def room
+    features = Stay::Feature.room
+    if features.any?
+      render json: { data:ActiveModelSerializers::SerializableResource.new(features, each_serializer: PropertyFeatureSerializer) ,success: true }, status: :ok
+    else
+      render json: { error:"no feature found", success: false }, status: :unprocessable_entity
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+class Stay::Api::V1::HouseRulesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+
+  def index
+    @rules = Stay::HouseRule.all
+    return render json: { error: "no data found", success: false }, status: :unprocessable_entity unless @rules.any?
+    render json: { message: "house rule found", data:  ActiveModelSerializers::SerializableResource.new(@rules, each_serializer: HouseRulesSerializer), success: true }, status: :ok
+  end
+end

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

@@ -0,0 +1,47 @@
+class Stay::Api::V1::InvoicesController < ApplicationController
+  before_action :authenticate_devise_api_token!
+
+  def index
+    invoices = Stay::Invoice.joins(booking: :property)
+                            .where(stay_properties: { user: current_devise_api_user })
+
+    if params[:start_date].present? && params[:end_date].present?
+      start_date = Date.parse(params[:start_date])
+      end_date = Date.parse(params[:end_date])
+      invoices = invoices.where(
+        "stay_bookings.check_in_date >= :start_date AND stay_bookings.check_out_date <= :end_date",
+        start_date: start_date,
+        end_date: end_date
+      )
+    end
+
+    if params[:type].present?
+      invoices = invoices.where("invoice_type LIKE ?", "%#{params[:type]}%")
+    end
+
+    if params[:status].present?
+      case params[:status]
+      when "confirmed"
+        invoices = invoices.where("stay_bookings.status = ?", "confirmed")
+      when "any"
+        invoices = invoices.where("stay_bookings.status = ?", "invoice_sent")
+      end
+    end
+
+    if invoices.any?
+      render json: { data: ActiveModelSerializers::SerializableResource.new(invoices, each_serializer: InvoiceSerializer), success: true }, status: :ok
+    else
+      render json: { error: "no invoice found", success: false }, status: :unprocessable_entity
+    end
+  end
+
+
+  def show
+    invoice = Stay::Invoice.find_by(id: params[:id])
+    if invoice.present?
+      render json: { data: ActiveModelSerializers::SerializableResource.new(invoice, serializer: InvoiceSerializer), success: true }, status: :ok
+    else
+      render json: { error: "no invoice found", success: false }, status: :unprocessable_entity
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+class Stay::Api::V1::MessagesController < Stay::BaseApiController
+  protect_from_forgery with: :null_session, if: -> { request.format.json? }
+  before_action :authenticate_devise_api_token!
+  before_action :set_chat
+  before_action :set_message, only: [ :mark_as_read ]
+
+  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 : 20
+      cumulative_limit = page * per_page
+
+      @chat.messages
+           .where("sender_id = :user_id OR receiver_id = :user_id", user_id: current_devise_api_user.id)
+           .where(read_at: nil)
+           .update_all(read_at: DateTime.now)
+
+      total_count = @chat.messages.count
+      total_pages = (total_count.to_f / per_page).ceil
+
+      messages = @chat.messages
+                     .order(created_at: :asc)
+                     .limit(cumulative_limit)
+
+      chat_json = ChatSerializer.new(
+        @chat,
+        scope: { current_user: current_devise_api_user }
+      ).as_json
+
+      messages_json = messages.map do |message|
+        MessageSerializer.new(message, scope: current_devise_api_user).as_json
+      end
+
+      render json: {
+        data: "Messages Found",
+        chat: chat_json,
+        message: messages_json,
+        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 StandardError => e
+      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
+  rescue StandardError => e
+    render json: { error: e.message, success: false }, status: :internal_server_error
+  end
+
+  def create
+    begin
+      sender_id = @chat.sender_id
+      receiver_id = @chat.receiver_id
+
+      message = @chat.messages.new(message_params)
+      message.sender_id = current_devise_api_user.id
+      message.chat = @chat
+      message.event_for= Stay::Message.event_fors["both"]
+
+      if message.sender_id == sender_id
+        message.receiver_id = receiver_id
+      elsif message.sender_id == receiver_id
+        message.receiver_id = sender_id
+      else
+        return render json: { error: "Invalid sender or receiver", success: false }, status: :unprocessable_entity
+      end
+
+      return render json: { error: "You cannot send a message to yourself", success: false }, status: :unprocessable_entity if message.sender_id == message.receiver_id
+
+      if message.save
+        ActionCable.server.broadcast "ChatChannel", message
+        render json: {
+          data: "Message Created",
+          chat: ActiveModelSerializers::SerializableResource.new(@chat, serializer: ChatSerializer, scope: { current_user: current_devise_api_user }),
+          message: ActiveModelSerializers::SerializableResource.new(message, each_serializer: MessageSerializer),
+          success: true
+        }, status: :created
+      else
+        render json: { error: message.errors.full_messages.join(", "), success: false }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { error: "Chat not found: #{e.message}", success: false }, status: :not_found
+    rescue StandardError => e
+      render json: { error: e.message, success: false }, status: :internal_server_error
+    end
+  end
+
+  def mark_as_read
+    if @message.receiver_id == current_devise_api_user.id
+      @chat.messages.where(receiver_id: current_devise_api_user.id).update_all(read_at: DateTime.now)
+      render json: { message: "Message marked as read", success: true }, status: :ok
+    elsif @message.sender_id == current_devise_api_user.id
+      @chat.messages.where(sender_id: current_devise_api_user.id).update_all(read_at: DateTime.now)
+      render json: { message: "Message marked as read", success: true }, status: :ok
+    else
+      render json: { error: "You are not authorized to read this message" }, status: :unauthorized
+    end
+  end
+
+  private
+
+  def set_message
+    begin
+      @message = Stay::Message.find(params[:id])
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { success: false, error: "message not found" }, status: :not_found
+    end
+  end
+
+  def set_chat
+    begin
+      @chat = Stay::Chat.find(params[:chat_id])
+      unless @chat.sender_id == current_devise_api_user.id || @chat.receiver_id == current_devise_api_user.id
+        render json: { error: "not authorized to view this chat", success: false }, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      render json: { error: "Chat not found: #{e.message}", success: false }, status: :not_found
+    rescue StandardError => e
+      render json: { error: e.message, success: false }, status: :internal_server_error
+    end
+  end
+
+  def formatted_date(date)
+    if date.to_date == Date.today
+      "Today"
+    elsif date.to_date == Date.yesterday
+      "Yesterday"
+    else
+      date.to_date.strftime("%B %d, %Y")
+    end
+  end
+
+  def message_params
+    params.require(:message).permit(:body, :sender_id, :receiver_id, attachments: [])
+  end
+end

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

@@ -0,0 +1,61 @@
+class Stay::Api::V1::PaymentsController < Stay::BaseApiController
+  include Stay::StripeConcern 
+
+    before_action :set_booking, except: :payment_method
+    before_action :authenticate_devise_api_token!
+
+
+    def payment_method
+      methods =  Stay::PaymentMethod.all
+      if methods.any?
+        render json: { message: "Payment Method Found", data: methods, success: true }, status: :ok
+      else
+        render json: { error: "no method found", success: false }, status: :unprocessable_entity
+      end
+    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
+        end
+    end
+  
+    def confirm
+      payment_intent = get_payment_intent
+      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
+      end
+    end
+
+    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
+

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

@@ -0,0 +1,23 @@
+class Stay::Api::V1::ProfilesController < Stay::BaseApiController
+    before_action :set_user, only: [:show, :update]
+
+    def show
+      render json: { profile: @profile }
+    end
+
+    def update 
+      @profile.update(profile_params)
+      render json: { profile: @profile }, status: :ok
+    end
+
+    private
+
+    def set_user
+      @profile = current_devise_api_user || Stay::Profile.find(params[:id])
+    end
+
+    def profile_params
+      params.require(:profile).permit(:first_name, :last_name, :phone, :date_of_birth, :gender )
+    end
+    
+end

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

@@ -0,0 +1,233 @@
+class Stay::Api::V1::PropertiesController < Stay::BaseApiController
+    before_action :authenticate_devise_api_token!
+    before_action :set_property, only: [ :show, :update, :destroy ]
+    before_action :check_create_access, only: [ :create, :update ]
+    before_action :check_update_access, only: [ :update ]
+
+    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
+
+        @data = Stay::Property.approved.active.joins(:rooms).distinct
+        @properties = @data.order(created_at: :desc).limit(cumulative_per_page)
+        total_count =  @data.count
+        total_pages = (total_count.to_f / per_page).ceil
+
+        return render json: { data: "No properties found", properties: [], success: false }, status: :ok  if @properties.empty?
+
+        render json: {
+          data: "Data Found",
+          properties: ActiveModelSerializers::SerializableResource.new(@properties, each_serializer: PropertyListingSerializer),
+          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: "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 my_properties
+      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
+        @data =  current_devise_api_user.properties
+        @properties = @data.order(created_at: :asc).limit(cumulative_per_page)
+        total_count =  @data.count
+        total_pages = (total_count.to_f / per_page).ceil
+        return render json: { data: "No properties found", properties: [], success: false }, status: :ok  if @properties.empty?
+        render json: {
+          data: "Property Found",
+          properties: ActiveModelSerializers::SerializableResource.new(@properties, each_serializer: PropertyListingSerializer),
+          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: "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 show
+      render json: { data: "Data Found", property: PropertySerializer.new(@property), success: true }, status: :ok
+    end
+
+    def create
+      ActiveRecord::Base.transaction do
+        begin
+          @property = current_devise_api_user.properties.new(property_params)
+          if @property.save
+            render json: { message: "Property created", property: PropertySerializer.new(@property), success: true }, status: :created
+          else
+            raise ActiveRecord::RecordInvalid.new(@property)
+          end
+        rescue ActiveRecord::RecordInvalid => e
+          render json: { error: @property.errors.full_messages.to_sentence, success: false }, status: :unprocessable_entity
+          raise ActiveRecord::Rollback
+        rescue StandardError => e
+          render json: { error: "Something went wrong: #{e.message}", success: false }, status: :unprocessable_entity
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+
+    def update
+      ActiveRecord::Base.transaction do
+        if @property.update(property_params)
+          render json: {
+            message: "property updated",
+            property: PropertySerializer.new(@property),
+            success: true
+          }, status: :created
+        else
+          raise ActiveRecord::Rollback
+        end
+      rescue ActiveRecord::RecordInvalid
+        render json: {
+          message: @property.errors.full_messages,
+          success: false
+        }, status: :unprocessable_entity
+      end
+    end
+
+    def similar_property
+      begin
+        properties = Stay::Property.similar_properties(params[:property_type_id], params[:property_category_id], params[:property_id])
+
+        if properties.exists?
+          render json: {
+            data: "Data Found",
+            properties: ActiveModelSerializers::SerializableResource.new(properties, each_serializer: PropertyListingSerializer),
+            success: true
+          }, status: :ok
+        else
+          render json: { error: "No property found", success: false }, status: :unprocessable_entity
+        end
+      rescue StandardError => e
+        render json: { error: "No property found ", message: e.message, success: false }, status: :internal_server_error
+      end
+    end
+
+
+    def search
+      amenity_ids = parse_to_array(params[:q][:amenity_ids])
+      feature_ids = parse_to_array(params[:q][:feature_ids])
+      latitude, longitude = params[:q].values_at(:latitude, :longitude)
+
+      @q = Stay::Property.approved.active.ransack(params[:q])
+      @properties = @q.result.distinct
+
+      @properties = @properties.with_amenities(amenity_ids) if amenity_ids.any?
+      @properties = @properties.with_features(feature_ids) if feature_ids.any?
+      @properties = @properties.nearby(latitude, longitude, params[:distance] || 10) if latitude && longitude
+      @properties = @properties.by_property_type(params[:q][:property_type_id]) if params[:q][:property_type_id].present?
+      @properties = @properties.price_filter(params[:q][:min_price], params[:q][:max_price]) if params[:q][:min_price] && params[:q][:max_price].present?
+      @properties = @properties.by_property_category(params[:q][:property_category_id]) if params[:q][:property_category_id].present?
+
+      @properties = @properties.page(params[:page]).per(params[:per_page] || 10)
+
+      if @properties.any?
+        render json: {
+          message: "data found",
+          properties: ActiveModelSerializers::SerializableResource.new(@properties, each_serializer: PropertyListingSerializer),
+          total_pages: @properties.total_pages,
+          current_page: @properties.current_page,
+          next_page: @properties.next_page,
+          prev_page: @properties.prev_page,
+          total_count: @properties.total_count,
+          success: true
+        }, status: :ok
+      else
+        render json: { message: "No properties found" }, status: :not_found
+      end
+    end
+
+    def property_tax
+      @taxes = Stay::Tax.all
+      if @taxes.any?
+        render json: { message: "tax found", tax: @taxes, success: true }, status: :ok
+      else
+        render json: { message: "No properties found" }, status: :not_found
+      end
+    end
+
+    def resubmit
+      render json: { message: "Property resubmitted for approval", data: PropertyListingSerializer.new(@property), success: :true }, status: :ok if @property.resubmit!
+      render json: { error: "Property not approved",  success: :false }, status: :unprocessable_entity
+    end
+
+    def destroy
+      if @property.destroy
+        render json: { message: "Property destroyed successfully", success: true }, status: :ok
+      else
+        render json: { error: "Property not destroyed",  success: :false }, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def property_params
+      params.require(:property).permit(:active, :title, :description, :user_id, :guest_number, :availability_start, :availability_end,  :bedroom_description, :cancellation_policy_id,
+                                        :university_nearby, :about_neighbourhoods, :instant_booking, :minimum_months_of_booking, :security_deposit,
+                                        :extra_guest, :allow_extra_guest, :city, :address, :latitude, :longitude, :total_rooms, :total_bathrooms, :state, :country, :zipcode, :property_state,
+                                        :property_size, :property_category_id, :property_type_id, :cover_image, :price_per_month, :taxes_in_percentage, :cleaning_fee, :city_fee,
+                                        :early_bird_discount, :advance_days, :is_city_fee_percentage, :unlimited_availability,  place_images: [],
+                                        additional_rules_attributes: [ :id, :name,  :_destroy ],
+                                        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: [],
+                                          room_features_attributes: [ :id, :feature_id, :_destroy ],
+                                          room_amenities_attributes: [ :id, :amenity_id, :_destroy ]
+                                        ],
+                                        property_taxes_attributes: [ :id, :tax_id, :value, :_destroy ],
+                                      )
+    end
+
+    def set_property
+      begin
+        @property = Stay::Property.friendly.find(params[:id])
+      rescue ActiveRecord::RecordNotFound => e
+        render json: { success: false, error: "Properties not found" }, status: :not_found
+      end
+    end
+
+    def parse_to_array(param)
+      return [] unless param.present?
+      param = JSON.parse(param) if param.is_a?(String)
+      Array(param)
+    rescue JSON::ParserError
+      []
+    end
+
+  def check_create_access
+    render json: { error: "You don't have access to create property", success: false }, status: :unprocessable_entity unless current_devise_api_user.stay_host?
+  end
+
+  def check_update_access
+    render json: { error: "You don't have access to update this property", success: false }, status: :unprocessable_entity if current_devise_api_user != @property.user
+  end
+end

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

@@ -0,0 +1,14 @@
+class Stay::Api::V1::PropertyCategoriesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+
+  def index
+    @type = Stay::PropertyCategory.all
+    render json: { data: ActiveModelSerializers::SerializableResource.new(@type, each_serializer: PropertyCategorySerializer), message: "data found", success: true }, status: :ok
+  end
+
+  def show
+    @type = Stay::PropertyCategory.find_by(id: params[:id])
+    return render json: { error: "no data found", success: false }, status: :unprocessable_entity if @type.nil?
+    render json: { data:  PropertyCategorySerializer.new(@type), message: "data found", success: true },  status: :ok
+  end
+end

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

@@ -0,0 +1,14 @@
+class Stay::Api::V1::PropertyTypesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+
+  def index
+    @type = Stay::PropertyType.all
+    render json: { data: ActiveModelSerializers::SerializableResource.new(@type, each_serializer: PropertyTypeSerializer), message: "data found", success: true }, status: :ok
+  end
+
+  def show
+    @type = Stay::PropertyType.find_by(id: params[:id])
+    return render json: { error: "no data found", success: false }, status: :unprocessable_entity if @type.nil?
+    render json: { data:  PropertyTypeSerializer.new(@type), message: "data found", success: true },  status: :ok
+  end
+end

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

@@ -0,0 +1,14 @@
+class Stay::Api::V1::RoomTypesController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+
+  def index
+    @type = Stay::RoomType.all
+    render json: { data: ActiveModelSerializers::SerializableResource.new(@type, each_serializer: RoomTypeSerializer), message: "data found", success: true }, status: :ok
+  end
+
+  def show
+    @type = Stay::RoomType.find_by(id: params[:id])
+    return render json: { error: "no data found", success: false }, status: :unprocessable_entity if @type.nil?
+    render json: { data:  RoomTypeSerializer.new(@type), message: "data found", success: true },  status: :ok
+  end
+end

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

@@ -0,0 +1,23 @@
+class Stay::Api::V1::RoomsController < Stay::BaseApiController
+    before_action :authenticate_devise_api_token!
+    before_action :set_property
+    before_action :set_room, only: [ :show ]
+
+    def index
+        @rooms = @property.rooms
+        render json: { rooms: @rooms }
+    end
+
+    def show
+        render json: { room: @room }
+    end
+
+    private
+    def set_property
+        @property = Stay::Property.find(params[:property_id])
+    end
+
+    def set_room
+        @room = @property.rooms.find(params[:id])
+    end
+end

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

@@ -0,0 +1,53 @@
+class Stay::Api::V1::UserPaypalController < Stay::BaseApiController
+  before_action :authenticate_devise_api_token!
+  before_action :set_paypal, only: %i[show edit update]
+
+  def index
+    @paypal = current_devise_api_user.user_paypal
+    if @paypal.present?
+      render json: {
+        message: "paypal account found",
+        data: @paypal,
+        success: true },
+      status: :ok
+    else
+      render json: { error: "No paypal account found", success: false }, status: :unprocessable_entity
+    end
+  end
+
+  def show
+    render json: { data: @paypal, success: true }, status: :ok
+  end
+
+  def create
+    paypal = current_devise_api_user.build_user_paypal(user_paypal_params)
+    if paypal.save
+      render json: { message: "PayPal account saved successfully", data: paypal, success: true }, status: :ok
+    else
+      render json: { error: "PayPal account not saved", success: false, errors: paypal.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+
+  def edit
+    render json: { data: paypal, success: true }, status: :ok
+  end
+
+  def update
+    if @paypal.update(user_paypal_params)
+      render json: { message: "Credit card updated successfully", data: @paypal, success: true }, status: :ok
+    else
+      render json: { error: "Credit card not updated", success: false, errors: paypal.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def set_paypal
+    @paypal = current_devise_api_user.user_paypal
+  end
+
+  def user_paypal_params
+    params.require(:user_paypal).permit(:email, :user_id)
+  end
+end