Class: Samanage::Api

Inherits:
Object
  • Object
show all
Includes:
HTTParty
Defined in:
lib/samanage/api.rb,
lib/samanage/api/sites.rb,
lib/samanage/api/tasks.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/vendors.rb,
lib/samanage/api/category.rb,
lib/samanage/api/comments.rb,
lib/samanage/api/problems.rb,
lib/samanage/api/releases.rb,
lib/samanage/api/contracts.rb,
lib/samanage/api/hardwares.rb,
lib/samanage/api/incidents.rb,
lib/samanage/api/requester.rb,
lib/samanage/api/solutions.rb,
lib/samanage/api/attachments.rb,
lib/samanage/api/departments.rb,
lib/samanage/api/time_tracks.rb,
lib/samanage/api/custom_forms.rb,
lib/samanage/api/other_assets.rb,
lib/samanage/api/custom_fields.rb,
lib/samanage/api/purchase_orders.rb,
lib/samanage/api/configuration_items.rb

Constant Summary collapse

PATHS = 
{
  attachment: "attachments.json",
  category: "categories.json",
  change: "changes.json",
  contract: "contracts.json",
  configuration_item: "configuration_items.json",
  custom_field: "custom_fields.json",
  custom_fields: "custom_fields.json",
  custom_form: "custom_forms.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",
  problem: "problems.json",
  purchase_order: "purchase_orders.json",
  requester: "requesters.json",
  release: "releases.json",
  site: "sites.json",
  task: "tasks.json",
  solution: "solutions.json",
  user: "users.json",
  vendor: "vendors.json"
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(token:, datacenter: nil, development_mode: false, max_retries: 3, content_type: "json", sleep_time: 5) ⇒ Api

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



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/samanage/api.rb', line 38

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

Instance Attribute Details

#admins ⇒ Object

Returns the value of attribute admins.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def admins
  @admins
end

#authorized ⇒ Object

Returns the value of attribute authorized.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def authorized
  @authorized
end

#base_url ⇒ Object

Returns the value of attribute base_url.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def base_url
  @base_url
end

#content_type ⇒ Object

Returns the value of attribute content_type.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def content_type
  @content_type
end

#custom_forms ⇒ Object

Returns the value of attribute custom_forms.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def custom_forms
  @custom_forms
end

#datacenter ⇒ Object

Returns the value of attribute datacenter.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def datacenter
  @datacenter
end

#max_retries ⇒ Object

Returns the value of attribute max_retries.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def max_retries
  @max_retries
end

#sleep_time ⇒ Object

Returns the value of attribute sleep_time.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def sleep_time
  @sleep_time
end

#token ⇒ Object

Returns the value of attribute token.



8
9
10
 
# File 'lib/samanage/api.rb', line 8

def token
  @token
end

Instance Method Details

#add_item_to_contract(id:, payload:) ⇒ Object 



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

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 



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

def add_member_to_group(email:, group_id: nil, group_name: nil)
  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 “oken against api.json”



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

def authorize
  execute(path: "api.#{content_type}")
  self.authorized = true
end

#authorized? ⇒ Boolean

Returns:

  • (Boolean) 


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

def authorized?
  authorized
end

#check_contract(options: {}) ⇒ Object

Check for contract using URL builder



42
43
44
45
 
# File 'lib/samanage/api/contracts.rb', line 42

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



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

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



42
43
44
45
 
# File 'lib/samanage/api/mobiles.rb', line 42

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

#check_user(field: "email", value:, options: {}) ⇒ Object

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



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

def check_user(field: "email", value:, options: {})
  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(options: {}) ⇒ Object Also known as: categories

Samanage categories are not paginated

  • to break into subcategories, add



13
14
15
16
 
# File 'lib/samanage/api/category.rb', line 13

def collect_categories(options: {})
  request = self.execute(http_method: "get", path: "categories.json", options: options)
  request[:data]
end

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

Returns all changes. Options:

- audit_archives: true
- layout: 'long'



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

def collect_changes(options: {})
  changes = Array.new
  total_pages = self.get_changes(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Changes page: #{page}/#{total_pages}" if options[:verbose]
    path = "changes.json?"
    request = self.execute(http_method: "get", path: path, options: options)
    request[:data].each do |change|
      if block_given?
        yield change
      end
      changes << change
    end
  end
  changes
end

#collect_configuration_items(options: {}) ⇒ Object Also known as: configuration_items

Returns all configuration_items. Options:

- audit_archives: true
- layout: 'long'



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/samanage/api/configuration_items.rb', line 16

def collect_configuration_items(options: {})
  configuration_items = Array.new
  total_pages = self.get_configuration_items(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Configuration Items page: #{page}/#{total_pages}" if options[:verbose]
    path = "configuration_items.json?"
    request = self.execute(http_method: "get", path: path, options: options)
    request[:data].each do |configuration_item|
      if block_given?
        yield configuration_item
      end
      configuration_items << configuration_item
    end
  end
  configuration_items
end

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

Get all contracts



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

def collect_contracts(options: {})
  contracts = Array.new
  total_pages = self.get_contracts(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Contracts page: #{page}/#{total_pages}" if options[:verbose]
    path = "contracts.json?"
    self.execute(path: path, options: options)[: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



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

def collect_custom_fields(options: {})
  custom_fields = Array.new
  total_pages = self.get_custom_fields(options: options)[:total_pages] ||= 2
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Custom Fields page: #{page}/#{total_pages}" if options[:verbose]
    path = "custom_fields.json?"
    self.execute(path: path, options: options)[: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



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

def collect_custom_forms(options: {})
  custom_forms = Array.new
  total_pages = self.get_custom_forms(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Custom Forms page: #{page}/#{total_pages}" if options[:verbose]
    path = "custom_forms.json?"
    self.execute(path: path, options: options)[: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 



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

def collect_departments(options: {})
  departments = Array.new
  total_pages = self.get_departments(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Departments page: #{page}/#{total_pages}" if options[:verbose]
    path = "departments.json?"
    self.execute(path: path, options: options)[:data].each do |department|
      if block_given?
        yield department
      end
      departments << department
    end
  end
  departments
end

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



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

def collect_groups(options: {})
  groups = Array.new
  total_pages = self.get_groups(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Groups page: #{page}/#{total_pages}" if options[:verbose]
    path = "groups.json?"
    self.execute(path: path, options: options)[: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



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

def collect_hardwares(options: {})
  hardwares = Array.new
  total_pages = self.get_hardwares(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Hardwares page: #{page}/#{total_pages}" if options[:verbose]
    path = "hardwares.json?"
    self.execute(path: path, options: options)[: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'



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

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

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

Get all mobiles



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

def collect_mobiles(options: {})
  mobiles = Array.new
  total_pages = self.get_mobiles(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Mobiles page: #{page}/#{total_pages}" if options[:verbose]
    path = "mobiles.json?"
    self.execute(path: path, options: options)[: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



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

def collect_other_assets(options: {})
  other_assets = Array.new
  total_pages = self.get_other_assets(options: options)[:total_pages]
  other_assets = []
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Other Assets page: #{page}/#{total_pages}" if options[:verbose]
    path = "other_assets.json?"
    self.execute(path: path, options: options)[:data].each do |other_asset|
      if block_given?
        yield other_asset
      end
      other_assets << other_asset
    end
  end
  other_assets
end

#collect_problems(options: {}) ⇒ Object Also known as: problems

Returns all problems. Options:

- audit_archives: true
- layout: 'long'



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/samanage/api/problems.rb', line 16

def collect_problems(options: {})
  problems = Array.new
  total_pages = self.get_problems(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Problems page: #{page}/#{total_pages}" if options[:verbose]
    path = "problems.json?"
    request = self.execute(http_method: "get", path: path, options: options)
    request[:data].each do |problem|
      if block_given?
        yield problem
      end
      problems << problem
    end
  end
  problems
end

#collect_purchase_orders(options: {}) ⇒ Object Also known as: purchase_orders

Returns all purchase_orders. Options:

- audit_archives: true
- layout: 'long'



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/samanage/api/purchase_orders.rb', line 16

def collect_purchase_orders(options: {})
  purchase_orders = Array.new
  total_pages = self.get_purchase_orders(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Purchase Orders page: #{page}/#{total_pages}" if options[:verbose]
    path = "purchase_orders.json?"
    request = self.execute(http_method: "get", path: path, options: options)
    request[:data].each do |purchase_order|
      if block_given?
        yield purchase_order
      end
      purchase_orders << purchase_order
    end
  end
  purchase_orders
end

#collect_releases(options: {}) ⇒ Object Also known as: releases

Returns all other assets



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

def collect_releases(options: {})
  releases = Array.new
  total_pages = self.get_releases(options: options)[:total_pages]
  releases = []
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Other Assets page: #{page}/#{total_pages}" if options[:verbose]
    path = "releases.json?"
    self.execute(path: path, options: options)[:data].each do |release|
      if block_given?
        yield release
      end
      releases << release
    end
  end
  releases
end

#collect_requesters(options: {page: 1}, requesters: [], path: ) ⇒ Object Also known as: requesters

X-Total headers are not returned on this resource



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

def collect_requesters(options: {page: 1}, requesters: [], path: PATHS[:requester])
  puts "Collecting requesters page: #{options[:page]}" if options[:verbose]
  paginated_requesters = self.execute(path: path, options: options)[:data]
  paginated_requesters.each do |requester|
    if block_given?
      yield requester
    end
    requesters << requester
  end
  if paginated_requesters.empty?
    return requesters.uniq{|r| r['id']}
  else
    collect_requesters(options: {page: options[:page] + 1}, requesters: requesters)
  end
end

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



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

def collect_sites(options: {})
  sites = Array.new
  total_pages = self.get_sites(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Sites page: #{page}/#{total_pages}" if options[:verbose]
    path = "sites.json?"
    self.execute(path: path, options: options)[:data].each do |site|
      if block_given?
        yield site
      end
      sites << site
    end
  end
  sites
end

#collect_solutions(options: {}) ⇒ Object Also known as: solutions 



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

def collect_solutions(options: {})
  solutions = Array.new
  total_pages = self.get_solutions(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Solutions page: #{page}/#{total_pages}" if options[:verbose]
    path = "solutions.json?"
    self.execute(http_method: "get", path: path, options: options)[:data].each do |solution|
      if block_given?
        yield solution
      end
      solutions << solution
    end
  end
  solutions
end

#collect_tasks(options: {}) ⇒ Object Also known as: tasks 



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

def collect_tasks(options: {})
  tasks = Array.new
  total_pages = self.get_tasks(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting tasks page: #{page}/#{total_pages}" if options[:verbose]
    path = "tasks.json?"
    self.execute(path: path, options: options)[:data].each do |task|
      if block_given?
        yield task
      end
      tasks << task
    end
  end
  tasks
end

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

Returns all users in the account



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

def collect_users(options: {})
  users = Array.new
  total_pages = self.get_users(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Users page: #{page}/#{total_pages}" if options[:verbose]
    path = "users.json?"
    self.execute(path: path, options: options)[:data].each do |user|
      if block_given?
        yield user
      end
      users << user
    end
  end
  users
end

#collect_vendors(options: {}) ⇒ Object Also known as: vendors 



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

def collect_vendors(options: {})
  vendors = Array.new
  total_pages = self.get_vendors(options: options)[:total_pages]
  1.upto(total_pages) do |page|
    options[:page] = page

    puts "Collecting Vendors page: #{page}/#{total_pages}" if options[:verbose]
    path = "vendors.json?"
    self.execute(http_method: "get", path: path, options: options)[:data].each do |vendor|
      if block_given?
        yield vendor
      end
      vendors << vendor
    end
  end
  vendors
end

#create_attachment(filepath:, attachable_type:, attachable_id:) ⇒ Object 



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

def create_attachment(filepath:, attachable_type:, attachable_id:)
  unless File.exist?(filepath)
    puts "Cannot find filepath: '#{filepath.inspect}'"
    return
  end
  req = execute(
    path: "attachments.json",
    http_method: "post",
    multipart: true,
    payload: {
      "file[attachable_type]" => attachable_type,
      "file[attachable_id]" => attachable_id,
      "file[attachment]" => File.open(filepath, "rb")
    },
    headers: {
      "Content-Type" => "multipart/form-data",
      "X-Samanage-Authorization" => "Bearer " + token
    }
  )
  req
end

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



18
19
20
 
# File 'lib/samanage/api/category.rb', line 18

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

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

Create an change given json



37
38
39
 
# File 'lib/samanage/api/changes.rb', line 37

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, options: options)
end

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

Create an configuration_item given json



37
38
39
 
# File 'lib/samanage/api/configuration_items.rb', line 37

def create_configuration_item(payload: nil, options: {})
  self.execute(path: PATHS[:configuration_item], http_method: "post", payload: payload)
end

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

Create contract given json payload



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

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

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



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

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

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



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

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



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

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



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

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

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

Create mobile given json payload



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

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



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

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

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

Create an problem given json



37
38
39
 
# File 'lib/samanage/api/problems.rb', line 37

def create_problem(payload: nil, options: {})
  self.execute(path: PATHS[:problem], http_method: "post", payload: payload)
end

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

Create an purchase_order given json



37
38
39
 
# File 'lib/samanage/api/purchase_orders.rb', line 37

def create_purchase_order(payload: nil, options: {})
  self.execute(path: PATHS[:purchase_order], http_method: "post", payload: payload)
end

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

Create an release given json



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

def create_release(payload:, options: {})
  self.execute(path: PATHS[:release], http_method: "post", payload: payload)
end

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



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

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

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



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

def create_solution(payload:, options: {})
  self.execute(path: PATHS[:solution], http_method: "post", payload: payload)
end

#create_task(incident_id:, payload:, options: {}) ⇒ Object 



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

def create_task(incident_id:, payload:, options: {})
  path = "incidents/#{incident_id}/tasks.json"
  self.execute(path: path, http_method: "post", payload: payload)
end

#create_time_track(incident_id:, payload:) ⇒ Object 



9
10
11
 
# File 'lib/samanage/api/time_tracks.rb', line 9

def create_time_track(incident_id:, payload:)
  self.execute(path: "incidents/#{incident_id}/time_tracks.json", http_method: "post", payload: payload)
end

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

Create user given JSON



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

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

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



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

def create_vendor(payload:, options: {})
  self.execute(path: PATHS[:vendor], http_method: "post", payload: payload)
end

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



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

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

#delete_change(id:) ⇒ Object 



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

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

#delete_configuration_item(id:) ⇒ Object 



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

def delete_configuration_item(id:)
  self.execute(path: "configuration_items/#{id}.json", http_method: "delete")
end

#delete_contract(id:) ⇒ Object 



58
59
60
 
# File 'lib/samanage/api/contracts.rb', line 58

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

#delete_department(id:) ⇒ Object 



31
32
33
 
# File 'lib/samanage/api/departments.rb', line 31

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

#delete_group(id:) ⇒ Object 



55
56
57
 
# File 'lib/samanage/api/groups.rb', line 55

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

#delete_hardware(id:) ⇒ Object 



60
61
62
 
# File 'lib/samanage/api/hardwares.rb', line 60

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

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



59
60
61
 
# File 'lib/samanage/api/incidents.rb', line 59

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

#delete_mobile(id:) ⇒ Object 



53
54
55
 
# File 'lib/samanage/api/mobiles.rb', line 53

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

#delete_other_asset(id:) ⇒ Object 



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

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

#delete_problem(id:) ⇒ Object 



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

def delete_problem(id:)
  self.execute(path: "problems/#{id}.json", http_method: "delete")
end

#delete_purchase_order(id:) ⇒ Object 



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

def delete_purchase_order(id:)
  self.execute(path: "purchase_orders/#{id}.json", http_method: "delete")
end

#delete_release(id:) ⇒ Object 



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

def delete_release(id:)
  self.execute(path: "releases/#{id}.json", http_method: "delete")
end

#delete_site(id:) ⇒ Object 



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

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

#delete_solution(id:) ⇒ Object 



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

def delete_solution(id:)
  self.execute(path: "solutions/#{id}.json", http_method: "delete")
end

#delete_task(incident_id:, task_id:) ⇒ Object 



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

def delete_task(incident_id:, task_id:)
  self.execute(path: "incidents/#{incident_id}/tasks/#{task_id}.json", http_method: "delete")
end

#delete_user(id:) ⇒ Object 



80
81
82
 
# File 'lib/samanage/api/users.rb', line 80

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

#delete_vendor(id:) ⇒ Object 



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

def delete_vendor(id:)
  self.execute(path: "vendors/#{id}.json", http_method: "delete")
end

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



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

def download_attachment(attachment: {}, filename: nil, path: nil)
  attachable_type = attachment["attachable_type"]
  attachable_id = attachment["attachable_id"].to_s
  filename ||= attachment["filename"]
  url = attachment["url"]

  file_path = path || File.join(Dir.pwd, attachable_type, attachable_id)
  FileUtils.mkpath(file_path) unless File.directory?(file_path)

  exact_path = File.join(file_path, filename)
  downloaded_attachment = File.open(exact_path, "wb+") do |file|
    file << URI.parse(url).read
  end
  downloaded_attachment
end

#execute(http_method: "get", path: nil, payload: nil, verbose: nil, headers: {}, options: {}, multipart: false) ⇒ Object

Calling execute without a method defaults to GET



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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/samanage/api.rb', line 66

def execute(http_method: "get", path: nil, payload: nil, verbose: nil, headers: {}, options: {}, multipart: false)
  if payload.class == Hash && content_type == "json"
    begin
      payload = payload.to_json if path != "attachments.json"
    rescue StandardError => e
      puts "Invalid JSON: #{payload.inspect}"
      raise Samanage::Error.new(error: e, response: nil, options: options)
    end
  end
  verbose = "?layout=long" unless verbose.nil?

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

  end

  response = {}
  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}: #{e}" unless path.match?("send_activation_email")
    end
    response
  when 401
    response[:data] = api_call.body
    error = response[:response]
    self.authorized = false
    raise Samanage::AuthorizationError.new(error: error, response: response, options: options)
  when 404
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::NotFound.new(error: error, response: response, options: options)
  when 422
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
  when 429
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
  else
    response[:data] = api_call.body
    error = response[:response]
    raise Samanage::InvalidRequest.new(error: error, response: response, options: options)
  end
end

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

Find change by ID



42
43
44
45
46
47
48
 
# File 'lib/samanage/api/changes.rb', line 42

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

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

Find configuration_item by ID



42
43
44
45
46
47
48
 
# File 'lib/samanage/api/configuration_items.rb', line 42

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

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

Find contract given id



36
37
38
39
 
# File 'lib/samanage/api/contracts.rb', line 36

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

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



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

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

#find_group_id_by_name(group: "", options: {}) ⇒ Object 



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

def find_group_id_by_name(group: "", options: {})
  options[:name] = group if group && !options.keys.include?(:name)

  path = "groups.json?"
  group_api = self.execute(path: path, options: options)
  # Group names are case sensitive
  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



36
37
38
39
 
# File 'lib/samanage/api/hardwares.rb', line 36

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



42
43
44
45
 
# File 'lib/samanage/api/hardwares.rb', line 42

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



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

def find_incident(id:, options: {})
  path = "incidents/#{id}.json?"
  execute(path: path, options: options)
end

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

Find mobile given id



36
37
38
39
 
# File 'lib/samanage/api/mobiles.rb', line 36

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

#find_name_from_group_id(group_id:) ⇒ Object 



19
20
21
22
23
24
25
26
 
# File 'lib/samanage/api/utils.rb', line 19

def find_name_from_group_id(group_id:)
  return if [-1, "-1", nil, ""].include?(group_id)
  begin
    self.find_group(id: group_id).to_h.dig(:data, "name")
  rescue => e
    return "[#{e.class}]: #{e.inspect} Unable to find user for group id #{group_id}"
  end
end

#find_other_asset(id:) ⇒ Object

Find other_asset by id



39
40
41
42
 
# File 'lib/samanage/api/other_assets.rb', line 39

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

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

Find problem by ID



42
43
44
45
46
47
48
 
# File 'lib/samanage/api/problems.rb', line 42

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

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

Find purchase_order by ID



42
43
44
45
46
47
48
 
# File 'lib/samanage/api/purchase_orders.rb', line 42

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

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

Find release by id



39
40
41
42
 
# File 'lib/samanage/api/releases.rb', line 39

def find_release(id:, options: {})
  path = "releases/#{id}.json"
  self.execute(path: path, options: {})
end

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



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

def find_solution(id:, options: {})
  path = "solutions/#{id}.json"
  self.execute(path: path)
end

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

Return user by ID



36
37
38
39
 
# File 'lib/samanage/api/users.rb', line 36

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

#find_user_group_id_by_email(email:) ⇒ Object

Returns nil if no matching group_id



50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/samanage/api/users.rb', line 50

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)
    group_email = group[:data]["email"].to_s.downcase
    if group[:data]["is_user"] && email.to_s.downcase == group_email
      return group_id
    end
  end
  nil
end

#find_user_id_by_email(email:) ⇒ Object

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



42
43
44
45
46
47
 
# File 'lib/samanage/api/users.rb', line 42

def find_user_id_by_email(email:)
  api_call = self.get_users(options: { email: 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



46
47
48
49
50
51
 
# File 'lib/samanage/api/custom_forms.rb', line 46

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 



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

def get_categories(path: PATHS[:category], options: {})
  path = "categories.json"
  self.execute(path: path, options: options)
end

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

Default get change path



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

def get_changes(path: PATHS[:change], options: {})
  path = "changes.json?"
  self.execute(path: path, options: options)
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_configuration_items(path: PATHS[:configuration_item], options: {}) ⇒ Object

Default get configuration_item path



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

def get_configuration_items(path: PATHS[:configuration_item], options: {})
  path = "configuration_items.json?"
  self.execute(path: path, options: options)
end

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

Get contract default path



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

def get_contracts(path: PATHS[:contract], options: {})
  path = "contracts.json?"
  self.execute(path: path, options: options)
end

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

Get custom fields default url



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

def get_custom_fields(path: PATHS[:custom_fields], options: {})
  path = "custom_fields.json?"
  self.execute(path: path, options: options)
end

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

Get custom forms path



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

def get_custom_forms(path: PATHS[:custom_forms], options: {})
  self.execute(path: path)
end

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



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

def get_departments(path: PATHS[:department], options: {})
  path = "departments.json?"
  self.execute(path: path, options: options)
end

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



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

def get_groups(path: PATHS[:group], options: {})
  path = "groups.json?"
  self.execute(path: path, options: options)
end

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

Get hardware default path



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

def get_hardwares(path: PATHS[:hardware], options: {})
  path = "hardwares.json?"
  self.execute(path: path, options: options)
end

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

Default get incident path



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

def get_incidents(path: PATHS[:incident], options: {})
  execute(path: path, options: options)
end

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

Get mobile default path



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

def get_mobiles(path: PATHS[:mobile], options: {})
  path = "mobiles.json?"
  self.execute(path: path, options: options)
end

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

Default get other_assets path



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

def get_other_assets(path: PATHS[:other_asset], options: {})
  path = "other_assets.json?"
  self.execute(path: path, options: options)
end

#get_problems(path: PATHS[:problem], options: {}) ⇒ Object

Default get problem path



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

def get_problems(path: PATHS[:problem], options: {})
  path = "problems.json?"
  self.execute(path: path, options: options)
end

#get_purchase_orders(path: PATHS[:purchase_order], options: {}) ⇒ Object

Default get purchase_order path



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

def get_purchase_orders(path: PATHS[:purchase_order], options: {})
  path = "purchase_orders.json?"
  self.execute(path: path, options: options)
end

#get_releases(path: PATHS[:release], options: {}) ⇒ Object

Default get releases path



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

def get_releases(path: PATHS[:release], options: {})
  path = "releases.json?"
  self.execute(path: path, options: options)
end

#get_requester_id(value:) ⇒ Object

Get requester from value (email)



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

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_requesters(path: PATHS[:requester], options: {}) ⇒ Object 



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

def get_requesters(path: PATHS[:requester], options: {})
  self.execute(path: path, options: options)
end

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



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

def get_sites(path: PATHS[:site], options: {})
  path = "sites.json?"
  self.execute(path: path, options: options)
end

#get_solutions(path: PATHS[:solution], options: {}) ⇒ Object 



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

def get_solutions(path: PATHS[:solution], options: {})
  path = "solutions.json?"
  self.execute(path: path, options: options)
end

#get_tasks(path: PATHS[:task], options: {}) ⇒ Object 



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

def get_tasks(path: PATHS[:task], options: {})
  path = "tasks.json?"
  self.execute(path: path, options: options)
end

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

Get users, using URL builder



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

def get_users(path: PATHS[:user], options: {})
  path = "users.json?"
  self.execute(path: path, options: options)
end

#get_vendors(path: PATHS[:vendor], options: {}) ⇒ Object 



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

def get_vendors(path: PATHS[:vendor], options: {})
  path = "vendors.json?"
  self.execute(path: path, options: options)
end

#list_admins ⇒ Object

Return all admins in the account



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

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

#organize_forms ⇒ Object

Set forms by type and map fields



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

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:



9
10
11
12
13
14
15
16
17
 
# File 'lib/samanage/api/utils.rb', line 9

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
  options = {
    send_activation_email: 1,
    add_callbacks: 1
  }
  self.execute(http_method: "put", path: "users/#{user_id}.json", options: options)
end

#set_params(options:) ⇒ Object 



167
168
169
170
 
# File 'lib/samanage/api.rb', line 167

def set_params(options:)
  options[:audit_archive] = options[:audit_archive] || options[:audit_archives] if options[:audit_archives]
  URI.encode_www_form(options.except(:verbose))
end

#time_tracks(incident_id:) ⇒ Object 



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

def time_tracks(incident_id:)
  self.execute(path: "incidents/#{incident_id}/time_tracks.json")[:data]
end

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

Update an change given id and json



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

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

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

Update an configuration_item given id and json



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

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

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

Update contract given id



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

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



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

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



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

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

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

Update mobile given id



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

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



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

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

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

Update an problem given id and json



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

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

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

Update an purchase_order given id and json



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

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

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

Update release given json and id



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

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

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



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

def update_solution(id:, payload:, options: {})
  self.execute(path: "solutions/#{id}.json", http_method: "put", payload: payload)
end

#update_time_track(incident_id:, time_track_id:, payload:) ⇒ Object 



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

def update_time_track(incident_id:, time_track_id:, payload:)
  self.execute(path: "incidents/#{incident_id}/time_tracks.json")
end

#update_user(payload:, id:) ⇒ Object

Update user by id



75
76
77
78
 
# File 'lib/samanage/api/users.rb', line 75

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

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



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

def update_vendor(id:, payload:, options: {})
  self.execute(path: "vendors/#{id}.json", http_method: "put", payload: payload)
end