Class: Xsys::Api

Inherits:
Object
  • Object
show all
Defined in:
lib/xsys/api.rb

Class Method Summary collapse

Class Method Details

.add_background_job_event(code, event_description) ⇒ Object 



23
24
25
26
 
# File 'lib/xsys/api.rb', line 23

def self.add_background_job_event(code, event_description)
  params = { description: event_description }
  Model::JobEvent.new(post_request("/background_jobs/#{code}/job_events", params)[:body])
end

.calculate_company_taxes(company_code, items) ⇒ Object 



224
225
226
227
228
229
230
231
 
# File 'lib/xsys/api.rb', line 224

def self.calculate_company_taxes(company_code, items)
  attrs = {
    company_code: company_code,
    items: items.to_json
  }

  Model::CompanyTaxCalculation.new(get_request('/companies/calculate_taxes', attrs)[:body])
end

.calculate_corporation_taxes(cuit, items) ⇒ Object 



243
244
245
246
247
248
249
250
 
# File 'lib/xsys/api.rb', line 243

def self.calculate_corporation_taxes(cuit, items)
  response = post_request('/corporations/taxes_calculation', {
    cuit: cuit,
    items: items.to_json
  })

  Model::CorporationTaxesCalculation.new(response[:body])
end

.cancel_stock_reserve(stock_reserve_code, user_login, cancellation_reason = nil) ⇒ Object 



188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/xsys/api.rb', line 188

def self.cancel_stock_reserve(stock_reserve_code, , cancellation_reason=nil)
  response = put_request("/stock_reserves/#{stock_reserve_code}/cancel", {
    user_login: ,
    cancellation_reason: cancellation_reason
  })

  if response[:status_code] == 200
    Model::StockReserve.new(response[:body])
  else
    false
  end
end

.configure(args = {}) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
 
# File 'lib/xsys/api.rb', line 3

def self.configure(args={})
  if args[:endpoint].present?
    @endpoint = "#{args[:endpoint]}/api"
  else
    @endpoint = "https://gestion.lhconfort.com.ar/api"
  end

  @access_token = args[:access_token]

  self
end

.create_stock_reserve(attrs = {}) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/xsys/api.rb', line 160

def self.create_stock_reserve(attrs={})
  response = post_request('/stock_reserves', attrs)

  if response[:status_code] == 200
    if response[:body] == 'null'
      false
    else
      Model::StockReserve.new(response[:body])
    end
  else
    false
  end
end

.defer_stock_reserve(stock_reserve_code, expiration_date, user_login) ⇒ Object 



201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/xsys/api.rb', line 201

def self.defer_stock_reserve(stock_reserve_code, expiration_date, )
  response = put_request("/stock_reserves/#{stock_reserve_code}/defer", {
    expiration_date: expiration_date,
    user_login: 
  })

  if response[:status_code] == 200
    Model::StockReserve.new(response[:body])
  else
    false
  end
end

.get_background_job(code) ⇒ Object 



15
16
17
 
# File 'lib/xsys/api.rb', line 15

def self.get_background_job(code)
  Model::BackgroundJob.new(get_request("/background_jobs/#{code}")[:body])
end

.get_cash_register_period(code) ⇒ Object 



257
258
259
260
261
262
263
264
265
 
# File 'lib/xsys/api.rb', line 257

def self.get_cash_register_period(code)
  response = get_request("/cash_register_periods/#{code}")

  if response[:body].blank?
    nil
  else
    Model::CashRegisterPeriod.new(response[:body])
  end
end

.get_cash_register_periods(filters = {}) ⇒ Object 



252
253
254
255
 
# File 'lib/xsys/api.rb', line 252

def self.get_cash_register_periods(filters={})
  response = get_request('/cash_register_periods', filters)
  response[:body].map { |x| Model::CashRegisterPeriod.new(x) }
end

.get_company(code) ⇒ Object 



214
215
216
217
218
219
220
221
222
 
# File 'lib/xsys/api.rb', line 214

def self.get_company(code)
  result = get_request("/companies/#{code}")[:body]

  if result == 'null'
    nil
  else
    Model::Company.new(result)
  end
end

.get_corporation(cuit) ⇒ Object 



233
234
235
236
237
238
239
240
241
 
# File 'lib/xsys/api.rb', line 233

def self.get_corporation(cuit)
  result = get_request("/corporations/#{cuit}")[:body]

  if result.blank?
    nil
  else
    Model::Corporation.new(result)
  end
end

.get_invoice_kind(code) ⇒ Object 



272
273
274
275
276
277
278
279
280
 
# File 'lib/xsys/api.rb', line 272

def self.get_invoice_kind(code)
  response = get_request("/invoice_kinds/#{code}")

  if response[:body].blank?
    nil
  else
    Model::InvoiceKind.new(response[:body])
  end
end

.get_invoice_kinds(filters = {}) ⇒ Object 



267
268
269
270
 
# File 'lib/xsys/api.rb', line 267

def self.get_invoice_kinds(filters={})
  response = get_request('/invoice_kinds', filters)
  response[:body].map { |x| Model::InvoiceKind.new(x) }
end

.get_locality(locality_code) ⇒ Object 



302
303
304
305
306
307
308
309
310
 
# File 'lib/xsys/api.rb', line 302

def self.get_locality(locality_code)
  response = get_request("/localities/#{locality_code}")

  if response[:body].blank?
    nil
  else
    Model::Locality.new(response[:body])
  end
end

.get_price_lists(filters = {}) ⇒ Object 



28
29
30
 
# File 'lib/xsys/api.rb', line 28

def self.get_price_lists(filters={})
  get_request('/price_lists')[:body].map { |r| Model::PriceList.new(r) }
end

.get_product(product_id) ⇒ Object 



51
52
53
54
55
56
57
58
59
 
# File 'lib/xsys/api.rb', line 51

def self.get_product(product_id)
  response_body = get_request("/products/#{product_id}")[:body]

  if response_body == 'null'
    nil
  else
    Model::Product.new(response_body)
  end
end

.get_product_categories(filters = {}) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/xsys/api.rb', line 78

def self.get_product_categories(filters={})
  response = get_request('/product_categories', filters)

  if response[:headers][:link]
    {
      pagination: Pagination.new(JSON.parse(response[:headers][:link])),
      results: response[:body].map { |r| Model::ProductCategory.new(r) }
    }
  else
    response[:body].map { |r| Model::ProductCategory.new(r) }
  end
end

.get_product_category(category_id) ⇒ Object 



91
92
93
 
# File 'lib/xsys/api.rb', line 91

def self.get_product_category(category_id)
  Model::ProductCategory.new(get_request("/product_categories/#{category_id}")[:body])
end

.get_product_price_lists(filters = {}) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/xsys/api.rb', line 95

def self.get_product_price_lists(filters={})
  response = get_request('/product_price_lists', filters)

  if response[:headers][:link]
    {
      pagination: Pagination.new(JSON.parse(response[:headers][:link])),
      results: response[:body].map { |r| Model::ProductPriceList.new(r) }
    }
  else
    response[:body].map { |r| Model::ProductPriceList.new(r) }
  end
end

.get_product_provider(provider_id) ⇒ Object 



74
75
76
 
# File 'lib/xsys/api.rb', line 74

def self.get_product_provider(provider_id)
  Model::ProductProvider.new(get_request("/product_providers/#{provider_id}")[:body])
end

.get_product_providers(filters = {}) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/xsys/api.rb', line 61

def self.get_product_providers(filters={})
  response = get_request('/product_providers', filters)

  if response[:headers][:link]
    {
      pagination: Pagination.new(JSON.parse(response[:headers][:link])),
      results: response[:body].map { |r| Model::ProductProvider.new(r) }
    }
  else
    response[:body].map { |r| Model::ProductProvider.new(r) }
  end
end

.get_province(province_code) ⇒ Object 



287
288
289
290
291
292
293
294
295
 
# File 'lib/xsys/api.rb', line 287

def self.get_province(province_code)
  response = get_request("/provinces/#{province_code}")

  if response[:body].blank?
    nil
  else
    Model::Province.new(response[:body])
  end
end

.get_provinces ⇒ Object 



282
283
284
285
 
# File 'lib/xsys/api.rb', line 282

def self.get_provinces
  response = get_request('/provinces')
  response[:body].map { |x| Model::Province.new(x) }
end

.get_sale(code) ⇒ Object 



138
139
140
141
142
143
144
145
146
 
# File 'lib/xsys/api.rb', line 138

def self.get_sale(code)
  response_body = get_request("/sales/#{code}")[:body]

  if response_body == 'null'
    nil
  else
    Model::Sale.new(response_body)
  end
end

.get_sellers ⇒ Object 



108
109
110
 
# File 'lib/xsys/api.rb', line 108

def self.get_sellers
  get_request('/sellers')[:body].map { |r| Model::Seller.new(r) }
end

.get_shops(kind = nil) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/xsys/api.rb', line 112

def self.get_shops(kind=nil)
  shop_kinds = [:commercial, :virtual, :physical, :stockable, :service, :with_target]

  if kind.nil?
    get_request('/shops')[:body].map { |r| Model::Shop.new(r) }
  elsif shop_kinds.include?(kind.to_sym)
    get_request("/shops/#{kind}")[:body].map { |r| Model::Shop.new(r) }
  else
    []
  end
end

.get_stock_reserve(code) ⇒ Object 



174
175
176
177
178
179
180
181
182
 
# File 'lib/xsys/api.rb', line 174

def self.get_stock_reserve(code)
  response_body = get_request("/stock_reserves/#{code}")[:body]

  if response_body == 'null'
    nil
  else
    Model::StockReserve.new(response_body)
  end
end

.mass_update_product_marketplaces(attrs = {}) ⇒ Object 



156
157
158
 
# File 'lib/xsys/api.rb', line 156

def self.mass_update_product_marketplaces(attrs={})
  post_request('/product_marketplace_listings/mass_update', attrs)[:body]    
end

.search_localities(filters = {}) ⇒ Object 



297
298
299
300
 
# File 'lib/xsys/api.rb', line 297

def self.search_localities(filters={})
  response = get_request('/localities', filters)
  response[:body].map { |x| Model::Locality.new(x) }
end

.search_product_ids(filters = {}) ⇒ Object 



45
46
47
48
49
 
# File 'lib/xsys/api.rb', line 45

def self.search_product_ids(filters={})
  response = get_request('/product_ids', filters)

  response[:body]['product_ids']
end

.search_products(filters = {}) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/xsys/api.rb', line 32

def self.search_products(filters={})
  response = get_request('/products', filters)

  if response[:headers][:link]
    {
      pagination: Pagination.new(JSON.parse(response[:headers][:link])),
      results: response[:body].map { |r| Model::Product.new(r) }
    }
  else
    response[:body].map { |r| Model::Product.new(r) }
  end
end

.search_stock_reserves(filters = {}) ⇒ Object 



184
185
186
 
# File 'lib/xsys/api.rb', line 184

def self.search_stock_reserves(filters={})
  get_request('/stock_reserves', filters)[:body].map { |x| Model::StockReserve.new(x) }
end

.update_background_job(code, params) ⇒ Object 



19
20
21
 
# File 'lib/xsys/api.rb', line 19

def self.update_background_job(code, params)
  Model::BackgroundJob.new(put_request("/background_jobs/#{code}", params)[:body])
end

.update_cash_withdrawal_items(shop_code, cash_withdrawal_items) ⇒ Object 



131
132
133
134
135
136
 
# File 'lib/xsys/api.rb', line 131

def self.update_cash_withdrawal_items(shop_code, cash_withdrawal_items)
  post_request('/cash_withdrawal_items', {
    shop_code: shop_code,
    cash_withdrawal_items: cash_withdrawal_items
  })[:body]
end

.update_cash_withdrawals(shop_code, cash_withdrawals) ⇒ Object 



124
125
126
127
128
129
 
# File 'lib/xsys/api.rb', line 124

def self.update_cash_withdrawals(shop_code, cash_withdrawals)
  post_request('/cash_withdrawals', {
    shop_code: shop_code,
    cash_withdrawals: cash_withdrawals
  })[:body]
end

.update_product(product_id, attrs = {}) ⇒ Object 



148
149
150
 
# File 'lib/xsys/api.rb', line 148

def self.update_product(product_id, attrs={})
  Model::Product.new(put_request("/products/#{product_id}", attrs)[:body])
end

.update_product_price_list(attrs = {}) ⇒ Object 



152
153
154
 
# File 'lib/xsys/api.rb', line 152

def self.update_product_price_list(attrs={})
  put_request('/product_price_lists', attrs)[:body]
end