octocore-cassandra 0.0.6

data/lib/octocore-cassandra/models.rb

@@ -0,0 +1,274 @@
+require 'cequel'
+require 'redis'
+
+
+module Cequel
+  module Record
+
+    include ActiveModel::Serializers::JSON
+
+    DUMP_ATTRS = [:@attributes] #, :@collection_proxies, :@loaded, :@persisted, :@record_collection]
+
+    # Updates caching config
+    # @param [String] host The host to connect to
+    # @param [Fixnum] port The port to connect to
+    def self.update_cache_config(host, port)
+      @redis = Redis.new(host: host,
+                         port: port,
+                         driver: :hiredis)
+    end
+
+    # Getter for redis object
+    # @return [Redis] redis cache instance
+    def self.redis
+      @redis
+    end
+
+    def marshal_dump
+      DUMP_ATTRS.inject({}) do |val, attr|
+        val[attr] = self.instance_variable_get(attr)
+        val
+      end
+    end
+
+    def marshal_load(data)
+      DUMP_ATTRS.each do |attr|
+        instance_variable_set(attr, data[attr])
+      end
+      instance_variable_set(:@collection_proxies, {})
+      instance_variable_set(:@record_collection, nil)
+    end
+
+    # Override Cequel::Record here
+    module ClassMethods
+
+      # fakes up data
+      def fake_data_with(args, values, opts={})
+        res = []
+        ts = args.fetch(:ts, 7.days.ago..Time.now.floor)
+        if ts.class == Range
+          bod = opts.fetch(:bod, false)
+          ts_begin = ts.begin
+          ts_end = ts.end
+          if bod
+            ts_begin = ts_begin.beginning_of_day
+            ts_end = ts_end.end_of_day
+          end
+          step = opts.fetch(:step, 1.minute)
+          ts_begin.to(ts_end, step).each do |_ts|
+            _args = args.merge({ ts: _ts })
+            r = self.where(_args)
+            if r.count == 0
+              res << self.new(_args.merge(values)).save!
+            else
+              res << r
+            end
+          end
+        elsif ts.class == Time
+          _args = args.merge({ ts: ts }).merge(values)
+          res << self.new(_args).save!
+        end
+        res.flatten
+      end
+
+      # Recreates this object from other object
+      def recreate_from(obj)
+        keys = self.key_column_names
+        args = {}
+        if obj.respond_to?(:enterprise_id) and obj.respond_to?(:uid)
+          args[keys.delete(:enterprise_id)] = obj.enterprise_id
+          if keys.length == 1
+            args[keys.first] = obj.uid
+            self.get_cached(args)
+          else
+            puts keys.to_a.to_s
+            raise NotImplementedError, 'See octocore/models.rb'
+          end
+        end
+      end
+
+      # If a record exists, will find it and update it's value with the
+      #   provided options. Else, will just create the record.
+      def findOrCreateOrUpdate(args, options = {})
+        cache_key = gen_cache_key(args)
+        res = get_cached(args)
+        if res
+          dirty = false
+
+          # handle price separately because of float issues
+          if options.has_key?(:price)
+            _v = options.delete(:price)
+            dirty = _v.round(2) != res.price.round(2)
+          end
+
+          # remaining opts
+          options.each do |k, v|
+            if res.respond_to?(k)
+              unless res.public_send(k) == v
+                dirty = true
+                res.public_send("#{ k }=", v)
+              end
+            end
+          end
+
+          if dirty
+            res.save!
+            Cequel::Record.redis.setex(cache_key, get_ttl,
+                                       Octo::Utils.serialize(res))
+          end
+        else
+          _args = args.merge(options)
+          res = self.new(_args).save!
+          Cequel::Record.redis.setex(cache_key, get_ttl,
+                                     Octo::Utils.serialize(res))
+        end
+        res
+      end
+
+      # Finds the record/recordset satisfying a `where` condition
+      #   or create a new record from the params passed
+      # @param [Hash] args The args used to build `where` condition
+      # @param [Hash] options The options used to construct record
+      def findOrCreate(args, options = {})
+        # attempt to find the record
+        res = get_cached(args)
+
+        # on failure, do
+        unless res
+          args.merge!(options)
+          res = self.new(args).save!
+
+          # Update cache
+          cache_key = gen_cache_key(args)
+          Cequel::Record.redis.setex(cache_key, get_ttl, Octo::Utils.serialize(res))
+        end
+        res
+      end
+
+
+      # If a record exists in a COUNTER TABLE, it will find
+      #  it and increment or decrement it's value with the
+      #  provided options. Else, will just create the
+      #  record with default value.
+      def findOrCreateOrAdjust(args, options)
+        self.where(args).data_set.increment(options)
+      end
+
+
+      # Perform a cache backed get
+      # @param [Hash] args The arguments hash for the record
+      #   to be found
+      # @return [Cequel::Record::RecordSet] The record matching
+      def get_cached(args)
+        cache_key = gen_cache_key(args)
+
+        begin
+          cached_val = Cequel::Record.redis.get(cache_key)
+        rescue Exception
+          cached_val = nil
+        end
+
+        unless cached_val
+          res = where(args)
+          result_count = res.count
+          if result_count == 0
+            return nil
+          elsif result_count == 1
+            cached_val = Octo::Utils.serialize(res.first)
+            Cequel::Record.redis.setex(cache_key, get_ttl, cached_val)
+          elsif result_count > 1
+            cached_val = Octo::Utils.serialize(res)
+            Cequel::Record.redis.setex(cache_key, get_ttl, cached_val)
+          end
+        end
+        begin
+          Octo::Utils.deserialize(cached_val)
+        rescue Exception => e
+          Octo.logger.error e
+          nil
+        end
+      end
+
+      private
+
+      # Generate cache key
+      # @param [Hash] args The arguments for fetching hash
+      # @return [String] Cache key generated
+      def gen_cache_key(args)
+        args = args.flatten
+        args.unshift(self.name.to_s)
+        args.join('::')
+      end
+
+      def get_ttl
+        # default ttl of 1 hour
+        ttl = 60
+        if self.constants.include?(:TTL)
+          ttl = self.const_get(:TTL)
+        end
+
+        # convert ttl into seconds
+        ttl *= 60
+      end
+
+    end
+  end
+end
+
+
+require 'octocore-cassandra/models/enterprise'
+require 'octocore-cassandra/models/enterprise/adapter_details'
+require 'octocore-cassandra/models/enterprise/api_event'
+require 'octocore-cassandra/models/enterprise/api_hit'
+require 'octocore-cassandra/models/enterprise/api_key'
+require 'octocore-cassandra/models/enterprise/api_track'
+require 'octocore-cassandra/models/enterprise/app_init'
+require 'octocore-cassandra/models/enterprise/app_login'
+require 'octocore-cassandra/models/enterprise/app_logout'
+require 'octocore-cassandra/models/enterprise/authorization'
+require 'octocore-cassandra/models/enterprise/category'
+require 'octocore-cassandra/models/enterprise/category_baseline'
+require 'octocore-cassandra/models/enterprise/category_hit'
+require 'octocore-cassandra/models/enterprise/category_trend'
+require 'octocore-cassandra/models/enterprise/conversions'
+require 'octocore-cassandra/models/enterprise/ctr'
+require 'octocore-cassandra/models/enterprise/dimension_choice'
+require 'octocore-cassandra/models/enterprise/engagement_time'
+require 'octocore-cassandra/models/enterprise/funnels'
+require 'octocore-cassandra/models/enterprise/funnel_data'
+require 'octocore-cassandra/models/enterprise/funnel_tracker'
+
+require 'octocore-cassandra/models/enterprise/gcm'
+require 'octocore-cassandra/models/enterprise/newsfeed_hit'
+require 'octocore-cassandra/models/enterprise/notification_hit'
+require 'octocore-cassandra/models/enterprise/page'
+require 'octocore-cassandra/models/enterprise/pageload_time'
+require 'octocore-cassandra/models/enterprise/page_view'
+require 'octocore-cassandra/models/enterprise/product'
+require 'octocore-cassandra/models/enterprise/product_baseline'
+require 'octocore-cassandra/models/enterprise/product_hit'
+require 'octocore-cassandra/models/enterprise/product_page_view'
+require 'octocore-cassandra/models/enterprise/product_trend'
+require 'octocore-cassandra/models/enterprise/push_key'
+require 'octocore-cassandra/models/enterprise/rules'
+require 'octocore-cassandra/models/enterprise/segment.rb'
+require 'octocore-cassandra/models/enterprise/segment_data.rb'
+require 'octocore-cassandra/models/enterprise/tag'
+require 'octocore-cassandra/models/enterprise/tag_hit'
+require 'octocore-cassandra/models/enterprise/tag_baseline'
+require 'octocore-cassandra/models/enterprise/tag_trend'
+require 'octocore-cassandra/models/enterprise/template'
+
+require 'octocore-cassandra/models/user'
+require 'octocore-cassandra/models/user/push_token'
+require 'octocore-cassandra/models/user/user_browser_details'
+require 'octocore-cassandra/models/user/user_location_history'
+require 'octocore-cassandra/models/user/user_persona'
+require 'octocore-cassandra/models/user/user_phone_details'
+require 'octocore-cassandra/models/user/user_profile'
+require 'octocore-cassandra/models/user/user_timeline'
+
+require 'octocore-cassandra/models/subscribe'
+require 'octocore-cassandra/models/contactus'
+
+require 'octocore-cassandra/utils'

data/lib/octocore-cassandra/models/contactus.rb

@@ -0,0 +1,42 @@
+require 'cequel'
+
+# Model for contact us page on the microsite
+module Octo
+  class ContactUs
+    include Cequel::Record
+
+    key :email, :text
+    key :created_at, :timestamp
+
+    column :typeofrequest, :text
+    column :firstname, :text
+    column :lastname, :text
+    column :message, :text
+
+    after_create :send_email
+
+    # Send Email after model save
+    def send_email
+
+      # Send thankyou mail
+      subject = 'Thanks for contacting us - Octo.ai'
+    	opts = {
+    		text: 'Hey we will get in touch with you shortly. Thanks :)',
+    		name: self.firstname + ' ' + self.lastname
+    	}
+    	Octo::Email.send(self.email, subject, opts)
+
+      # Send mail to aron and param
+      Octo.get_config(:email_to).each { |x|
+        opts1 = {
+            text: self.email + ' \n\r ' + self.typeofrequest + '\n\r' +  self.message,
+            name: x.fetch('name')
+        }
+        Octo::Email.send(x.fetch('email'), subject, opts1)
+      }
+
+
+    end
+
+  end
+end

data/lib/octocore-cassandra/models/enterprise.rb

@@ -0,0 +1,76 @@
+require 'cequel'
+
+module Octo
+  class Enterprise
+    include Cequel::Record
+
+    # Set ttl of 120 minutes for the caches
+    TTL = 120
+
+    key :id, :uuid, auto: true
+    column :name, :varchar
+
+    has_many :users, class_name: 'Octo::User'
+    has_many :segments, class_name: 'Octo::Segment'
+    has_many :templates, class_name: 'Octo::Template'
+    has_many :funnels, class_name: 'Octo::Funnel'
+    has_many :conversions, class_name: 'Octo::Conversions'
+
+    after_save :_setup
+
+    # Setup the new enterprise
+    def _setup
+      setup_notification_categories
+      setup_intelligent_segments
+    end
+
+    # Method to check if it is okay to create fakedata for this
+    #   client
+    # @return [Boolean]
+    def fakedata?
+      self.name.start_with?('Octo')
+    end
+
+    private
+
+    # Setup the notification categories for the enterprise
+    def setup_notification_categories
+      templates = Octo.get_config(:push_templates)
+      if templates
+        templates.each do |t|
+          args = {
+            enterprise_id: self.id,
+            category_type: t[:name],
+            template_text: t[:text],
+            active: true
+          }
+          Octo::Template.new(args).save!
+        end
+        Octo.logger.info("Created templates for Enterprise: #{ self.name }")
+      end
+    end
+
+    # Setup the intelligent segments for the enterprise
+    def setup_intelligent_segments
+      segments = Octo.get_config(:intelligent_segments)
+      if segments
+        segments.each do |seg|
+          args = {
+            enterprise_id: self.id,
+            name: seg[:name],
+            type: seg[:type].constantize,
+            dimensions: seg[:dimensions].collect(&:constantize),
+            operators: seg[:operators].collect(&:constantize),
+            values: seg[:values].collect(&:constantize),
+            active: true,
+            intelligence: true,
+          }
+          Octo::Segment.new(args).save!
+        end
+        Octo.logger.info "Created segents for Enterprise: #{ self.name }"
+      end
+    end
+
+  end
+
+end

data/lib/octocore-cassandra/models/enterprise/adapter_details.rb

@@ -0,0 +1,18 @@
+require 'cequel'
+require 'octocore-cassandra/record'
+
+module Octo
+	# Store adapter details of Enterprise
+  class AdapterDetails
+    include Cequel::Record
+    include Octo::Record
+
+    belongs_to :enterprise, class_name: 'Octo::Enterprise'
+
+    key :adapter_id, :int
+    key :enable, :boolean
+    
+    column :settings, :text
+
+  end
+end

data/lib/octocore-cassandra/models/enterprise/api_event.rb

@@ -0,0 +1,14 @@
+require 'cequel'
+require 'octocore-cassandra/record'
+
+module Octo
+  class ApiEvent
+    include Cequel::Record
+    include Octo::Record
+
+    belongs_to :enterprise, class_name: 'Octo::Enterprise'
+
+    key :eventname, :text
+  end
+end
+

data/lib/octocore-cassandra/models/enterprise/api_hit.rb

@@ -0,0 +1,20 @@
+require 'cequel'
+
+require 'octocore-cassandra/counter'
+require 'octocore-cassandra/trendable'
+require 'octocore-cassandra/schedeuleable'
+
+module Octo
+  class ApiHit
+    include Cequel::Record
+    extend Octo::Counter
+    extend Octo::Scheduleable
+
+    COUNTERS = 30
+
+    belongs_to :enterprise, class_name: 'Octo::Enterprise'
+
+    countables
+
+  end
+end