cdp-sdk 0.14.2

data/lib/cdp/timeline/client/swagger/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'timeline-swagger-client'
+require 'cdp/timeline/response'
+require 'cdp/timeline/summary_response'
+require 'cdp/timeline/event'
+require 'cdp/timeline/client/swagger/configuration'
+
+module CDP
+  module Timeline
+    module Client
+      module Swagger
+        class Client
+
+          MAX_ATTEMPTS = 5
+          TIMEOUT_MESSAGE = 'Connection timed out'
+
+          def initialize(config: Configuration.default)
+            @client = TimelineSwaggerClient::TimelineApi.new(
+              TimelineSwaggerClient::ApiClient.new(
+                translate_config(config)
+              )
+            )
+          end
+
+          def get_timeline(tenant_id:, entity_uuid:, event_types:, limit: 10, after: nil, event_source: nil, include_lead_tracker: nil)
+            opts = {}
+            opts[:limit] = limit if limit
+            opts[:after] = after if after
+            opts[:event_source] = event_source if event_source
+            opts[:include_lead_tracker] = include_lead_tracker unless include_lead_tracker.nil?
+            api_response = send_request(
+              :v1_timeline_get,
+              tenant_id,
+              entity_uuid,
+              event_types,
+              opts
+            )
+
+            parsed_items = api_response.events.map do |event|
+              transform_event(event)
+            end
+
+            paging = CDP::Timeline::Response::Paging.new
+            paging.cursor.after = api_response.paging.cursor.after
+
+            Timeline::Response.new(
+              success: true,
+              items: parsed_items,
+              paging: paging,
+              error: api_response.error
+            )
+          rescue TimelineSwaggerClient::ApiError => error
+            Timeline::Response.new(success: false, error: error)
+          end
+
+          def get_timeline_summary(tenant_id:, entity_uuid:, event_types:, event_source: nil)
+            opts = {}
+            opts[:event_source] = event_source if event_source
+
+            summary_response = Timeline::SummaryResponse.new
+            api_response = send_request(
+              :v1_timeline_summary_get,
+              tenant_id,
+              entity_uuid,
+              event_types,
+              opts
+            )
+            summary_response.events_summary = api_response.events_summary
+            summary_response
+          rescue TimelineSwaggerClient::ApiError => error
+            response = Timeline::SummaryResponse.new
+            response.error = error
+            response
+          end
+
+          private
+
+          def send_request(client_method, *params)
+            response = nil
+            error = nil
+
+            attempts = 1
+            begin
+              @client.public_send(client_method, *params)
+            rescue TimelineSwaggerClient::ApiError => api_error
+              if retryable_error?(api_error) && attempts < MAX_ATTEMPTS
+                attempts += 1
+                retry
+              else
+                raise
+              end
+            end
+          end
+
+          def retryable_error?(api_error)
+            api_error.message == TIMEOUT_MESSAGE || api_error.code >= 500
+          end
+
+          def translate_config(cdp_config)
+            TimelineSwaggerClient::Configuration.new do |config|
+              config.scheme = cdp_config.scheme
+              config.host = cdp_config.host
+              config.base_path = cdp_config.base_path
+              config.api_key['x-api-key'] = cdp_config.api_key if cdp_config.api_key.to_s != ''
+            end
+          end
+
+          def transform_event(event)
+            CDP::Timeline::Event.new(
+              event_uuid: event.event_uuid,
+              event_timestamp: event.event_timestamp,
+              event_identifier: event.event_identifier,
+              event_type: event.event_type,
+              event_canceled_at: event.event_canceled_at,
+              payload: event.payload,
+            )
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/cdp/timeline/client/swagger/configuration.rb

@@ -0,0 +1,32 @@
+module CDP
+  module Timeline
+    module Client
+      module Swagger
+        class Configuration
+
+          attr_accessor :scheme
+          attr_accessor :host
+          attr_accessor :base_path
+          attr_accessor :api_key
+
+          def initialize
+            @scheme = 'https'
+            @host = 'cdp.rd.services'
+            @base_path = '/event_api'
+
+            yield(self) if block_given?
+          end
+
+          # The default Configuration object.
+          def self.default
+            @@default ||= Configuration.new
+          end
+
+          def configure
+            yield(self) if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cdp/timeline/event.rb

@@ -0,0 +1,56 @@
+module CDP
+  module Timeline
+    class Event
+      attr_accessor :event_uuid
+      attr_accessor :event_identifier
+      attr_accessor :event_type
+      attr_accessor :event_timestamp
+      attr_accessor :event_canceled_at
+      attr_accessor :payload
+
+      def initialize(
+        event_uuid: nil,
+        event_identifier: nil,
+        event_type: nil,
+        event_timestamp: nil,
+        event_canceled_at: nil,
+        payload: nil
+      )
+        @event_uuid = event_uuid
+        @event_identifier = event_identifier
+        @event_type = event_type
+        @event_timestamp = event_timestamp
+        @event_canceled_at = event_canceled_at
+        @payload = payload
+      end
+
+      def ==(o)
+        return true if self.equal?(o)
+        self.class == o.class &&
+          event_uuid == o.event_uuid &&
+          event_identifier == o.event_identifier &&
+          event_timestamp == o.event_timestamp &&
+          event_canceled_at == o.event_canceled_at &&
+          event_type == o.event_type &&
+          payload == o.payload
+      end
+
+      # @see the `==` method
+      # @param [Object] Object to be compared
+      def eql?(o)
+        self == o
+      end
+
+      def to_hash
+        {
+          event_uuid: event_uuid,
+          event_identifier: event_identifier,
+          event_type: event_type,
+          event_timestamp: event_timestamp,
+          event_canceled_at: event_canceled_at,
+          payload: payload,
+        }
+      end
+    end
+  end
+end

data/lib/cdp/timeline/response.rb

@@ -0,0 +1,37 @@
+module CDP
+  module Timeline
+    class Response
+      class Paging
+
+        class Cursor
+          attr_accessor :after
+        end
+
+        def initialize
+          @cursor = Cursor.new
+        end
+
+        attr_accessor :cursor
+      end
+
+      attr_reader :items, :paging, :error
+
+      def initialize(success: true, items: [], paging: nil, error: nil)
+        raise ArgumentError, "Invalid paging object." if paging && !paging.is_a?(Paging)
+
+        @success = success
+        @items = items
+        @paging = paging || Paging.new
+        @error = error
+      end
+
+      def success?
+        !!@success
+      end
+
+      def error?
+        !success?
+      end
+    end
+  end
+end

data/lib/cdp/timeline/summary_response.rb

@@ -0,0 +1,22 @@
+module CDP
+  module Timeline
+    class SummaryResponse
+
+      attr_accessor :events_summary
+      attr_accessor :error
+
+      def initialize
+        @error = false
+      end
+
+      def success?
+        !@error
+      end
+
+      def error?
+        @error
+      end
+
+    end
+  end
+end

data/lib/cdp/timeline.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'cdp/timeline/client/swagger/client'
+
+module CDP
+  module Timeline
+
+    CDP_EVENT_SOURCE = 'CDP'
+    MONGO_EVENT_SOURCE = 'MONGO'
+
+    module_function
+
+    def timeline_for_entity(tenant_id:, entity_uuid:, event_types:, limit: 10, after: nil, event_source: nil, include_lead_tracker: nil)
+      client.get_timeline(
+        tenant_id: tenant_id,
+        entity_uuid: entity_uuid,
+        event_types: event_types,
+        limit: limit,
+        after: after,
+        event_source: event_source,
+        include_lead_tracker: include_lead_tracker
+      )
+    end
+
+    def timeline_summary_for_entity(tenant_id:, entity_uuid:, event_types:, event_source: nil)
+      client.get_timeline_summary(
+        tenant_id: tenant_id,
+        entity_uuid: entity_uuid,
+        event_types: event_types,
+        event_source: event_source
+      )
+    end
+
+    def client
+      @client ||= default_client
+    end
+
+    def client=(client)
+      @client = client
+    end
+
+    def default_client
+      Client::Swagger::Client.new
+    end
+
+  end
+end

data/lib/cdp/transaction.rb

@@ -0,0 +1,10 @@
+CDP::Transaction.class_eval do
+  def <<(transaction)
+    raise ArgumentError, "transaction should be a CDP::Transaction" unless transaction.is_a?(CDP::Transaction)
+    raise ArgumentError, "transaction.item should be a CDP::Command" unless transaction.commands.all?{|command| command.is_a?(CDP::Command)}
+
+    transaction.commands.each do |command|
+      self.commands << command
+    end
+  end
+end

data/lib/cdp/validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module CDP
+  class Validator
+    def initialize(field_schema:)
+      @field_schema = field_schema
+      field_types = @field_schema[:field_types]
+
+      @fields_validations = build_statements(field_types)
+    end
+
+    def create(attributes:)
+      validator = ValidKit::Validator.new(@fields_validations.values.flatten)
+
+      validator.validate(attributes)
+    end
+
+    def update(attributes:)
+      update_validations = @fields_validations.slice(*attributes.keys.map(&:to_s))
+      validator = ValidKit::Validator.new(update_validations.values.flatten)
+
+      validator.validate(attributes)
+    end
+
+    def upsert(attributes:)
+      create(attributes: attributes)
+    end
+
+
+    def is_correlator?(field_name:)
+      return true if field_name == 'entity_uuid'
+      field = @field_schema[:field_types][field_name]
+
+      return false unless field && field.key?(:is_correlator)
+
+      field[:is_correlator]
+    end
+
+    private
+
+    def build_statements(field_types)
+      statements = {}
+
+      field_types.each do |_, field_type|
+        rules = []
+        validation_rules = field_type[:validation_rules]
+
+        next unless validation_rules
+
+        validation_rules.each do |key, value|
+          next unless value
+
+          rule = create_rule(key, value)
+          rules << rule if rule
+        end
+
+        statements[field_type[:name]] = ValidKit::Statement.new(path: "$.#{field_type[:name]}",
+                                              data_type: field_type[:data_type],
+                                              rules: rules)
+
+      end
+
+      statements
+    end
+
+    def create_rule(rule_type, rule_params)
+      case rule_type
+      when :length
+        ValidKit::Rule::Length.new(min: rule_params[:min], max: rule_params[:max])
+      when :required
+        ValidKit::Rule::Required.new
+      end
+    end
+  end
+end

data/lib/cdp/value.rb

@@ -0,0 +1,98 @@
+module CDP
+  class Value
+    def value_type
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.value_type
+    end
+
+    def raw
+      case value_type
+      when :string_value
+        string_value
+      when :text_value
+        text_value
+      when :bool_value
+        bool_value
+      when :int_value
+        int_value
+      when :float_value
+        float_value
+      when :timestamp_value
+        time = timestamp_value
+        Time.at(time.seconds, time.nanos)
+      else
+        raise 'value type "%s" is not valid' % [value_type]
+      end
+    end
+    
+    def string_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.string_value
+    end
+
+    def self.create_string(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_string(field_value))
+    end  
+
+    def text_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.text_value
+    end
+
+    def self.create_text(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_text(field_value))
+    end  
+
+    def bool_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.bool_value
+    end
+
+    def self.create_bool(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_bool(field_value))
+    end  
+
+    def int_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.int_value
+    end
+
+    def self.create_int(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_int(field_value))
+    end  
+
+    def float_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.float_value
+    end
+
+    def self.create_float(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_float(field_value))
+    end  
+
+    def timestamp_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.timestamp_value
+    end
+
+    def self.create_timestamp(field_value)
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_timestamp(field_value))
+    end  
+
+    def array_value
+      raise ArgumentError, "value is empty" if self.value.nil?
+      self.value.array_value
+    end
+
+    def self.create_set_values(field_value)
+      set_values = field_value.map do |item|
+        Platform::Model::ValueBuilder.create_string(item)
+      end
+
+      CDP::Value.new(value: Platform::Model::ValueBuilder.create_array(
+        Platform::Model::ValueType::STRING,
+        set_values
+      ))
+    end  
+  end
+end

data/lib/cdp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CDP
+  VERSION = '0.14.2'
+end

data/lib/cdp.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'platform-model'
+require 'cdp/schema_client'
+require 'cdp/version'
+
+require 'persistency_pb'
+require 'persistency_services_pb'
+require 'legacy_pb'
+require 'legacy_services_pb'
+
+require 'cdp/builders/entity'
+require 'cdp/builders/event'
+require 'cdp/builders/after_created'
+require 'cdp/builders/value'
+require 'cdp/validator'
+require 'cdp/builder'
+require 'cdp/client'
+require 'cdp/query/actions'
+require 'cdp/persistency'
+require 'cdp/transaction'
+require 'cdp/value'
+
+module CDP
+  class Error < StandardError; end
+
+  class InvalidCorrelatorError < Error; end
+
+  class SchemaMissingFieldError < Error; end
+
+  class InvalidFieldTypeError < Error; end
+
+  class InvalidEntityError < Error
+    def initialize(errors)
+      @errors = errors
+      super(errors)
+    end
+  end
+end

data/lib/common_pb.rb

@@ -0,0 +1,30 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: common.proto
+
+require 'google/protobuf'
+
+require 'value_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("common.proto", :syntax => :proto3) do
+    add_message "cdp.CommandReference" do
+      optional :id, :string, 1
+    end
+    add_message "cdp.Value" do
+      oneof :_value do
+        optional :value, :message, 1, "platformmodel.Value"
+        optional :reference, :message, 2, "cdp.CommandReference"
+      end
+    end
+    add_message "cdp.FieldCondition" do
+      optional :field_name, :string, 1
+      optional :field_value, :message, 2, "cdp.Value"
+    end
+  end
+end
+
+module CDP
+  CommandReference = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.CommandReference").msgclass
+  Value = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.Value").msgclass
+  FieldCondition = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.FieldCondition").msgclass
+end

data/lib/configuration.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Configuration
+  CDP_CORE_SERVICE_URL = ENV.fetch('CDP_CORE_SERVICE_URL', 'localhost:8080')
+end

data/lib/legacy_pb.rb

@@ -0,0 +1,49 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: legacy.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/struct_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("legacy.proto", :syntax => :proto3) do
+    add_message "cdp.legacy.ContactScoreRequest" do
+      optional :tenant_id, :int64, 1
+      repeated :contact_uuids, :string, 2
+      repeated :event_types, :string, 3
+    end
+    add_message "cdp.legacy.ContactScoreResponse" do
+      repeated :responses, :message, 1, "google.protobuf.Struct"
+    end
+    add_message "cdp.legacy.ExistsEventRequest" do
+      optional :tenant_id, :string, 1
+      optional :type, :string, 2
+      optional :event_identifier, :string, 3
+      optional :contact_uuid, :string, 4
+    end
+    add_message "cdp.legacy.ExistsEventResponse" do
+      optional :response, :bool, 1
+    end
+    add_message "cdp.legacy.GetEventRequest" do
+      optional :tenant_id, :string, 1
+      optional :type, :string, 2
+      optional :event_identifier, :string, 3
+      optional :contact_uuid, :string, 4
+      repeated :field_projection, :string, 5
+    end
+    add_message "cdp.legacy.GetEventResponse" do
+      repeated :responses, :message, 1, "google.protobuf.Struct"
+    end
+  end
+end
+
+module CDP
+  module Legacy
+    ContactScoreRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.ContactScoreRequest").msgclass
+    ContactScoreResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.ContactScoreResponse").msgclass
+    ExistsEventRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.ExistsEventRequest").msgclass
+    ExistsEventResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.ExistsEventResponse").msgclass
+    GetEventRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.GetEventRequest").msgclass
+    GetEventResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("cdp.legacy.GetEventResponse").msgclass
+  end
+end

data/lib/legacy_services_pb.rb

@@ -0,0 +1,26 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: legacy.proto for package 'CDP.Legacy'
+
+require 'grpc'
+require 'legacy_pb'
+
+module CDP
+  module Legacy
+    module Service
+      class Service
+
+        include ::GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'cdp.legacy.Service'
+
+        rpc :GetContactScore, ::CDP::Legacy::ContactScoreRequest, ::CDP::Legacy::ContactScoreResponse
+        rpc :ExistsEvent, ::CDP::Legacy::ExistsEventRequest, ::CDP::Legacy::ExistsEventResponse
+        rpc :GetEvent, ::CDP::Legacy::GetEventRequest, ::CDP::Legacy::GetEventResponse
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+  end
+end