xcal-parktronic 0.0.1 → 1.0.0

data/lib/xcal/parktronic/routes/custom_queries.rb

@@ -0,0 +1,80 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module CustomQueries
+
+        # Fetches *active* custom queries
+        #
+        # ==== Examples
+        #   api.get_custom_queries
+        #   api.custom_queries
+        def get_custom_queries
+          response = http.get("/#{api_version}/custom_queries?#{URI.encode_www_form(:access_token => access_token)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200'
+            generic_response.custom_queries.map { |cq| Xcal::Parktronic::GenericResponse.new(cq.custom_query, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :custom_queries :get_custom_queries
+
+
+        # Posts new Custom Query
+        #
+        # ==== Parameters
+        # * +params+ hash of Custom Query data.
+        #
+        # ==== Examples
+        #   api.post_custom_query(body: 'test query', bucket_interval: 30, database_name: 'database')
+        def post_custom_query(params)
+          request = Net::HTTP::Post.new("/#{api_version}/custom_queries", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, custom_query: params }.to_json
+          response = http.start { |net| net.request(request) }
+
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+
+        # Update Custom Query with specific ID
+        #
+        # ==== Parameters
+        # * +id+ alarm ID
+        # * +params+ custom query params
+        #
+        # ==== Examples
+        #   api.update_custom_query(2, body: 'new body')
+        #   api.update_custom_query(5, active: false, bucket_interval: 5, source: 'xbo')
+        def update_custom_query(id, params)
+          request = Net::HTTP::Patch.new("/#{api_version}/custom_queries/#{id}", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, custom_query: params }.to_json
+
+          response = http.start { |net| net.request(request) }
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+
+        # Find last Custom Query by reference (by widget id and type)
+        #
+        # ==== Parameters
+        # * +referencable_id+ referencable ID (widget id)
+        # * +referencable_type+ referencable_type (widget type)
+        #
+        # ==== Examples
+        #   api.find_custom_query(3, 'ChartSeries')
+        def find_custom_query(referencable_id, referencable_type)
+          response = http.get("/#{api_version}/custom_queries/find/#{referencable_id}/#{referencable_type}?#{URI.encode_www_form(:access_token => access_token)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          response.code == '200' ? Xcal::Parktronic::GenericResponse.new(generic_response.custom_query, self) : generic_response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/routes/event_history_items.rb

@@ -0,0 +1,36 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module EventHistoryItems
+
+        # Fetches event history items by *host* and *service*
+        #
+        # ==== Parameters
+        # * +host_impacted+ event host
+        # * +service_impacted+ event service
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_event_history_items
+        #   api.events_history(host_impacted: 'google.com', service_impacted: 'http')
+        def get_paged_event_history_items(args = {})
+          args.merge!(access_token: access_token)
+          response = http.get("/#{api_version}/events_history?#{URI.encode_www_form(args)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200' && generic_response.has_key?(:event_history_items)
+            generic_response.event_history_items.map { |history| Xcal::Parktronic::GenericResponse.new(history.event_history_item, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :events_history :get_paged_event_history_items
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/routes/events.rb

@@ -0,0 +1,67 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module Events
+
+        # Fetches event with specific ID
+        #
+        # ==== Parameters
+        # * +id+ event ID
+        #
+        # ==== Examples
+        #   api.get_event(1)
+        #   api.event(1)
+        def get_event(id)
+          response = http.get("/#{api_version}/events/#{id}?access_token=#{access_token}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          response.code == '200' ? Xcal::Parktronic::GenericResponse.new(generic_response.event, self) : generic_response
+
+          # TODO Add caching
+        end
+        alias :event :get_event
+
+
+        # Update event with specific ID
+        #
+        # ==== Parameters
+        # * +id+ event ID
+        # * +params+ alarm params
+        #
+        # ==== Examples
+        #   api.update_event(2, subject: 'new subject')
+        #   api.update_event(5, subject: 'new subject', description: 'new description')
+        def update_event(id, params)
+          begin
+            request = Net::HTTP::Patch.new("/#{api_version}/events/#{id}", 'Content-Type' => 'application/json')
+          rescue # ruby 1.9.2
+            request = Net::HTTP::Put.new("/#{api_version}/events/#{id}", 'Content-Type' => 'application/json')
+          end
+          request.body = { access_token: access_token, event: params }.to_json
+
+          response = http.start { |net| net.request(request) }
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+        # Find all Event Tags
+        #
+        # ==== Parameters
+        # * +id+ event ID
+        #
+        # ==== Examples
+        #   api.get_event_tags(2)
+        #   api.event_tags(2)
+        def get_event_tags(id)
+          response = http.get("/#{api_version}/events/#{id}/tags?#{URI.encode_www_form(access_token: access_token)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body, self)
+          response.code == '200' && generic_response.has_key?(:tags) ? generic_response.tags.map(&:tag) : generic_response
+        end
+        alias :event_tags :get_event_tags
+
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/routes/metrics.rb

@@ -0,0 +1,120 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module Metrics
+
+        # Fetches latest metrics
+        #
+        # ==== Parameters
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_metrics
+        #   api.metrics
+        #   api.metrics(page: 2, per_page: 5)
+        def get_paged_metrics(args = {})
+          args.merge!(:access_token => access_token)
+          response = http.get("/#{api_version}/metrics?#{URI.encode_www_form(args)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200'
+            generic_response.metrics.map { |metric| Xcal::Parktronic::GenericResponse.new(metric.metric, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :metrics :get_paged_metrics
+
+
+        # Fetches metric with specific ID
+        #
+        # ==== Parameters
+        # * +id+ metric ID
+        #
+        # ==== Examples
+        #   api.get_metric(2)
+        def get_metric(id)
+          response = http.get("/#{api_version}/metrics/#{id}?access_token=#{access_token}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          response.code == '200' ? Xcal::Parktronic::GenericResponse.new(generic_response.metric, self) : generic_response
+
+          # TODO Add caching
+        end
+        alias :metric :get_metric
+
+        # Posts new metric
+        #
+        # Alarm argument should be a hash of Alarm + Events data.
+        #
+        # Example of metric data:
+        #
+        #    +metric+ :
+        #    {
+        #      :name => 'metric name',
+        #      :originating_system => 'Source System',
+        #      :impact_level => 'low',
+        #      :tag_list => %w(taga tagb)
+        #    }
+        #
+        # Example of events array:
+        #    +events+ :
+        #    [
+        #      {
+        #        :subject => 'EventSubj',
+        #        :description => 'EventDesc',
+        #        :host_impacted => 'host',
+        #        :initiated_at => '2013-11-22T01:00:24Z',
+        #        :service_impacted => 'EventSvc',
+        #        :incident_status => 'CRITICAL'
+        #      }
+        #    ]
+        #
+
+        # Posts new metric
+        #
+        # ==== Parameters
+        # * +metric+ hash of Metric data.
+        # * +metric_values+ array of Metric Values.
+        # * +device_errors+ array of Device Errors.
+        #
+        # ==== Examples
+        #   metric_params   = { name: 'metric name', description: 'metric description', created_at: Time.now }
+        #   metric_value_1  = { value: 2, timestamp: (Time.now - 240)}
+        #   metric_value_2  = { value: 4, timestamp: (Time.now - 120)}
+        #   device_error_1  = { timestamp: (Time.now() - 120), value: 5}
+        #   api.post_metric( metric: metric_params, metric_values: [metric_value_1, metric_value_2], device_error: [device_error_1] )
+        # TODO check this method!
+        def post_metric(args = {})
+          request = Net::HTTP::Post.new("/#{api_version}/metrics", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, metric: args[:metric], metric_values: args[:metric_values], device_errors: [args[:device_errors]] }.to_json
+          response = http.start { |net| net.request(request) }
+
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+        # Update metric with specific ID
+        #
+        # ==== Parameters
+        # * +id+ metric ID
+        # * +params+ metric params
+        #
+        # ==== Examples
+        #   api.update_metric(2, description: 'new description')
+        def update_metric(id, params)
+          request = Net::HTTP::Patch.new("/#{api_version}/metrics/#{id}", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, metric: params }.to_json
+
+          response = http.start { |net| net.request(request) }
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/routes/nested/alarm_actions.rb

@@ -0,0 +1,84 @@
+module Xcal
+  module Parktronic
+    module Routes
+      module Nested
+
+        module AlarmActions
+
+          # Fetches alarm_actions for the specific alarm
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   alarm(3).get_alarm_actions
+          def get_alarm_actions
+            response = client.http.get("/#{client.api_version}/alarms/#{id}/alarm_actions?#{URI.encode_www_form(access_token: client.access_token)}")
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+
+            if response.code == '200' && generic_response.has_key?(:alarm_actions)
+              generic_response.alarm_actions.map(&:alarm_action)
+            else
+              generic_response
+            end
+          end
+
+          # Fetches alarm action with specific ID
+          #
+          # Accepted attributes:
+          #   +id+ alarm_action ID
+          def get_alarm_action(alarm_action_id)
+            response = client.http.get("/#{client.api_version}/alarms/#{id}/alarm_actions/#{alarm_action_id}?access_token=#{client.access_token}")
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+
+            if response.code == '200' && generic_response.has_key?(:alarm_action)
+              generic_response.alarm_action
+            else
+              #TODO think, maybe return false or nil or 'Record not found?'
+              generic_response
+            end
+
+            # TODO Add caching
+          end
+
+          # Posts new alarm
+          #
+          # +params+ hash of AlarmAction data.
+          def post_alarm_action(params)
+            request = Net::HTTP::Post.new("/#{client.api_version}/alarms/#{id}/alarm_actions", 'Content-Type' => 'application/json')
+            request.body = { access_token: client.access_token, alarm_action: params }.to_json
+            response = client.http.start { |net| net.request(request) }
+
+            Xcal::Parktronic::GenericResponse.new(response.body)
+          end
+
+          # Update Alarm Action
+          #
+          # Accepted attributes:
+          # +alarm_action_id+ alarm action id
+          # +params+ alarm params
+          def update_alarm_action(alarm_action_id, params)
+            begin
+              request = Net::HTTP::Patch.new("/#{client.api_version}/alarms/#{id}/alarm_actions/#{alarm_action_id}", 'Content-Type' => 'application/json')
+            rescue # ruby 1.9.2
+              request = Net::HTTP::Put.new("/#{client.api_version}/alarms/#{id}/alarm_actions/#{alarm_action_id}", 'Content-Type' => 'application/json')
+            end
+            request.body = { access_token: client.access_token, alarm_action: params }.to_json
+
+            response = client.http.start { |net| net.request(request) }
+            Xcal::Parktronic::GenericResponse.new(response.body)
+          end
+
+          # Insert the Alarm Action at the given position
+          def set_position(alarm_action_id, position)
+            request = Net::HTTP::Post.new("/#{client.api_version}/alarms/#{id}/alarm_actions/#{alarm_action_id}/insert_at", 'Content-Type' => 'application/json')
+            request.body = { access_token: client.access_token, position: position }.to_json
+
+            response = client.http.start { |net| net.request(request) }
+            Xcal::Parktronic::GenericResponse.new(response.body)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/xcal/parktronic/routes/nested/device_errors.rb

@@ -0,0 +1,35 @@
+module Xcal
+  module Parktronic
+    module Routes
+      module Nested
+
+        module DeviceErrors
+
+          # Fetches device_errors for the specific metric
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   metric(id).get_device_errors(page: 2, per_page: 4)
+          #
+          # Accepted attributes:
+          #   +page+ page number, defaults to 1
+          #   +per_page+ per page value, defaults to 100
+          def get_paged_device_errors(args = {})
+            args.merge!(:access_token => client.access_token)
+            response = client.http.get("/#{client.api_version}/metrics/#{id}/device_errors?#{URI.encode_www_form(args)}")
+
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+            if response.code == '200' && generic_response.has_key?(:device_errors)
+              generic_response.device_errors.map(&:device_error)
+            else
+              generic_response
+            end
+          end
+          alias :get_device_errors :get_paged_device_errors
+
+        end
+
+      end
+    end
+  end
+end

data/lib/xcal/parktronic/routes/nested/events.rb

@@ -0,0 +1,57 @@
+module Xcal
+  module Parktronic
+    module Routes
+      module Nested
+
+        module Events
+
+          # Fetches events for the specific alarm
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   alarm(id).get_events(page: 2, per_page: 4)
+          #
+          # Accepted attributes:
+          #   +page+ page number, defaults to 1
+          #   +per_page+ per page value, defaults to 100
+          def get_paged_events(args = {})
+            args.merge!(:access_token => client.access_token)
+            response = client.http.get("/#{client.api_version}/alarms/#{id}/events?#{URI.encode_www_form(args)}")
+
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+            response.code == '200' && generic_response.has_key?(:events) ? generic_response.events.map(&:event) : generic_response
+          end
+          alias :get_events :get_paged_events
+
+          # Fetches all events for the specific alarm
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   alarm(id).get_all_events
+          def get_all_events
+            response = client.http.get("/#{client.api_version}/alarms/#{id}/events?#{URI.encode_www_form(access_token: client.access_token)}")
+
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+            response.code == '200' && generic_response.has_key?(:events) ? generic_response.events.map(&:event) : generic_response
+          end
+
+          # Create event for the specific alarm
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   alarms.last.post_event(subject: 'example', host_impacted: 'test')
+          #   alarm(id).post_event(subject: 'example', host_impacted: 'test')
+          def post_event(params)
+            request = Net::HTTP::Post.new("/#{client.api_version}/alarms/#{id}/events", 'Content-Type' => 'application/json')
+            request.body = { access_token: client.access_token, event: params }.to_json
+            response = client.http.start { |net| net.request(request) }
+
+            Xcal::Parktronic::GenericResponse.new(response.body)
+          end
+
+        end
+
+      end
+    end
+  end
+end