lita-pagerduty 0.2.0 → 1.0.0

data/lib/lita/commands/pager_me.rb

@@ -0,0 +1,48 @@
+module Commands
+  class PagerMe
+    include Base
+
+    def call
+      response message: 'pager_me.success', params: success_response_params
+    rescue Exceptions::SchedulesEmptyList
+      response schedules_empty_list
+    rescue Exceptions::UserNotIdentified
+      response message: 'identify.missing'
+    rescue Exceptions::UsersEmptyList
+      response message: 'identify.unrecognised'
+    rescue Exceptions::OverrideUnsuccess
+      response message: 'pager_me.failure'
+    end
+
+    private
+
+    def schedules_empty_list
+      {
+        message: 'on_call_lookup.no_matching_schedule',
+        params: {
+          schedule_name: message.match_data[1].strip
+        }
+      }
+    end
+
+    def schedule
+      @schedule ||= pagerduty.get_schedules(
+        query: message.match_data[1].strip
+      ).first
+    end
+
+    def override
+      @override ||= pagerduty.override(
+        schedule[:id], current_user[:id], message.match_data[2].strip.to_i
+      )
+    end
+
+    def success_response_params
+      {
+        name: override[:user][:summary],
+        email: current_user[:email],
+        finish: override[:end]
+      }
+    end
+  end
+end

data/lib/lita/commands/resolve.rb

@@ -0,0 +1,15 @@
+module Commands
+  class Resolve
+    include Base
+
+    def call
+      incident_id = message.match_data['incident_id']
+      return if incident_id =~ /\A(all|mine)\z/i
+
+      pagerduty.manage_incidents(:resolve, [incident_id])
+      response message: 'all.resolved', params: { list: incident_id.to_s }
+    rescue Exceptions::IncidentManageUnsuccess
+      nil
+    end
+  end
+end

data/lib/lita/commands/resolve_all.rb

@@ -0,0 +1,21 @@
+module Commands
+  class ResolveAll
+    include Base
+
+    def call
+      ids = pagerduty.get_incidents(query_params).map { |i| i[:id] }
+      pagerduty.manage_incidents(:resolve, ids)
+      response message: 'all.resolved', params: { list: ids.join(', ') }
+    rescue Exceptions::IncidentsEmptyList
+      response message: 'incident.none'
+    rescue Exceptions::IncidentManageUnsuccess
+      nil
+    end
+
+    private
+
+    def query_params
+      { statuses: %w[triggered acknowledged] }
+    end
+  end
+end

data/lib/lita/commands/resolve_mine.rb

@@ -0,0 +1,26 @@
+module Commands
+  class ResolveMine
+    include Base
+
+    def call
+      ids = pagerduty.get_incidents(query_params).map { |i| i[:id] }
+      pagerduty.manage_incidents(:resolve, ids)
+      response message: 'all.resolved', params: { list: ids.join(', ') }
+    rescue Exceptions::UserNotIdentified
+      response message: 'incident.none_mine'
+    rescue Exceptions::IncidentsEmptyList
+      response message: 'incident.none_mine'
+    rescue Exceptions::IncidentManageUnsuccess
+      nil
+    end
+
+    private
+
+    def query_params
+      {
+        statuses: %w[triggered acknowledged],
+        'user_ids[]' => current_user[:id]
+      }
+    end
+  end
+end

data/lib/lita/handlers/commands.yml

@@ -0,0 +1,30 @@
+- pattern: ^pager\sidentify\s(?<email>[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+)$
+  method: identify
+- pattern: ^pager\sforget$
+  method: forget
+- pattern: ^pager\sincidents\sall$
+  method: incidents_all
+- pattern: ^pager\sincidents\smine$
+  method: incidents_mine
+- pattern: ^pager\sincident\s(?<incident_id>[a-zA-Z0-9+]+)$
+  method: incident
+- pattern: ^pager\snotes\s(?<incident_id>[a-zA-Z0-9+]+)$
+  method: notes
+- pattern: ^pager\sack\sall$
+  method: ack_all
+- pattern: ^pager\sack\smine$
+  method: ack_mine
+- pattern: ^pager\sack\s(?<incident_id>[a-zA-Z0-9+]+)$
+  method: ack
+- pattern: ^pager\sresolve\sall$
+  method: resolve_all
+- pattern: ^pager\sresolve\smine$
+  method: resolve_mine
+- pattern: ^pager\sresolve\s(?<incident_id>[a-zA-Z0-9+]+)$
+  method: resolve
+- pattern: ^pager\soncall$
+  method: on_call_list
+- pattern: ^pager\soncall\s(.*)$
+  method: on_call_lookup
+- pattern: ^pager\s+me\s+(.+?)\s+(\d+)m?$
+  method: pager_me

data/lib/lita/handlers/pagerduty.rb

@@ -0,0 +1,57 @@
+module Lita
+  module Handlers
+    class Pagerduty < Handler
+      namespace 'Pagerduty'
+      config :api_key, required: true
+      config :email, required: true
+
+      COMMANDS_PATH = File.read("#{File.dirname(__FILE__)}/commands.yml")
+      COMMANDS = YAML.safe_load(COMMANDS_PATH)
+      COMMANDS.each do |command|
+        route(
+          /#{command['pattern']}/,
+          command['method'].to_sym,
+          command: true,
+          help: {
+            "help.#{command['method']}.syntax" =>
+              "help.#{command['method']}.desc"
+          }
+        )
+      end
+
+      def method_missing(method, message)
+        super if COMMANDS.map { |i| i['method'] }.include? method
+        response = Object.const_get(
+          'Commands::' << method.to_s.split('_').map(&:capitalize).join
+        ).send(:call, message, pagerduty, store)
+        handle_response(message, response) if response
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        COMMANDS.map { |i| i['method'] }.include?(method) || super
+      end
+
+      def pagerduty
+        @pagerduty ||= ::Pagerduty.new(http, config.api_key, config.email)
+      end
+
+      def store
+        @store ||= Store.new(redis)
+      end
+
+      def handle_response(message, response)
+        message.reply case response
+                      when String
+                        response
+                      when Hash
+                        t response[:message], response[:params]
+                      when Array
+                        response.map { |item| t item[:message], item[:params] }
+                                .join("\n")
+                      end
+      end
+
+      Lita.register_handler(self)
+    end
+  end
+end

data/lib/pagerduty.rb

@@ -0,0 +1,94 @@
+class Pagerduty
+  def initialize(http, token, email)
+    @token = token
+    @http = http
+    http.url_prefix = 'https://api.pagerduty.com/'
+    http.headers = headers(email)
+  end
+
+  def get_incidents(params = {})
+    response = @http.get '/incidents', params
+    data = JSON.parse(response.body, symbolize_names: true)
+               .fetch(:incidents, [])
+    raise Exceptions::IncidentsEmptyList if data.empty?
+
+    data
+  end
+
+  def get_users(params = {})
+    response = @http.get '/users', params
+    data = JSON.parse(response.body, symbolize_names: true).fetch(:users, [])
+    raise Exceptions::UsersEmptyList if data.empty?
+
+    data
+  end
+
+  def get_schedules(params = {})
+    response = @http.get '/schedules', params
+    data = JSON.parse(response.body, symbolize_names: true)
+               .fetch(:schedules, [])
+    raise Exceptions::SchedulesEmptyList if data.empty?
+
+    data
+  end
+
+  def get_oncall_user(params = {})
+    response = @http.get '/oncalls', params
+    data = JSON.parse(response.body, symbolize_names: true).fetch(:oncalls, [])
+    raise Exceptions::NoOncallUser if data.empty?
+
+    data.first.fetch(:user)
+  end
+
+  def get_incident(id = '404stub')
+    response = @http.get "/incidents/#{id}"
+    raise Exceptions::IncidentNotFound if response.status == 404
+
+    JSON.parse(response.body, symbolize_names: true).fetch(:incident, nil)
+  end
+
+  def get_notes_by_incident_id(incident_id)
+    response = @http.get "/incidents/#{incident_id}/notes"
+    raise Exceptions::IncidentNotFound if response.status == 404
+
+    data = JSON.parse(response.body, symbolize_names: true).fetch(:notes, [])
+    raise Exceptions::NotesEmptyList if data.empty?
+
+    data
+  end
+
+  def manage_incidents(action, ids)
+    incidents = ids.map do |id|
+      { id: id, type: 'incident_reference', status: "#{action}d" }
+    end
+    payload = { incidents: incidents }
+    response = @http.put '/incidents', payload
+    raise Exceptions::IncidentManageUnsuccess if response.status != 200
+
+    response
+  end
+
+  def override(schedule_id, user_id, minutes)
+    from = ::Time.now.utc + 10
+    to = from + (60 * minutes)
+    payload = { override: {
+      start: from.iso8601,
+      end: to.iso8601,
+      user: { id: user_id, type: 'user_reference' }
+    } }
+    response = @http.post "/schedules/#{schedule_id}/overrides", payload
+    raise Exceptions::OverrideUnsuccess if response.status != 201
+
+    JSON.parse(response.body, symbolize_names: true).fetch(:override, nil)
+  end
+
+  private
+
+  def headers(email)
+    {
+      'Accept' => 'application/vnd.pagerduty+json;version=2',
+      'Authorization' => "Token token=#{@token}",
+      'From' => email
+    }
+  end
+end

data/lib/store.rb

@@ -0,0 +1,20 @@
+class Store
+  def initialize(redis)
+    @redis = redis
+  end
+
+  def get_user(response)
+    email = @redis.get("user_#{response.user.id}")
+    raise Exceptions::UserNotIdentified unless email
+
+    email
+  end
+
+  def remember_user(response)
+    @redis.set("user_#{response.user.id}", response.match_data['email'])
+  end
+
+  def forget_user(response)
+    @redis.del("user_#{response.user.id}")
+  end
+end

data/lita-pagerduty.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-pagerduty'
-  spec.version       = '0.2.0'
+  spec.version       = '1.0.0'
   spec.authors       = ['Eric Sigler']
   spec.email         = ['eric@pagerduty.com']
   spec.description   = 'A Lita handler to interact with PagerDuty'
@@ -15,7 +15,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'lita', '>= 4.0'
-  spec.add_runtime_dependency 'pagerduty-sdk', '>= 1.0.9'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'coveralls'

data/locales/en.yml

@@ -78,13 +78,13 @@ en:
           acknowledged: "Acknowledged: %{list}"
           resolved: "Resolved: %{list}"
         note:
-          show: "%{id}: %{content} (%{email})"
+          show: "%{id}: %{content} (%{user})"
         on_call_list:
           response: "Available schedules:\n%{schedules}"
           no_schedules_found: "No schedules found"
         on_call_lookup:
           response: "%{name} (%{email}) is currently on call for %{schedule_name}"
-          no_matching_schedule: "No matching schedules found for '%{schedule_name}'" 
+          no_matching_schedule: "No matching schedules found for '%{schedule_name}'"
           no_one_on_call: "No one is currently on call for %{schedule_name}"
         pager_me:
           success: "%{name} (%{email}) is now on call until %{finish}"

data/spec/lita/handlers/ack_all_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Lita::Handlers::Pagerduty, lita_handler: true do
+  context 'ack all' do
+    it do
+      is_expected.to route_command('pager ack all').to(:ack_all)
+    end
+
+    it 'empty list' do
+      expect_any_instance_of(Pagerduty).to receive(:get_incidents).and_raise(Exceptions::IncidentsEmptyList)
+      send_command('pager ack all')
+      expect(replies.last).to eq('No triggered, open, or acknowledged incidents')
+    end
+
+    it 'list of incidents' do
+      expect_any_instance_of(Pagerduty).to receive(:get_incidents).and_return([
+        { id: 'ABC123' }, { id: 'ABC124' }
+      ])
+      expect_any_instance_of(Pagerduty).to receive(:manage_incidents).and_return(
+        OpenStruct.new(status: 200)
+      )
+      send_command('pager ack all')
+      expect(replies.last).to eq('Acknowledged: ABC123, ABC124')
+    end
+  end
+end

data/spec/lita/handlers/ack_id_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Lita::Handlers::Pagerduty, lita_handler: true do
+  context 'ack ABC123' do
+    it do
+      is_expected.to route_command('pager ack ABC123').to(:ack)
+    end
+
+    it 'not found' do
+      expect_any_instance_of(Pagerduty).to receive(:manage_incidents).and_raise(Exceptions::IncidentManageUnsuccess)
+      send_command('pager ack ABC123')
+      expect(replies.last).to be_nil
+    end
+
+    it 'found' do
+      expect_any_instance_of(Pagerduty).to receive(:manage_incidents).and_return(
+        OpenStruct.new(status: 200)
+      )
+      send_command('pager ack ABC123')
+      expect(replies.last).to eq 'Acknowledged: ABC123'
+    end
+  end
+end

data/spec/lita/handlers/ack_mine_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Lita::Handlers::Pagerduty, lita_handler: true do
+  context 'ack mine' do
+    it do
+      is_expected.to route_command('pager ack mine').to(:ack_mine)
+    end
+
+    it 'unknown user' do
+      user = Lita::User.create(123, name: 'foo')
+      send_command('pager ack mine', as: user)
+      expect(replies.last).to eq('You have no triggered, open, or acknowledged incidents')
+    end
+
+    it 'empty list' do
+      user = Lita::User.create(123, name: 'foo')
+      send_command('pager identify foo@pagerduty.com', as: user)
+      expect_any_instance_of(Pagerduty).to receive(:get_users).and_return([{ id: 'abc123' }])
+      expect_any_instance_of(Pagerduty).to receive(:get_incidents).and_raise(Exceptions::IncidentsEmptyList)
+      send_command('pager ack mine', as: user)
+      expect(replies.last).to eq('You have no triggered, open, or acknowledged incidents')
+    end
+
+    it 'list of incidents' do
+      user = Lita::User.create(123, name: 'foo')
+      send_command('pager identify foo@pagerduty.com', as: user)
+      expect_any_instance_of(Pagerduty).to receive(:get_users).and_return([{ id: 'abc123' }])
+      expect_any_instance_of(Pagerduty).to receive(:get_incidents).and_return([
+        { id: 'ABC123' }, { id: 'ABC124' }
+      ])
+      expect_any_instance_of(Pagerduty).to receive(:manage_incidents).and_return(
+        OpenStruct.new(status: 200)
+      )
+      send_command('pager ack mine', as: user)
+      expect(replies.last).to eq('Acknowledged: ABC123, ABC124')
+    end
+  end
+end