blue_state_digital 0.6.0

data/lib/blue_state_digital/dataset_map.rb

@@ -0,0 +1,138 @@
+module BlueStateDigital
+  class DatasetMap < ApiDataModel
+
+    extend ActiveModel::Naming
+    include ActiveModel::Validations
+
+    UPLOAD_ENDPOINT = '/cons/upload_dataset_map'
+    DELETE_ENDPOINT = '/cons/delete_dataset_map'
+
+    FIELDS = [
+      :map_id,
+      :type
+    ]
+    attr_accessor *FIELDS
+    attr_reader   :data,:data_header,:errors
+
+    validate :data_must_have_header
+
+    def initialize(args={})
+      super
+      @data = []
+      @data_header = nil
+      @errors = ActiveModel::Errors.new(self)
+    end
+
+    def data
+      @data
+    end
+
+    def add_data_row(row)
+      @data.push row
+    end
+
+    def add_data_header(header_row)
+      @data_header = header_row
+    end
+
+    def save
+      #errors.add(:data, "cannot be blank") if @data.blank?
+      if valid?
+        if connection
+          response = connection.perform_request_raw(
+            UPLOAD_ENDPOINT,
+            { api_ver: 2, content_type: "text/csv", accept: 'application/json' },
+            "PUT",
+            csv_payload
+          )
+          if(response.status == 202)
+            true
+          else
+            errors.add(:web_service,"#{response.body}")
+            false
+          end
+        else
+          errors.add(:connection,"is missing")
+          false
+        end
+      else
+        false
+      end
+    end
+
+    def delete
+    	if map_id.nil?
+    		errors.add(:map_id,"is missing")
+    		return false
+    	end
+    	if connection
+          response = connection.perform_request_raw(
+            DELETE_ENDPOINT,
+            { api_ver: 2 },
+            "POST",
+            {map_id: map_id}.to_json
+          )
+          if(response.status==200)
+            true
+          else
+            errors.add(:web_service,"#{response.body}")
+            false
+          end
+        else
+          errors.add(:connection,"is missing")
+          false
+        end
+    end
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+    def self.lookup_ancestors
+      [self]
+    end
+
+    private
+
+    def csv_payload
+      csv_string = CSV.generate do |csv|
+        csv << (@data_header||[])
+        @data.each do |row|
+          csv << row
+        end
+      end
+    end
+
+    def data_must_have_header
+      errors.add(:data_header, "is missing") if !@data.blank? && @data_header.nil?
+    end
+  end
+
+  class DatasetMaps < CollectionResource
+    FETCH_ENDPOINT = '/cons/list_dataset_maps'
+    def get_dataset_maps
+      if connection
+        response = connection.perform_request FETCH_ENDPOINT, { api_ver: 2 }, "GET"
+        # TODO: Should check response's status code
+        begin
+          parsed_response = JSON.parse(response)
+
+          data = parsed_response['data']
+          if(data)
+            data.map do |dataset|
+              DatasetMap.new(dataset)
+            end
+          else
+            nil
+          end
+        rescue StandardError => e
+          raise FetchFailureException.new("#{e}")
+        end
+      else
+        raise NoConnectionException.new
+      end
+    end
+  end
+end

data/lib/blue_state_digital/email.rb

@@ -0,0 +1,22 @@
+#    <email>gil+punky1@thoughtworks.com</email>
+#    <email_type>personal</email_type>
+#    <is_subscribed>1</is_subscribed>
+#    <is_primary>1</is_primary>
+
+module BlueStateDigital
+  class Email < ApiDataModel
+    FIELDS = [:email, :email_type, :is_subscribed, :is_primary]
+
+    attr_accessor *FIELDS
+
+    def to_xml(builder = Builder::XmlMarkup.new)
+      builder.email do | email |
+        FIELDS.each do | field |
+          email.__send__(field, self.send(field)) if self.send(field)
+        end
+      end
+      builder
+    end
+
+  end
+end

data/lib/blue_state_digital/email_unsubscribe.rb

@@ -0,0 +1,11 @@
+module BlueStateDigital
+  class EmailUnsubscribe < ApiDataModel
+    attr_accessor :email, :reason
+
+    def unsubscribe!
+      result = connection.perform_request '/cons/email_unsubscribe', {email: email, reason: reason}, 'POST'
+      result == ''
+    end
+  end
+end
+

data/lib/blue_state_digital/error_middleware.rb

@@ -0,0 +1,29 @@
+module BlueStateDigital
+  class Unauthorized < ::Faraday::Error::ClientError ; end
+  class ResourceDoesNotExist < ::Faraday::Error::ClientError ; end
+  class EmailNotFound < ::Faraday::Error::ClientError ; end
+
+  class ErrorMiddleware < ::Faraday::Response::RaiseError
+    def on_complete(env)
+      case env[:status]
+      when 404
+        raise Faraday::Error::ResourceNotFound, response_values(env).to_s
+      when 403
+        raise BlueStateDigital::Unauthorized, response_values(env).to_s
+      when 409
+        if env.body =~ /does not exist/
+          raise BlueStateDigital::ResourceDoesNotExist, response_values(env).to_s
+        elsif env.body =~ /Email not found/
+          raise BlueStateDigital::EmailNotFound, response_values(env).to_s
+        else
+          raise Faraday::Error::ClientError, response_values(env).to_s
+        end
+      when 407
+        # mimic the behavior that we get with proxy requests with HTTPS
+        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+      when ClientErrorStatuses
+        raise Faraday::Error::ClientError, response_values(env).to_s
+      end
+    end
+  end
+end

data/lib/blue_state_digital/event.rb

@@ -0,0 +1,46 @@
+module BlueStateDigital
+  class Event < ApiDataModel
+
+    class EventSaveValidationException < StandardError
+      def initialize(validation_errors)
+        error_message = ""
+        validation_errors.each { |field, errors| error_message << "Validation errors on field #{field}: #{errors}\n" }
+
+        super(error_message)
+      end
+    end
+
+    FIELDS = [:event_id_obfuscated, :event_type_id, :creator_cons_id, :name, :description, :venue_name, :venue_country, :venue_zip, :venue_city, :venue_state_cd, :start_date, :end_date]
+    attr_accessor *FIELDS
+
+    def save
+      if self.event_id_obfuscated.blank?
+        response_json_text = connection.perform_request '/event/create_event', {accept: 'application/json', event_api_version: '2', values: self.to_json}, "POST"
+      else
+        response_json_text = connection.perform_request '/event/update_event', {accept: 'application/json', event_api_version: '2', values: self.to_json}, "POST"
+      end
+
+      response = JSON.parse(response_json_text)
+      if response['validation_errors']
+        raise EventSaveValidationException, response['validation_errors']
+      else
+        self.event_id_obfuscated = response['event_id_obfuscated']
+      end
+
+      self
+    end
+
+    def to_json
+      event_attrs = self.event_id_obfuscated.blank? ? { } : { event_id_obfuscated: self.event_id_obfuscated }
+      (FIELDS - [:event_id_obfuscated, :start_date, :end_date]).each do |field|
+        event_attrs[field] = self.send(field)
+      end
+
+      duration_in_minutes = ((end_date - start_date) / 60).to_i
+      day_attrs = { start_datetime_system: start_date.strftime('%Y-%m-%d %H:%M:%S %z'), duration: duration_in_minutes }
+      event_attrs[:days] = [ day_attrs ]
+
+      event_attrs.to_json
+    end
+  end
+end

data/lib/blue_state_digital/event_rsvp.rb

@@ -0,0 +1,17 @@
+module BlueStateDigital
+  class EventRSVP < ApiDataModel
+    FIELDS = [:event_id_obfuscated, :will_attend, :email, :zip, :country]
+    attr_accessor *FIELDS
+
+    def save
+      connection.perform_graph_request '/addrsvp', self.attributes, "POST"
+    end
+
+    def attributes
+      FIELDS.inject({}) do |attrs, field|
+        attrs[field] = self.send(field)
+        attrs
+      end
+    end
+  end
+end

data/lib/blue_state_digital/event_type.rb

@@ -0,0 +1,19 @@
+module BlueStateDigital
+  class EventType < ApiDataModel
+    FIELDS = [:event_type_id, :name, :description]
+    attr_accessor *FIELDS
+  end
+
+  class EventTypes < CollectionResource
+    def get_event_types
+      from_response(connection.perform_request('/event/get_available_types', {}, 'GET'))
+    end
+
+    private
+
+    def from_response(response)
+      parsed_response = JSON.parse(response)
+      parsed_response.collect { |pet| EventType.new(pet) }
+    end
+  end
+end

data/lib/blue_state_digital/phone.rb

@@ -0,0 +1,20 @@
+# <phone>0408573670</phone>
+# <phone_type>unknown</phone_type>
+# <is_subscribed>1</is_subscribed>
+# <is_primary>1</is_primary>
+module BlueStateDigital
+  class Phone < ApiDataModel
+    FIELDS = [:phone, :phone_type, :is_primary, :is_subscribed]
+    attr_accessor *FIELDS
+
+    def to_xml(builder = Builder::XmlMarkup.new)
+      builder.phone do | phone |
+        FIELDS.each do | field |
+          phone.__send__(field, self.send(field)) if self.send(field)
+        end
+      end
+      builder
+    end
+
+  end
+end

data/lib/blue_state_digital/version.rb

@@ -0,0 +1,3 @@
+module BlueStateDigital
+  VERSION = "0.6.0"
+end

data/spec/blue_state_digital/address_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe BlueStateDigital::Address do
+  subject { BlueStateDigital::Address.new({latitude: "40.1", longitude: "40.2"}) }
+  specify { expect(subject.latitude).to eq("40.1") }
+  specify { expect(subject.longitude).to eq("40.2") }
+
+
+  it "should return a builder" do
+    expect(subject.to_xml).to be_a(Builder)
+  end
+
+  describe :to_hash do
+    it "should return a hash of all fields" do
+      attr_hash = BlueStateDigital::Address::FIELDS.inject({}) {|h,k| h[k]="#{k.to_s}_value"; h}
+      phone = BlueStateDigital::Address.new attr_hash
+      expect(phone.to_hash).to eq(attr_hash)
+    end
+    it "should include nil fields" do
+      expected_hash = BlueStateDigital::Address::FIELDS.inject({}) {|h,k| h[k]=nil; h}
+      phone = BlueStateDigital::Address.new {}
+      expect(phone.to_hash).to eq(expected_hash)
+    end
+  end
+end

data/spec/blue_state_digital/api_data_model_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class DummyModel < BlueStateDigital::ApiDataModel
+  attr_accessor :attr1, :attr2
+end
+
+describe BlueStateDigital::ApiDataModel do
+  it "should initialize model with attributes" do
+    model = DummyModel.new({ attr1: "1", attr2: "2" })
+    expect(model.attr1).to eq("1")
+    expect(model.attr2).to eq("2")
+  end
+end

data/spec/blue_state_digital/connection_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'blue_state_digital/connection'
+require 'timecop'
+
+describe BlueStateDigital::Connection do
+  let(:api_host) { 'enoch.bluestatedigital.com' }
+  let(:api_id) { 'sfrazer' }
+  let(:api_secret) { '7405d35963605dc36702c06314df85db7349613f' }
+  let(:connection) { BlueStateDigital::Connection.new({host: api_host, api_id: api_id, api_secret: api_secret})}
+
+  if Faraday::VERSION != "0.8.9"
+    describe '#compute_hmac' do
+      it "should not escape whitespaces on params" do
+        timestamp = Time.parse('2014-01-01 00:00:00 +0000')
+        Timecop.freeze(timestamp) do
+          api_call = '/somemethod'
+          api_ts = timestamp.utc.to_i.to_s
+          expect(OpenSSL::HMAC).to receive(:hexdigest) do |digest, key, data|
+            expect(digest).to eq('sha1')
+            expect(key).to eq(api_secret)
+            expect(data).to match(/name=string with multiple whitespaces/)
+          end
+
+          api_mac = connection.compute_hmac("/page/api#{api_call}", api_ts, { api_ver: '2', api_id: api_id, api_ts: api_ts, name: 'string with multiple whitespaces' })
+        end
+      end
+    end
+  end
+
+  describe "#perform_request" do
+    context 'POST' do
+      it "should perform POST request" do
+        timestamp = Time.now
+        Timecop.freeze(timestamp) do
+          api_call = '/somemethod'
+          api_ts = timestamp.utc.to_i.to_s
+          api_mac = connection.compute_hmac("/page/api#{api_call}", api_ts, { api_ver: '2', api_id: api_id, api_ts: api_ts })
+
+          stub_url = "https://#{api_host}/page/api/somemethod?api_id=#{api_id}&api_mac=#{api_mac}&api_ts=#{api_ts}&api_ver=2"
+          stub_request(:post, stub_url).with do |request|
+            expect(request.body).to eq("a=b")
+            expect(request.headers['Accept']).to eq('text/xml')
+            expect(request.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+            true
+          end.to_return(body: "body")
+
+          response = connection.perform_request(api_call, params = {}, method = "POST", body = "a=b")
+          expect(response).to eq("body")
+        end
+      end
+
+      context 'well stubbed' do
+        before(:each) do
+          faraday_client = double(request: nil, response: nil, adapter: nil, options: {})
+          expect(faraday_client).to receive(:post).and_yield(post_request).and_return(post_request)
+          allow(Faraday).to receive(:new).and_yield(faraday_client).and_return(faraday_client)
+        end 
+
+        let(:post_request) do
+          pr = double(headers: headers, body: '', url: nil)
+          allow(pr).to receive(:body=)
+          options = double()
+          allow(options).to receive(:timeout=)
+          allow(pr).to receive(:options).and_return(options)
+          pr
+        end
+
+        let(:headers) { {} } 
+
+        it "should override Content-Type with param" do
+          connection = BlueStateDigital::Connection.new({host: api_host, api_id: api_id, api_secret: api_secret})
+
+          connection.perform_request '/somemethod', { content_type: 'application/json' }, 'POST'
+
+          expect(headers.keys).to include('Content-Type')
+          expect(headers['Content-Type']).to eq('application/json')
+        end
+
+        it "should override Accept with param" do
+          connection = BlueStateDigital::Connection.new({host: api_host, api_id: api_id, api_secret: api_secret})
+
+          connection.perform_request '/somemethod', { accept: 'application/json' }, 'POST'
+
+          expect(headers.keys).to include('Accept')
+          expect(headers['Accept']).to eq('application/json')
+        end
+      end
+    end
+
+    it "should perform PUT request" do
+      timestamp = Time.now
+      Timecop.freeze(timestamp) do
+        api_call = '/somemethod'
+        api_ts = timestamp.utc.to_i.to_s
+        api_mac = connection.compute_hmac("/page/api#{api_call}", api_ts, { api_ver: '2', api_id: api_id, api_ts: api_ts })
+
+        stub_url = "https://#{api_host}/page/api/somemethod?api_id=#{api_id}&api_mac=#{api_mac}&api_ts=#{api_ts}&api_ver=2"
+        stub_request(:put, stub_url).with do |request|
+          expect(request.body).to eq("a=b")
+          expect(request.headers['Accept']).to eq('text/xml')
+          expect(request.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+          true
+        end.to_return(body: "body")
+
+        response = connection.perform_request(api_call, params = {}, method = "PUT", body = "a=b")
+        expect(response).to eq("body")
+      end
+    end
+
+    it "should perform GET request" do
+      timestamp = Time.now
+      Timecop.freeze(timestamp) do
+        api_call = '/somemethod'
+        api_ts = timestamp.utc.to_i.to_s
+        api_mac = connection.compute_hmac("/page/api#{api_call}", api_ts, { api_ver: '2', api_id: api_id, api_ts: api_ts })
+
+        stub_url = "https://#{api_host}/page/api/somemethod?api_id=#{api_id}&api_mac=#{api_mac}&api_ts=#{api_ts}&api_ver=2"
+        stub_request(:get, stub_url).to_return(body: "body")
+
+        response = connection.perform_request(api_call, params = {})
+        expect(response).to eq("body")
+      end
+    end
+  end
+
+  describe "perform_graph_request" do
+    let(:faraday_client) { double(request: nil, response: nil, adapter: nil) }
+
+    it "should perform Graph API request" do
+      post_request = double
+      expect(post_request).to receive(:url).with('/page/graph/rsvp/add', {param1: 'my_param', param2: 'my_other_param'})
+      expect(faraday_client).to receive(:post).and_yield(post_request).and_return(post_request)
+      allow(Faraday).to receive(:new).and_yield(faraday_client).and_return(faraday_client)
+      connection = BlueStateDigital::Connection.new({host: api_host, api_id: api_id, api_secret: api_secret})
+
+      connection.perform_graph_request('/rsvp/add', {param1: 'my_param', param2: 'my_other_param'}, 'POST')
+    end
+  end
+
+  describe "#get_deferred_results" do
+    it "should make a request" do
+      expect(connection).to receive(:perform_request).and_return("foo")
+      expect(connection.get_deferred_results("deferred_id")).to eq("foo")
+    end
+  end
+
+  describe "#compute_hmac" do
+    it "should compute proper hmac hash" do
+      params = { api_id: api_id, api_ts: '1272659462', api_ver: '2' }
+      expect(connection.compute_hmac('/page/api/circle/list_circles', '1272659462', params)).to eq('c4a31bdaabef52d609cbb5b01213fb267af4e808')
+    end
+  end
+end