3scale_toolbox 0.17.1 → 0.19.0

data/lib/3scale_toolbox/entities/backend_metric.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class BackendMetric
+      include CRD::BackendMetricSerializer
+
       VALID_PARAMS = %w[friendly_name system_name unit description].freeze
       public_constant :VALID_PARAMS
 
@@ -42,11 +44,19 @@ module ThreeScaleToolbox
       end
 
       def system_name
-        @attrs['system_name']
+        attrs['system_name']
       end
 
       def friendly_name
-        @attrs['friendly_name']
+        attrs['friendly_name']
+      end
+
+      def unit
+        attrs['unit']
+      end
+
+      def description
+        attrs['description']
       end
 
       def update(m_attrs)

data/lib/3scale_toolbox/entities/backend_usage.rb

@@ -3,6 +3,8 @@ module ThreeScaleToolbox
     ##
     # BackendUsage represents Product - Backend mapping entry
     class BackendUsage
+      include CRD::BackendUsageSerializer
+
       CREATE_PARAMS = %w[path backend_api_id].freeze
       public_constant :CREATE_PARAMS
       UPDATE_PARAMS = %w[path].freeze
@@ -54,7 +56,7 @@ module ThreeScaleToolbox
 
       def backend_id
         # 3scale API returns 'backend_id'
-        # 3scale API only accepts 'backend_api_id' as params
+        # 3scale API only accepts 'backend_api_id' as params on create endpoint
         # good job
         attrs['backend_id']
       end
@@ -82,6 +84,10 @@ module ThreeScaleToolbox
         remote.delete_backend_usage product.id, id
       end
 
+      def backend
+        Backend.new(id: backend_id, remote: remote)
+      end
+
       private
 
       def fetch_attrs

data/lib/3scale_toolbox/entities/limit.rb

@@ -0,0 +1,71 @@
+module ThreeScaleToolbox
+  module Entities
+    class Limit
+      include CRD::Limit
+
+      class << self
+        def create(plan:, metric_id:, attrs:)
+          resp_attrs = plan.remote.create_application_plan_limit plan.id, metric_id, attrs
+          if (errors = resp_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been created', errors)
+          end
+
+          new(id: resp_attrs.fetch('id'), plan: plan, metric_id: metric_id, attrs: resp_attrs)
+        end
+      end
+
+      attr_reader :id, :plan, :remote, :attrs, :metric_id
+
+      def initialize(id:, plan:, metric_id:, attrs:)
+        @id = id.to_i
+        @plan = plan
+        @remote = plan.remote
+        @metric_id = metric_id
+        @attrs = attrs
+      end
+
+      def period
+        attrs['period']
+      end
+
+      def value
+        attrs['value']
+      end
+
+      def links
+        attrs['links'] || []
+      end
+
+      def metric_link
+        links.find { |link| link['rel'] == 'metric' }
+      end
+
+      def update(new_limit_attrs)
+        new_attrs = remote.update_application_plan_limit(plan.id, metric_id, id, new_limit_attrs)
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_application_plan_limit plan.id, metric_id, id
+      end
+
+      private
+
+      # Used by CRD::Limit
+      # Returns the backend hosting the metric
+      def backend_from_metric
+        backend_id = Helper.backend_metric_link_parser(metric_link['href'] || '')
+        return if backend_id.nil?
+
+        Backend.new(id: backend_id.to_i, remote: remote)
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/entities/mapping_rule.rb

@@ -0,0 +1,90 @@
+module ThreeScaleToolbox
+  module Entities
+    class MappingRule
+      include CRD::MappingRuleSerializer
+
+      VALID_PARAMS = %w[metric_id pattern http_method delta position last].freeze
+      public_constant :VALID_PARAMS
+
+      class << self
+        def create(service:, attrs:)
+          mapping_rule = service.remote.create_mapping_rule(
+            service.id,
+            Helper.filter_params(VALID_PARAMS, attrs)
+          )
+          if (errors = mapping_rule['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('mapping rule has not been created',
+                                                            errors)
+          end
+
+          new(id: mapping_rule.fetch('id'), service: service, attrs: mapping_rule)
+        end
+      end
+
+      attr_reader :id, :service, :remote
+
+      def initialize(id:, service:, attrs: nil)
+        @id = id.to_i
+        @service = service
+        @remote = service.remote
+        @attrs = attrs
+      end
+
+      def attrs
+        @attrs ||= mapping_rule_attrs
+      end
+
+      def http_method
+        attrs['http_method']
+      end
+
+      def pattern
+        attrs['pattern']
+      end
+
+      def delta
+        attrs['delta']
+      end
+
+      def last
+        attrs['last']
+      end
+
+      def metric_id
+        attrs['metric_id']
+      end
+
+      def update(mr_attrs)
+        new_attrs = remote.update_mapping_rule(
+          service.id, id,
+          Helper.filter_params(VALID_PARAMS, mr_attrs)
+        )
+        if (errors = new_attrs['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service mapping rule has not been updated', errors)
+        end
+
+        # update current attrs
+        @attrs = new_attrs
+
+        new_attrs
+      end
+
+      def delete
+        remote.delete_mapping_rule service.id, id
+      end
+
+      private
+
+      def mapping_rule_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
+        mapping_rule = remote.show_mapping_rule service.id, id
+        if (errors = mapping_rule['errors'])
+          raise ThreeScaleToolbox::ThreeScaleApiError.new('Service mapping rule not read', errors)
+        end
+
+        mapping_rule
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/entities/method.rb

@@ -1,38 +1,35 @@
 module ThreeScaleToolbox
   module Entities
     class Method
+      include CRD::MethodSerializer
+
       class << self
-        def create(service:, parent_id:, attrs:)
-          method = service.remote.create_method service.id, parent_id, attrs
-          if (errors = method['errors'])
+        def create(service:, attrs:)
+          method_attrs = service.remote.create_method service.id, service.hits.id, attrs
+          if (errors = method_attrs['errors'])
             raise ThreeScaleToolbox::ThreeScaleApiError.new('Method has not been created', errors)
-
           end
 
-          new(id: method.fetch('id'), parent_id: parent_id, service: service, attrs: method)
+          new(id: method_attrs.fetch('id'), service: service, attrs: method_attrs)
         end
 
         # ref can be system_name or method_id
-        def find(service:, parent_id:, ref:)
-          new(id: ref, parent_id: parent_id, service: service).tap(&:attrs)
+        def find(service:, ref:)
+          new(id: ref, service: service).tap(&:attrs)
         rescue ThreeScale::API::HttpClient::NotFoundError
-          find_by_system_name(service: service, parent_id: parent_id, system_name: ref)
+          find_by_system_name(service: service, system_name: ref)
         end
 
-        def find_by_system_name(service:, parent_id:, system_name:)
-          method = service.methods(parent_id).find { |m| m['system_name'] == system_name }
-          return if method.nil?
-
-          new(id: method.fetch('id'), parent_id: parent_id, service: service, attrs: method)
+        def find_by_system_name(service:, system_name:)
+          service.methods.find { |m| m.system_name == system_name }
         end
       end
 
-      attr_reader :id, :parent_id, :service, :remote
+      attr_reader :id, :service, :remote
 
-      def initialize(id:, parent_id:, service:, attrs: nil)
+      def initialize(id:, service:, attrs: nil)
         @id = id.to_i
         @service = service
-        @parent_id = parent_id
         @remote = service.remote
         @attrs = attrs
       end
@@ -41,6 +38,18 @@ module ThreeScaleToolbox
         @attrs ||= method_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def friendly_name
+        attrs['friendly_name']
+      end
+
+      def description
+        attrs['description']
+      end
+
       def disable
         Metric.new(id: id, service: service).disable
       end
@@ -50,7 +59,7 @@ module ThreeScaleToolbox
       end
 
       def update(m_attrs)
-        new_attrs = remote.update_method(service.id, parent_id, id, m_attrs)
+        new_attrs = remote.update_method(service.id, hits_id, id, m_attrs)
         if (errors = new_attrs['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Method has not been updated', errors)
         end
@@ -62,13 +71,18 @@ module ThreeScaleToolbox
       end
 
       def delete
-        remote.delete_method service.id, parent_id, id
+        remote.delete_method service.id, hits_id, id
       end
 
+
       private
 
+      def hits_id
+        service.hits.id
+      end
+
       def method_attrs
-        method = remote.show_method service.id, parent_id, id
+        method = remote.show_method service.id, hits_id, id
         if (errors = method['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Method not read', errors)
         end

data/lib/3scale_toolbox/entities/metric.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class Metric
+      include CRD::MetricSerializer
+
       class << self
         def create(service:, attrs:)
           metric = service.remote.create_metric service.id, attrs
@@ -19,10 +21,7 @@ module ThreeScaleToolbox
         end
 
         def find_by_system_name(service:, system_name:)
-          metric = service.metrics.find { |m| m['system_name'] == system_name }
-          return if metric.nil?
-
-          new(id: metric.fetch('id'), service: service, attrs: metric)
+          service.metrics.find { |m| m.system_name == system_name }
         end
       end
 
@@ -39,25 +38,41 @@ module ThreeScaleToolbox
         @attrs ||= metric_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def friendly_name
+        attrs['friendly_name']
+      end
+
+      def unit
+        attrs['unit']
+      end
+
+      def description
+        attrs['description']
+      end
+
       def disable
         # For each plan, get limits for the current metric
         # if already disabled -> NOOP
         # if non zero eternity limit exist, update
         # if non eternity limit exist, create
-        service_plans.each do |plan|
+        service.plans.each do |plan|
           eternity_limit = plan_eternity_limit(plan)
           if eternity_limit.nil?
             plan.create_limit(id, zero_eternity_limit_attrs)
-          elsif !eternity_limit.fetch('value').zero?
-            plan.update_limit(id, eternity_limit.fetch('id'), zero_eternity_limit_attrs)
+          elsif !eternity_limit.value.zero?
+            eternity_limit.update(zero_eternity_limit_attrs)
           end
         end
       end
 
       def enable
-        service_plans.each do |plan|
+        service.plans.each do |plan|
           limit = plan_zero_eternity_limit(plan)
-          plan.delete_limit(id, limit.fetch('id')) unless limit.nil?
+          limit.delete unless limit.nil?
         end
       end
 
@@ -90,19 +105,15 @@ module ThreeScaleToolbox
 
       def plan_zero_eternity_limit(plan)
         # only one limit for eternity period is allowed per (plan_id, metric_id)
-        plan.metric_limits(id).find { |limit| limit > zero_eternity_limit_attrs }
+        #plan.metric_limits(id).find { |limit| limit.attrs > zero_eternity_limit_attrs }
+        plan.metric_limits(id).find do |limit|
+          limit.attrs > zero_eternity_limit_attrs
+        end
       end
 
       def plan_eternity_limit(plan)
         # only one limit for eternity period is allowed per (plan_id, metric_id)
-        plan.metric_limits(id).find { |limit| limit['period'] == 'eternity' }
-      end
-
-      def service_plans
-        service.plans.map do |plan_attrs|
-          ThreeScaleToolbox::Entities::ApplicationPlan.new(id: plan_attrs.fetch('id'),
-                                                           service: service)
-        end
+        plan.metric_limits(id).find { |limit| limit.period == 'eternity' }
       end
 
       def zero_eternity_limit_attrs

data/lib/3scale_toolbox/entities/pricing_rule.rb

@@ -0,0 +1,63 @@
+module ThreeScaleToolbox
+  module Entities
+    class PricingRule
+      include CRD::PricingRuleSerializer
+
+      class << self
+        def create(plan:, metric_id:, attrs:)
+          resp_attrs = plan.remote.create_pricingrule plan.id, metric_id, attrs
+          if (errors = resp_attrs['errors'])
+            raise ThreeScaleToolbox::ThreeScaleApiError.new('Pricing rule has not been created', errors)
+          end
+
+          new(id: resp_attrs.fetch('id'), plan: plan, metric_id: metric_id, attrs: resp_attrs)
+        end
+      end
+
+      attr_reader :id, :plan, :remote, :attrs, :metric_id
+
+      def initialize(id:, plan:, metric_id:, attrs:)
+        @id = id.to_i
+        @plan = plan
+        @remote = plan.remote
+        @metric_id = metric_id
+        @attrs = attrs
+      end
+
+      def cost_per_unit
+        attrs['cost_per_unit'].to_f
+      end
+
+      def min
+        attrs['min']
+      end
+
+      def max
+        attrs['max']
+      end
+
+      def links
+        attrs['links'] || []
+      end
+
+      def metric_link
+        links.find { |link| link['rel'] == 'metric' }
+      end
+
+      def delete
+        remote.delete_application_plan_pricingrule plan.id, metric_id, id
+      end
+
+      private
+
+      # Used by CRD::PricingRule
+      # Returns the backend hosting the metric
+      def backend_from_metric
+        backend_id = Helper.backend_metric_link_parser(metric_link['href'] || '')
+        return if backend_id.nil?
+
+        Backend.new(id: backend_id.to_i, remote: remote)
+      end
+    end
+  end
+end