Class: Dscf::Marketplace::SuppliersController

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

Instance Method Summary collapse

Methods inherited from ApplicationController

#bypass_permissions_for_demo?, #pundit_user

Instance Method Details

#approve ⇒ Object 



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

def approve
  set_object
  authorize @obj, :approve?

  reason = params[:reason]
  @obj.approve!(current_user, reason)
  create_notification(:approval, reason)

  render_success("suppliers.success.approve", data: @obj)
rescue StandardError => e
  render_error(errors: e.message, status: :unprocessable_entity)
end

#modify ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'app/controllers/dscf/marketplace/suppliers_controller.rb', line 113

def modify
  set_object
  authorize @obj, :modify?

  reason = params[:reason]
  raise ArgumentError, "Reason is required for modification request" if reason.blank?

  @obj.modify!(current_user, reason)
  create_notification(:modification, reason)

  render_success("suppliers.success.modify", data: @obj)
rescue ArgumentError => e
  render_error(errors: e.message, status: :unprocessable_entity)
rescue StandardError => e
  render_error(errors: e.message, status: :unprocessable_entity)
end

#my_suppliers ⇒ Object 



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

def my_suppliers
  authorize @clazz.new, :index?
  businesses = current_user.businesses.pluck(:id)
  suppliers = @clazz.where(business_id: businesses)

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

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

#register ⇒ Object 



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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'app/controllers/dscf/marketplace/suppliers_controller.rb', line 8

def register
  ActiveRecord::Base.transaction do
    email = params[:email].presence || "supplier_#{params[:contact_person_phone]}@temp.com"

    user = Dscf::Core::User.create!(
      email: email,
      phone: params[:contact_person_phone],
      password: params[:password],
      password_confirmation: params[:password_confirmation],
      temp_password: true
    )

    business_type = Dscf::Core::BusinessType.find_or_create_by!(name: "Supplier")

    business = Dscf::Core::Business.create!(
      name: params[:business_name],
      tin_number: params[:tin_number],
      contact_phone: params[:contact_person_phone],
      user: user,
      business_type: business_type
    )

    supplier = Dscf::Marketplace::Supplier.create!(
      name: params[:business_name],
      address: params[:location],
      contact_phone: params[:contact_person_phone],
      business_type: :retailer,
      business: business
    )

    if params[:business_license].present?
      supplier.documents.attach(params[:business_license])
    end

    if params[:additional_documents].present?
      params[:additional_documents].each do |doc|
        supplier.documents.attach(doc)
      end
    end

    Dscf::Core::Review.create!(
      reviewable: supplier,
      context: :default,
      status: :pending,
      reviewed_at: Time.current
    )

    Dscf::Core::Review.create!(
      reviewable: business,
      context: :default,
      status: :pending,
      reviewed_at: Time.current
    )

    render_success("suppliers.success.register", data: supplier, status: :created)
  end
rescue ActiveRecord::RecordInvalid => e
  render_error(errors: e.message, status: :unprocessable_entity)
rescue StandardError => e
  render_error(errors: e.message, status: :unprocessable_entity)
end

#reject ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'app/controllers/dscf/marketplace/suppliers_controller.rb', line 96

def reject
  set_object
  authorize @obj, :reject?

  reason = params[:reason]
  raise ArgumentError, "Reason is required for rejection" if reason.blank?

  @obj.reject!(current_user, reason)
  create_notification(:rejection, reason)

  render_success("suppliers.success.reject", data: @obj)
rescue ArgumentError => e
  render_error(errors: e.message, status: :unprocessable_entity)
rescue StandardError => e
  render_error(errors: e.message, status: :unprocessable_entity)
end