lex-pagerduty 0.2.1

data/lib/legion/extensions/pagerduty/runners/incidents.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Incidents
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_incidents(statuses: [], service_ids: [], urgencies: [], per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params['statuses[]'] = statuses unless statuses.empty?
+            params['service_ids[]'] = service_ids unless service_ids.empty?
+            params['urgencies[]'] = urgencies unless urgencies.empty?
+            response = connection(**).get('/incidents', params)
+            { result: response.body }
+          end
+
+          def get_incident(id:, **)
+            response = connection(**).get("/incidents/#{id}")
+            { result: response.body }
+          end
+
+          def create_incident(title:, service_id:, type: 'incident', urgency: nil, body: nil, escalation_policy_id: nil, **)
+            payload = { incident: { type: type, title: title, service: { id: service_id, type: 'service_reference' } } }
+            payload[:incident][:urgency] = urgency if urgency
+            payload[:incident][:body] = { type: 'incident_body', details: body } if body
+            payload[:incident][:escalation_policy] = { id: escalation_policy_id, type: 'escalation_policy_reference' } if escalation_policy_id
+            response = connection(**).post('/incidents', payload)
+            { result: response.body }
+          end
+
+          def update_incident(id:, from:, status: nil, title: nil, urgency: nil, escalation_policy_id: nil, **)
+            payload = { incident: { type: 'incident_reference' } }
+            payload[:incident][:status] = status if status
+            payload[:incident][:title] = title if title
+            payload[:incident][:urgency] = urgency if urgency
+            payload[:incident][:escalation_policy] = { id: escalation_policy_id, type: 'escalation_policy_reference' } if escalation_policy_id
+            conn = connection(**)
+            conn.headers['From'] = from
+            response = conn.put("/incidents/#{id}", payload)
+            { result: response.body }
+          end
+
+          def merge_incidents(id:, from:, source_incident_ids:, **)
+            source = source_incident_ids.map { |sid| { id: sid, type: 'incident_reference' } }
+            conn = connection(**)
+            conn.headers['From'] = from
+            response = conn.put("/incidents/#{id}/merge", { source_incidents: source })
+            { result: response.body }
+          end
+
+          def snooze_incident(id:, from:, duration:, **)
+            conn = connection(**)
+            conn.headers['From'] = from
+            response = conn.post("/incidents/#{id}/snooze", { duration: duration })
+            { result: response.body }
+          end
+
+          def list_incident_notes(id:, **)
+            response = connection(**).get("/incidents/#{id}/notes")
+            { result: response.body }
+          end
+
+          def create_incident_note(id:, from:, content:, **)
+            conn = connection(**)
+            conn.headers['From'] = from
+            response = conn.post("/incidents/#{id}/notes", { note: { content: content } })
+            { result: response.body }
+          end
+
+          def list_incident_alerts(id:, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            response = connection(**).get("/incidents/#{id}/alerts", params)
+            { result: response.body }
+          end
+
+          def get_incident_alert(incident_id:, alert_id:, **)
+            response = connection(**).get("/incidents/#{incident_id}/alerts/#{alert_id}")
+            { result: response.body }
+          end
+
+          def update_incident_alert(incident_id:, alert_id:, from:, status:, **)
+            conn = connection(**)
+            conn.headers['From'] = from
+            response = conn.put("/incidents/#{incident_id}/alerts/#{alert_id}", { alert: { type: 'alert', status: status } })
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/log_entries.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module LogEntries
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_log_entries(since_time: nil, until_time: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:since] = since_time if since_time
+            params[:until] = until_time if until_time
+            response = connection(**).get('/log_entries', params)
+            { result: response.body }
+          end
+
+          def get_log_entry(id:, **)
+            response = connection(**).get("/log_entries/#{id}")
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/maintenance_windows.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module MaintenanceWindows
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_maintenance_windows(service_ids: [], query: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params['service_ids[]'] = service_ids unless service_ids.empty?
+            params[:query] = query if query
+            response = connection(**).get('/maintenance_windows', params)
+            { result: response.body }
+          end
+
+          def get_maintenance_window(id:, **)
+            response = connection(**).get("/maintenance_windows/#{id}")
+            { result: response.body }
+          end
+
+          def create_maintenance_window(start_time:, end_time:, service_ids:, description: nil, **)
+            services = service_ids.map { |sid| { id: sid, type: 'service_reference' } }
+            payload = {
+              maintenance_window: {
+                type:       'maintenance_window',
+                start_time: start_time,
+                end_time:   end_time,
+                services:   services
+              }
+            }
+            payload[:maintenance_window][:description] = description if description
+            response = connection(**).post('/maintenance_windows', payload)
+            { result: response.body }
+          end
+
+          def update_maintenance_window(id:, **opts)
+            payload = opts.slice(:start_time, :end_time, :description)
+            payload[:services] = opts[:service_ids].map { |sid| { id: sid, type: 'service_reference' } } if opts[:service_ids]
+            response = connection(**opts).put("/maintenance_windows/#{id}",
+                                              { maintenance_window: { type: 'maintenance_window', **payload } })
+            { result: response.body }
+          end
+
+          def delete_maintenance_window(id:, **)
+            response = connection(**).delete("/maintenance_windows/#{id}")
+            { result: response.status == 204 }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/notifications.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Notifications
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_notifications(since_time:, until_time:, filter: nil, per_page: 25, page: 0, **)
+            params = { since: since_time, until: until_time, limit: per_page, offset: page * per_page }
+            params[:filter] = filter if filter
+            response = connection(**).get('/notifications', params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/on_calls.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module OnCalls
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_on_calls(schedule_ids: [], escalation_policy_ids: [], since_time: nil, until_time: nil,
+                            per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params['schedule_ids[]'] = schedule_ids unless schedule_ids.empty?
+            params['escalation_policy_ids[]'] = escalation_policy_ids unless escalation_policy_ids.empty?
+            params[:since] = since_time if since_time
+            params[:until] = until_time if until_time
+            response = connection(**).get('/oncalls', params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/priorities.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Priorities
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_priorities(per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            response = connection(**).get('/priorities', params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/schedules.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Schedules
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_schedules(query: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:query] = query if query
+            response = connection(**).get('/schedules', params)
+            { result: response.body }
+          end
+
+          def get_schedule(id:, since_time: nil, until_time: nil, **)
+            params = {}
+            params[:since] = since_time if since_time
+            params[:until] = until_time if until_time
+            response = connection(**).get("/schedules/#{id}", params)
+            { result: response.body }
+          end
+
+          def create_schedule(schedule:, **)
+            response = connection(**).post('/schedules', { schedule: schedule })
+            { result: response.body }
+          end
+
+          def update_schedule(id:, schedule:, **)
+            response = connection(**).put("/schedules/#{id}", { schedule: schedule })
+            { result: response.body }
+          end
+
+          def delete_schedule(id:, **)
+            response = connection(**).delete("/schedules/#{id}")
+            { result: response.status == 204 }
+          end
+
+          def list_schedule_overrides(id:, since_time:, until_time:, **)
+            response = connection(**).get("/schedules/#{id}/overrides", since: since_time, until: until_time)
+            { result: response.body }
+          end
+
+          def create_schedule_override(id:, overrides:, **)
+            response = connection(**).post("/schedules/#{id}/overrides", { overrides: overrides })
+            { result: response.body }
+          end
+
+          def delete_schedule_override(schedule_id:, override_id:, **)
+            response = connection(**).delete("/schedules/#{schedule_id}/overrides/#{override_id}")
+            { result: response.status == 204 }
+          end
+
+          def list_on_call_users(id:, since_time: nil, until_time: nil, **)
+            params = {}
+            params[:since] = since_time if since_time
+            params[:until] = until_time if until_time
+            response = connection(**).get("/schedules/#{id}/users", params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/services.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Services
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_services(per_page: 25, page: 0, query: nil, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:query] = query if query
+            response = connection(**).get('/services', params)
+            { result: response.body }
+          end
+
+          def get_service(id:, **)
+            response = connection(**).get("/services/#{id}")
+            { result: response.body }
+          end
+
+          def create_service(name:, escalation_policy_id:, description: nil, auto_resolve_timeout: nil,
+                             acknowledgement_timeout: nil, **)
+            payload = {
+              service: {
+                type:              'service',
+                name:              name,
+                escalation_policy: { id: escalation_policy_id, type: 'escalation_policy_reference' }
+              }
+            }
+            payload[:service][:description] = description if description
+            payload[:service][:auto_resolve_timeout] = auto_resolve_timeout if auto_resolve_timeout
+            payload[:service][:acknowledgement_timeout] = acknowledgement_timeout if acknowledgement_timeout
+            response = connection(**).post('/services', payload)
+            { result: response.body }
+          end
+
+          def update_service(id:, **opts)
+            payload = opts.slice(:name, :description, :auto_resolve_timeout, :acknowledgement_timeout, :status)
+            response = connection(**opts).put("/services/#{id}", { service: { type: 'service', **payload } })
+            { result: response.body }
+          end
+
+          def delete_service(id:, **)
+            response = connection(**).delete("/services/#{id}")
+            { result: response.status == 204 }
+          end
+
+          def list_integrations(service_id:, **)
+            response = connection(**).get("/services/#{service_id}/integrations")
+            { result: response.body }
+          end
+
+          def create_integration(service_id:, type: 'generic_events_api_inbound_integration', name: nil, vendor_id: nil, **)
+            payload = { integration: { type: type } }
+            payload[:integration][:name] = name if name
+            payload[:integration][:vendor] = { id: vendor_id, type: 'vendor_reference' } if vendor_id
+            response = connection(**).post("/services/#{service_id}/integrations", payload)
+            { result: response.body }
+          end
+
+          def get_integration(service_id:, integration_id:, **)
+            response = connection(**).get("/services/#{service_id}/integrations/#{integration_id}")
+            { result: response.body }
+          end
+
+          def update_integration(service_id:, integration_id:, **opts)
+            payload = opts.slice(:name, :type)
+            response = connection(**opts).put("/services/#{service_id}/integrations/#{integration_id}",
+                                              { integration: { type: 'generic_events_api_inbound_integration', **payload } })
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/tags.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Tags
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_tags(query: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:query] = query if query
+            response = connection(**).get('/tags', params)
+            { result: response.body }
+          end
+
+          def get_tag(id:, **)
+            response = connection(**).get("/tags/#{id}")
+            { result: response.body }
+          end
+
+          def create_tag(label:, **)
+            response = connection(**).post('/tags', { tag: { type: 'tag', label: label } })
+            { result: response.body }
+          end
+
+          def delete_tag(id:, **)
+            response = connection(**).delete("/tags/#{id}")
+            { result: response.status == 204 }
+          end
+
+          def list_entity_tags(entity_type:, entity_id:, **)
+            response = connection(**).get("/#{entity_type}/#{entity_id}/tags")
+            { result: response.body }
+          end
+
+          def assign_tags(entity_type:, entity_id:, tags:, **)
+            add = tags.map { |t| t.is_a?(Hash) ? t : { type: 'tag_reference', id: t } }
+            response = connection(**).post("/#{entity_type}/#{entity_id}/change_tags", { add: add, remove: [] })
+            { result: response.status == 200 }
+          end
+
+          def remove_tags(entity_type:, entity_id:, tags:, **)
+            remove = tags.map { |t| t.is_a?(Hash) ? t : { type: 'tag_reference', id: t } }
+            response = connection(**).post("/#{entity_type}/#{entity_id}/change_tags", { add: [], remove: remove })
+            { result: response.status == 200 }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/teams.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Teams
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_teams(query: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:query] = query if query
+            response = connection(**).get('/teams', params)
+            { result: response.body }
+          end
+
+          def get_team(id:, **)
+            response = connection(**).get("/teams/#{id}")
+            { result: response.body }
+          end
+
+          def create_team(name:, description: nil, **)
+            payload = { team: { type: 'team', name: name } }
+            payload[:team][:description] = description if description
+            response = connection(**).post('/teams', payload)
+            { result: response.body }
+          end
+
+          def update_team(id:, **opts)
+            payload = opts.slice(:name, :description)
+            response = connection(**opts).put("/teams/#{id}", { team: { type: 'team', **payload } })
+            { result: response.body }
+          end
+
+          def delete_team(id:, **)
+            response = connection(**).delete("/teams/#{id}")
+            { result: response.status == 204 }
+          end
+
+          def add_member(team_id:, user_id:, role: 'member', **)
+            response = connection(**).put("/teams/#{team_id}/users/#{user_id}", { role: role })
+            { result: response.status == 204 }
+          end
+
+          def remove_member(team_id:, user_id:, **)
+            response = connection(**).delete("/teams/#{team_id}/users/#{user_id}")
+            { result: response.status == 204 }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/users.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Users
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_users(query: nil, per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            params[:query] = query if query
+            response = connection(**).get('/users', params)
+            { result: response.body }
+          end
+
+          def get_user(id:, **)
+            response = connection(**).get("/users/#{id}")
+            { result: response.body }
+          end
+
+          def create_user(name:, email:, role: 'user', description: nil, **)
+            payload = { user: { type: 'user', name: name, email: email, role: role } }
+            payload[:user][:description] = description if description
+            response = connection(**).post('/users', payload)
+            { result: response.body }
+          end
+
+          def update_user(id:, **opts)
+            payload = opts.slice(:name, :email, :role, :description)
+            response = connection(**opts).put("/users/#{id}", { user: { type: 'user', **payload } })
+            { result: response.body }
+          end
+
+          def delete_user(id:, **)
+            response = connection(**).delete("/users/#{id}")
+            { result: response.status == 204 }
+          end
+
+          def list_contact_methods(user_id:, **)
+            response = connection(**).get("/users/#{user_id}/contact_methods")
+            { result: response.body }
+          end
+
+          def create_contact_method(user_id:, type:, label:, address:, country_code: nil, **)
+            payload = { contact_method: { type: type, label: label, address: address } }
+            payload[:contact_method][:country_code] = country_code.to_i if country_code
+            response = connection(**).post("/users/#{user_id}/contact_methods", payload)
+            { result: response.body }
+          end
+
+          def list_notification_rules(user_id:, **)
+            response = connection(**).get("/users/#{user_id}/notification_rules")
+            { result: response.body }
+          end
+
+          def create_notification_rule(user_id:, start_delay_in_minutes:, contact_method_id:, type: 'assignment_notification_rule', urgency: 'high', **)
+            payload = {
+              notification_rule: {
+                type:                   type,
+                start_delay_in_minutes: start_delay_in_minutes,
+                contact_method:         { id: contact_method_id, type: 'contact_method_reference' },
+                urgency:                urgency
+              }
+            }
+            response = connection(**).post("/users/#{user_id}/notification_rules", payload)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/runners/vendors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/pagerduty/helpers/client'
+
+module Legion
+  module Extensions
+    module Pagerduty
+      module Runners
+        module Vendors
+          include Legion::Extensions::Pagerduty::Helpers::Client
+
+          def list_vendors(per_page: 25, page: 0, **)
+            params = { limit: per_page, offset: page * per_page }
+            response = connection(**).get('/vendors', params)
+            { result: response.body }
+          end
+
+          def get_vendor(id:, **)
+            response = connection(**).get("/vendors/#{id}")
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/pagerduty/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Pagerduty
+      VERSION = '0.2.1'
+    end
+  end
+end