leadsquared 0.2.0

data/lib/leadsquared/api_connection.rb

@@ -0,0 +1,35 @@
+module Leadsquared
+  class ApiConnection
+    attr_reader :connection
+
+    def initialize(service)
+      @connection = Leadsquared::Client.new
+      @service = service
+    end
+
+    protected
+
+    def url_with_service(action)
+      @service + action
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200
+        return JSON.parse response.body
+      when 400
+        raise InvalidRequestError.new("Bad Request")
+      when 401
+        raise InvalidRequestError.new("Unauthorized Request")
+      when 404
+        raise InvalidRequestError.new("API Not Found")
+      when 500
+        message = response.body.try(:[],  "ExceptionMessage")
+        raise InvalidRequestError.new("Internal Error: #{message}")
+      else
+        raise InvalidRequestError.new("Unknown Error#{response.body}")
+      end
+    end
+
+  end
+end

data/lib/leadsquared/client.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+
+module Leadsquared
+  class Client
+    ENDPOINT = 'https://api.leadsquared.com'.freeze
+    HEADERS = {'Content-Type' => 'application/json', 'Accept' => 'application/json'}.freeze
+
+    attr_reader :key, :secret, :endpoint
+
+    def initialize(key = nil, secret = nil, endpoint = nil)
+      @key      = key       || Leadsquared.config.key
+      @secret   = secret    || Leadsquared.config.secret
+      @endpoint = endpoint  || Leadsquared.config.endpoint || ENDPOINT
+      raise ArgumentError.new("Missing key or secret") unless @secret and @key
+    end
+
+    def post(url, params = {}, body = nil)
+      conn = Faraday.new(url: @endpoint)
+      merged_params = {accessKey: @key, secretKey: @secret}.merge(params)
+      response = conn.post(url) do |req|
+        req.headers = HEADERS
+        req.params  = merged_params
+        req.body    = body if body
+      end
+
+      response
+    end
+
+    def get(url, params = {})
+      conn = Faraday.new(url: @endpoint)
+      merged_params = {accessKey: @key, secretKey: @secret}.merge(params)
+      response = conn.get(url) do |req|
+        req.headers = HEADERS
+        req.params  = merged_params
+      end
+
+      response
+    end
+
+  end
+end

data/lib/leadsquared/config.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+module Leadsquared
+
+  class Config
+    attr_accessor :key, :secret, :endpoint, :logger
+
+    def logger
+      @logger ||= Logger.new(STDERR)
+    end
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+end

data/lib/leadsquared/engine.rb

@@ -0,0 +1,5 @@
+module Leadsquared
+  class Engine < Rails::Engine
+    isolate_namespace Leadsquared
+  end
+end

data/lib/leadsquared/invalid_request_error.rb

@@ -0,0 +1,7 @@
+module Leadsquared
+  class InvalidRequestError < StandardError
+    def initialize(error)
+      super(error)
+    end
+  end
+end

data/lib/leadsquared/lead.rb

@@ -0,0 +1,106 @@
+require 'json'
+require 'active_support/core_ext/object/try'
+
+module Leadsquared
+  class Lead < ApiConnection
+    SERVICE = '/v2/LeadManagement.svc/'.freeze
+
+    def initialize
+      super(SERVICE)
+    end
+
+    def get_meta_data
+      url = url_with_service("LeadsMetaData.Get")
+      response = connection.get(url, {})
+      handle_response response
+    end
+
+    def get_lead_by_id(lead_id)
+      url = url_with_service("Leads.GetById")
+      response = connection.get(url, {id: lead_id})
+      parsed_response = handle_response response
+      parsed_response.first
+    end
+
+    def get_lead_by_email(email)
+      url = url_with_service("Leads.GetByEmailaddress")
+      response = connection.get(url, {emailaddress: email})
+      parsed_response = handle_response response
+      parsed_response.first
+    end
+
+    def quick_search(key)
+      url = url_with_service("Leads.GetByQuickSearch")
+      response = connection.get(url, {key: key})
+      handle_response response
+    end
+
+    def create_lead(email = nil, first_name = nil, last_name = nil)
+      url = url_with_service("Lead.Create")
+      body = [
+        {
+          "Attribute": "EmailAddress",
+          "Value": email
+        },
+        {
+          "Attribute": "FirstName",
+          "Value": first_name
+        },
+        {
+          "Attribute": "LastName",
+          "Value": last_name
+        }
+      ]
+      response = connection.post(url, {}, body.to_json)
+      parsed_response = handle_response response
+      parsed_response["Message"]["Id"]
+    end
+
+    def update_lead(lead_id, values_hash = {})
+      url = url_with_service("Lead.Update")
+      body = values_hash.map {|key, val| {"Attribute" => key, "Value" => val} }
+      response = connection.post(url, {leadId: lead_id}, body.to_json)
+      parsed_response = handle_response response
+      parsed_response["Status"]
+    end
+
+    def create_or_update(email = nil, first_name = nil, last_name = nil, phone = nil, search_by = "EmailAddress")
+      url = url_with_service("Lead.CreateOrUpdate")
+      body = [
+        {
+          "Attribute": "EmailAddress",
+          "Value": email
+        },
+        {
+          "Attribute": "FirstName",
+          "Value": first_name
+        },
+        {
+          "Attribute": "LastName",
+          "Value": last_name
+        },
+        {
+          "Attribute": "Phone",
+          "Value": phone
+        },
+        {
+          "Attribute": "SearchBy",
+          "Value": search_by
+        }
+      ]
+      response = connection.post(url, {}, body.to_json)
+      parsed_response = handle_response response
+      parsed_response["Message"]["Id"]
+    end
+
+    def visitor_to_lead(prospect_id, values_hash = {})
+      url = url_with_service("Lead.Convert")
+      body = values_hash.map {|key, val| {"Attribute" => key, "Value" => val} }
+      response = connection.post(url, {leadId: prospect_id}, body.to_json)
+      parsed_response = handle_response response
+      parsed_response["Status"]
+    end
+
+  end
+
+end

data/spec/leadsquared/activity_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Leadsquared::Lead do
+  let(:mock_connection)   { double("connection") }
+  let(:service) { '/v2/ProspectActivity.svc/' }
+  let(:lead_id) { "3131ea6a-bb20-4457-b183-ddf6d8716dfe" }
+  let(:email) { "test@example.com" }
+  let(:current_utc_time) { Time.now.utc.to_s.gsub(/ UTC$/, "") }
+  subject { Leadsquared::Activity.new }
+
+  before do
+    expect(Leadsquared::Client).to receive(:new).and_return mock_connection
+  end
+
+  describe "#get_activities" do
+    let(:url) { "#{service}Retrieve" }
+    let(:activity_event_id) { 201 }
+    let(:body) do
+      {
+        "Parameter" => {"ActivityEvent" => activity_event_id},
+        "Paging" => {"Offset" => 0, "RowCount" => 10}
+      }
+    end
+    let(:success_response) do
+      {
+        "RecordCount" => 0,
+        "ProspectActivities" => []
+      }
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+
+    it "valid request with existing id" do
+      expect(mock_connection).to receive(:post).with(url, {leadId: lead_id}, body.to_json).and_return valid_response
+      subject.get_activities(lead_id, activity_event_id)
+    end
+  end
+
+  describe "#create_activity_type" do
+    let(:url) { "#{service}CreateType" }
+    let(:score) { 10 }
+    let(:activity_name) { "New Activity" }
+    let(:description) { "Some Description" }
+    let(:body) do
+      {
+        "ActivityEventName" => activity_name,
+        "Score" => score,
+        "Description" => description,
+        "Direction" => 0
+      }
+    end
+    let(:success_response) do
+      {
+        "Status": "Success",
+        "Message": {
+          "Id": "206"
+        }
+      }
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+
+    it "activity event" do
+      expect(mock_connection).to receive(:post).with(url, {}, body.to_json).and_return valid_response
+      response = subject.create_activity_type(activity_name, score, description)
+      expect(response).to eq("206")
+    end
+  end
+
+  describe "#create" do
+    let(:url) { "#{service}Create" }
+    let(:id) { "d91bd87a-7bca-11e5-a199-22000aa4133b" }
+    let(:event_id) { "201" }
+    let(:body) do
+      {
+        "EmailAddress"      => email,
+        "ActivityEvent"     => event_id,
+        "ActivityNote"      => nil,
+        "ActivityDateTime"  => current_utc_time,
+        "FirstName"         => nil,
+        "LastName"          => nil
+      }
+    end
+
+    let(:success_response) do
+      {
+        "Status": "Success",
+        "Message": {
+          "Id": id
+        }
+      }
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+
+    before do
+      Timecop.freeze(Time.local(2015))
+    end
+
+    after do
+      Timecop.return
+    end
+
+    it "valid activity" do
+      expect(mock_connection).to receive(:post).with(url, {}, body.to_json).and_return valid_response
+      response = subject.create(email, event_id)
+      expect(response).to eq(id)
+    end
+  end
+
+  describe "#create_lead_activity" do
+    let(:url) { "#{service}Create" }
+    let(:id) { "d91bd87a-7bca-11e5-a199-22000aa4133b" }
+    let(:event_id) { "201" }
+    let(:notes) { "Some Description" }
+    let(:body) do
+      {
+        "RelatedProspectId" => lead_id,
+        "ActivityEvent"     => event_id,
+        "ActivityNote"      => notes,
+        "ActivityDateTime"  => current_utc_time
+      }
+    end
+
+    let(:success_response) do
+      {
+        "Status": "Success",
+        "Message": {
+          "Id": id
+        }
+      }
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+
+    before do
+      Timecop.freeze(Time.local(2015))
+    end
+
+    after do
+      Timecop.return
+    end
+
+    it "valid activity" do
+      expect(mock_connection).to receive(:post).with(url, {leadId: lead_id}, body.to_json).and_return valid_response
+      response = subject.create_lead_activity(lead_id, event_id, notes)
+      expect(response).to eq(id)
+    end
+  end
+
+end

data/spec/leadsquared/client_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Leadsquared::Client do
+  let(:client) { Leadsquared::Client.new('token', 'pass', 'http://localhost:8088/mock') }
+
+  describe "Valid Request" do
+    let(:service) { "service1" }
+    let(:body) do
+      {key1: 'value1', key2: 'value2'}
+    end
+    let(:auth_params) { "?accessKey=token&secretKey=pass" }
+
+    it "#post" do
+      blk = lambda do |req|
+        expect(req.body).to  match(body)
+      end
+      stub_request(:post, "http://localhost:8088/mock/#{service}#{auth_params}").with(&blk).
+        to_return(status: 200, body: "{\"id\": \"123456\"}")
+      response = client.post(service, {}, body)
+      expect(response.status).to eql(200)
+    end
+
+    it "#get" do
+      params = {xid: '1'}
+      stub_request(:get, "http://localhost:8088/mock/#{service}#{auth_params}&xid=1").
+        to_return(status: 200, body: body.to_json)
+      response = client.get(service, params)
+      expect(response.status).to eql(200)
+
+    end
+  end
+
+  describe "Invalid Request" do
+    pending "TODO"
+  end
+
+  describe "Configuration" do
+    it "requires token and secret" do
+      expect { Leadsquared::Client.new }.to raise_error(ArgumentError)
+    end
+
+    describe "preset" do
+      before do
+        Leadsquared.configure do |config|
+          config.key      = 'mylogin'
+          config.secret   = 'mypassword'
+          config.endpoint = "http://google.com"
+        end
+      end
+
+      after do
+        Leadsquared.configure do |config|
+          config.key      = nil
+          config.secret   = nil
+          config.endpoint = Leadsquared::Client::ENDPOINT
+        end
+      end
+
+      it "configures the client" do
+        Leadsquared.configure do |config|
+          config.key      = 'mylogin'
+          config.secret   = 'mypassword'
+          config.endpoint = "http://google.com"
+        end
+        client = Leadsquared::Client.new
+        expect(client.key).to eq('mylogin')
+        expect(client.secret).to eq('mypassword')
+        expect(client.endpoint).to eq("http://google.com")
+      end
+    end
+  end
+end

data/spec/leadsquared/lead_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+
+describe Leadsquared::Lead do
+  let(:mock_connection)   { double("connection") }
+  let(:lead_id) { "3131ea6a-bb20-4457-b183-ddf6d8716dfe" }
+  let(:email) { "test@example.com" }
+  let(:first_name) { "Bob" }
+  let(:last_name) { "Zeiger" }
+
+  let(:invalid_response_body) do
+    {
+      "Status" => "Error",
+      "ExceptionType" => "MXDuplicateEntryException",
+      "ExceptionMessage" => "Duplicate entry 'john.smith@acmeconsulting.co' for key 'UQ_Prospect_Base_EmailAddress'"
+    }
+  end
+  let(:invalid_response)  { double("response", status: 500, body: invalid_response_body) }
+  let(:service) { '/v2/LeadManagement.svc/' }
+
+  subject { Leadsquared::Lead.new }
+
+  before do
+    expect( Leadsquared::Client).to receive(:new).and_return mock_connection
+  end
+
+  describe "#get_lead_by_id" do
+    let(:url) { "#{service}Leads.GetById" }
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+    let(:empty_response) { double("response", status: 200, body: [].to_json) }
+    let(:success_response) do
+      [
+        {
+          "ProspectID" => " Lead Id ",
+          "FirstName" => "Syed",
+          "LastName" => "Rizwan Ali",
+          "EmailAddress" => "rizwan@yopmail.com",
+          "Company" => "Roga",
+          "SourceReferrer" => ""
+        }
+      ]
+    end
+
+    it "valid request with existing id" do
+      expect(mock_connection).to receive(:get).with(url, {id: lead_id}).and_return valid_response
+      response = subject.get_lead_by_id(lead_id)
+    end
+
+    it "with missing id" do
+      missing_id = "12345"
+      expect(mock_connection).to receive(:get).with(url, {id: missing_id}).and_return empty_response
+      response = subject.get_lead_by_id(missing_id)
+    end
+  end
+
+  describe "#get_lead_by_email" do
+    let(:url) { "#{service}Leads.GetByEmailaddress" }
+    let(:email) { "test@example.com" }
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+    let(:empty_response) { double("response", status: 200, body: [].to_json) }
+    let(:success_response) do
+      [
+        {
+          "ProspectID" => " Lead Email ",
+          "FirstName" => "Syed",
+          "LastName" => "Rizwan Ali",
+          "EmailAddress" => "rizwan@yopmail.com",
+          "Company" => "Roga",
+          "SourceReferrer" => ""
+        }
+      ]
+    end
+
+    it "valid request with existing id" do
+      expect(mock_connection).to receive(:get).with(url, {emailaddress: email}).and_return valid_response
+      response = subject.get_lead_by_email(email)
+    end
+
+    it "with missing id" do
+      expect(mock_connection).to receive(:get).with(url, {emailaddress: email}).and_return empty_response
+      response = subject.get_lead_by_email(email)
+    end
+  end
+
+  describe "#quick_search" do
+    let(:url) { "#{service}Leads.GetByQuickSearch" }
+    let(:key) { "Jhon" }
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+    let(:empty_response) { double("response", status: 200, body: [].to_json) }
+    let(:success_response) do
+      [
+        {
+          "ProspectID": "16837df6-ec85werwer9b1f3a902",
+          "FirstName" => "Syed",
+          "LastName" => "Rizwan Ali",
+          "EmailAddress" => "rizwan@yopmail.com",
+          "Company" => "Roga",
+          "SourceReferrer" => ""
+        },
+        {
+          "ProspectID": "16837df6-ec85werwer9b1f3a903",
+          "FirstName" => "Syed2",
+          "LastName" => "Rizwan Ali",
+          "EmailAddress" => "rizwan2@yopmail.com",
+          "Company" => "Roga",
+          "SourceReferrer" => ""
+        }
+      ]
+    end
+
+    it "valid request with existing id" do
+      expect(mock_connection).to receive(:get).with(url, {key: key}).and_return valid_response
+      response = subject.quick_search(key)
+    end
+
+    it "with missing id" do
+      expect(mock_connection).to receive(:get).with(url, {key: key}).and_return empty_response
+      response = subject.quick_search(key)
+    end
+
+  end
+
+  describe "#visitor_to_lead" do
+    let(:url) { "#{service}Lead.Convert" }
+    let(:values_hash) do
+      {"OwnerId" => "1234567"}
+    end
+    let(:success_response) do
+      {
+        "Status" => "Success",
+        "Message" => {
+          "AffectedRows" => 1
+        }
+      }
+    end
+    let(:body) do
+      [
+        {
+          "Attribute": "OwnerId",
+          "Value": "1234567"
+        }
+      ]
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+
+    it "converts valid user" do
+      expect(mock_connection).to receive(:post).with(url, {leadId: lead_id}, body.to_json).and_return valid_response
+      response = subject.visitor_to_lead(lead_id, values_hash)
+      expect(response).to eq(success_response["Status"])
+    end
+  end
+
+  describe "#update" do
+    let(:url) { "#{service}Lead.Update" }
+    let(:new_values) do
+      {phone: "1234567", city: "NY"}
+    end
+    let(:success_response) do
+      {
+        "Status" => "Success",
+        "Message" => {
+          "AffectedRows" => 1
+        }
+      }
+    end
+    let(:failed_response) do
+      {
+        "Status" => "Error",
+        "ExceptionType" => "MXInvalidEntityException",
+        "ExceptionMessage" => "Lead does not exist in the system"
+      }
+    end
+    let(:body) do
+      [
+        {
+          "Attribute": "phone",
+          "Value": "1234567"
+        },
+        {
+          "Attribute": "city",
+          "Value": "NY"
+        }
+      ]
+    end
+    let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+    let(:invalid_response) { double("response", status: 500, body: failed_response.to_json) }
+
+    it "existing lead" do
+      expect(mock_connection).to receive(:post).with(url, {leadId: lead_id}, body.to_json).and_return valid_response
+      response = subject.update_lead(lead_id, new_values)
+      expect(response).to eq(success_response["Status"])
+    end
+
+    it "missing lead" do
+      expect(mock_connection).to receive(:post).with(url, {leadId: lead_id}, body.to_json).and_return invalid_response
+      expect {
+        subject.update_lead(lead_id, new_values)
+      }.to raise_error(Leadsquared::InvalidRequestError)
+    end
+  end
+
+  describe "#create_or_update" do
+    let(:success_response) do
+      {
+        "Status" => "Success",
+        "Message" => {
+          "Id" => "xxxxxxxx-Lead-Idxx-xxxx-xxxxxxxxxxx",
+          "AffectedRows" => 1
+        }
+      }
+    end
+
+    describe "search by email" do
+      let(:url) { "#{service}Lead.CreateOrUpdate" }
+      let(:valid_response) { double("response", status: 200, body: success_response.to_json) }
+      let(:body) do
+        [
+        {
+          "Attribute": "EmailAddress",
+          "Value": email
+        },
+        {
+          "Attribute": "FirstName",
+          "Value": first_name
+        },
+        {
+          "Attribute": "LastName",
+          "Value": last_name
+        },
+        {
+          "Attribute": "Phone",
+          "Value": nil
+        },
+        {
+          "Attribute": "SearchBy",
+          "Value": "EmailAddress"
+        }
+      ]
+      end
+      it "valid request" do
+        expect(mock_connection).to receive(:post).with(url, {}, body.to_json).and_return valid_response
+        response = subject.create_or_update(email, first_name, last_name)
+        expect(response).to eq(success_response["Message"]["Id"])
+      end
+    end
+
+    describe "search by phone" do
+      pending "TODO"
+    end
+  end
+
+  describe "#create_lead" do
+    let(:url) { "#{service}Lead.Create" }
+    let(:body) do
+      [
+        {
+          "Attribute" => "EmailAddress",
+          "Value" => email
+        },
+        {
+          "Attribute" => "FirstName",
+          "Value" => first_name
+        },
+        {
+          "Attribute" => "LastName",
+          "Value" => last_name
+        }
+      ]
+    end
+    let(:success_response) do
+      {
+        "Status" => "Success",
+        "Message" => {
+          "Id" => "3131ea6a-bb20-4457-b183-ddf6d8716dfe"
+        }
+      }
+    end
+    let(:valid_response)  { double("response", status: 200, body: success_response.to_json) }
+
+    it "valid request with given params" do
+      expect(mock_connection).to receive(:post).with(url, {}, body.to_json).and_return valid_response
+      response = subject.create_lead(email, first_name, last_name)
+      expect(response).to eq(success_response["Message"]["Id"])
+    end
+
+    it "invalid request" do
+      expect(mock_connection).to receive(:post).with(url, {}, body.to_json).and_return invalid_response
+      expect {
+        subject.create_lead(email, first_name, last_name)
+      }.to raise_error(Leadsquared::InvalidRequestError)
+    end
+  end
+
+  describe "#get_meta_data" do
+    let(:success_response) do
+      [
+        {
+          "SchemaName" => "mx_CreationTime",
+          "DisplayName" => "CreationTime",
+          "DataType" => "Time",
+          "IsMandatory" => false,
+          "MaxLength" => "50",
+          "RenderType" => 21,
+          "RenderTypeTextValue" => "Time"
+        },
+        {
+          "SchemaName" => "mx_ModifiedTime",
+          "DisplayName" => "ModifiedTime",
+          "DataType" => "Time",
+          "IsMandatory" => false,
+          "MaxLength" => "50",
+          "RenderType" => 21,
+          "RenderTypeTextValue" => "Time"
+        }]
+    end
+    let(:valid_response)  { double("response", status: 200, body: success_response.to_json) }
+    let(:url) { "#{service}LeadsMetaData.Get" }
+
+    it "valid request with given params" do
+      expect(mock_connection).to receive(:get).with(url, {}).and_return valid_response
+      response = subject.get_meta_data
+    end
+
+  end
+end