betterplace-bi 0.7.0

data/lib/bi/event.rb

@@ -0,0 +1,52 @@
+module BI
+  class Event
+    def self.write(**args)
+      new.write(**args)
+    end
+
+    def event_class
+      cc.bi.event_class.constantize
+    end
+
+    # The parameter +channel+ is the channel that selects an ab test from the
+    # configuration.
+    # The paramter +name+ is the name of the event, e. g. show_form.
+    # The parameter session is either a session object or a session id string.
+    # In the former case the session object will be loaded if hasn't been
+    # loaded yet to generate the unique session id we need..
+    # The remaining parameters +**data+ are passed through to the created event
+    # as tracking parameters.
+    def write(
+      channel:, name:, version:, session:,
+      **data
+    )
+      event_class < BI::Tracking or
+        raise TypeError, 'event class has to mixin BI::Tracking'
+
+      if session.respond_to?(:loaded?)
+        session.loaded? or session.send(:load!)
+        session = BI::SessionID.session_id(session)
+      elsif session.respond_to?(:to_str)
+        session = session.to_str
+      else
+        session = nil
+      end
+
+      created_event = event_class.create!(
+        tracking: {
+          channel:              channel,
+          name:                 name,
+          version:              version,
+          session:              session,
+          **data.transform_keys { |k| k.to_s.sub(/\Atracking_/, '').to_sym },
+        }
+      )
+      Log.info "Stored a #{self.class} for #{name}",
+        meta: { module: 'bi', event: created_event.attributes }
+      created_event
+    rescue => e
+      Log.error(e, notify: true, meta: { module: 'bi' })
+      raise e
+    end
+  end
+end

data/lib/bi/planning_value_parser.rb

@@ -0,0 +1,100 @@
+require 'csv'
+require 'set'
+
+module BI
+  class PlanningValueParser
+    class ParserError < StandardError
+      attr_accessor :row
+
+      attr_accessor :line
+    end
+
+    def self.parse(csv_text, class_name:)
+      begin
+        model_class = Object.const_get(class_name)
+      rescue NameError
+        raise ParserError, "unknown class name #{class_name.inspect}"
+      end
+      csv_text = csv_text.gsub(/\r\n?/, "\n")
+      errors = {}
+      values = []
+      table = CSV.parse(csv_text, headers: true, row_sep: ?\n, col_sep: ?;)
+      table.each_with_index do |row, i|
+        values << Check.new(row, line: i + 2, class_name: class_name).value
+      rescue ParserError => e
+        errors[e.line] = e.message
+      end
+      new(values, errors: errors, model_class: model_class)
+    end
+
+    def initialize(values, model_class:, errors: [])
+      @model_class = model_class
+      @values = values
+      @errors = errors
+    end
+
+    attr_reader :model_class
+
+    def import
+      model_class.where(data_version: data_versions).
+        destroy_all
+      each { |pv| pv.save! }
+      self
+    end
+
+    include Enumerable
+    def each(&block)
+      @values.each(&block)
+    end
+
+    def data_versions
+      @values.each_with_object(Set[]) { |v, s| s << v.data_version }.to_a
+    end
+
+    def valid?
+      @errors.blank? && all?(&:valid?)
+    end
+
+    def errors
+      if @errors.present?
+        @errors
+      else
+        @values.each_with_index.each_with_object({}) do |(v, i), errors|
+          v.valid?
+          e = v.errors.messages.full? or next
+          errors[i + 2] = e.transform_values { |value| value.join(' & ') }.
+            map { |a| "%s: %s" % a }.join(' | ')
+        end
+      end
+    end
+
+    VALID_HEADERS = [
+      "amount_in_cents",
+      "data_type",
+      "data_version",
+      "product_tracking",
+      "yearmonth",
+    ].sort
+
+    class Check
+      def initialize(row, line:, class_name:)
+        parser_error = ParserError.new.tap { |pe|
+          pe.row  = row
+          pe.line = line
+        }
+        if row.size != VALID_HEADERS.size
+          raise parser_error,
+            "#values has to match #headers = #{VALID_HEADERS.size}"
+        end
+        if row.headers.sort != VALID_HEADERS
+          raise parser_error, "headers need to be #{VALID_HEADERS.inspect}"
+        end
+        @value = Object.const_get(class_name).new(row.to_h)
+      end
+
+      attr_reader :value
+
+      delegate :valid?, to: :@value
+    end
+  end
+end

data/lib/bi/planning_value_validations.rb

@@ -0,0 +1,15 @@
+module BI
+  module PlanningValueValidations
+    extend ActiveSupport::Concern
+
+    included do
+      validates :product_tracking, presence: true
+      validates :amount_in_cents, presence: true,
+        numericality: { only_integer: true }
+      validates :yearmonth, presence: true,
+        format: { with: /\A[0-9]{4}-(1[0-2]|0[1-9])\z/ }
+      validates :data_type, presence: true
+      validates :data_version, presence: true
+    end
+  end
+end

data/lib/bi/railtie.rb

@@ -0,0 +1,13 @@
+module BI
+  if defined?(Rails::Railtie)
+    class Railtie < Rails::Railtie
+      initializer 'bi.configure_rails_initialization' do |app|
+        app.config.active_job.custom_serializers << BI::Commands::Serializer
+      end
+
+      rake_tasks do
+        load 'tasks/bime.rake'
+      end
+    end
+  end
+end

data/lib/bi/request_analyzer.rb

@@ -0,0 +1,64 @@
+module BI
+  class RequestAnalyzer
+    def initialize(request)
+      @request = request
+    end
+
+    attr_reader :request
+
+    def user_agent
+      request.user_agent
+    end
+
+    def ignore?
+      preview? || robot?
+    end
+
+    def preview?
+      request.headers['x-purpose'] == 'preview'
+    end
+
+    def robot?
+      robot_regexp.match?(user_agent)
+    end
+
+    def mobile?
+      mobile_regexp.match?(user_agent)
+    end
+
+    def device_type
+      case
+      when mobile?
+        :mobile
+      when robot?
+        :bot
+      else
+        :desktop
+      end
+    end
+
+    private
+
+    def user_agent_configuration
+      cc.bi.requests.user_agents?
+    end
+
+    memoize function:
+    def robot_regexp
+      combine_patterns(user_agent_configuration&.robot?)
+    end
+
+    memoize function:
+    def mobile_regexp
+      combine_patterns(user_agent_configuration&.mobile?)
+    end
+
+    def combine_patterns(patterns)
+      if patterns
+        /\b(?:#{patterns.to_h.keys * ?|})\b|\A\W*\z/i
+      else
+        /\p{^any}/
+      end
+    end
+  end
+end

data/lib/bi/session_id.rb

@@ -0,0 +1,11 @@
+module BI
+  module SessionID
+    def self.session_id(session)
+      if session.respond_to?(:id)
+        session.id.inspect[/\A"(\h*)"\z/i, 1].to_s
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/bi/shared_value.rb

@@ -0,0 +1,102 @@
+require 'active_support/time'
+
+module BI
+  module SharedValue
+    extend Tins::Concern
+
+    included do
+      annotate :field
+
+      include GlobalID::Identification
+    end
+
+    module ClassMethods
+      def find(id)
+        new(update_class.find(id.ask_and_send_or_self(:id)))
+      end
+
+      implement def update_class() end, :subclass
+
+      GormTimestamp = Struct.new(:type, :gorm)
+
+      memoize function:
+      def bp_timestamp
+        Hash.new do |_, k|
+          raise KeyError, "illegal Attribute name #{k.inspect}"
+        end.merge(
+          Local:          GormTimestamp.new('*time.Time', 'gorm:"type:timestamp;index"'),
+          YearLocal:      GormTimestamp.new('*int', 'gorm:"type:int;index"'),
+          MonthLocal:     GormTimestamp.new('*int', 'gorm:"type:int;index"'),
+          DayLocal:       GormTimestamp.new('*int', 'gorm:"type:int;index"'),
+          HourLocal:      GormTimestamp.new('*int', 'gorm:"type:int;index"'),
+          CWLocal:        GormTimestamp.new('*int', 'gorm:"type:int;index"'),
+          DateLocal:      GormTimestamp.new('*string', 'gorm:"type:varchar;index"'),
+          YearMonthLocal: GormTimestamp.new('*string', 'gorm:"type:varchar;index"'),
+          YearCWLocal:    GormTimestamp.new('*string', 'gorm:"type:varchar;index"'),
+        )
+      end
+
+      def url(method: 'POST', id: nil)
+        if ep = cc.bi.endpoints[name]
+          if u = ep[method]
+            id and return u = u.sub(':id', id)
+            u
+          end
+        end
+      end
+
+      def clear
+        command = BI::Commands::Delete.new(
+          url: cc.bi.clear.sub(':id', update_class.name)
+        )
+        BI::Commands::Connection.connect_to_server do |connection|
+          command.perform_via(connection)
+        end
+        self
+      end
+    end
+
+    def initialize(object)
+      if object_uuid = object.ask_and_send(:to_str)
+        object = update_class.find(object_uuid)
+      end
+      @object = object
+    end
+
+    private
+
+    def iso_timestamp(time)
+      if time
+        time.in_time_zone('Europe/Berlin').strftime('%FT%T.%6NZ') # with precision 6 sub seconds
+      end
+    end
+
+    public
+
+    def update_class
+      self.class.update_class
+    end
+
+    def url(**args)
+      self.class.url(**args)
+    end
+
+    def to_s
+      "#<#{self.class} type=#{update_class} id=#{@object.id}>"
+    end
+
+    def attributes
+      field_annotations.each_with_object({}) do |(name, opts), result|
+        result[name] = __send__(name)
+      end
+    end
+
+    def as_json(*)
+      attributes
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+  end
+end

data/lib/bi/tracking.rb

@@ -0,0 +1,28 @@
+module BI
+  module Tracking
+    extend ActiveSupport::Concern
+
+    included do
+      serialize :tracking, coder: JSON
+    end
+
+    def tracking_hash
+      tracking.to_h.symbolize_keys
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name =~ /\Atracking_(.+=|.*[^?!])\z/ or super
+    end
+
+    def method_missing(name, *args, &block)
+      case name
+      when /\Atracking_(.+)=\z/
+        tracking[$1] = args.first
+      when /\Atracking_(.*[^?!])\z/
+        tracking[$1]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/bi/type_generator.rb

@@ -0,0 +1,79 @@
+module BI
+  class TypeGenerator
+    def initialize(output_dir: cc.bi.bime_dir)
+      @output_dir    = Pathname.new(output_dir)
+      @value_classes = cc.bi.endpoints.attribute_names.
+        map(&:to_s).map(&:constantize)
+    end
+
+    def timestamp_value(attribute_name, attribute_suffix, db_value)
+      %{  #{attribute_name + attribute_suffix.to_s} #{db_value.type} `json:"-" #{db_value.gorm}`}
+    end
+
+    def gofmt
+      command = `which gofmt`.chomp
+      return if command.empty?
+      command
+    end
+
+    def generate
+      STDOUT.puts "Generating GO types in directory #{@output_dir}"
+      @value_classes.each do |vc|
+        c = vc.name.demodulize
+        output_filename = @output_dir.join(vc.update_class.name.underscore + ".go")
+        temp_io(name: 'go-type', content: -> src {
+          code =  ''
+          STDOUT.print "Generating type code for #{c} …"
+          imports = Set[]
+          vc.field_annotations.each do |name, opts|
+            attribute_name = name.to_s.camelize
+            db = opts.fetch(:db)
+            case type = opts.fetch(:type)
+            when '*time.Time'
+              imports << 'time'
+              code << %{  #{attribute_name} #{type} `json:"#{name}" gorm:"-" timestamp:"split"`\n}
+              db.each do |attribute_suffix, db_value|
+                code << timestamp_value(attribute_name, attribute_suffix, db_value) << "\n"
+              end
+              next
+            when 'pq.StringArray'
+              imports << 'github.com/lib/pq'
+            end
+            code << %{  #{attribute_name} #{type} `json:"#{name}" #{db}`\n}
+          rescue KeyError, NoMethodError => e
+            raise "Error for #{name} #{e.class}: #{e}"
+          end
+          code << "}\n"
+          code = preamble(vc.update_class, imports: imports) + code
+          src.write code
+          STDOUT.puts "done."
+        }) do |src|
+          STDOUT.print "Outputting type code to #{output_filename} …"
+          File.open(output_filename, ?w) do |out|
+            if g = gofmt
+              out.puts `#{g} #{src.path}`
+            else
+              out.puts IO.read(src.path)
+            end
+          end
+          STDOUT.puts "done."
+        end
+      end
+    end
+
+    private
+
+    def preamble(type_name, imports:)
+      result = "package bime\n\n"
+      if i = imports.full?(:to_a)
+        result << <<~end
+          import (
+          #{i.map { |x| "  #{x.dump}" }.join(?\n)}
+          )
+
+        end
+      end
+      result << "type #{type_name} struct {\n"
+    end
+  end
+end

data/lib/bi/update_error.rb

@@ -0,0 +1,4 @@
+module BI
+  class UpdateError < StandardError
+  end
+end

data/lib/bi/updater.rb

@@ -0,0 +1,61 @@
+module BI
+  module Updater
+    extend Tins::Concern
+
+    included do
+      before_save :schedule_bi_update_job_on_change, if: :changed?
+
+      before_destroy :schedule_bi_update_job_on_change
+
+      after_commit :schedule_bi_update_job
+
+      thread_local :change_detected, false
+    end
+
+    class << self
+      thread_local :bi_commands
+    end
+
+    def schedule_bi_update_job_on_change
+      self.change_detected = true
+    end
+
+    def bi_commands
+      BI::Updater.bi_commands ||= BI::Commands::Collector.new
+      yield BI::Updater.bi_commands
+      if BI::Updater.bi_commands.schedule_job?(self)
+        BI::Updater.bi_commands.schedule_job
+        BI::Updater.bi_commands = nil
+      end
+    end
+
+    def bi_update(really = true)
+      if cc.bi.update
+        if really
+          self.change_detected = false # Set to false as early as possible
+          bi_commands do |commands|
+            value_type = "BI::%sValue" % self.class.name
+            begin
+              value_class = value_type.constantize
+            rescue NameError => e
+              BI.error(e, notify: true, meta: { module: 'bi' })
+            else
+              BI::Updater.bi_commands.add(self, value_class)
+            end
+            ask_and_send(:trigger_dependent_updates)
+          end
+        end
+      else
+        Log.info "Would send a BI Command for #{self.class}##{id} if not disabled"
+      end
+    end
+
+    def schedule_bi_update_job(default_change_detected = false)
+      self.change_detected ||= default_change_detected
+      bi_update(change_detected)
+      true
+    ensure
+      self.change_detected = false
+    end
+  end
+end

data/lib/bi/version.rb

@@ -0,0 +1,8 @@
+module BI
+  # BI version
+  VERSION         = '0.7.0'
+  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/bi.rb

@@ -0,0 +1,27 @@
+require 'complex_config/rude'
+require 'tins/xt'
+require 'globalid'
+require 'excon'
+require 'logger'
+require 'betterlog'
+
+module BI
+end
+
+require 'bi/version'
+require 'bi/railtie'
+require 'bi/shared_value'
+require 'bi/type_generator'
+require 'bi/update_error'
+require 'bi/updater'
+require 'bi/commands'
+require 'bi/commands_job' if defined?(ActiveJob::Base)
+
+require 'bi/planning_value_validations'
+require 'bi/planning_value_parser'
+require 'bi/session_id'
+require 'bi/event'
+require 'bi/request_analyzer'
+require 'bi/tracking'
+require 'bi/ab_test_helper'
+require 'bi/api'

data/lib/tasks/bime.rake

@@ -0,0 +1,55 @@
+namespace :bime do
+  desc 'Generate golang type definitions'
+  task :types => :environment do
+    BI::TypeGenerator.new.generate
+  end
+
+  silence = proc { |&b| ActiveJob::Base.logger.silence(&b) }
+
+  desc 'Update all BI values'
+  task :update => :environment do |task, args|
+    cc.bi.update or raise "BI Update was disabled in cc.bi.update!"
+
+    args = args.to_a
+
+    if args.empty?
+      args.concat(cc.bi.endpoints.attribute_names.map { |n|
+        n.to_s.demodulize.sub(/Value\z/, '').underscore
+      })
+    end
+
+    models = args.map { |a| a.camelize.constantize }
+
+    silence.() {
+      models.each do |model|
+        model.find_each.with_infobar(label: model.name) do |o|
+          infobar << o.bi_update
+        end
+        infobar.finish
+        infobar.newline
+      end
+    }
+  end
+
+  desc 'Clear all BI values'
+  task :clear => :environment do |task, args|
+    cc.bi.update or raise "BI Update was disabled in cc.bi.update!"
+
+    args = args.to_a
+    if args.empty?
+      args.concat(cc.bi.endpoints.attribute_names.map { |n|
+        n.to_s.demodulize.sub(/Value\z/, '').underscore
+      })
+    end
+
+    args.each.with_infobar(label: 'BI Values') do |v|
+      infobar << "BI::#{(v + '_value').camelize}".constantize.clear
+    end
+
+    infobar.finish
+    infobar.newline
+  end
+
+  desc 'Reset all BI values'
+  task :reset => %i[ clear update ]
+end