sensor 0.0.1

data/lib/sensor/actuator/analytics_retrieval.rb

@@ -0,0 +1,68 @@
+require 'garb'
+
+CA_CERT_FILE = File.join(File.dirname(__FILE__),
+  '../../../certs/cacert.pem')
+
+module Sensor
+  module Actuator
+    class AnalyticsRetrieval
+      extend Garb::Model
+
+      metrics :visitors,
+        :visit_bounce_rate,
+        :avg_time_on_site,
+        :pageviews
+
+      def initialize(time_range)
+        @time_range = time_range
+      end
+
+      def acquire
+        results = self.class.results(profile,
+          start_date: @time_range.start_date,
+          end_date: @time_range.end_date)
+        if results
+          map = results.to_a[0].marshal_dump.inject({}) do |map, key_values|
+            map[key_values[0]] = key_values[1].to_f
+            map
+          end
+          {
+            analytics: map
+          }
+        else
+          {}
+        end
+      end
+
+      protected
+      def client
+        if !@client
+          session = Garb::Session.login(analytics_user, analytics_password)
+        end
+
+      end
+
+      def analytics_user
+        ENV['GOOGLE_ANALYTICS_USER']
+      end
+
+      def analytics_password
+        ENV['GOOGLE_ANALYTICS_PASSWORD']
+      end
+
+      def analytics_profile_id
+        ENV['GOOGLE_ANALYTICS_WEB_PROPERTY_ID']
+      end
+
+      def profile
+        if !@profile
+          client
+          @profile = Garb::Management::Profile.all.detect do |p|
+            p.web_property_id == analytics_profile_id
+          end
+        end
+        @profile
+      end
+    end
+  end
+end

data/lib/sensor/actuator/facebook_retrieval.rb

@@ -0,0 +1,82 @@
+require 'koala'
+module Sensor
+  module Actuator
+    class FacebookRetrieval
+      def initialize(time_range)
+        @time_range = time_range
+      end
+
+      def acquire
+        results = graph.get_object("TheLaunchAcademy")
+        likes = results["likes"]
+        talking = results["talking_about_count"]
+        posts = graph.get_object("TheLaunchAcademy/posts",
+          since: format_date(@time_range.start_date),
+          until: format_date(@time_range.end_date),
+          limit: 200
+        )
+
+        post_likes = posts.inject(0) do |post_likes, post|
+          if post["likes"] && post["likes"]["data"]
+            post_likes += post["likes"]["data"].size
+          else
+            post_likes
+          end
+        end
+
+        {
+          facebook: {
+            likes: likes,
+            talking: talking,
+            posts: posts.size,
+            post_likes: post_likes
+          }
+        }
+      end
+
+      protected
+      def format_date(date)
+        date.strftime("%Y-%m-%d")
+      end
+
+      def graph
+        @graph ||= Koala::Facebook::API.new(access_token)
+      end
+
+      def oauth_url
+        "https://www.facebook.com/dialog/oauth?" +
+          "client_id=#{api_key}&client_secret=#{secret_key}" +
+          "scope=manage_pages,read_insights&redirect_uri=#{redirect_uri}&" +
+          "response_type=token"
+      end
+
+      def token_exchange_url
+        "https://www.facebook.com/oauth/access_token?" +
+          "grant_type=fb_exchange_token&" +
+          "client_id=#{api_key}&" +
+          "client_secret=#{secret_key}&" +
+          "fb_exchange_token=#{short_lived_token}"
+      end
+
+      def redirect_uri
+        ENV['FACEBOOK_REDIRECT_URI']
+      end
+
+      def short_lived_token
+        ENV['FACEBOOK_SHORT_LIVED_TOKEN']
+      end
+
+      def access_token
+        ENV['FACEBOOK_TOKEN']
+      end
+
+      def api_key
+        ENV['FACEBOOK_API_KEY']
+      end
+
+      def secret_key
+        ENV['FACEBOOK_SECRET_KEY']
+      end
+    end
+  end
+end

data/lib/sensor/actuator/twitter_retrieval.rb

@@ -0,0 +1,59 @@
+require 'twitter'
+
+module Sensor
+  module Actuator
+    class TwitterRetrieval
+      def initialize(time_range)
+        @time_range = time_range
+      end
+
+      def acquire
+        map = {}
+        map.tap do |map|
+          map[:twitter] = {}
+          map[:twitter][:followers] = client.user.followers_count
+          map[:twitter][:tweets] = tweet_count
+          map[:twitter][:mentions] = mention_count
+        end
+      end
+
+      protected
+      def format_date(date)
+        date.strftime("%Y-%m-%d")
+      end
+
+      def search_options
+        {
+          count: 100,
+          since: format_date(@time_range.start_date),
+          until: format_date(@time_range.end_date)
+        }
+      end
+
+      def tweet_count
+        search = client.search("from:launchacademy_",
+          search_options
+        )
+        search.entries.count
+      end
+
+      def mention_count
+        search = client.search("to:launchacademy_",
+          search_options)
+        search.entries.count
+      end
+
+      def client
+        if !@client
+          @client = Twitter::REST::Client.new do |config|
+            config.consumer_key        = ENV["TWITTER_CONSUMER_KEY"]
+            config.consumer_secret     = ENV["TWITTER_CONSUMER_SECRET"]
+            config.access_token        = ENV["TWITTER_ACCESS_TOKEN"]
+            config.access_token_secret = ENV["TWITTER_ACCESS_TOKEN_SECRET"]
+          end
+        end
+        @client
+      end
+    end
+  end
+end

data/lib/sensor/output_distribution/flow_dock.rb

@@ -0,0 +1,54 @@
+require 'flowdock'
+
+module Sensor
+  module OutputDistribution
+    class FlowDock
+      def initialize(payload)
+        @payload = payload
+        @time_range = payload.time_range
+      end
+
+      def distribute
+        flow.push_to_team_inbox({
+          subject: "Sensor Output: " +
+            "#{format_date(@payload.start_date)} - " +
+            "#{format_date(@payload.end_date)}",
+          content: content
+        })
+      end
+
+      protected
+      def format_date(date)
+        date.strftime("%m/%d/%Y")
+      end
+
+      def content
+        @payload.data.inject("") do |str, key_value|
+          str += "<h3>#{key_value[0]}</h3>"
+
+          str += "<ul>"
+          key_value[1].each do |attribute, value|
+            str += "<li><strong>#{attribute}</strong>: #{value}</li>"
+          end
+          str += "</ul>"
+        end
+      end
+
+      def flow
+        @flow ||= ::Flowdock::Flow.new(
+          api_token: token,
+          source: 'Sensor',
+          from: {
+            name: 'Sensor',
+            address: 'hello@sensor.com'
+          }
+        )
+      end
+
+      def token
+        ENV['FLOWDOCK_TOKEN']
+      end
+    end
+  end
+end
+

data/lib/sensor/payload.rb

@@ -0,0 +1,35 @@
+require 'sensor'
+
+Sensor.require("analytics_retrieval")
+Sensor.require("twitter_retrieval")
+Sensor.require("facebook_retrieval")
+Sensor.require("flow_dock")
+
+module Sensor
+  class Payload
+    attr_reader :data, :time_range
+    delegate :start_date, to: :time_range
+    delegate :end_date, to: :time_range
+
+    def initialize(time_range)
+      @time_range = time_range
+      @data = {}
+    end
+
+    def acquire
+      [
+        Sensor::Actuator::AnalyticsRetrieval,
+        Sensor::Actuator::TwitterRetrieval,
+        Sensor::Actuator::FacebookRetrieval
+      ].each do |actuator|
+        @data.merge!(actuator.new(@time_range).acquire)
+      end
+
+      @data
+    end
+
+    def distribute
+      Sensor::OutputDistribution::FlowDock.new(self).distribute
+    end
+  end
+end

data/lib/sensor/rake_task.rb

@@ -0,0 +1,38 @@
+require 'sensor/payload'
+
+module Sensor
+  class RakeTask < Rake::TaskLib
+    def initialize(name)
+      desc "run sensors for yesterday"
+      namespace name do
+        task :yesterday do
+          yesterday = Date.today - 1
+          time_range = Sensor::TimeRange.new(yesterday, yesterday)
+          payload = Sensor::Payload.new(time_range)
+          payload.acquire
+          payload.distribute
+        end
+
+        desc "run sensors for last week (Mon-Sun)"
+        task :last_week do
+          today = Date.today
+          week_start = today - today.wday - 6
+          week_end = week_start + 6
+
+          time_range = Sensor::TimeRange.new(week_start, week_end)
+          payload = Sensor::Payload.new(time_range)
+          payload.acquire
+          payload.distribute
+        end
+
+        desc "run sensors for an arbitrary range of dates"
+        task :custom do
+          time_range = Sensor::TimeRange.new(ENV['START'], ENV['END'])
+          payload = Sensor::Payload.new(time_range)
+          payload.acquire
+          payload.distribute
+        end
+      end
+    end
+  end
+end

data/lib/sensor/time_range.rb

@@ -0,0 +1,36 @@
+require 'chronic'
+
+module Sensor
+  class TimeRange
+    attr_reader :start, :end
+    def initialize(start_date, end_date)
+      @start = timify(start_date)
+      @end = timify(end_date, true)
+    end
+
+    def start_date
+      datify(@start)
+    end
+
+    def end_date
+      datify(@end)
+    end
+
+    protected
+    def datify(time)
+      Date.new(time.year, time.month, time.day)
+    end
+
+    def timify(date, as_end = false)
+      if date.kind_of?(String)
+        Chronic.parse(date)
+      elsif date.kind_of?(Date)
+        as_end ? (date + 1).to_time - 1 : date.to_time
+      elsif date.kind_of?(Time)
+        date
+      else
+        raise "Unknown date parameter: #{date}"
+      end
+    end
+  end
+end

data/lib/sensor/version.rb

@@ -0,0 +1,3 @@
+module Sensor
+  VERSION = "0.0.1"
+end

data/lib/sensor.rb

@@ -0,0 +1,14 @@
+module Sensor
+  def self.require(path)
+    begin
+      super("sensor/actuator/#{path}")
+    rescue LoadError
+      super("sensor/output_distribution/#{path}")
+    end
+  end
+end
+
+require "sensor/version"
+require "sensor/time_range"
+
+require "sensor/payload"

data/sensor.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sensor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sensor"
+  spec.version       = Sensor::VERSION
+  spec.authors       = ["Dan Pickett"]
+  spec.email         = ["dan.pickett@launchware.com"]
+  spec.description   = %q{Sensor provides a set of marketing metrics}
+  spec.summary       = %q{Marketing Metrics Acquisition Tool}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "chronic"
+  spec.add_dependency "garb", "~> 0.9.1"
+  spec.add_dependency "twitter", "~> 5.0.0"
+  spec.add_dependency "koala"
+  spec.add_dependency "flowdock"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "dotenv"
+end

data/spec/payload_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sensor::Payload, :vcr do
+
+  it 'fetches relevant data' do
+    date_range = Sensor::TimeRange.new('yesterday', 'today')
+    act = Sensor::Payload.new(date_range)
+    results = act.acquire
+    expect(results).to_not be_nil
+
+    act.distribute
+  end
+end

data/spec/sensor/actuator/analytics_retrieval_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+Sensor.require("analytics_retrieval")
+
+describe Sensor::Actuator::AnalyticsRetrieval, vcr: true do
+  it 'returns the count of visits' do
+    Timecop.freeze(Chronic.parse('01/01/13')) do
+      date_range = Sensor::TimeRange.new('yesterday', 'today')
+      act = Sensor::Actuator::AnalyticsRetrieval.new(date_range)
+      results = act.acquire
+      expect(results).to_not be_nil
+      expect(results[:analytics]).to_not be_nil
+      expect(results[:analytics][:visitors]).to_not be_nil
+    end
+  end
+end

data/spec/sensor/actuator/facebook_retrieval_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+Sensor.require("facebook_retrieval")
+
+describe Sensor::Actuator::FacebookRetrieval, :vcr do
+  it 'fetches relevant stats' do
+    date_range = Sensor::TimeRange.new('yesterday', 'today')
+    act = Sensor::Actuator::FacebookRetrieval.new(date_range)
+    results = act.acquire
+    expect(results).to_not be_nil
+    expect(results[:facebook]).to_not be_nil
+    expect(results[:facebook][:likes]).to_not be_nil
+  end
+end

data/spec/sensor/actuator/twitter_retrieval_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+Sensor.require("twitter_retrieval")
+
+describe Sensor::Actuator::TwitterRetrieval, :vcr do
+  it 'fetches relevant stats' do
+    date_range = Sensor::TimeRange.new('yesterday', 'today')
+    act = Sensor::Actuator::TwitterRetrieval.new(date_range)
+    results = act.acquire
+    expect(results).to_not be_nil
+    expect(results[:twitter]).to_not be_nil
+    expect(results[:twitter][:followers]).to_not be_nil
+    expect(results[:twitter][:tweets]).to_not be_nil
+    expect(results[:twitter][:mentions]).to_not be_nil
+  end
+end

data/spec/sensor/time_range_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Sensor::TimeRange, :vcr do
+  before do
+    Timecop.freeze
+  end
+
+  after do
+    Timecop.return
+  end
+
+  let(:day) { 24 * 60 * 60 }
+
+  let(:start_time) do
+    twenty_four_hours_ago = Time.now - day
+    Date.new(twenty_four_hours_ago.year,
+      twenty_four_hours_ago.month,
+      twenty_four_hours_ago.day).to_time
+  end
+
+  let(:end_time) do
+    now = Time.now
+    (Date.new(now.year, now.month, now.day) + 1).to_time - 1
+  end
+
+  let(:date_range) { Sensor::TimeRange.new(start_time, end_time) }
+
+  context 'instantiated with Time objects' do
+    it 'has a start correlated to the constructor argument' do
+      expect(date_range.start).to eql(start_time)
+    end
+
+    it 'has an end correlated to the constructor argument' do
+      expect(date_range.end).to eql(end_time)
+    end
+
+    it 'has a start date' do
+      date = Date.new(start_time.year, start_time.month, start_time.day)
+      expect(date_range.start_date).to eql(date)
+    end
+
+    it 'has an end date' do
+      date = Date.new(end_time.year, end_time.month, end_time.day)
+      expect(date_range.end_date).to eql(date)
+    end
+  end
+
+  context 'instantiated with strings' do
+    let(:string_range) { Sensor::TimeRange.new('yesterday at 0', 'today at 11:59:59PM') }
+
+    it 'parses a string for the start' do
+      expect(string_range.start).to eql(start_time)
+    end
+
+    it 'parses a string for the end' do
+      expect(string_range.end).to eql(end_time)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'sensor'
+
+require 'rspec'
+
+require 'timecop'
+
+require 'vcr'
+require 'webmock'
+
+require 'dotenv'
+Dotenv.load
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.hook_into :webmock # or :fakeweb
+  c.default_cassette_options = { :record => :new_episodes }
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end