Class: StarkInfra::IssuingRule

Inherits:
StarkCore::Utils::Resource
  • Object
show all
Defined in:
lib/issuing_rule/issuing_rule.rb

Overview

# IssuingRule object

The IssuingRule object displays the spending rules of IssuingCards and IssuingHolders created in your Workspace.

## Parameters (required):

  • name [string]: rule name. ex: ‘Travel’ or ‘Food’

  • amount [integer]: maximum amount that can be spent in the informed interval. ex: 200000 (= R$ 2000.00)

## Parameters (optional):

  • id [string, default nil]: unique id returned when an IssuingRule is created, used to update a specific IssuingRule. ex: ‘5656565656565656’

  • interval [string, default ‘lifetime’]: interval after which the rule amount counter will be reset to 0. ex: ‘instant’, ‘day’, ‘week’, ‘month’, ‘year’ or ‘lifetime’

  • currency_code [string, default ‘BRL’]: code of the currency that the rule amount refers to. ex: ‘BRL’ or ‘USD’

  • categories [list of MerchantCategories, default nil]: merchant categories accepted by the rule. ex: [MerchantCategory(code=‘fastFoodRestaurants’)]

  • countries [list of MerchantCountries, default nil]: countries accepted by the rule. ex: [MerchantCountry(code=‘BRA’)]

  • methods [list of CardMethods, default nil]: card purchase methods accepted by the rule. ex: [CardMethod(code=‘magstripe’)]

## Attributes (expanded return-only):

  • counter_amount [integer]: current rule spent amount. ex: 1000

  • currency_symbol [string]: currency symbol. ex: ‘R$’

  • currency_name [string]: currency name. ex: ‘Brazilian Real’

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name:, amount:, id: nil, interval: nil, currency_code: nil, categories: nil, countries: nil, methods: nil, counter_amount: nil, currency_symbol: nil, currency_name: nil) ⇒ IssuingRule

Returns a new instance of IssuingRule.



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/issuing_rule/issuing_rule.rb', line 30

def initialize(
  name:, amount:, id: nil, interval: nil, currency_code: nil, categories: nil, countries: nil, methods: nil,
  counter_amount: nil, currency_symbol: nil, currency_name: nil
)
  super(id)
  @name = name
  @amount = amount
  @interval = interval
  @currency_code = currency_code
  @categories = IssuingRule.parse_categories(categories)
  @countries = IssuingRule.parse_categories(countries)
  @methods = IssuingRule.parse_categories(methods)
  @counter_amount = counter_amount
  @currency_symbol = currency_symbol
  @currency_name = currency_name
end

Instance Attribute Details

#amount ⇒ Object (readonly)

Returns the value of attribute amount.



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

def amount
  @amount
end

#categories ⇒ Object (readonly)

Returns the value of attribute categories.



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

def categories
  @categories
end

#counter_amount ⇒ Object (readonly)

Returns the value of attribute counter_amount.



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

def counter_amount
  @counter_amount
end

#countries ⇒ Object (readonly)

Returns the value of attribute countries.



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

def countries
  @countries
end

#currency_code ⇒ Object (readonly)

Returns the value of attribute currency_code.



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

def currency_code
  @currency_code
end

#currency_name ⇒ Object (readonly)

Returns the value of attribute currency_name.



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

def currency_name
  @currency_name
end

#currency_symbol ⇒ Object (readonly)

Returns the value of attribute currency_symbol.



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

def currency_symbol
  @currency_symbol
end

#interval ⇒ Object (readonly)

Returns the value of attribute interval.



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

def interval
  @interval
end

#methods ⇒ Object (readonly)

Returns the value of attribute methods.



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

def methods
  @methods
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



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

def name
  @name
end

Class Method Details

.parse_categories(categories) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/issuing_rule/issuing_rule.rb', line 47

def self.parse_categories(categories)
  resource_maker = StarkInfra::MerchantCategory.resource[:resource_maker]
  return categories if categories.nil?

  parsed_categories = []
  categories.each do |category|
    unless category.is_a? MerchantCategory
      category = StarkCore::Utils::API.from_api_json(resource_maker, category)
    end
    parsed_categories << category
  end
  parsed_categories
end

.parse_countries(countries) ⇒ Object 



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

def self.parse_countries(countries)
  resource_maker = StarkInfra::MerchantCountry.resource[:resource_maker]
  return countries if countries.nil?

  parsed_countries = []
  countries.each do |country|
    unless country.is_a? MerchantCountry
      country = StarkCore::Utils::API.from_api_json(resource_maker, country)
    end
    parsed_countries << country
  end
  parsed_countries
end

.parse_methods(methods) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/issuing_rule/issuing_rule.rb', line 75

def self.parse_methods(methods)
  resource_maker = StarkInfra::CardMethod.resource[:resource_maker]
  return methods if methods.nil?

  parsed_methods = []
  methods.each do |method|
    unless method.is_a? CardMethod
      method = StarkCore::Utils::API.from_api_json(resource_maker, method)
    end
    parsed_methods << method
  end
  parsed_methods
end

.parse_rules(rules) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/issuing_rule/issuing_rule.rb', line 89

def self.parse_rules(rules)
  rule_maker = StarkInfra::IssuingRule.resource[:resource_maker]
  return rules if rules.nil?

  parsed_rules = []
  rules.each do |rule|
    unless rule.is_a? IssuingRule
      rule = StarkCore::Utils::API.from_api_json(rule_maker, rule)
    end
    parsed_rules << rule
  end
  parsed_rules
end

.resource ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/issuing_rule/issuing_rule.rb', line 103

def self.resource
  {
    resource_name: 'IssuingRule',
    resource_maker: proc { |json|
      IssuingRule.new(
        name: json['name'],
        amount: json['amount'],
        interval: json['interval'],
        currency_code: json['currency_code'],
        categories: json['categories'],
        countries: json['countries'],
        methods: json['methods'],
        counter_amount: json['counter_amount'],
        currency_symbol: json['currency_symbol'],
        currency_name: json['currency_name']
      )
    }
  }
end