emailhunter 1.0.0 → 2.0.0

data/lib/email_hunter/campaigns.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class Campaigns
+    API_URL = 'https://api.hunter.io/v2/campaigns'
+
+    attr_reader :key, :params, :action, :campaign_id, :data
+
+    def initialize(key, action: :list, campaign_id: nil, data: nil, params: {})
+      @key = key
+      @action = action
+      @campaign_id = campaign_id
+      @data = data
+      @params = params
+    end
+
+    def hunt
+      case action
+      when :list
+        list_campaigns
+      when :recipients
+        list_recipients
+      when :add_recipient
+        add_recipient
+      when :delete_recipient
+        delete_recipient
+      else
+        raise ArgumentError, "Unknown action: #{action}"
+      end
+    end
+
+    private
+
+    def list_campaigns
+      response_data = fetch_campaigns_data
+      return nil if response_data.empty?
+
+      # Convert to OpenStruct for easy access
+      result = OpenStruct.new(response_data)
+
+      # Convert campaigns array to OpenStruct objects if it exists
+      if result.data.is_a?(Hash) && result.data[:campaigns].is_a?(Array)
+        campaigns_array = result.data[:campaigns].map { |c| OpenStruct.new(c) }
+        result.data = OpenStruct.new(result.data.merge(campaigns: campaigns_array))
+      elsif result.data.is_a?(OpenStruct) && result.data.campaigns.is_a?(Array)
+        result.data.campaigns = result.data.campaigns.map { |c| OpenStruct.new(c) }
+      end
+
+      result
+    end
+
+    def list_recipients
+      response_data = fetch_recipients_data
+      return nil if response_data.empty?
+
+      result = OpenStruct.new(response_data)
+
+      # Convert recipients array to OpenStruct objects if it exists
+      if result.data.is_a?(Hash) && result.data[:recipients].is_a?(Array)
+        recipients_array = result.data[:recipients].map { |r| OpenStruct.new(r) }
+        result.data = OpenStruct.new(result.data.merge(recipients: recipients_array))
+      elsif result.data.is_a?(OpenStruct) && result.data.recipients.is_a?(Array)
+        result.data.recipients = result.data.recipients.map { |r| OpenStruct.new(r) }
+      end
+
+      result
+    end
+
+    def add_recipient
+      response_data = post_recipient_data
+      return nil if response_data.empty?
+
+      OpenStruct.new(response_data)
+    end
+
+    def delete_recipient
+      response = delete_recipient_data
+      response.success?
+    end
+
+    def fetch_campaigns_data
+      connection = Faraday.new
+      request_params = {
+        api_key: key,
+        limit: params.fetch(:limit, 20),
+        offset: params.fetch(:offset, 0)
+      }
+
+      response = connection.get(API_URL, request_params)
+
+      return {} unless response.success?
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+
+    def fetch_recipients_data
+      connection = Faraday.new
+      url = "#{API_URL}/#{campaign_id}/recipients"
+      request_params = {
+        api_key: key,
+        limit: params.fetch(:limit, 20),
+        offset: params.fetch(:offset, 0)
+      }
+
+      response = connection.get(url, request_params)
+
+      return {} unless response.success?
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+
+    def post_recipient_data
+      connection = Faraday.new
+      url = "#{API_URL}/#{campaign_id}/recipients"
+      request_data = data.merge(api_key: key)
+
+      response = connection.post(url) do |req|
+        req.headers['Content-Type'] = 'application/json'
+        req.body = request_data.to_json
+      end
+
+      return {} unless response.success?
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+
+    def delete_recipient_data
+      connection = Faraday.new
+      email = data[:email]
+      url = "#{API_URL}/#{campaign_id}/recipients/#{email}"
+
+      connection.delete(url, api_key: key)
+    end
+  end
+end

data/lib/email_hunter/combined_enrichment.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require_relative 'lead_enrichment'
+require_relative 'company_enrichment'
+
+module EmailHunter
+  class CombinedEnrichment
+    attr_reader :key, :email, :linkedin
+
+    def initialize(key, email: nil, linkedin: nil)
+      @key = key
+      @email = email
+      @linkedin = linkedin
+
+      raise ArgumentError, 'Either email or linkedin must be provided' if email.nil? && linkedin.nil?
+    end
+
+    def hunt
+      # First get lead enrichment data
+      lead_data = LeadEnrichment.new(key, email: email, linkedin: linkedin).hunt
+      return nil if lead_data.nil?
+
+      # Extract domain from employment if available
+      domain = lead_data.data.employment&.domain
+      return lead_data if domain.nil?
+
+      # Get company enrichment data
+      company_data = CompanyEnrichment.new(domain, key).hunt
+
+      # Combine the data
+      OpenStruct.new(
+        lead: lead_data,
+        company: company_data,
+        meta: OpenStruct.new(
+          email: email,
+          linkedin: linkedin,
+          domain: domain
+        )
+      )
+    rescue StandardError => e
+      # If company enrichment fails, just return lead data
+      OpenStruct.new(
+        lead: lead_data,
+        company: nil,
+        meta: OpenStruct.new(
+          email: email,
+          linkedin: linkedin,
+          error: e.message
+        )
+      )
+    end
+  end
+end

data/lib/email_hunter/company.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class Company
+    API_URL = 'https://api.hunter.io/v2/companies/find'
+
+    attr_reader :domain, :key
+
+    def initialize(domain, key)
+      @domain = domain
+      @key = key
+    end
+
+    def hunt
+      response_data = fetch_company_data
+      return nil if response_data.empty?
+
+      # Convert nested data structure to a Struct
+      data = response_data[:data]
+      meta = response_data[:meta]
+
+      result = OpenStruct.new(
+        data: OpenStruct.new(data),
+        meta: OpenStruct.new(meta)
+      )
+
+      # Recursively convert nested hashes to OpenStructs for deeper access
+      convert_hash_to_struct(result.data, data)
+
+      result
+    end
+
+    private
+
+    def fetch_company_data
+      @fetch_company_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, domain: domain, api_key: key)
+
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+  end
+end

data/lib/email_hunter/company_enrichment.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class CompanyEnrichment
+    API_URL = 'https://api.hunter.io/v2/companies/find'
+
+    attr_reader :domain, :key
+
+    def initialize(domain, key)
+      @domain = domain
+      @key = key
+    end
+
+    def hunt
+      response_data = fetch_enrichment_data
+      return nil if response_data.empty?
+
+      # Convert nested data structure to OpenStruct
+      data = response_data[:data]
+      meta = response_data[:meta]
+
+      result = OpenStruct.new(
+        data: OpenStruct.new(data),
+        meta: OpenStruct.new(meta)
+      )
+
+      # Recursively convert nested hashes to OpenStructs for deeper access
+      convert_hash_to_struct(result.data, data)
+
+      result
+    end
+
+    private
+
+    def fetch_enrichment_data
+      @fetch_enrichment_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, domain: domain, api_key: key)
+
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+  end
+end

data/lib/email_hunter/count.rb

@@ -1,27 +1,35 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'json'
 
-API_COUNT_URL = 'https://api.hunter.io/v2/email-count?'.freeze
-
 module EmailHunter
   class Count
-    attr_reader :data, :meta, :domain
+    API_URL = 'https://api.hunter.io/v2/email-count'
+
+    attr_reader :domain
 
     def initialize(domain)
       @domain = domain
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_count_data
+      return nil if response_data.empty?
+
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
-    def apiresponse
-      @data ||= begin
-        response = Faraday.new("#{API_COUNT_URL}domain=#{domain}").get
+    private
+
+    def fetch_count_data
+      @fetch_count_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, domain: domain)
 
-        return [] unless response.success?
+        return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/discover.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module EmailHunter
+  class Discover
+    API_URL = 'https://api.hunter.io/v2/discover'
+
+    attr_reader :query, :key, :params
+
+    def initialize(query, key, params = {})
+      @query = query
+      @key = key
+      @params = params
+    end
+
+    def hunt
+      response_data = fetch_discover_data
+      return nil if response_data.empty?
+
+      # Convert to OpenStruct for easy access
+      result = OpenStruct.new(response_data)
+
+      # Recursively convert nested hashes to OpenStructs
+      convert_hash_to_struct(result, response_data)
+
+      result
+    end
+
+    private
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+
+    def limit
+      params.fetch(:limit, 100).to_i
+    end
+
+    def offset
+      params.fetch(:offset, 0).to_i
+    end
+
+    def filters
+      params.fetch(:filters, {})
+    end
+
+    def fetch_discover_data
+      @fetch_discover_data ||= begin
+        connection = Faraday.new
+        request_data = {
+          query: query,
+          api_key: key,
+          limit: limit,
+          offset: offset
+        }
+
+        # Add filters if provided
+        request_data[:filters] = filters unless filters.empty?
+
+        response = connection.post(API_URL) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = request_data.to_json
+        end
+
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+  end
+end

data/lib/email_hunter/exist.rb

@@ -3,11 +3,11 @@
 require 'faraday'
 require 'json'
 
-API_EXIST_URL = 'https://api.emailhunter.co/v1/exist?'
-
 module EmailHunter
   class Exist
-    attr_reader :status, :email, :exist, :sources, :key
+    API_URL = 'https://api.emailhunter.co/v1/exist'
+
+    attr_reader :email, :key
 
     def initialize(email, key)
       @email = email
@@ -15,16 +15,22 @@ module EmailHunter
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_exist_data
+      return nil if response_data.empty?
+
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
-    def data
-      @data ||= begin
-        response = Faraday.new("#{API_EXIST_URL}email=#{email}&api_key=#{key}").get
+    private
+
+    def fetch_exist_data
+      @fetch_exist_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, email: email, api_key: key)
 
         return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/finder.rb

@@ -3,10 +3,10 @@
 require 'faraday'
 require 'json'
 
-API_FINDER_URL = 'https://api.hunter.io/v2/email-finder?'
-
 module EmailHunter
   class Finder
+    API_FINDER_URL = 'https://api.hunter.io/v2/email-finder'
+
     attr_reader :email, :score, :sources, :domain, :meta, :key, :first_name, :last_name
 
     def initialize(domain, first_name, last_name, key)
@@ -22,12 +22,26 @@ module EmailHunter
 
     def data
       @data ||= begin
-        response = Faraday.new("#{API_FINDER_URL}domain=#{domain}&first_name=#{first_name}&last_name=#{last_name}&api_key=#{key}").get
+        response = fetch_finder_data
 
-        return [] unless response.success?
+        return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
+
+    private
+
+    def fetch_finder_data
+      connection = Faraday.new
+      params = {
+        domain: domain,
+        first_name: first_name,
+        last_name: last_name,
+        api_key: key
+      }
+
+      connection.get(API_FINDER_URL, params)
+    end
   end
 end

data/lib/email_hunter/lead_enrichment.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class LeadEnrichment
+    API_URL = 'https://api.hunter.io/v2/people/find'
+
+    attr_reader :key, :email, :linkedin
+
+    def initialize(key, email: nil, linkedin: nil)
+      @key = key
+      @email = email
+      @linkedin = linkedin
+
+      raise ArgumentError, 'Either email or linkedin must be provided' if email.nil? && linkedin.nil?
+    end
+
+    def hunt
+      response_data = fetch_enrichment_data
+      return nil if response_data.empty?
+
+      # Convert nested data structure to OpenStruct
+      data = response_data[:data]
+      meta = response_data[:meta]
+
+      result = OpenStruct.new(
+        data: OpenStruct.new(data),
+        meta: OpenStruct.new(meta)
+      )
+
+      # Recursively convert nested hashes to OpenStructs for deeper access
+      convert_hash_to_struct(result.data, data)
+
+      result
+    end
+
+    private
+
+    def fetch_enrichment_data
+      @fetch_enrichment_data ||= begin
+        connection = Faraday.new
+        request_params = { api_key: key }
+
+        request_params[:email] = email if email
+        request_params[:linkedin_handle] = linkedin if linkedin
+
+        response = connection.get(API_URL, request_params)
+
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+  end
+end