octocore 0.0.2

data/lib/octocore/models/user/user_phone_details.rb

@@ -0,0 +1,17 @@
+require 'cequel'
+
+module Octo
+  class UserPhoneDetails
+    include Cequel::Record
+
+    belongs_to :user, class_name: 'Octo::User'
+
+    key :deviceid, :text
+    column :manufacturer, :text
+    column :model, :text
+    column :os, :text
+
+    timestamps
+  end
+end
+

data/lib/octocore/models/user/user_profile.rb

@@ -0,0 +1,20 @@
+require 'cequel'
+
+module Octo
+  class UserProfileDetails
+    include Cequel::Record
+
+    belongs_to :user, class_name: 'Octo::User'
+
+    key :email, :text
+    column :username, :text
+    column :dob, :text
+    column :gender, :text
+    column :alternate_email, :text
+    column :mobile, :text
+    column :extras, :text
+
+    timestamps
+  end
+end
+

data/lib/octocore/models/user/user_timeline.rb

@@ -0,0 +1,111 @@
+require 'cequel'
+require 'ostruct'
+
+module Octo
+  class UserTimeline
+    include Cequel::Record
+
+    BROWSE_PRODUCT  = 0
+    BROWSE_PAGE     = 1
+    SEARCH          = 2
+    SHARE           = 3
+    ADD_TO_CART     = 4
+    CHECKOUT        = 5
+    APP_OPEN        = 6
+    APP_CLOSE       = 7
+    PAGE_RELOAD     = 8
+
+    LOC_HOME        = 11
+    LOC_OFFICE      = 12
+    LOC_TRANSIT     = 13
+    LOC_VACATION    = 14
+    LOC_OOH         = 15
+    LOC_OTHERS      = 16
+
+    belongs_to :user, class_name: 'Octo::User'
+
+    key :ts, :timestamp
+
+    column :type, :int
+    column :title, :text
+    column :location_type, :int
+    column :insight, :text
+    column :details, :text
+
+    timestamps
+
+    def self.fakedata(user, n = rand(7..20))
+      Array.new(3*n) do |i|
+        i+1
+      end.shuffle.sample(n).sort.reverse.collect do |i|
+        args = {
+          user: user,
+          ts: i.minutes.ago,
+          type: rand(0..8),
+          title: 'Product Name',
+          location_type: rand(11..16),
+          insight: 'some valueable insight',
+          details: 'other details here'
+        }
+        self.new(args).save!
+      end
+    end
+
+    def location_text(location_type)
+      case location_type
+      when LOC_HOME
+        'Home'
+      when LOC_OFFICE
+        'Office'
+      when LOC_TRANSIT
+        'In Transit'
+      when LOC_VACATION
+        'While Vacation'
+      when LOC_OOH
+        'Out of Home City'
+      when LOC_OTHERS
+        'Other Location'
+      end
+    end
+
+    def type_text(activity_type)
+      case activity_type
+      when BROWSE_PRODUCT
+        'Browsed for Product'
+      when BROWSE_PAGE
+        'Browsed for Page'
+      when SEARCH
+        'Searched'
+      when SHARE
+        'Shared'
+      when ADD_TO_CART
+        'Added to Cart'
+      when CHECKOUT
+        'Performed Checkout'
+      when APP_OPEN
+        'Opened App'
+      when APP_CLOSE
+        'Closed App'
+      when PAGE_RELOAD
+        'Reloaded Page'
+      end
+    end
+
+    def human_readable
+      args = {
+        user: self.user,
+        ts: self.ts,
+        type: type_text(self.type),
+        type_raw: self.type,
+        title: self.title,
+        location: location_text(self.location_type),
+        location_raw: self.location_type,
+        insight: self.insight,
+        details: self.details
+      }
+      OpenStruct.new(args)
+    end
+
+  end
+end
+

data/lib/octocore/record.rb

@@ -0,0 +1,20 @@
+module Octo
+  module Record
+
+    def unique_id
+      candidates = self.key_attributes
+      if candidates.length == 1
+        # This is most likely going to be the enterpriseid of some sort
+        candidates.first[1].to_s
+      elsif candidates.length == 2
+        if candidates.has_key?(:enterprise_id)
+          candidates.delete(:enterprise_id)
+          candidates.first[1].to_s
+        end
+      else
+        raise NotImplementedError, 'See Octo::Record#unique_id'
+      end
+    end
+
+  end
+end

data/lib/octocore/schedeuleable.rb

@@ -0,0 +1,20 @@
+require 'octocore/counter'
+
+module Octo
+  module Scheduleable
+
+    def perform(*args)
+      type = args[0].to_sym
+
+      if Octo::Counter.constants.include?type
+        if type == :TYPE_MINUTE and self.respond_to?(:aggregate!)
+          aggregate!
+        else
+          method_name = type_counters_method_names type
+          send(method_name.to_sym, Time.now.floor)
+        end
+      end
+    end
+
+  end
+end

data/lib/octocore/scheduler.rb

@@ -0,0 +1,59 @@
+require 'rake'
+require 'resque'
+require 'resque/tasks'
+require 'resque/scheduler/tasks'
+
+# Make sure dynamic scheduling is turned ON
+Resque::Scheduler.dynamic = true
+
+module Octo
+  module Scheduler
+
+    # Setup the schedules for counters.
+    def schedule_counters
+      counter_classes = [
+        Octo::ProductHit,
+        Octo::CategoryHit,
+        Octo::TagHit,
+        Octo::ApiHit,
+        Octo::NewsfeedHit
+      ]
+      counter_classes.each do |clazz|
+        clazz.send(:get_typecounters).each do |counter|
+          name = [clazz, counter].join('::')
+          config = {
+            class: clazz.to_s,
+            args: [counter],
+            cron: '* * * * *',
+            persist: true,
+            queue: 'high'
+          }
+          Resque.set_schedule name, config
+        end
+      end
+
+      # Schedules the processing of baselines
+      def schedule_baseline
+        baseline_classes = [
+            Octo::ProductBaseline,
+            Octo::CategoryBaseline,
+            Octo::TagBaseline
+        ]
+        baseline_classes.each do |clazz|
+          clazz.send(:get_typecounters).each do |counter|
+            name = [clazz, counter].join('::')
+            config = {
+                class: clazz.to_s,
+                args: [counter],
+                cron: '* * * * *',
+                persists: true,
+                queue: 'baseline_processing'
+            }
+            Resque.set_schedule name, config
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/octocore/search.rb

@@ -0,0 +1,5 @@
+require 'octocore/search/client'
+require 'octocore/search/setup'
+require 'octocore/search/indexer'
+require 'octocore/search/searchable'
+

data/lib/octocore/search/client.rb

@@ -0,0 +1,33 @@
+require 'multi_json'
+require 'faraday'
+require 'elasticsearch/api'
+
+module Octo
+
+  # Search wrapper around ElasticSearch
+  module Search
+
+    class Client
+
+      include Elasticsearch::API
+
+      CONNECTION = ::Faraday::Connection.new(url: Octo.get_config(:search)[:server])
+
+      # Low level method for performing a request to Elastic Search cluster
+      # @param [String] method The method ex: get, put, post, etc..
+      # @param [String] path The path of the request
+      # @param [Hash] params The params of the request
+      # @param [String] body The body of the request
+      def perform_request(method, path, params, body)
+        Octo.logger.debug "--> #{method.upcase} #{path} #{params} #{body}"
+
+        CONNECTION.run_request \
+          method.downcase.to_sym,
+          path,
+          ( body ? MultiJson.dump(body): nil ),
+          {'Content-Type' => 'application/json'}
+      end
+    end
+  end
+end
+

data/lib/octocore/search/searchable.rb

@@ -0,0 +1,18 @@
+module Octo
+  module Searchable
+
+    # Gets the search client
+    def searchclient
+      unless @searchClient
+        @searchClient = Octo::Search::Client.new
+      end
+      @searchClient
+    end
+
+    # Defines the indice with which this would be indexed
+    def indexable_with(indice_name, type)
+
+    end
+
+  end
+end

data/lib/octocore/search/setup.rb

@@ -0,0 +1,71 @@
+module Octo
+
+    # Setup module for ElasticSearch
+    module Setup
+
+      # Creates the necessary indices
+      class Create
+
+        def self.perform
+          sclient = Octo::Search::Client.new
+          sconfig = Octo.get_config(:search)
+
+          # Set the cluster disk space thresholds first. That's necessary
+          # because the defaults are too less for development machines. So,
+          # in order to keep it moving, we set a lower threshold in development.
+          # Refer
+          # https://www.elastic.co/guide/en/elasticsearch/reference/current/disk-allocator.html
+          if sconfig.has_key?(:disk_threshold_low) and sconfig.has_key?(:disk_threshold_high)
+            cluster_settings = {
+              body: {
+                persistent: {
+                  'cluster.routing.allocation.disk.threshold_enabled' => true,
+                  'cluster.routing.allocation.disk.watermark.low' => sconfig[:disk_threshold_low],
+                  'cluster.routing.allocation.disk.watermark.high' => sconfig[:disk_threshold_high],
+                  'cluster.info.update.interval' => '60s'
+                }
+              }
+            }
+            sclient.cluster.put_settings cluster_settings
+          end
+
+          # Check if any indices specified exists. If not exists, create them
+          sconfig[:index].keys.each do |index_name|
+            args = { index: index_name }
+            if sclient.indices.exists?(args)
+              Octo.logger.info "Search Index: #{ index_name } exists."
+            else
+              Octo.logger.warn "Search Index: #{ index_name } DOES NOT EXIST."
+              Octo.logger.info "Creating Index: #{ index_name }"
+              create_args = {
+                index: index_name,
+                body: sconfig[:index][index_name]
+              }
+              sclient.indices.create create_args
+            end
+          end
+
+          # Also check if there are any indices present that should not be
+          # present
+          _indices = JSON.parse(sclient.cluster.state)['metadata']['indices'].
+            keys.map(&:to_sym)
+          extra_indices = _indices - sconfig[:index].keys
+          Octo.logger.warn "Found extra indices: #{ extra_indices }"
+        end
+      end
+
+      # Updates the indices.
+      #   The major differene between this and the Create is that while create
+      #   just checks for the existance by name, and passes if the name is found
+      #   This actually overwrites all the mappings, properties, warmers etc
+      #   So, this should be used only when we need to explicitly "UPDATE" the
+      #   index.
+      class Update
+
+      end
+
+
+    end
+
+
+end

data/lib/octocore/segment.rb

@@ -0,0 +1,285 @@
+require 'set'
+require 'active_support/concern'
+require 'octocore/helpers/api_consumer_helper'
+
+module Octo
+
+  # The Segmentation module
+  module Segmentation
+
+    extend ActiveSupport::Concern
+
+    module Helpers
+
+      class << self
+
+        # Helper method for returning operators as a hash to be used in UX
+        # @param [Fixnum] dimension The dimension for which the operators
+        #   are to be fetched
+        # @return [Array<Hash{Symbol => String }>] The hash containing key :text
+        #   as the text to display, and another key :id as the id to be used
+        #   as reference while communicating
+        def operators_as_choice(dimension = nil)
+          mapping_as_choice operator_text
+        end
+
+        # Helper method for returning dimensions as choice to be used in the UX
+        # @return [Array<Hash{Symbol => String }>] The hash containing key :text
+        #   as the text to display, and another key :id as the id to be used
+        #   as reference while communicating
+        def dimensions_as_choice
+          mapping_as_choice dimension_text
+        end
+
+        # Returns logic operatos as a choice for operating between dimensions
+        def logic_operators_as_choice
+          mapping_as_choice logic_text
+        end
+
+        # Helper method to return valid choices for a given dimension. It tries
+        #   to find the values from db first. In case, there is nothing, it
+        #   shows some default values, so the dashboard does not look totally
+        #   blank.
+        # @param [Fixnum] dimension The dimension ID for which choices to be
+        #   found
+        # @param [String] enterprise_id The enterprise ID for which the choices
+        #   to be found
+        def choices_for_dimensions(dimension, enterprise_id)
+          args = {
+            enterprise_id: enterprise_id,
+            dimension: dimension
+          }
+          res = Octo::DimensionChoice.where(args)
+          choices = Array.new
+          if res.count > 0
+            choices = res.collect do |r|
+              r.column
+            end
+          elsif dimension_choice.has_key?(dimension)
+            func = dimension_choice[dimension]
+            choices = self.send(func, enterprise_id)
+          end
+          mapping_as_choice Hash[Array.new(choices.count) { |i| i }.zip(choices)]
+        end
+
+
+        private
+
+        # Returns a hash containing keys as Operators and the values as string
+        #   text corresponding to them.
+        def operator_text
+          {
+            Octo::Segmentation::Operators::EQUAL => '= Equals',
+            Octo::Segmentation::Operators::NOT_EQUAL => '!= Not Equals',
+            Octo::Segmentation::Operators::IN => 'Within range'
+          }
+        end
+
+        # Return a hash containing keys as dimensions and the values as methods
+        #   which should be called to populate the values
+        def dimension_choice
+          {
+            Octo::Segmentation::Dimensions::CITY => :city_choices,
+            Octo::Segmentation::Dimensions::STATE => :state_choices,
+            Octo::Segmentation::Dimensions::COUNTRY => :country_choices,
+            Octo::Segmentation::Dimensions::OS => :os_choices,
+            Octo::Segmentation::Dimensions::MANUFACTURER => :manufacturer_choices,
+            Octo::Segmentation::Dimensions::BROWSER => :browser_choices,
+            Octo::Segmentation::Dimensions::MODEL => :model_choices,
+            Octo::Segmentation::Dimensions::ENGAGEMENT => :engagement_choices
+          }
+        end
+
+        # Returns a hash containing the dimension value and the string text
+        def dimension_text
+          {
+            Octo::Segmentation::Dimensions::CITY => 'City',
+            Octo::Segmentation::Dimensions::STATE => 'State',
+            Octo::Segmentation::Dimensions::COUNTRY => 'Country',
+            Octo::Segmentation::Dimensions::OS => 'OS',
+            Octo::Segmentation::Dimensions::MANUFACTURER => 'Manufacturer',
+            Octo::Segmentation::Dimensions::BROWSER => 'Browser',
+            Octo::Segmentation::Dimensions::MODEL => 'Model',
+            Octo::Segmentation::Dimensions::ENGAGEMENT => 'Engagement',
+            Octo::Segmentation::Dimensions::LAST_ACTIVE => 'Last Active On',
+            Octo::Segmentation::Dimensions::CREATED_ON => 'Created On'
+          }
+        end
+
+        # Defines which operators can be used for which dimensions
+        def dimension_operator
+          ops = Set.new([Octo::Segmentation::Operators::EQUAL,
+                 Octo::Segmentation::Operators::NOT_EQUAL,
+                 Octo::Segmentation::Operators::IN])
+          Hash.new { |h,k| h[k] = ops }
+        end
+
+        def logic_text
+          {
+            Octo::Segmentation::Operators::AND => 'AND',
+            Octo::Segmentation::Operators::OR  => 'OR',
+            Octo::Segmentation::Operators::NOT => 'NOT',
+            Octo::Segmentation::Operators::XOR => 'XOR',
+          }
+        end
+
+        # Generates the city choices for the enterprise
+        # @param [String] enterprise_id The enterpriseID for which city choices
+        #   to be found
+        # @return [Array<String>] Array of string values
+        def city_choices(enterprise_id=nil)
+          ['New Delhi', 'Mumbai', 'Bengaluru', 'San Francisco', 'Seattle']
+        end
+
+        def state_choices(enterprise_id=nil)
+          ['Delhi', 'Maharashtra', 'Karnataka', 'California']
+        end
+
+        def country_choices(enterprise_id=nil)
+          ['India', 'United States of America (USA)']
+        end
+
+        def os_choices(enterprise_id=nil)
+          ['Windows', 'OS X', 'iOS', 'android']
+        end
+
+        def manufacturer_choices(enterprise_id=nil)
+          ['Apple', 'Dell', 'HP', 'Samsung', 'Micromax']
+        end
+
+        def browser_choices(enterprise_id=nil)
+          ['Firefox', 'Chrome', 'Safari']
+        end
+
+        def model_choices(enterprise_id=nil)
+          ['iPhone 6', 'iPhone 6s', 'iPhone 5', 'Samsung S6']
+        end
+
+        def engagement_choices(enterprise_id=nil)
+          [Octo::UserPersona::HIGH_ENGAGED,
+           Octo::UserPersona::MEDIUM_ENGAGED,
+           Octo::UserPersona::LOW_ENGAGED,
+           Octo::UserPersona::DEAD].collect { |x| Octo::UserPersona.engaged_text(x) }
+        end
+
+
+        # Converts a hash mapping into choices ready for UX
+        # @return [Array<Hash{Symbol => String }>] The hash containing key :text
+        #   as the text to display, and another key :id as the id to be used
+        #   as reference while communicating
+        def mapping_as_choice(map)
+          map.inject([]) do | choices, pair |
+            key, val = pair
+            choices << { text: val, id: key }
+          end
+        end
+
+      end
+    end
+
+    module SegmentType
+
+      USER  = 0
+      EVENT = 1
+    end
+
+    # The Operators modules. Defines Operators and necessary methods around
+    module Operators
+
+      EQUAL           = 0
+      NOT_EQUAL       = 1
+      GTE             = 2
+      GT              = 3
+      LTE             = 4
+      LT              = 5
+      IN              = 6
+      AND             = 7
+      OR              = 8
+      NOT             = 9
+      XOR             = 10
+
+      class << self
+
+        # Returns if the given operator is valid or not
+        def valid?(operator)
+          Set.new([EQUAL, NOT_EQUAL, GTE, GT, LTE, LT, IN]).include?(operator.to_i)
+        end
+
+      end
+    end
+
+    # The Dimensions module. Defines the dimensions possible and its abstraction
+    module Dimensions
+
+      # Geographical Dimensions seems most obvious
+      CITY          = 0
+      STATE         = 1
+      COUNTRY       = 2
+
+      # Followed by User's device details
+      OS            = 3
+      MANUFACTURER  = 4
+      BROWSER       = 5
+      MODEL         = 6
+
+      # Followed by User's engagement patterns
+      ENGAGEMENT      = 7
+
+      # What about their last active, created dates
+      LAST_ACTIVE     = 8
+      CREATED_ON      = 9
+
+      # Usage Pattern
+      DAYTIME_USAGE   = 10
+
+
+    end
+
+    # Extend
+    module ClassMethods
+
+      # Returns a boolean specifying if the segment is a valid choice or not
+      # @param [String] segment The string to be evaluated
+      # @return [Boolean] If the provided string exists in valid choices
+      def is_valid_segment segment
+        all_segment_choices.include?segment
+      end
+
+      # Returns all possible segment choices. Segment choices are the first
+      #   data point that is picked on top of which segment would be made. It
+      #   could be one of the supported octo events (eg: app.init etc) or users
+      def all_segment_choices
+        valid_events << :users
+      end
+
+      private
+
+      # Get all the valid events
+      # @return [Set<Symbol>] Valid events globally
+      def valid_events
+        Set.new(Octo.get_config(:allowed_events))
+      end
+
+
+
+      # Merges choices and returns the set with opts taken care of
+      # @param [Array] c The initial choices
+      # @param [Hash] opts Optional hash specifying anything to be exluded or
+      #   included
+      # @option opts [Array<String>] :include Strings to be included in choices
+      # @option opts [Array<String>] :exclude Strings to be excluded in choices
+      # @return [Array<String>] Merged choices
+      def merge_choices(c, opts={})
+        Set.new(c).merge(
+          Set.new(opts.fetch(:include, []))
+        ).subtract(
+          Set.new(opts.fetch(:exclude, []))
+        )
+      end
+
+
+    end
+
+  end
+end
+