Class: Api::Partner::V1::InventoriesController

Inherits:
BaseController
  • Object
show all
Includes:
ActionView::Helpers::DateHelper, ElasticAPM::SpanHelpers
Defined in:
app/controllers/api/partner/v1/inventories_controller.rb

Instance Method Summary collapse

Methods inherited from BaseController

#default_restaurant, #identity_cache_memoization, #render_unauthorize_action, #restaurants, #set_options

Methods included from LogrageCustomLogger

#append_info_to_payload

Methods included from ControllerHelpers

#check_boolean_param, #get_banners, #inventory_params, #reservation_params

Methods included from ResponseCacheConcern

#my_response_cache

Instance Method Details

#all_branches ⇒ Object 



24
25
26
27
28
29
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 24

def all_branches
  service = PartnerService::Inventories::FetchService.new(params[:type], params[:time], nil, restaurants)
  inventories_data = service.fetch_all_branches

  render json: { success: true, data: inventories_data }
end

#block ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 101

def block
  valid_params = params.require(:data).require(:attributes).permit(:start_date, :end_date,
                                                                   :start_time, :end_time, :reason, :restaurant_id)
  restaurant_id = valid_params[:restaurant_id].presence || default_restaurant.id
  restaurant_ids = restaurant_id == 'all' ? restaurants.pluck(:id) : [restaurant_id]
  @change_tracker.track_block_inventory(valid_params, restaurant_id)
  service = PartnerService::Inventories::BlockService.new(params, restaurant_ids).call
  if service.success?
    @change_tracker.notify_managers default_restaurant || Restaurant.find(restaurant_id)
    render json: { success: true, message: service.message }
  else
    render json: { success: false, message: service.message }, status: :unprocessable_entity
  end
end

#chart ⇒ Object 



94
95
96
97
98
99
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 94

def chart
  inventories = Inventory.joins(:restaurant).
    where(restaurant_id: default_restaurant.id)
  result = PartnerService::Inventories::ChartService.new(inventories, default_restaurant).call
  render json: { data: result, success: true }
end

#create ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 36

def create
  service = PartnerService::Inventories::CreateService.new(inventory_templates_param, default_restaurant)
  if default_restaurant.use_third_party_inventory?
    render json: { success: false,
                   message: "#{default_restaurant.name}:" + I18n.t('partner.tc_inventory.tc_dashboard') }
    return
  end
  result = service.execute
  if result.success?
    PartnerService::Inventories::FetchService.lock_inv_worker(default_restaurant.id)
    success(I18n.t('partner.inventories.create.success'), :ok)
  else
    error(I18n.t('partner.inventories.create.fail'), :bad_reqeust)
  end
  PartnerService::Inventories::SyncBookedSeatService.new(default_restaurant).sync_booked_seat
end

#edit_inventory ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 58

def edit_inventory
  if default_restaurant.use_third_party_inventory?
    render json: { success: false,
                   message: "#{default_restaurant.name}:" + I18n.t('partner.tc_inventory.tc_dashboard') }
  else
    service = PartnerService::Inventories::EditService.new(default_restaurant)
    result = service.call
    return render json: { success: true, data: result } if result.present?

    render json: { success: false, message: I18n.t('partner.errors.inventories.edit_inventory.wrong') }
  end
end

#history ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 164

def history
  updated_inventories = UpdatedInventory.includes(restaurant: :translations).where(restaurant_id: restaurants.ids)

  filter_params = params.fetch(:filter, {})
  updated_inventory_filter = Api::Partner::UpdatedInventoryFilter.new(updated_inventories)
  updated_inventory_filter.filter(filter_params)

  pagy, collections_updated_inventories = pagy(updated_inventory_filter.to_collections)
  json = Api::Partner::UpdatedInventorySerializer.new(collections_updated_inventories, set_options(pagy)).as_json
  render json: json, status: :ok
end

#index ⇒ Object 



12
13
14
15
16
17
18
19
20
21
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 12

def index
  service = PartnerService::Inventories::FetchService.new(params[:type], params[:time], default_restaurant)
  result = service.fetch_single_restaurant

  if result[:error]
    render_no_inventory(default_restaurant)
  else
    render json: result
  end
end

#show ⇒ Object 



32
33
34
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 32

def show
  render json: ::Api::Partner::InventorySerializer.new(@inventory).as_json
end

#undo ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
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
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 116

def undo
  inventory_type = 'dine_in'
  if default_restaurant.inventory_tablecheck?
    return error(I18n.t('partner.errors.inventories.update_inventory_detail.invalid_modify_inventory'),
                 :unprocessable_entity)
  end

  UpdatedInventory.transaction do
    start_date = valid_params[:start_date].to_date
    end_date = valid_params[:end_date].to_date
    start_time = valid_params[:start_time]
    end_time = valid_params[:end_time]
    upd_inventories = UpdatedInventory.where(restaurant_id: default_restaurant.id).
      where('DATE(end_date) >= ? AND DATE(start_date) <= ?', end_date, start_date)
    list = []
    upd_inventories.each do |ui|
      date_to = (end_date.to_s + " #{end_time}").to_datetime
      date_from = (start_date.to_s + " #{start_time}").to_datetime
      ui_start_date = (ui.start_date.to_s + " #{ui.start_time.to_formatted_s(:time)}").to_datetime
      ui_end_date = (ui.end_date.to_s + " #{ui.end_time.to_formatted_s(:time)}").to_datetime
      list << ui.id if ui_start_date <= date_from && ui_end_date >= date_to
    end
    upd_inventory = UpdatedInventory.where(id: list).first

    if upd_inventory.blank?
      return render json: { success: false, message: I18n.t('partner.inventories.undo.inv_not_found') },
                    status: :unprocessable_entity
    end

    restaurant = upd_inventory.restaurant
    if restaurant.use_third_party_inventory?
      render json: { success: false,
                     message: "#{default_restaurant.name}:" + I18n.t('partner.tc_inventory.tc_dashboard') }
      return
    else
      begin
        upd_inventory.destroy!
        # TODO: this one should update specific dates only
        InventoryV2Worker.perform_async(restaurant.id, inventory_type, false)
        render json: { success: true, message: I18n.t('partner.inventories.undo.system_recreating') }
      rescue StandardError
        render json: { success: false, message: I18n.t('partner.errors.inventories.edit_inventory.wrong') },
               status: :unprocessable_entity
      end
    end
  end
end

#update_inventory ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 71

def update_inventory
  if default_restaurant.inventory_tablecheck?
    return error(I18n.t('partner.errors.inventories.update_inventory_detail.invalid_modify_inventory'),
                 :unprocessable_entity)
  end

  service = PartnerService::Inventories::UpdateService.new(inventory_templates_param, default_restaurant)

  if default_restaurant.use_third_party_inventory?
    render json: { success: false,
                   message: "#{default_restaurant.name}:" + I18n.t('partner.tc_inventory.tc_dashboard') }
    nil
  else
    result = service.execute
    if result.success?
      PartnerService::Inventories::FetchService.lock_inv_worker(default_restaurant.id)
      success(I18n.t('partner.inventories.update_inventory.success'), :ok)
    else
      error(I18n.t('partner.inventories.update_inventory.fail'), :bad_reqeust)
    end
  end
end

#update_inventory_detail ⇒ Object 



53
54
55
56
 
# File 'app/controllers/api/partner/v1/inventories_controller.rb', line 53

def update_inventory_detail
  service = PartnerService::Inventories::DetailUpdaterService.new(current_staff, params)
  render json: service.call
end