octocore 0.0.2

data/lib/octocore/counter/helpers.rb

@@ -0,0 +1,168 @@
+module Octo
+  module Counter
+    module Helper
+
+
+      #The prefix to use when converting a type constant into an
+      #aggregator method name
+      METHOD_PREFIX = 'aggregate'
+
+
+      # Defined the method names for the type counters.
+      def type_counters_method_names(type = nil)
+        if type.nil?
+          get_typecounters.map do |typ|
+            [METHOD_PREFIX, typ.to_s.downcase].join('_')
+          end
+        else
+          [METHOD_PREFIX, type.to_s.downcase].join('_')
+        end
+      end
+
+      # Get all the type counters i.e. TYPE_MINUTE_30 etc from
+      #   Counter class.
+      # @return [Array] Array of all the constants that define a counter type
+      def get_typecounters
+        max = max_type
+        Counter.constants.select do |x|
+          if x.to_s.start_with?('TYPE')
+            Counter.const_get(x) <= max
+          else
+            false
+          end
+        end
+      end
+
+      # Define the max granularity that should exist
+      def max_type(type = nil)
+        if @max_type
+          @max_type
+        else
+          if type
+            @max_type = type
+          else
+            @max_type = 9
+          end
+        end
+        @max_type
+      end
+
+      # Coverts the method name to the constant type
+      # @param [String] method_name The method name to convert into constant
+      # @return [Symbol] The constant
+      def method_names_type_counter(method_name)
+        prefix, *counterType = method_name.to_s.split('_')
+        if prefix == METHOD_PREFIX
+          cnst = counterType.join('_').upcase.to_sym
+          string_to_const_val(cnst)
+        end
+      end
+
+      # Converts a string (which may represent a counter constant) into its
+      #   corresponding constant
+      # @param [String] cnst The string which may represent a constant
+      # @return [Fixnum] The constant value; iff the string represent a constant.
+      #   Nil otherwise
+      def string_to_const_val(cnst)
+        index = Counter.constants.index(cnst)
+        if index
+          Counter.const_get(cnst)
+        end
+      end
+
+      # Generates a fromtype for a totype. This defines the relation
+      #  of aggregation needed for the counters.
+      def get_fromtype_for_totype(totype)
+        case totype
+          when TYPE_MINUTE_30
+            TYPE_MINUTE
+          when TYPE_HOUR
+            TYPE_MINUTE_30
+          when TYPE_HOUR_3
+            TYPE_HOUR
+          when TYPE_HOUR_6
+            TYPE_HOUR_3
+          when TYPE_HOUR_12
+            TYPE_HOUR_6
+          when TYPE_DAY
+            TYPE_HOUR_6
+          when TYPE_DAY_3
+            TYPE_DAY
+          when TYPE_DAY_6
+            TYPE_DAY_3
+          when TYPE_WEEK
+            TYPE_DAY_3
+          else
+            TYPE_WEEK
+        end
+      end
+
+      # Gets the duration for a particular counter type. This helps in
+      #    aggregation.
+      # @param [Fixnum] type The counter type
+      # @param [Time] ts The time at wich duration needs to be passed
+      # @return [Time] The time or time range for the given specs
+      def get_duration_for_counter_type(type, ts=Time.now.ceil)
+        start_time, step =  case type
+                              when TYPE_MINUTE
+                                [2.minute.ago, 1.minute]
+                              when TYPE_MINUTE_30
+                                [30.minute.ago, 1.minute]
+                              when TYPE_HOUR
+                                [1.hour.ago, 30.minute]
+                              when TYPE_HOUR_3
+                                [3.hour.ago, 1.hour]
+                              when TYPE_HOUR_6
+                                [6.hour.ago, 3.hour]
+                              when TYPE_HOUR_12
+                                [12.hour.ago, 6.hour]
+                              when TYPE_DAY
+                                [1.day.ago, 6.hour]
+                              when TYPE_DAY_3
+                                [3.day.ago, 1.day]
+                              when TYPE_DAY_6
+                                [6.day.ago, 3.day]
+                              when TYPE_WEEK
+                                [1.week.ago, 1.week]
+                            end
+        start_time.ceil.to(ts, step)
+      end
+
+      # Returns the mapping for counters as text
+      # @return [Hash]
+      def self.counter_text
+        {
+          TYPE_MINUTE => 'Near Real Time',
+          TYPE_MINUTE_30 => '30 Minute',
+          TYPE_HOUR => 'Hourly',
+          TYPE_HOUR_3 => '3 Hourly',
+          TYPE_HOUR_6 => '6 Hourly',
+          TYPE_HOUR_12 => '12 Hourly',
+          TYPE_DAY => 'Daily',
+          TYPE_DAY_3 => '3 Days',
+          TYPE_DAY_6 => '6 Days',
+          TYPE_WEEK => 'Weekly'
+        }
+      end
+
+      # Generate aggregator methods for a class. You can pass
+      # your own block to generator for all custom needs.
+      # Check out the implementation at Octo::Counter#countables
+      # or Octo::Trends#trendable
+      # @param [Block] block The block to be evaluated while executing
+      #   the method
+      def generate_aggregators(&block)
+        @stored_block = block
+        type_counters_method_names.each do |method_name|
+          singleton_class.module_eval(<<-RUBY, __FILE__, __LINE__+1)
+            def #{ method_name } (ts=Time.now.floor)
+              bl = self.instance_variable_get(:@stored_block)
+              instance_exec(ts, __method__, &bl) if bl
+            end
+          RUBY
+        end
+      end
+
+    end
+  end
+end

data/lib/octocore/helpers.rb

@@ -0,0 +1,6 @@
+require 'octocore/helpers/api_helper'
+require 'octocore/helpers/api_logger'
+require 'octocore/helpers/api_consumer_helper'
+require 'octocore/helpers/client_helper'
+require 'octocore/helpers/kong_helper'
+require 'octocore/helpers/sinatra_helper'

data/lib/octocore/helpers/api_consumer_helper.rb

@@ -0,0 +1,371 @@
+require 'json'
+require 'set'
+
+module Octo
+  module Helpers
+
+    module ApiConsumerHelper
+
+      # Get all the valid events
+      # @return [Set<Symbol>] Valid events globally
+      def valid_events
+        Set.new(Octo.get_config(:allowed_events))
+      end
+
+      # Get the API events. These are the ones that the client is billed for
+      #   This should eventually be placed under kong helpers when that is
+      #   ready
+      # @return [Set<Symbol>] Set of api_events
+      def api_events
+        Set.new(%w(app.init app.login app.logout page.view productpage.view update.profile))
+      end
+
+      def handle(msg)
+        msg_dump = msg
+        msg = parse(msg)
+
+        eventName = msg.delete(:event_name)
+
+        if valid_events.include?eventName
+          enterprise = checkEnterprise(msg)
+          unless enterprise
+            Octo.logger.info 'Unable to find enterprise. Something\'s wrong'
+          end
+          user = checkUser(enterprise, msg)
+
+          hook_opts = {
+              enterprise: enterprise,
+              user: user
+          }
+
+          if api_events.include?eventName
+            hook_opts[:event] = register_api_event(enterprise, eventName)
+          end
+
+          Octo::ApiTrack.new(customid: msg[:id],
+                            created_at: Time.now,
+                            json_dump: msg_dump,
+                            type: eventName).save!
+
+          case eventName
+            when 'app.init'
+              Octo::AppInit.new(enterprise: enterprise,
+                                created_at: Time.now,
+                                userid: user.id).save!
+              updateUserDeviceDetails(user, msg)
+              call_hooks(eventName, hook_opts)
+            when 'app.login'
+              Octo::AppLogin.new(enterprise: enterprise,
+                                 created_at: Time.now,
+                                 userid: user.id).save!
+              updateUserDeviceDetails(user, msg)
+              call_hooks(eventName, hook_opts)
+            when 'app.logout'
+              event = Octo::AppLogout.new(enterprise: enterprise,
+                                          created_at: Time.now,
+                                          userid: user.id).save!
+              updateUserDeviceDetails(user, msg)
+              call_hooks(eventName, hook_opts)
+            when 'page.view'
+              page, categories, tags = checkPage(enterprise, msg)
+              Octo::PageView.new(enterprise: enterprise,
+                                 created_at: Time.now,
+                                 userid: user.id,
+                                 routeurl: page.routeurl
+              ).save!
+              updateUserDeviceDetails(user, msg)
+              call_hooks(eventName, hook_opts)
+            when 'productpage.view'
+              product, categories, tags = checkProduct(enterprise, msg)
+              Octo::ProductPageView.new(
+                                       enterprise: enterprise,
+                                       created_at: Time.now,
+                                       userid: user.id,
+                                       product_id: product.id
+              ).save!
+              updateUserDeviceDetails(user, msg)
+              hook_opts.merge!({ product: product,
+                                 categories: categories,
+                                 tags: tags })
+              call_hooks(eventName, hook_opts)
+            when 'update.profile'
+              checkUserProfileDetails(enterprise, user, msg)
+              updateUserDeviceDetails(user, msg)
+              call_hooks(eventName, hook_opts)
+            when 'update.push_token'
+              checkPushToken(enterprise, user, msg)
+              checkPushKey(enterprise, msg)
+          end
+        end
+      end
+
+      private
+
+      def register_api_event(enterprise, event_name)
+        Octo::ApiEvent.findOrCreate({ enterprise_id: enterprise.id,
+                                      eventname: event_name})
+      end
+
+      def call_hooks(event, *args)
+        hook = [:after, event.gsub('.', '_')].join('_').to_sym
+        Octo::Callbacks.run_hook(hook, *args)
+      end
+
+      def checkUserProfileDetails(enterprise, user, msg)
+        args = {
+          user_id: user.id,
+          user_enterprise_id: enterprise.id,
+          email: msg[:profileDetails].fetch('email')
+        }
+        opts = {
+          username: msg[:profileDetails].fetch('username', ''),
+          gender: msg[:profileDetails].fetch('gender', ''),
+          dob: msg[:profileDetails].fetch('dob', ''),
+          alternate_email: msg[:profileDetails].fetch('alternate_email', ''),
+          mobile: msg[:profileDetails].fetch('mobile', ''),
+          extras: msg[:profileDetails].fetch('extras', '{}').to_s
+        }
+        Octo::UserProfileDetails.findOrCreateOrUpdate(args, opts)
+      end
+
+      # Checks for push tokens and creates or updates it
+      # @param [Octo::Enterprise] enterprise The Enterprise object
+      # @param [Octo::User] user The user to whom this token belongs to
+      # @param [Hash] msg The message hash
+      # @return [Octo::PushToken] The push token object corresponding to this user
+      def checkPushToken(enterprise, user, msg)
+        args = {
+          user_id: user.id,
+          user_enterprise_id: enterprise.id,
+          push_type: msg[:pushType].to_i
+        }
+        opts = {
+          pushtoken: msg[:pushToken]
+        }
+        Octo::PushToken.findOrCreateOrUpdate(args, opts)
+      end
+
+      # Checks for push keys and creates or updates it
+      # @param [Octo::Enterprise] enterprise The Enterprise object
+      # @param [Hash] msg The message hash
+      # @return [Octo::PushKey] The push key object corresponding to this user
+      def checkPushKey(enterprise, msg)
+        args = {
+            enterprise_id: enterprise.id,
+            push_type: msg[:pushType].to_i
+        }
+        opts = {
+            key: msg[:pushKey]
+        }
+        Octo::PushKey.findOrCreateOrUpdate(args, opts)
+      end
+
+      # Check if the enterprise exists. Create a new enterprise if it does
+      #   not exist. This method makes sense because the enterprise authentication
+      #   is handled by kong. Hence we can be sure that all these enterprises
+      #   are valid.
+      # @param [Hash] msg The message hash
+      # @return [Octo::Enterprise] The enterprise object
+      def checkEnterprise(msg)
+        Octo::Enterprise.findOrCreate({id: msg[:enterpriseId]},
+                                      {name: msg[:enterpriseName]})
+      end
+
+      # Checks for user and creates if not exists
+      # @param [Octo::Enterprise] enterprise The Enterprise object
+      # @param [Hash] msg The message hash
+      # @return [Octo::User] The push user object corresponding to this user
+      def checkUser(enterprise, msg)
+        args = {
+            enterprise_id: enterprise.id,
+            id: msg[:userId]
+        }
+        Octo::User.findOrCreate(args)
+      end
+
+      # Updates location for a user
+      # @param [Octo::User] user The user to whom this token belongs to
+      # @param [Hash] msg The message hash
+      # @return [Octo::UserLocationHistory] The location history object
+      #   corresponding to this user
+      def updateLocationHistory(user, msg)
+        Octo::UserLocationHistory.new(
+            user: user,
+            latitude: msg[:phone].fetch('latitude', 0.0),
+            longitude: msg[:phone].fetch('longitude', 0.0),
+            created_at: Time.now
+        ).save!
+      end
+
+      # Updates user's device details
+      # @param [Octo::User] user The user to whom this token belongs to
+      # @param [Hash] msg The message hash
+      def updateUserDeviceDetails(user, msg)
+        args = {user_id: user.id, user_enterprise_id: user.enterprise.id}
+
+        # Check Device Type
+        if msg[:browser]
+          updateUserBrowserDetails(args, msg)
+        elsif msg[:phone]
+          updateLocationHistory(user, msg)
+          updateUserPhoneDetails(args, msg)
+        end
+      end
+
+      # Updates user's phone details
+      # @param [Hash] args The user details to whom this token belongs to
+      # @param [Hash] msg The message hash
+      # @return [Octo::UserPhoneDetails] The phone details object
+      #   corresponding to this user
+      def updateUserPhoneDetails(args, msg)
+        opts = {deviceid: msg[:phone].fetch('deviceId', ''),
+                manufacturer: msg[:phone].fetch('manufacturer', ''),
+                model: msg[:phone].fetch('model', ''),
+                os: msg[:phone].fetch('os', '')}
+        Octo::UserPhoneDetails.findOrCreateOrUpdate(args, opts)
+      end
+
+      # Updates user's browser details
+      # @param [Hash] args The user details to whom this token belongs to
+      # @param [Hash] msg The message hash
+      # @return [Octo::UserBrowserDetails] The browser details object
+      #   corresponding to this user
+      def updateUserBrowserDetails(args, msg)
+        opts = {name: msg[:browser].fetch('name', ''),
+                platform: msg[:browser].fetch('platform', ''),
+                manufacturer: msg[:browser].fetch('manufacturer', ''),
+                cookieid: msg[:browser].fetch('cookieid', '')}
+        Octo::UserBrowserDetails.findOrCreateOrUpdate(args, opts)
+      end
+
+      # Checks the existence of a page and creates if not found
+      # @param [Octo::Enterprise] enterprise The Enterprise object
+      # @param [Hash] msg The message hash
+      # @return [Array<Octo::Page, Array<Octo::Category>, Array<Octo::Tag>] The
+      #   page object, array of categories objects and the array of tags
+      #   object
+      def checkPage(enterprise, msg)
+        cats = checkCategories(enterprise, msg[:categories])
+        tags = checkTags(enterprise, msg[:tags])
+
+        args = {
+            enterprise_id: enterprise.id,
+            routeurl: msg[:routeUrl]
+        }
+        opts = {
+            categories: Set.new(msg[:categories]),
+            tags: Set.new(msg[:tags])
+        }
+        page = Octo::Page.findOrCreateOrUpdate(args, opts)
+        [page, cats, tags]
+      end
+
+      # Checks for existence of a product and creates if not found
+      # @param [Octo::Enterprise] enterprise The Enterprise object
+      # @param [Hash] msg The message hash
+      # @return [Array<Octo::Product, Array<Octo::Category>, Array<Octo::Tag>] The
+      #   product object, array of categories objects and the array of tags
+      #   object
+      def checkProduct(enterprise, msg)
+        categories = checkCategories(enterprise, msg[:categories])
+        tags = checkTags(enterprise, msg[:tags])
+
+        args = {
+            enterprise_id: enterprise.id,
+            id: msg[:productId]
+        }
+        opts = {
+            categories: Set.new(msg[:categories]),
+            tags: Set.new(msg[:tags]),
+            price: msg[:price].to_f.round(2),
+            name: msg[:productName],
+            routeurl: msg[:routeUrl]
+        }
+        prod = Octo::Product.findOrCreateOrUpdate(args, opts)
+        [prod, categories, tags]
+      end
+
+      # Checks for categories and creates if not found
+      # @param [Octo::Enterprise] enterprise The enterprise object
+      # @param [Array<String>] categories An array of categories to be checked
+      # @return [Array<Octo::Category>] An array of categories object
+      def checkCategories(enterprise, categories)
+        if categories
+          categories.collect do |category|
+            Octo::Category.findOrCreate({enterprise_id: enterprise.id,
+                                         cat_text: category})
+          end
+        end
+      end
+
+      # Checks for tags and creates if not found
+      # @param [Octo::Enterprise] enterprise The enterprise object
+      # @param [Array<String>] tags An array of tags to be checked
+      # @return [Array<Octo::Tag>] An array of tags object
+      def checkTags(enterprise, tags)
+        if tags
+          tags.collect do |tag|
+            Octo::Tag.findOrCreate({enterprise_id: enterprise.id, tag_text: tag})
+          end
+        end
+      end
+
+      def parse(msg)
+        msg2 = JSON.parse(msg)
+        msg = msg2
+        enterprise = msg['enterprise']
+        raise StandardError, 'Parse Error' if enterprise.nil?
+
+        eid = if enterprise.has_key?'custom_id'
+                enterprise['custom_id']
+              elsif enterprise.has_key?'customId'
+                enterprise['customId']
+              end
+
+        ename = if enterprise.has_key?'user_name'
+                  enterprise['user_name']
+                elsif enterprise.has_key?'userName'
+                  enterprise['userName']
+                end
+        m = {
+            id:             msg['uuid'],
+            enterpriseId:   eid,
+            enterpriseName: ename,
+            event_name:     msg['event_name'],
+            phone:          msg.fetch('phoneDetails', nil),
+            browser:        msg.fetch('browserDetails', nil),
+            userId:         msg.fetch('userId', -1),
+            created_at:     Time.now
+        }
+        case msg['event_name']
+          when 'update.profile'
+            m.merge!({
+                        profileDetails: msg['profileDetails']
+                    })
+          when 'page.view'
+            m.merge!({
+                        routeUrl:     msg['routeUrl'],
+                        categories:   msg.fetch('categories', []),
+                        tags:         msg.fetch('tags', [])
+                     })
+          when 'productpage.view'
+            m.merge!({
+                        routeUrl:     msg['routeUrl'],
+                        categories:   msg.fetch('categories', []),
+                        tags:         msg.fetch('tags', []),
+                        productId:    msg['productId'],
+                        productName:  msg['productName'],
+                        price:        msg['price']
+                     })
+          when 'update.push_token'
+            m.merge!({
+                        pushType:     msg['notificationType'],
+                        pushKey:      msg['pushKey'],
+                        pushToken:    msg['pushToken']
+                     })
+        end
+        m
+      end
+    end
+  end
+end