barkibu-kb 0.16.1

data/lib/kb/errors/client_error.rb

@@ -0,0 +1,9 @@
+module KB
+  class ClientError < Error
+    def message
+      JSON.parse(body)['message']
+    rescue StandardError
+      body
+    end
+  end
+end

data/lib/kb/errors/conflict_error.rb

@@ -0,0 +1,3 @@
+module KB
+  class ConflictError < ClientError; end
+end

data/lib/kb/errors/error.rb

@@ -0,0 +1,26 @@
+module KB
+  class Error < StandardError
+    attr_accessor :status_code, :body, :message
+
+    def initialize(status_code = nil, body = nil, error = nil)
+      super(error)
+      @status_code = status_code
+      @body = body
+      @message = "Received Status: #{status_code}\n#{body}"
+      set_backtrace error.backtrace if error
+    end
+
+    def self.from_faraday(error)
+      case error.response[:status]
+      when 404
+        ResourceNotFound
+      when 409
+        ConflictError
+      when 422
+        UnprocessableEntityError
+      else
+        self
+      end.new(error.response[:status], error.response[:body], error)
+    end
+  end
+end

data/lib/kb/errors/resource_not_found.rb

@@ -0,0 +1,3 @@
+module KB
+  class ResourceNotFound < Error; end
+end

data/lib/kb/errors/unprocessable_entity_error.rb

@@ -0,0 +1,3 @@
+module KB
+  class UnprocessableEntityError < ClientError; end
+end

data/lib/kb/errors.rb

@@ -0,0 +1,6 @@
+require 'kb/errors/error'
+require 'kb/errors/client_error'
+
+require 'kb/errors/conflict_error'
+require 'kb/errors/unprocessable_entity_error'
+require 'kb/errors/resource_not_found'

data/lib/kb/fake/api.rb

@@ -0,0 +1,72 @@
+require 'kb/fake/bounded_context/pet_family/breeds'
+require 'kb/fake/bounded_context/pet_family/pet_parents'
+require 'kb/fake/bounded_context/pet_family/pets'
+require 'kb/fake/bounded_context/pet_family/products'
+require 'kb/fake/bounded_context/pet_family/pet_contracts'
+require 'kb/fake/bounded_context/pet_family/hubspot_relationship'
+
+module KB
+  module Fake
+    class ApiState
+      attr_accessor :petparents, :pets, :consultations, :petcontracts, :plans, :breeds, :products, :hubspot_relationship
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(petparents: [], pets: [], consultations: [], petcontracts: [], plans: [], breeds: [],
+                     products: [], hubspot_relationship: [])
+        @petparents = petparents
+        @pets = pets
+        @consultations = consultations
+        @petcontracts = petcontracts
+        @plans = plans
+        @breeds = breeds
+        @products = products
+        @hubspot_relationship = hubspot_relationship
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def to_snapshot
+        {
+          pets: @pets.clone,
+          petparents: @petparents.clone,
+          consultations: @consultations.clone,
+          petcontracts: @petcontracts.clone,
+          plans: @plans.clone,
+          breeds: @breeds.clone,
+          products: @products.clone,
+          hubspot_relationship: @hubspot_relationship.clone
+        }
+      end
+    end
+
+    class Api < Sinatra::Base
+      include BoundedContext::PetFamily::Breeds
+      include BoundedContext::PetFamily::Pets
+      include BoundedContext::PetFamily::PetParents
+      include BoundedContext::PetFamily::PetContracts
+      include BoundedContext::PetFamily::Products
+      include BoundedContext::PetFamily::HubspotRelationship
+
+      set :state, ApiState.new
+
+      def self.snapshot
+        Api.state.to_snapshot
+      end
+
+      def self.restore(snapshot)
+        set :state, ApiState.new(**snapshot)
+      end
+
+      def resource_state(name)
+        Api.state.send(name)
+      end
+
+      def set_resource_state(name, value)
+        Api.state.send("#{name}=", value)
+      end
+
+      resource :consultations, except: %i[create update destroy]
+
+      resource :plans, except: %i[show create update destroy]
+    end
+  end
+end

data/lib/kb/fake/bounded_context/pet_family/breeds.rb

@@ -0,0 +1,15 @@
+require 'kb/fake/bounded_context/rest_resource'
+
+module BoundedContext
+  module PetFamily
+    module Breeds
+      extend ActiveSupport::Concern
+
+      included do
+        include RestResource
+
+        listen_on_index :breeds, :v1
+      end
+    end
+  end
+end

data/lib/kb/fake/bounded_context/pet_family/hubspot_relationship.rb

@@ -0,0 +1,17 @@
+require 'kb/fake/bounded_context/rest_resource'
+
+module BoundedContext
+  module PetFamily
+    module HubspotRelationship
+      extend ActiveSupport::Concern
+
+      included do
+        include RestResource
+
+        get '/v1/hubspot/:model/:key/relationship' do
+          resource_by_key(:hubspot_relationship, params['key'])
+        end
+      end
+    end
+  end
+end

data/lib/kb/fake/bounded_context/pet_family/pet_contracts.rb

@@ -0,0 +1,24 @@
+require 'kb/fake/bounded_context/rest_resource'
+
+module BoundedContext
+  module PetFamily
+    module PetContracts
+      extend ActiveSupport::Concern
+
+      included do
+        include RestResource
+
+        get '/v1/petcontracts/contractnumber/:contract_number' do
+          resource = resource_state(:petcontracts).detect do |contract|
+            contract['contractNumber'] == params['contract_number']
+          end
+          return json_response 404, {} if resource.nil?
+
+          json_response 200, resource
+        end
+
+        resource :petcontracts, except: %i[index destroy]
+      end
+    end
+  end
+end

data/lib/kb/fake/bounded_context/pet_family/pet_parents.rb

@@ -0,0 +1,98 @@
+require 'kb/fake/bounded_context/rest_resource'
+# rubocop:disable Metrics/BlockLength
+
+module BoundedContext
+  module PetFamily
+    module PetParents
+      extend ActiveSupport::Concern
+
+      included do
+        include RestResource
+
+        resource :petparents
+
+        def petparents_filterable_attributes
+          KB::PetParent::FIELDS.map { |k| k.to_s.camelize(:lower) }
+        end
+
+        get '/v1/petparents/:key/pets' do
+          json_response 200, pets_by_pet_parent_key(params['key'])
+        end
+
+        get '/v1/petparents/:key/contracts' do
+          pet_keys = pets_by_pet_parent_key(params['key']).map { |pet| pet['key'] }
+          contracts = resource_state(:petcontracts).select { |contract| pet_keys.include? contract['petKey'] }
+
+          json_response 200, contracts
+        end
+
+        put '/v1/petparents' do
+          params = JSON.parse(request.body.read)
+          existing_pet_parent = pet_parent_by_key(params) || pet_parent_by_email(params) || pet_parent_by_phone(params)
+          resource = (existing_pet_parent || { 'key' => SecureRandom.uuid }).merge params
+
+          if existing_pet_parent.present?
+            if same_phone_number_but_different_email?(existing_pet_parent, params)
+              return json_response 422, { error: 'Unprocessable Entity', message: 'Email can not be overridden' }
+            end
+
+            if same_email_but_different_phone_number?(existing_pet_parent, params)
+              previous_pet_parent_by_phone = pet_parent_by_phone(params)
+              if previous_pet_parent_by_phone.present?
+                return json_response 409,
+                                     { error: 'ConflictError',
+                                       message: 'Duplicated pet parent: same partner, phoneNumber \
+                                                and phoneNumberPrefix' }
+              end
+            end
+
+            update_resource_state(:petparents, resource)
+          else
+            resource_state(:petparents) << resource
+          end
+
+          json_response 200, resource
+        end
+
+        private
+
+        def pet_parent_by_key(params)
+          find_resource(:petparents, params['key']) if params['key']
+        end
+
+        def pet_parent_by_phone(params)
+          matches_by_phone = (if params['phoneNumber']
+                                filter_resources(:petparents,
+                                                 params.slice('phoneNumber',
+                                                              'prefixPhoneNumber'))
+                              end)
+          matches_by_phone.first if matches_by_phone&.count == 1
+        end
+
+        def pet_parent_by_email(params)
+          matches_by_email = (filter_resources(:petparents, params.slice('email')) if params['email'])
+          matches_by_email.first if matches_by_email&.count == 1
+        end
+
+        def pets_by_pet_parent_key(key)
+          resource_state(:pets).select { |pet| pet['petParentKey'] == key }
+        end
+
+        def same_email_but_different_phone_number?(previous, new)
+          (previous['email'] == new['email']) &&
+            ((previous['phoneNumber'] != new['phoneNumber']) ||
+             (previous['prefixPhoneNumber'] != new['prefixPhoneNumber']))
+        end
+
+        def same_phone_number_but_different_email?(previous, new_resource)
+          return false unless new_resource.key?('email')
+
+          (previous['phoneNumber'] == new_resource['phoneNumber']) &&
+            (previous['prefixPhoneNumber'] == new_resource['prefixPhoneNumber']) &&
+            (previous['email'] != new_resource['email'])
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/kb/fake/bounded_context/pet_family/pets.rb

@@ -0,0 +1,84 @@
+require 'kb/fake/bounded_context/rest_resource'
+require 'date'
+# rubocop:disable Metrics/BlockLength
+
+module BoundedContext
+  module PetFamily
+    module Pets
+      extend ActiveSupport::Concern
+      include RestResource
+
+      included do
+        include RestResource
+
+        resource :pets
+
+        def pets_filterable_attributes
+          KB::Pet::FIELDS.map { |k| k.to_s.camelize(:lower) }
+        end
+
+        def on_pets_create(_version)
+          resource = JSON.parse(request.body.read)
+          resource['ageCategory'] = stage(resource['birthDate'], resource['species'])
+          resource = resource.merge 'key' => SecureRandom.uuid
+          resource_state(:pets) << resource
+          json_response 201, resource
+        end
+
+        def on_pets_update(_version)
+          resource_to_update = find_resource :pets, params['key']
+
+          return json_response 404, {} if resource_to_update.nil?
+
+          partial_resource = JSON.parse(request.body.read)
+          partial_resource['ageCategory'] = stage(partial_resource['birthDate'], resource_to_update['species'])
+          updated_resource = resource_to_update.merge partial_resource
+
+          update_resource_state(:pets, updated_resource)
+
+          json_response 200, updated_resource
+        end
+
+        get '/v1/pets/:key/contracts' do
+          contracts = resource_state(:petcontracts).select { |contract| contract['petKey'] == params['key'] }
+
+          json_response 200, contracts
+        end
+
+        put '/v1/pets' do
+          params = JSON.parse(request.body.read)
+          pet_parent = find_resource(:petparents, params['petParentKey'])
+
+          return json_response 422, {} if pet_parent.nil?
+
+          potential_matches = filter_resources(:pets, params.slice('name', 'petParentKey'))
+          existing_pet = (potential_matches.first if potential_matches.count == 1)
+
+          resource = (existing_pet || { 'key' => SecureRandom.uuid }).merge params
+
+          if existing_pet.present?
+            update_resource_state(:pets, resource)
+          else
+            resource_state(:pets) << resource
+          end
+
+          json_response 200, resource
+        end
+      end
+
+      def stage(birthdate, species)
+        return nil if birthdate.nil?
+
+        case ((Time.zone.now - Time.zone.parse(birthdate)) / 1.month).to_i
+        when 0..11
+          species == 'cat' ? 'kitten' : 'puppy'
+        when 12..99
+          'adult'
+        else
+          'senior'
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/kb/fake/bounded_context/pet_family/products.rb

@@ -0,0 +1,28 @@
+require 'kb/fake/bounded_context/rest_resource'
+
+module BoundedContext
+  module PetFamily
+    module Products
+      extend ActiveSupport::Concern
+      include RestResource
+
+      included do
+        include RestResource
+
+        resource :products, except: %i[create update destroy]
+
+        def products_filterable_attributes
+          [:country]
+        end
+
+        def on_products_index(_version)
+          return json_response 400, {} if params['country'].nil?
+
+          return json_response 422, {} if ISO3166::Country.search(params['country']).nil?
+
+          json_response 200, filter_resources(:products, params)
+        end
+      end
+    end
+  end
+end

data/lib/kb/fake/bounded_context/rest_resource.rb

@@ -0,0 +1,134 @@
+# rubocop:disable Metrics/BlockLength
+module BoundedContext
+  module RestResource
+    extend ActiveSupport::Concern
+
+    included do
+      def resource_by_key(resource, key)
+        entity = find_resource(resource, key)
+        return json_response 404, {} if entity.nil?
+
+        json_response 200, entity
+      end
+
+      def json_response(response_code, body_content)
+        content_type :json
+        status response_code
+        body body_content.to_json
+      end
+
+      def on_index_action(name, version)
+        return send("on_#{name}_index", version) if respond_to? "on_#{name}_index"
+
+        json_response 200, filter_resources(name, params)
+      end
+
+      def filter_resources(name, filters)
+        resource_state(name).select do |item|
+          item[:deleted_at].blank? && filters.slice(*filterable_attributes(name)).reduce(true) do |sum, (key, value)|
+            sum && (value.blank? \
+                    || (item.fetch(key, '') || '').downcase.include?(value.downcase))
+          end
+        end
+      end
+
+      def filterable_attributes(name)
+        try("#{name}_filterable_attributes") || []
+      end
+
+      def on_show_action(name, version)
+        return send("on_#{name}_show", version) if respond_to? "on_#{name}_show"
+
+        resource_by_key name, params['key']
+      end
+
+      def on_create_action(name, version)
+        return send("on_#{name}_create", version) if respond_to? "on_#{name}_create"
+
+        resource = JSON.parse(request.body.read)
+        resource = resource.merge 'key' => SecureRandom.uuid
+        resource_state(name) << resource
+        json_response 201, resource
+      end
+
+      def on_update_action(name, version)
+        return send("on_#{name}_update", version) if respond_to? "on_#{name}_update"
+
+        resource_to_update = find_resource name, params['key']
+
+        return json_response 404, {} if resource_to_update.nil?
+
+        partial_resource = JSON.parse(request.body.read)
+        updated_resource = resource_to_update.merge partial_resource
+
+        update_resource_state(name, updated_resource)
+
+        json_response 200, updated_resource
+      end
+
+      def on_destroy_action(name, version)
+        return send("on_#{name}_destroy", version) if respond_to? "on_#{name}_destroy"
+
+        resource_to_delete = find_resource name, params['key']
+        resource_to_delete[:deleted_at] = DateTime.now
+
+        update_resource_state(name, resource_to_delete)
+
+        json_response 204, nil
+      end
+
+      private
+
+      def find_resource(name, key)
+        resource_state(name).detect { |resource| resource['key'] == key }
+      end
+
+      def update_resource_state(name, updated_resource)
+        updated_resources = resource_state(name).map do |resource|
+          resource['key'] == updated_resource['key'] ? updated_resource : resource
+        end
+
+        set_resource_state(name, updated_resources)
+      end
+    end
+
+    class_methods do
+      def listen_on_index(name, version)
+        get "/#{version}/#{name}" do
+          on_index_action(name, version)
+        end
+      end
+
+      def listen_on_show(name, version)
+        get "/#{version}/#{name}/:key" do
+          on_show_action(name, version)
+        end
+      end
+
+      def listen_on_create(name, version)
+        post "/#{version}/#{name}" do
+          on_create_action(name, version)
+        end
+      end
+
+      def listen_on_update(name, version)
+        patch "/#{version}/#{name}/:key" do
+          on_update_action(name, version)
+        end
+      end
+
+      def listen_on_destroy(name, version)
+        delete "/#{version}/#{name}/:key" do
+          on_destroy_action(name, version)
+        end
+      end
+
+      def resource(name, version: 'v1', except: [])
+        %i[index show create update destroy].each do |action|
+          send("listen_on_#{action}", name, version) unless except.include?(action)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/kb/fake.rb

@@ -0,0 +1,6 @@
+require 'active_support'
+require 'countries'
+require 'sinatra'
+require 'webmock'
+
+require 'kb/fake/api'

data/lib/kb/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym 'KB'
+end

data/lib/kb/models/assessment.rb

@@ -0,0 +1,58 @@
+require 'kb/types'
+
+module KB
+  class Assessment < BaseModel
+    include Findable
+    include Listable
+
+    kb_api :consultation
+
+    class << self
+      def by_pet(pet)
+        all(user: pet.kb_key)
+      end
+
+      def all(filters = {})
+        filters[:locale] ||= I18n.locale
+        filters[:pet_key] = filters[:user] if filters[:user].present?
+        super(filters)
+      end
+
+      def find(key, params = {})
+        params[:locale] ||= I18n.locale
+        super(key, params)
+      end
+
+      private
+
+      def attributes_from_response(response)
+        response.transform_keys(&:underscore).transform_keys(&:to_sym).slice(*FIELDS)
+      end
+    end
+
+    # Legacy Field Name From Anamnesis
+    alias_attribute :consultation_id, :key
+    alias_attribute :should_stop, :finished
+    alias_attribute :created_at, :date
+
+    attribute :invalid_symptoms, default: [] # Deprecated ?
+    attribute :conditions, :array_of_conditions
+    attribute :symptoms, :array_of_symptoms
+
+    attribute :date, :datetime
+    attribute :finished, :boolean, default: false
+
+    attribute :urgency, :string
+    attribute :key, :string
+    attribute :pet_key, :string
+
+    STRING_FIELDS = %i[key pet_key urgency].freeze
+    FIELDS = [*STRING_FIELDS, :date, :should_stop, :finished, :conditions, :symptoms, :next_question].freeze
+
+    def urgent
+      return false if urgency == 'low'
+
+      true
+    end
+  end
+end

data/lib/kb/models/base_model.rb

@@ -0,0 +1,40 @@
+module KB
+  class BaseModel
+    include Inspectionable
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Dirty
+
+    attr_accessor :persisted
+
+    define_model_callbacks :save
+    after_save :persist!
+
+    def initialize(attributes = {})
+      super
+      @persisted = false
+      yield self if block_given?
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def persist!
+      changes_applied
+      @persisted = true
+    end
+
+    def self.define_attribute_methods(*fields)
+      super
+      fields.each do |field|
+        define_method :"#{field}=" do |value|
+          super(value).tap do
+            public_send "#{field}_will_change!" if public_send("#{field}_changed?")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kb/models/breed.rb

@@ -0,0 +1,39 @@
+module KB
+  class Breed < BaseModel
+    include Listable
+
+    DEFAULT_LOCALE = ENV.fetch('KB_BREEDS_DEFAULT_LOCALE', 'es-es')
+
+    kb_api :breed
+
+    def self.all(filters = {})
+      filters[:locale] ||= DEFAULT_LOCALE
+      super(filters)
+    end
+
+    def self.dogs(filters = {})
+      filters[:species] = 'dog'
+      all(filters)
+    end
+
+    def self.cats(filters = {})
+      filters[:species] = 'cat'
+      all(filters)
+    end
+
+    def self.attributes_from_response(response)
+      response.transform_keys(&:underscore).transform_keys(&:to_sym).slice(*FIELDS)
+    end
+
+    private_class_method :attributes_from_response
+
+    STRING_FIELDS = %i[key locale name species weight_group external_id].freeze
+    FIELDS = [*STRING_FIELDS].freeze
+
+    define_attribute_methods(*FIELDS)
+
+    STRING_FIELDS.each do |field|
+      attribute field, :string
+    end
+  end
+end