Class: Stay::Api::V1::BookingsController

Inherits:
BaseApiController
  • Object
show all
Includes:
BookingValidations
Defined in:
app/controllers/stay/api/v1/bookings_controller.rb

Instance Method Summary collapse

Instance Method Details

#booking_chat ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 166

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

#create ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 115

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

#delete_line_item ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 207

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

#host_booking ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 45

def host_booking
        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

#host_request ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 78

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: BookingListingSerializer),
      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

#index ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 6

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

#my_reservation ⇒ Object 



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 127

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

#show ⇒ Object 



188
189
190
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 188

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

#update ⇒ Object 



192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'app/controllers/stay/api/v1/bookings_controller.rb', line 192

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