Class: Dscf::Marketplace::OrdersController

Inherits:
ApplicationController show all
Includes:
Core::Common
Defined in:
app/controllers/dscf/marketplace/orders_controller.rb

Instance Method Summary collapse

Methods inherited from ApplicationController

#bypass_permissions_for_demo?, #pundit_user

Instance Method Details

#assign_source ⇒ Object 



140
141
142
143
144
145
146
147
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 140

def assign_source
  obj = find_record
  authorize obj, :split?

  item = obj.order_items.find(params[:order_item_id])
  Dscf::Marketplace::OrderSplittingService.assign_source(item, source_type: params[:source_type], source_id: params[:source_id])
  render_success(data: item)
end

#cancel ⇒ Object 



55
56
57
58
59
60
61
62
63
64
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 55

def cancel
  @obj = find_record
  authorize @obj, :cancel?
  if @obj.update(status: :cancelled)
    @obj.order_items.update_all(status: OrderItem.statuses[:cancelled])
    render_success("orders.success.cancelled", data: @obj)
  else
    render_error("orders.errors.cancel_failed")
  end
end

#complete ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 66

def complete
  @obj = find_record
  authorize @obj, :complete?
  if @obj.can_be_completed? && @obj.update(status: :completed)
    @obj.order_items.update_all(status: OrderItem.statuses[:fulfilled])
    begin
      invoice = Dscf::Marketplace::InvoicePdfGenerator.new(@obj).generate!
      render_success("orders.success.completed", data: @obj, meta: {invoice_id: invoice.id})
    rescue => e
      Rails.logger.error("Invoice generation failed for order #{@obj.id}: #{e.message}")
      render_success("orders.success.completed", data: @obj)
    end
  else
    render_error("orders.errors.complete_failed")
  end
end

#confirm ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 45

def confirm
  @obj = find_record
  authorize @obj, :confirm?
  if @obj.confirm!
    render_success("orders.success.confirmed", data: @obj)
  else
    render_error("orders.errors.confirm_failed")
  end
end

#create ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 6

def create
  authorize @clazz.new, :create?
  return render_unsupported_payment_method if unsupported_payment_method_for_new_order?(model_params[:payment_method])

  return create_direct_listing_order if direct_listing_request?

  obj = @clazz.new(model_params)
  if obj.save
    obj = @clazz.includes(eager_loaded_associations).find(obj.id) if eager_loaded_associations.present?
    includes = default_serializer_includes[:create] || []
    options = {include: includes} if includes.present?
    render_success(data: obj, serializer_options: options, status: :created)
  else
    render_error(errors: obj.errors.full_messages.join(", "), status: :unprocessable_entity)
  end
rescue => e
  render_error(error: e.message)
end

#create_notification_for_order(order, action, reason: nil) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 193

def create_notification_for_order(order, action, reason: nil)
  recipient = order.ordered_by || order.user
  return unless recipient

  title = case action
  when :validation_completed then "Order ##{order.id} validation complete"
  when :item_resolved then "Item resolved in order ##{order.id}"
  when :split_ready then "Order ##{order.id} ready for supplier confirmation"
  when :supplier_confirmed then "Supplier confirmed order ##{order.id}"
  when :supplier_rejected then "Supplier rejected item in order ##{order.id}"
  when :retailer_confirmed then "Retailer confirmed order ##{order.id}"
  when :retailer_rejected then "Retailer cancelled order ##{order.id}"
  else "Order ##{order.id} update"
  end

  body = case action
  when :supplier_rejected, :retailer_rejected then "Reason: #{reason}" if reason
  else "Status: #{order.status}"
  end

  notification = Dscf::Core::Notification.create!(
    notifiable: order,
    recipient: recipient,
    notification_type: :general,
    title: title,
    body: body.to_s
  )
  Dscf::Core::NotificationService.deliver(notification)
end

#filter ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 25

def filter
  authorize @clazz.new, :filter?
  orders = @clazz.all

  # Apply Ransack filtering if q params present
  if params[:q].present?
    orders = orders.ransack(params[:q]).result
  end

  # Apply eager loading
  orders = orders.includes(eager_loaded_associations) if eager_loaded_associations.present?

  # Add serializer includes
  includes = serializer_includes_for_action(:index)
  options = {}
  options[:include] = includes if includes.present?

  render_success(data: orders, serializer_options: options)
end

#invoice ⇒ Object 



83
84
85
86
87
88
89
90
91
92
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 83

def invoice
  @obj = find_record
  authorize @obj, :show?
  invoice = @obj.order_invoice
  if invoice&.pdf_file&.attached?
    redirect_to rails_blob_url(invoice.pdf_file, disposition: "attachment")
  else
    render_error("orders.errors.no_invoice")
  end
end

#my_orders ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 94

def my_orders
  authorize @clazz.new, :my_orders?
  service = MyResourceService.new(current_user)
  orders = service.my_orders(params)

  options = {
    include: default_serializer_includes[:index] || [],
    meta: {resource_type: "my_orders"}
  }

  render_success("orders.success.index", data: orders, serializer_options: options)
end

#resolve_item ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 116

def resolve_item
  obj = find_record
  authorize obj, :resolve_item?

  item = obj.order_items.find(params[:order_item_id])
  # Example: for price_changed, accept optional resolved_unit_price from params
  if params[:resolved_unit_price].present?
    item.resolved_unit_price = params[:resolved_unit_price]
    item.validation_status = :validated
  end
  if params[:resolved_quantity].present?
    item.resolved_quantity = params[:resolved_quantity]
    item.validation_status = :validated
  end
  if params[:action_type] == "remove"
    item.validation_status = :validated
    item.quantity = 0 # will be cleaned or marked
  end

  item.save!
  create_notification_for_order(obj, :item_resolved)
  render_success(data: item)
end

#retailer_confirm ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 172

def retailer_confirm
  obj = find_record
  authorize obj, :confirm? # reuse existing or add specific

  return render_error(errors: "Order not ready for retailer confirmation") unless obj.retailer_can_confirm?

  if params[:confirmed] == false
    reason = params[:reason]
    obj.update!(status: :cancelled)
    obj.order_items.update_all(status: OrderItem.statuses[:cancelled])
    create_notification_for_order(obj, :retailer_rejected, reason: reason)
  else
    obj.update!(status: :confirmed)
    obj.order_items.update_all(status: OrderItem.statuses[:confirmed])
    create_notification_for_order(obj, :retailer_confirmed)
  end

  render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
end

#split ⇒ Object 



149
150
151
152
153
154
155
156
157
158
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 149

def split
  obj = find_record
  authorize obj, :split?

  return render_error(errors: "All items must be validated before splitting") unless obj.all_items_validated?

  Dscf::Marketplace::OrderSplittingService.perform_split(obj)
  create_notification_for_order(obj, :split_ready)
  render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
end

#supplier_confirm ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 160

def supplier_confirm
  obj = find_record
  authorize obj, :supplier_confirm?

  confirmed = params[:confirmed]
  reason = params[:reason]
  Dscf::Marketplace::OrderSplittingService.supplier_confirm(obj, confirmed: confirmed != false, reason: reason)

  create_notification_for_order(obj, confirmed ? :supplier_confirmed : :supplier_rejected, reason: reason)
  render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
end

#validate ⇒ Object 



107
108
109
110
111
112
113
114
 
# File 'app/controllers/dscf/marketplace/orders_controller.rb', line 107

def validate
  obj = find_record
  authorize obj, :validate?

  Dscf::Marketplace::OrderValidationService.validate(obj)
  create_notification_for_order(obj, :validation_completed)
  render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
end