Class: Samanage::Api

Inherits:
Object
  • Object
show all
Includes:
HTTParty
Defined in:
lib/samanage/api.rb,
lib/samanage/api/sites.rb,
lib/samanage/api/users.rb,
lib/samanage/api/utils.rb,
lib/samanage/api/groups.rb,
lib/samanage/api/changes.rb,
lib/samanage/api/mobiles.rb,
lib/samanage/api/category.rb,
lib/samanage/api/comments.rb,
lib/samanage/api/contracts.rb,
lib/samanage/api/hardwares.rb,
lib/samanage/api/incidents.rb,
lib/samanage/api/requester.rb,
lib/samanage/api/attachments.rb,
lib/samanage/api/departments.rb,
lib/samanage/api/custom_forms.rb,
lib/samanage/api/other_assets.rb,
lib/samanage/api/custom_fields.rb

Constant Summary collapse

MAX_RETRIES = 
3
PATHS = 
{
  category: 'categories.json',
  contract: 'contracts.json',
  change: 'changes.json',
  custom_fields: 'custom_fields.json',
  custom_forms: 'custom_forms.json',
  department: 'departments.json',
  group: 'groups.json',
  hardware: 'hardwares.json',
  incident: 'incidents.json',
  mobile: 'mobiles.json',
  other_asset: 'other_assets.json',
  site: 'sites.json',
  user: 'users.json',
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(token:, datacenter: nil, development_mode: false, max_retries: MAX_RETRIES) ⇒ Api

Development mode forces authorization & pre-populates admins and custom forms / fields datacenter should equal ‘eu’ or blank



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/samanage/api.rb', line 25

def initialize(token: , datacenter: nil, development_mode: false, max_retries: MAX_RETRIES)
  self.token = token
  if !datacenter.nil? && datacenter.to_s.downcase != 'eu'
    datacenter = nil
  end
  self.datacenter ||= datacenter.to_s.downcase
  self.base_url =  "https://api#{self.datacenter.to_s.downcase}.samanage.com/"
  self.content_type = 'json'
  self.admins = []
  self.max_retries = max_retries
  if development_mode
    if self.authorized? != true
      self.authorize
    end
    self.custom_forms = self.organize_forms
    self.admins = self.list_admins
  end
end

Instance Attribute Details

#admins ⇒ Object

Returns the value of attribute admins.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def admins
  @admins
end

#authorized ⇒ Object

Returns the value of attribute authorized.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def authorized
  @authorized
end

#base_url ⇒ Object

Returns the value of attribute base_url.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def base_url
  @base_url
end

#content_type ⇒ Object

Returns the value of attribute content_type.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def content_type
  @content_type
end

#custom_forms ⇒ Object

Returns the value of attribute custom_forms.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def custom_forms
  @custom_forms
end

#datacenter ⇒ Object

Returns the value of attribute datacenter.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def datacenter
  @datacenter
end

#max_retries ⇒ Object

Returns the value of attribute max_retries.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def max_retries
  @max_retries
end

#token ⇒ Object

Returns the value of attribute token.



21
22
23
 
# File 'lib/samanage/api.rb', line 21

def token
  @token
end

Instance Method Details

#add_item_to_contract(id:, payload:) ⇒ Object 



49
50
51
52
 
# File 'lib/samanage/api/contracts.rb', line 49

def add_item_to_contract(id: , payload: )
  path = "contracts/#{id}/items.json"
  self.execute(path: path, http_method: 'post', payload: payload)
end

#add_member_to_group(email:, group_id: nil, group_name: nil) ⇒ Object 



39
40
41
42
43
44
 
# File 'lib/samanage/api/groups.rb', line 39

def add_member_to_group(email: , group_id: nil, group_name: nil)
  group_id = group_id ||= self.find_group_id_by_name(group: group_name)
  user_id = self.find_user_id_by_email(email: email)
  member_path = "memberships.json?group_id=#{group_id}.json&user_ids=#{user_id}"
  self.execute(path: member_path, http_method: 'post')
end

#authorize ⇒ Object

Check token against api.json



49
50
51
52
 
# File 'lib/samanage/api.rb', line 49

def authorize
  self.execute(path: 'api.json')
  self.authorized = true
end

#authorized? ⇒ Boolean 



44
45
46
 
# File 'lib/samanage/api.rb', line 44

def authorized?
  self.authorized
end

#check_contract(options: {}) ⇒ Object

Check for contract using URL builder



38
39
40
41
 
# File 'lib/samanage/api/contracts.rb', line 38

def check_contract(options: {})
  url = Samanage::UrlBuilder.new(path: PATHS[:contract], options: options).url
  self.execute(path: url)
end

#check_hardware(options: {}) ⇒ Object

Check for hardware using URL builder



45
46
47
48
 
# File 'lib/samanage/api/hardwares.rb', line 45

def check_hardware(options: {})
  url = Samanage::UrlBuilder.new(path: PATHS[:hardware], options: options).url
  self.execute(path: url)
end

#check_mobile(options: {}) ⇒ Object

Check for mobile using URL builder



38
39
40
41
 
# File 'lib/samanage/api/mobiles.rb', line 38

def check_mobile(options: {})
  url = Samanage::UrlBuilder.new(path: PATHS[:mobile], options: options).url
  self.execute(path: url)
end

#check_user(field: 'email', value:) ⇒ Object

Check for user by field (ex: users.json?field=value)



57
58
59
60
61
62
63
 
# File 'lib/samanage/api/users.rb', line 57

def check_user(field: 'email', value: )
  if field.to_s.downcase == 'email'
    value = value.to_s.gsub("+",'%2B')
  end
  url = "users.json?#{field}=#{value}"
  self.execute(path: url)
end

#collect_categories ⇒ Object Also known as: categories

Samanage categories are not paginated

  • to break into subcategories, add



11
12
13
14
15
16
17
18
19
 
# File 'lib/samanage/api/category.rb', line 11

def collect_categories
  categories = Array.new
   self.execute(http_method: 'get', path: "categories.json")[:data].each do |category|
    if block_given?
      yield category
    end
    categories << category
   end
end

#collect_changes(options: {}) ⇒ Object Also known as: changes

Returns all changes. Options:

- audit_archives: true
- layout: 'long'



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/samanage/api/changes.rb', line 15

def collect_changes(options: {})
  changes = Array.new
  total_pages = self.get_changes[:total_pages]
  1.upto(total_pages) do |page|
  puts "Collecting changes page: #{page}/#{total_pages}" if options[:verbose]
    layout = options[:layout] == 'long' ? '&layout=long' : nil
    self.execute(http_method: 'get', path: "changes.json?page=#{page}#{layout}")[:data].each do |change|
      if block_given?
        yield change
      end
      changes << change
    end
  end
  changes
end

#collect_contracts(options: {}) ⇒ Object Also known as: contracts

Get all contracts



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/samanage/api/contracts.rb', line 11

def collect_contracts(options: {})
  contracts = Array.new
  total_pages = self.get_contracts[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting contracts page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "contracts.json?page=#{page}")[:data].each do |contract|
      if block_given?
        yield contract
      end
      contracts << contract
    end
  end
  contracts
end

#collect_custom_fields(options: {}) ⇒ Object Also known as: custom_fields

Gets all custom fields



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/samanage/api/custom_fields.rb', line 11

def collect_custom_fields(options: {})
  custom_fields = Array.new
  total_pages = self.get_custom_fields[:total_pages] ||= 2
  1.upto(total_pages) do |page|
    puts "Collecting Custom Fields page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(path: "custom_fields.json")[:data].each do |custom_field|
      if block_given?
        yield custom_field
      end
      custom_fields << custom_field 
    end
  end
  custom_fields
end

#collect_custom_forms(options: {}) ⇒ Object

Get all custom forms



10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/samanage/api/custom_forms.rb', line 10

def collect_custom_forms(options: {})
  custom_forms = Array.new
  total_pages = self.get_custom_forms[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Custom Forms page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "custom_forms.json?page=#{page}")[:data].each do |custom_form|
      if block_given?
        yield custom_form
      end
      custom_forms << custom_form
    end
  end
  custom_forms
end

#collect_departments(options: {}) ⇒ Object Also known as: departments 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/samanage/api/departments.rb', line 8

def collect_departments(options: {})
  departments = Array.new
  total_pages = self.get_departments[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Groups page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "departments.json?page=#{page}")[:data].each do |department|
      if block_given?
        yield department
      end
      departments << department
    end
  end
  departments
end

#collect_groups(options: {}) ⇒ Object Also known as: groups 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/samanage/api/groups.rb', line 8

def collect_groups(options: {})
  groups = Array.new
  total_pages = self.get_groups[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Groups page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "groups.json?page=#{page}")[:data].each do |group|
      if block_given?
        yield group
      end
      groups << group
    end
  end
  groups
end

#collect_hardwares(options: {}) ⇒ Object Also known as: hardwares

Get all hardwares



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/samanage/api/hardwares.rb', line 11

def collect_hardwares(options: {})
  hardwares = Array.new
  total_pages = self.get_hardwares[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Hardwares page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "hardwares.json?page=#{page}")[:data].each do |hardware|
      if block_given?
        yield hardware
      end
      hardwares << hardware
    end
  end
  hardwares
end

#collect_incidents(options: {}) ⇒ Object Also known as: incidents

Returns all incidents. Options:

- audit_archives: true
- layout: 'long'



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
 
# File 'lib/samanage/api/incidents.rb', line 15

def collect_incidents(options: {})
  incidents = Array.new
  total_pages = self.get_incidents[:total_pages]
  puts "Pulling Incidents with Audit Archives (this may take a while)" if options[:audit_archives] && options[:verbose]
  1.upto(total_pages) do |page|
    puts "Collecting Incidents page: #{page}/#{total_pages}" if options[:verbose]
    if options[:audit_archives]
      archives_params = 'layout=long&audit_archive=true'
      paginated_incidents = self.execute(path: "incidents.json?page=#{page}")[:data]
      paginated_incidents.map do |incident|
        archive_uri = "incidents/#{incident['id']}.json?#{archives_params}"
        incident_with_archive = self.execute(path: archive_uri)[:data]
        if block_given?
          yield incident_with_archive
        end
        incidents.push(incident_with_archive)
      end
    else
      layout = options[:layout] == 'long' ? '&layout=long' : nil
      self.execute(http_method: 'get', path: "incidents.json?page=#{page}#{layout}")[:data].each do |incident|
        if block_given?
          yield incident
        end
        incidents.push(incident)
      end
    end
  end
  incidents
end

#collect_mobiles(options: {}) ⇒ Object Also known as: mobiles

Get all mobiles



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/samanage/api/mobiles.rb', line 11

def collect_mobiles(options: {})
  mobiles = Array.new
  total_pages = self.get_mobiles[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Mobiles page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "mobiles.json?page=#{page}")[:data].each do |mobile|
      if block_given? 
        yield mobiles
      end
      mobiles << mobile
    end
  end
  mobiles
end

#collect_other_assets(options: {}) ⇒ Object Also known as: other_assets

Returns all other assets



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/samanage/api/other_assets.rb', line 11

def collect_other_assets(options: {})
  other_assets = Array.new
  total_pages = self.get_other_assets[:total_pages]
  other_assets = []
  1.upto(total_pages) do |page|
    puts "Collecting Other Assets page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "other_assets.json?page=#{page}")[:data].each do |other_asset|
      if block_given?
        yield other_asset
      end
      other_assets << other_asset
    end
  end
  other_assets
end

#collect_sites(options: {}) ⇒ Object Also known as: sites 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/samanage/api/sites.rb', line 8

def collect_sites(options: {})
  sites = Array.new
  total_pages = self.get_sites[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Sites page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "sites.json?page=#{page}")[:data].each do |site|
      if block_given?
        yield site
      end
      sites << site
    end
  end
  sites
end

#collect_users(options: {}) ⇒ Object Also known as: users

Returns all users in the account



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/samanage/api/users.rb', line 11

def collect_users(options: {})
  users = Array.new
  total_pages = self.get_users[:total_pages]
  1.upto(total_pages) do |page|
    puts "Collecting Users page: #{page}/#{total_pages}" if options[:verbose]
    self.execute(http_method: 'get', path: "users.json?page=#{page}")[:data].each do |user|
      if block_given?
        yield user
      end
      users << user
    end
  end
  users
end

#create_category(payload: nil, options: {}) ⇒ Object 



21
22
23
 
# File 'lib/samanage/api/category.rb', line 21

def create_category(payload: nil, options: {})
  self.execute(path: PATHS[:category], http_method: 'post', payload: payload)
end

#create_change(payload: nil, options: {}) ⇒ Object

Create an change given json



33
34
35
 
# File 'lib/samanage/api/changes.rb', line 33

def create_change(payload: nil, options: {})
  self.execute(path: PATHS[:change], http_method: 'post', payload: payload)
end

#create_comment(incident_id:, comment:, options: {}) ⇒ Object

Add a new comment



12
13
14
15
 
# File 'lib/samanage/api/comments.rb', line 12

def create_comment(incident_id: , comment: , options: {})
  path = "incidents/#{incident_id}/comments.json"
  self.execute(http_method: 'post', path: path, payload: comment)
end

#create_contract(payload:, options: {}) ⇒ Object

Create contract given json payload



27
28
29
 
# File 'lib/samanage/api/contracts.rb', line 27

def create_contract(payload: , options: {})
  self.execute(path: PATHS[:contract], http_method: 'post', payload: payload)
end

#create_department(payload:, options: {}) ⇒ Object 



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

def create_department(payload: , options: {})
  self.execute(path: PATHS[:department], http_method: 'post', payload: payload)

end

#create_group(payload:, options: {}) ⇒ Object 



23
24
25
 
# File 'lib/samanage/api/groups.rb', line 23

def create_group(payload: , options: {})
  self.execute(path: PATHS[:group], http_method: 'post', payload: payload)
end

#create_hardware(payload:, options: {}) ⇒ Object

Create hardware given json payload



27
28
29
 
# File 'lib/samanage/api/hardwares.rb', line 27

def create_hardware(payload: , options: {})
  self.execute(path: PATHS[:hardware], http_method: 'post', payload: payload)
end

#create_incident(payload: nil, options: {}) ⇒ Object

Create an incident given json



47
48
49
 
# File 'lib/samanage/api/incidents.rb', line 47

def create_incident(payload: nil, options: {})
  self.execute(path: PATHS[:incident], http_method: 'post', payload: payload)
end

#create_mobile(payload: nil, options: {}) ⇒ Object

Create mobile given json payload



27
28
29
 
# File 'lib/samanage/api/mobiles.rb', line 27

def create_mobile(payload: nil, options: {})
  self.execute(path: PATHS[:mobile], http_method: 'post', payload: payload)
end

#create_other_asset(payload:, options: {}) ⇒ Object

Create an other_asset given json



29
30
31
 
# File 'lib/samanage/api/other_assets.rb', line 29

def create_other_asset(payload: , options: {})
  self.execute(path: PATHS[:other_asset], http_method: 'post', payload: payload)
end

#create_site(payload:, options: {}) ⇒ Object 



23
24
25
 
# File 'lib/samanage/api/sites.rb', line 23

def create_site(payload: , options: {})
  self.execute(path: PATHS[:site], http_method: 'post', payload: payload)
end

#create_user(payload:, options: {}) ⇒ Object

Create user given JSON



27
28
29
 
# File 'lib/samanage/api/users.rb', line 27

def create_user(payload: , options: {})
  self.execute(path: PATHS[:user], http_method: 'post', payload: payload)
end

#delete_category(id:) ⇒ Object 



25
26
27
 
# File 'lib/samanage/api/category.rb', line 25

def delete_category(id: )
  self.execute(path: "categories/#{id}", http_method: 'delete')
end

#delete_change(id:) ⇒ Object 



52
53
54
 
# File 'lib/samanage/api/changes.rb', line 52

def delete_change(id: )
  self.execute(path: "changes/#{id}.json", http_method: 'delete')
end

#delete_contract(id:) ⇒ Object 



54
55
56
 
# File 'lib/samanage/api/contracts.rb', line 54

def delete_contract(id: )
  self.execute(path: "contracts/#{id}.json", http_method: 'delete')
end

#delete_department(id:) ⇒ Object 



27
28
29
 
# File 'lib/samanage/api/departments.rb', line 27

def delete_department(id: )
  self.execute(path: "departments/#{id}.json", http_method: 'delete')
end

#delete_group(id:) ⇒ Object 



46
47
48
 
# File 'lib/samanage/api/groups.rb', line 46

def delete_group(id: )
  self.execute(path: "groups/#{id}.json", http_method: 'delete')
end

#delete_hardware(id:) ⇒ Object 



56
57
58
 
# File 'lib/samanage/api/hardwares.rb', line 56

def delete_hardware(id: )
  self.execute(path: "hardwares/#{id}.json", http_method: 'delete')
end

#delete_incident(id:) ⇒ Object 



66
67
68
 
# File 'lib/samanage/api/incidents.rb', line 66

def delete_incident(id: )
  self.execute(path: "incidents/#{id}.json", http_method: 'delete')
end

#delete_mobile(id:) ⇒ Object 



49
50
51
 
# File 'lib/samanage/api/mobiles.rb', line 49

def delete_mobile(id: )
  self.execute(path: "mobiles/#{id}.json", http_method: 'delete')
end

#delete_other_asset(id:) ⇒ Object 



46
47
48
 
# File 'lib/samanage/api/other_assets.rb', line 46

def delete_other_asset(id: )
  self.execute(path: "other_assets/#{id}.json", http_method: 'delete')
end

#delete_site(id:) ⇒ Object 



27
28
29
 
# File 'lib/samanage/api/sites.rb', line 27

def delete_site(id: )
  self.execute(path: "sites/#{id}.json", http_method: 'delete')
end

#delete_user(id:) ⇒ Object 



71
72
73
 
# File 'lib/samanage/api/users.rb', line 71

def delete_user(id: )
  self.execute(path: "users/#{id}.json", http_method: 'delete')
end

#download_attachment(attachment: {}, filename: nil, path: nil) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/samanage/api/attachments.rb', line 3

def download_attachment(attachment: {}, filename: nil, path: nil)
  attachable_type = attachment['attachable_type']
  attachable_id = attachment['attachable_id'].to_s
  filename = filename || attachment['filename']
  url = attachment['url']
  
  file_path = path ?  path : File.join(Dir.pwd,attachable_type,attachable_id)
  unless File.directory?(file_path)
    FileUtils.mkpath(file_path)
  end
  
  exact_path = File.join(file_path,filename)
  downloaded_attachment = open(exact_path, "wb+") do |file|
    file << open(url).read
  end
  downloaded_attachment
end

#execute(http_method: 'get', path: nil, payload: nil, verbose: nil, headers: {}) ⇒ Object

Calling execute without a method defaults to GET



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
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
 
# File 'lib/samanage/api.rb', line 55

def execute(http_method: 'get', path: nil, payload: nil, verbose: nil, headers: {})
  if payload.class == String
    begin
      payload = JSON.parse(payload)
    rescue => e
      puts "Invalid JSON: #{payload.inspect}"
      raise Samanage::Error.new(error: e, response: nil)
    end
  end
  token = token ||= self.token
  unless verbose.nil?
    verbose = '?layout=long'
  end

  headers = headers.merge({
    'Accept' => "application/vnd.samanage.v2.0+#{self.content_type}#{verbose}",
    'Content-type'  => "application/#{self.content_type}",
    'X-Samanage-Authorization' => 'Bearer ' + self.token
  })
  @options = {
    headers: headers,
    payload: payload
  }
  full_path = self.base_url + path
  retries = 0
  begin
    case http_method.to_s.downcase
    when 'get'
      api_call = self.class.get(full_path, headers: headers)
    when 'post'
      api_call = self.class.post(full_path, query: payload, headers: headers)
    when 'put'
      api_call = self.class.put(full_path, query: payload, headers: headers)
    when 'delete'
      api_call = self.class.delete(full_path, query: payload, headers: headers)
    else
      raise Samanage::Error.new(response: {response: 'Unknown HTTP method'})
    end
  rescue Errno::ECONNREFUSED, Net::OpenTimeout, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError => e
    puts "Error:[#{e.class}] #{e} -  Retry: #{retries}/#{self.max_retries}"
    sleep 3
    retries += 1
    retry if retries < self.max_retries
    error = e
    response = e.class
    raise Samanage::InvalidRequest.new(error: error, response: response)
  end

  response = Hash.new
  response[:code] = api_call.code.to_i
  response[:json] = api_call.body
  response[:response] = api_call
  response[:headers] = api_call.headers
  response[:total_pages] = api_call.headers['X-Total-Pages'].to_i
  response[:total_pages] = 1 if response[:total_pages] == 0
  response[:total_count] = api_call.headers['X-Total-Count'].to_i

  # Error cases
  case response[:code]
  when 200..201
    begin
      response[:data] = JSON.parse(api_call.body)
    rescue JSON::ParserError => e
      response[:data] = api_call.body
      puts "** Warning **#{e.class}"
      puts e
    end
    response
  when 401
    response[:data] = api_call.body
    error = response[:response]
    self.authorized = false
    raise Samanage::AuthorizationError.new(error: error,response: response)
  when 404
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::NotFound.new(error: error, response: response)
  when 422
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::InvalidRequest.new(error: error, response: response)
  else
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::InvalidRequest.new(error: error, response: response)
  end
end

#find_change(id:, options: {}) ⇒ Object

Find change by ID



38
39
40
41
42
43
44
 
# File 'lib/samanage/api/changes.rb', line 38

def find_change(id: , options: {})
  path = "changes/#{id}.json"
  if options[:layout] == 'long'
    path += '?layout=long'
  end
  self.execute(path: path)
end

#find_contract(id:) ⇒ Object

Find contract given id



32
33
34
35
 
# File 'lib/samanage/api/contracts.rb', line 32

def find_contract(id: )
  path = "contracts/#{id}.json"
  self.execute(path: path)
end

#find_group(id:) ⇒ Object 



34
35
36
37
 
# File 'lib/samanage/api/groups.rb', line 34

def find_group(id: )
  path = "groups/#{id}.json"
  self.execute(path: path)
end

#find_group_id_by_name(group:) ⇒ Object 



27
28
29
30
31
32
 
# File 'lib/samanage/api/groups.rb', line 27

def find_group_id_by_name(group: )
  group_api = self.execute(path: "groups.json?name=#{group}")
  if !group_api[:data].empty? && group == group_api[:data].first['name']
    return group_api[:data].first['id']
  end
end

#find_hardware(id:) ⇒ Object

Find hardware given id



32
33
34
35
 
# File 'lib/samanage/api/hardwares.rb', line 32

def find_hardware(id: )
  path = "hardwares/#{id}.json"
  self.execute(path: path)
end

#find_hardwares_by_serial(serial_number:) ⇒ Object

Find hardware given a serial number



38
39
40
41
 
# File 'lib/samanage/api/hardwares.rb', line 38

def find_hardwares_by_serial(serial_number: )
  path = "hardwares.json?serial_number[]=#{serial_number}"
  self.execute(path: path)
end

#find_incident(id:, options: {}) ⇒ Object

Find incident by ID



52
53
54
55
56
57
58
 
# File 'lib/samanage/api/incidents.rb', line 52

def find_incident(id: , options: {})
  path = "incidents/#{id}.json"
  if options[:layout] == 'long'
    path += '?layout=long'
  end
  self.execute(path: path)
end

#find_mobile(id: nil) ⇒ Object

Find mobile given id



32
33
34
35
 
# File 'lib/samanage/api/mobiles.rb', line 32

def find_mobile(id: nil)
  path = "mobiles/#{id}.json"
  self.execute(path: path)
end

#find_other_asset(id:) ⇒ Object

Find other_asset by id



35
36
37
38
 
# File 'lib/samanage/api/other_assets.rb', line 35

def find_other_asset(id: )
  path = "other_assets/#{id}.json"
  self.execute(path: path)
end

#find_user(id:) ⇒ Object

Return user by ID



32
33
34
35
 
# File 'lib/samanage/api/users.rb', line 32

def find_user(id: )
  path = "users/#{id}.json"
  self.execute(path: path)
end

#find_user_group_id_by_email(email:) ⇒ Object

Returns nil if no matching group_id



44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/samanage/api/users.rb', line 44

def find_user_group_id_by_email(email: )
  user = self.check_user(value: email)
  group_ids = user[:data].select{|u| u['email'].to_s.downcase == email.to_s.downcase}.first.to_h['group_ids'].to_a
  group_ids.each do |group_id|
    group = self.find_group(id: group_id)
    if group[:data]['is_user'] && email == group[:data]['email']
      return group_id
    end
  end
  return nil
end

#find_user_id_by_email(email:) ⇒ Object

Email is unique so compare first for exact match only. Returns nil or the id



38
39
40
41
 
# File 'lib/samanage/api/users.rb', line 38

def find_user_id_by_email(email: )
  api_call = self.check_user(value: email)
  api_call[:data].select{|u| u['email'].to_s.downcase == email.to_s.downcase}.first.to_h['id']
end

#form_for(object_type: nil) ⇒ Object

Get form for a specific object type



40
41
42
43
44
45
 
# File 'lib/samanage/api/custom_forms.rb', line 40

def form_for(object_type: nil)
  if self.custom_forms == nil
    self.custom_forms = self.organize_forms
  end
  self.custom_forms[object_type]
end

#get_categories(path: PATHS[:category], options: {}) ⇒ Object 



3
4
5
6
 
# File 'lib/samanage/api/category.rb', line 3

def get_categories(path: PATHS[:category], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_changes(path: PATHS[:change], options: {}) ⇒ Object

Default get change path



5
6
7
8
 
# File 'lib/samanage/api/changes.rb', line 5

def get_changes(path: PATHS[:change], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_comments(incident_id:) ⇒ Object Also known as: comments

Find comments given incident_id



6
7
8
9
 
# File 'lib/samanage/api/comments.rb', line 6

def get_comments(incident_id: )
  path = "incidents/#{incident_id}/comments.json"
  self.execute(path: path)
end

#get_contracts(path: PATHS[:contract], options: {}) ⇒ Object

Get contract default path



5
6
7
8
 
# File 'lib/samanage/api/contracts.rb', line 5

def get_contracts(path: PATHS[:contract], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_custom_fields(path: PATHS[:custom_fields], options: {}) ⇒ Object

Get custom fields default url



5
6
7
8
 
# File 'lib/samanage/api/custom_fields.rb', line 5

def get_custom_fields(path: PATHS[:custom_fields], options:{})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_custom_forms(path: PATHS[:custom_forms], options: {}) ⇒ Object

Get custom forms path



4
5
6
7
 
# File 'lib/samanage/api/custom_forms.rb', line 4

def get_custom_forms(path: PATHS[:custom_forms], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_departments(path: PATHS[:department], options: {}) ⇒ Object 



3
4
5
6
 
# File 'lib/samanage/api/departments.rb', line 3

def get_departments(path: PATHS[:department], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_groups(path: PATHS[:group], options: {}) ⇒ Object 



3
4
5
6
 
# File 'lib/samanage/api/groups.rb', line 3

def get_groups(path: PATHS[:group], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_hardwares(path: PATHS[:hardware], options: {}) ⇒ Object

Get hardware default path



5
6
7
8
 
# File 'lib/samanage/api/hardwares.rb', line 5

def get_hardwares(path: PATHS[:hardware], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_incidents(path: PATHS[:incident], options: {}) ⇒ Object

Default get incident path



5
6
7
8
 
# File 'lib/samanage/api/incidents.rb', line 5

def get_incidents(path: PATHS[:incident], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_mobiles(path: PATHS[:mobile], options: {}) ⇒ Object

Get mobile default path



5
6
7
8
 
# File 'lib/samanage/api/mobiles.rb', line 5

def get_mobiles(path: PATHS[:mobile], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_other_assets(path: PATHS[:other_asset], options: {}) ⇒ Object

Default get other_assets path



5
6
7
8
 
# File 'lib/samanage/api/other_assets.rb', line 5

def get_other_assets(path: PATHS[:other_asset], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_requester_id(value:) ⇒ Object

Get requester from value (email)



4
5
6
7
 
# File 'lib/samanage/api/requester.rb', line 4

def get_requester_id(value: )
  api_call = self.execute(path: "requesters.json?name=#{value}")
  api_call[:data].size == 1 ? api_call[:data][0] : nil
end

#get_sites(path: PATHS[:site], options: {}) ⇒ Object 



3
4
5
6
 
# File 'lib/samanage/api/sites.rb', line 3

def get_sites(path: PATHS[:site], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#get_users(path: PATHS[:user], options: {}) ⇒ Object

Get users, using URL builder



5
6
7
8
 
# File 'lib/samanage/api/users.rb', line 5

def get_users(path: PATHS[:user], options: {})
  url = Samanage::UrlBuilder.new(path: path, options: options).url
  self.execute(path: url)
end

#list_admins ⇒ Object

Return all admins in the account



145
146
147
148
149
150
 
# File 'lib/samanage/api.rb', line 145

def list_admins
  admin_role_id = self.execute(path: 'roles.json')[:data].select{|role| role['name'] == 'Administrator'}.first['id']
  self.admins.push(
    self.execute(path: "users.json?role=#{admin_role_id}")[:data].map{|u| u['email']}
  ).flatten
end

#organize_forms ⇒ Object

Set forms by type and map fields



26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/samanage/api/custom_forms.rb', line 26

def organize_forms
  custom_forms = self.collect_custom_forms
  custom_forms.map{|form| form.delete_if{|k, v| v.nil?}}
  custom_forms.map{|form| form['custom_form_fields'].map{|fields| fields.delete_if{|k, v| v == false}}}
  custom_forms.map{|form| form['custom_form_fields'].map{|fields| fields['custom_field'].delete_if{|k, v| !v}}}
  custom_forms.group_by{|k|
    k['module']}.each_pair{|forms_name, forms|
      forms.each{|form|
        form['custom_form_fields'].group_by{|f| f['name'] }
      }
    }
end

#send_activation_email(email:) ⇒ Object

Raises:



5
6
7
8
9
 
# File 'lib/samanage/api/utils.rb', line 5

def send_activation_email(email: )
  user_id = self.find_user_id_by_email(email: email)
  raise Samanage::Error.new(error: 'Invalid Email', response: {}) unless user_id
  self.execute(http_method: 'put', path: "users/#{user_id}.json?send_activation_email=1&add_callbacks=1")
end

#update_change(payload:, id:, options: {}) ⇒ Object

Update an change given id and json



47
48
49
50
 
# File 'lib/samanage/api/changes.rb', line 47

def update_change(payload: , id: , options: {})
  path = "changes/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_contract(payload:, id:, options: {}) ⇒ Object

Update contract given id



44
45
46
47
 
# File 'lib/samanage/api/contracts.rb', line 44

def update_contract(payload: , id: , options: {})
  path = "contracts/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_hardware(payload:, id:, options: {}) ⇒ Object

Update hardware given id



51
52
53
54
 
# File 'lib/samanage/api/hardwares.rb', line 51

def update_hardware(payload: , id: , options: {})
  path = "hardwares/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_incident(payload:, id:, options: {}) ⇒ Object

Update an incident given id and json



61
62
63
64
 
# File 'lib/samanage/api/incidents.rb', line 61

def update_incident(payload: , id: , options: {})
  path = "incidents/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_mobile(payload:, id:, options: {}) ⇒ Object

Update mobile given id



44
45
46
47
 
# File 'lib/samanage/api/mobiles.rb', line 44

def update_mobile(payload: , id: , options: {})
  path = "mobiles/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_other_asset(payload:, id:, options: {}) ⇒ Object

Update other_asset given json and id



41
42
43
44
 
# File 'lib/samanage/api/other_assets.rb', line 41

def update_other_asset(payload: , id: , options: {})
  path = "other_assets/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end

#update_user(payload:, id:) ⇒ Object

Update user by id



66
67
68
69
 
# File 'lib/samanage/api/users.rb', line 66

def update_user(payload: , id: )
  path = "users/#{id}.json"
  self.execute(path: path, http_method: 'put', payload: payload)
end