mailjet 0.0.5 → 1.0.0

data/lib/mailjet/api_error.rb

@@ -1,19 +1,23 @@
 # encoding: utf-8
 require 'active_support'
 
-module Mailjet  
+module Mailjet
   class ApiError < StandardError
+
+    attr_accessor :code
+
     def initialize(code, res, request, request_path, params)
+      self.code = code
       # code is ugly, output is pretty
-      super("error #{code} while sending #{request.inspect} to #{request_path} with #{params.inspect}\n\n" + 
-        (res['errors'].present? ? 
+      super("error #{code} while sending #{request.inspect} to #{request_path} with #{params.inspect}\n\n" +
+        (res['errors'].present? ?
           [(res['errors'] || [])].flatten.map do |param, text|
             [param, text].map(&:to_s).reject(&:blank?).join(': ')
-          end.join("\n") : 
+          end.join("\n") :
           res.inspect
         ) +
         "\n\nPlease see http://api.mailjet.com/0.1/HelpStatus for more informations on error numbers.\n\n"
       )
     end
   end
-end
+end

data/lib/mailjet/collection_proxy.rb

@@ -0,0 +1,15 @@
+module Mailjet
+  class CollectionProxy
+    attr_accessor :count
+
+    def intialize(response = {})
+      self.count = response['Total']
+      @proxy = response['Data'] ? Array.new(response['Data']) : []
+    end
+
+    def method_missing(name, *args, &block)
+      @proxy.send(name, *args, &block)
+    end
+
+  end
+end

data/lib/mailjet/configuration.rb

@@ -2,15 +2,11 @@ require 'active_support/core_ext/module/attribute_accessors'
 
 module Mailjet
   module Configuration
-    mattr_accessor :api_version
     mattr_accessor :api_key
     mattr_accessor :secret_key
-    mattr_accessor :use_https
-    mattr_accessor :domain
+    mattr_accessor :end_point
     mattr_accessor :default_from
-    
-    @@use_https = true
-    @@api_version = 0.1
-    @@domain = ''
+
+    @@end_point = 'https://api.mailjet.com'
   end
-end
+end

data/lib/mailjet/connection.rb

@@ -0,0 +1,72 @@
+require 'rest_client'
+require 'mailjet/gem_extensions/rest_client'
+require 'active_support/core_ext/module/delegation'
+
+module Mailjet
+  class Connection
+
+    attr_accessor :adapter, :public_operations, :read_only
+    alias :read_only? :read_only
+
+    delegate :options, :concat_urls, :url, to: :adapter
+
+    def [](suburl, &new_block)
+      self.class.new(concat_urls(url, suburl), options[:user], options[:password], options)
+    end
+
+    def initialize(end_point, api_key, secret_key, options = {})
+      adapter_class = options[:adapter_class] || RestClient::Resource
+
+      self.public_operations = options[:public_operations] || []
+      self.read_only = options[:read_only]
+      self.adapter = adapter_class.new(end_point, options.merge(user: api_key, password: secret_key))
+    end
+
+    def get(additional_headers = {}, &block)
+      handle_api_call(:get, additional_headers, &block)
+    end
+
+    def post(payload, additional_headers = {}, &block)
+      handle_api_call(:post, additional_headers, payload, &block)
+    end
+
+    def put(payload, additional_headers = {}, &block)
+      handle_api_call(:put, additional_headers, payload, &block)
+    end
+
+    def delete(additional_headers = {}, &block)
+      handle_api_call(:delete, additional_headers, &block)
+    end
+
+    private
+
+    def handle_api_call(method, additional_headers = {}, payload = {}, &block)
+      raise Mailjet::MethodNotAllowed unless method_allowed(method)
+
+      if [:get, :delete].include?(method)
+        @adapter.send(method, additional_headers, &block)
+      else
+        @adapter.send(method, payload, additional_headers, &block)
+      end
+    rescue RestClient::Exception => e
+      handle_exeception(e, additional_headers, payload)
+    end
+
+    def method_allowed(method)
+      method = method.to_sym
+      public_operations.include?(method) && (method == :get || !read_only?)
+    end
+
+    def handle_exeception(e, additional_headers, payload = {})
+      params = additional_headers[:params] || {}
+      params = params.merge(payload)
+
+      raise Mailjet::ApiError.new(e.http_code, e.http_body, @adapter, @adapter.url, params)
+    end
+
+  end
+
+  class MethodNotAllowed < StandardError
+
+  end
+end

data/lib/mailjet/gem_extensions/rest_client.rb

@@ -0,0 +1,19 @@
+module RestClient
+  module Payload
+    class Base
+      def flatten_params_array value, calculated_key
+        result = []
+        value.each do |elem|
+          if elem.is_a? Hash
+            result += flatten_params(elem, calculated_key)
+          elsif elem.is_a? Array
+            result += flatten_params_array(elem, calculated_key)
+          else
+            result << ["#{calculated_key}", elem]
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/mailjet/mailer.rb

@@ -2,10 +2,10 @@ require 'action_mailer'
 require 'mail'
 
 class Mailjet::Mailer < ::Mail::SMTP
-  def initialize options = {}
+  def initialize(options = {})
     ActionMailer::Base.default(:from => Mailjet.config.default_from) if Mailjet.config.default_from.present?
     super({
-      :address  => "in.mailjet.com",
+      :address  => "in-v3.mailjet.com",
       :port  => 587,
       :authentication  => 'plain',
       :user_name => Mailjet.config.api_key,
@@ -16,3 +16,38 @@ class Mailjet::Mailer < ::Mail::SMTP
 end
 
 ActionMailer::Base.add_delivery_method :mailjet, Mailjet::Mailer
+
+
+
+class Mailjet::APIMailer
+  def initialize(options = {})
+    ActionMailer::Base.default(:from => Mailjet.config.default_from) if Mailjet.config.default_from.present?
+    @delivery_method_options = options.slice(:'mj-prio', :'mj-campaign', :'mj-deduplicatecampaign', :'mj-trackopen', :'mj-trackclick', :'header')
+  end
+
+  def deliver!(mail)
+    if mail.multipart?
+      content = {
+        text: mail.text_part.try(:decoded),
+        html: mail.html_part.try(:decoded),
+        attachment: mail.attachments.select{ |a| !a.inline? }.try(:decoded),
+        inlineattachment: mail.attachments.select{ |a| !a.inline? }.try(:decoded)
+      }
+    else
+      content = (mail.mime_type == "text/html") ? {html: mail.body.decoded} : {text: mail.body.decoded}
+    end
+
+    payload = {
+      from: mail.from || Mailjet.config.default_from,
+      sender: mail.sender,
+      to: mail.to,
+      cc: mail.cc,
+      bcc: mail.bcc,
+      subject: mail.subject
+    }.merge(content).merge(@delivery_method_options)
+
+    Mailjet::MessageDelivery.create(payload)
+  end
+end
+
+ActionMailer::Base.add_delivery_method :mailjet_api, Mailjet::APIMailer

data/lib/mailjet/message_delivery.rb

@@ -0,0 +1,9 @@
+require 'mailjet/resource'
+
+module Mailjet
+  class MessageDelivery
+    include Mailjet::Resource
+    self.resource_path = 'v3/send'
+    self.public_operations = [:post]
+  end
+end

data/lib/mailjet/reporting.rb

@@ -9,33 +9,36 @@ module Mailjet
           Mailjet::Click.new(click)
         end
       end
-      
+
       def domains(options = {})
         (options.delete(:api) || Mailjet::Api.singleton).reportDomain(options)["domains"] || []
       end
-      
+
       def clients(options = {})
         (options.delete(:api) || Mailjet::Api.singleton).reportEmailclients(options)["email_clients"] || []
       end
-      
+
       def emails(options = {})
         ((options.delete(:api) || Mailjet::Api.singleton).reportEmailsent(options)["emails"] || []).map do |email|
           Mailjet::Email.new(email)
         end
       end
-      
+
+      def bounce(options = {})
+        (options.delete(:api) || Mailjet::Api.singleton).reportEmailbounce(options)["bounces"] || []
+      end
+
       def statistics(options = {})
         (options.delete(:api) || Mailjet::Api.singleton).reportEmailstatistics(options)["stats"]
       end
-      
+
       def geolocation(options = {})
         (options.delete(:api) || Mailjet::Api.singleton).reportGeoip(options)["geos"]
       end
-      
+
       def agents(options = {})
         (options.delete(:api) || Mailjet::Api.singleton).reportUseragents(options)["user_agents"] || []
       end
     end
   end
 end
-  

data/lib/mailjet/resource.rb

@@ -0,0 +1,199 @@
+require 'mailjet/connection'
+require 'mailjet/resource'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/concern'
+require 'active_support/json/decoding'
+
+ActiveSupport.parse_json_times = true
+
+module Mailjet
+  module Resource
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :resource_path, :public_operations, :read_only, :filters, :properties
+      cattr_writer :connection
+
+      def self.connection
+        class_variable_get(:@@connection) || default_connection
+      end
+
+      def self.default_connection
+        Mailjet::Connection.new(
+          "#{Mailjet.config.end_point}/#{resource_path}",
+          Mailjet.config.api_key,
+          Mailjet.config.secret_key,
+          public_operations: public_operations,
+          read_only: read_only)
+      end
+    end
+
+    module ClassMethods
+      def first(params = {})
+        all(params.merge!(limit: 1)).first
+      end
+
+      def all(params = {})
+        params = format_params(params)
+        attribute_array = parse_api_json(connection.get(params: params))
+        attribute_array.map{ |attributes| instanciate_from_api(attributes) }
+      end
+
+      def count
+        response_json = connection.get(params: {limit: 1, countrecords: 1})
+        response_hash = ActiveSupport::JSON.decode(response_json)
+        response_hash['Total']
+      end
+
+      def find(id)
+        attributes = parse_api_json(connection[id].get).first
+        instanciate_from_api(attributes)
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def create(attributes = {})
+        self.new(attributes).tap do |resource|
+          resource.save!
+          resource.persisted = true
+        end
+      end
+
+      def delete(id)
+        connection[id].delete
+      end
+
+      def instanciate_from_api(attributes = {})
+        self.new(attributes.merge(persisted: true))
+      end
+
+      def parse_api_json(response_json)
+        response_hash = ActiveSupport::JSON.decode(response_json)
+        response_data_array = response_hash['Data']
+        response_data_array.map{ |response_data| underscore_keys(response_data) }
+      end
+
+      def format_params(params)
+        if params[:sort]
+          params[:sort] = params[:sort].map do |attribute, direction|
+            attribute = attribute.to_s.camelcase
+            direction = direction.to_s.upcase
+            "#{attribute} #{direction}"
+          end.join(', ')
+        end
+        params
+      end
+
+      def camelcase_keys(hash)
+        map_keys(hash, :camelcase)
+      end
+
+      def underscore_keys(hash)
+        map_keys(hash, :underscore)
+      end
+
+      def map_keys(hash, method)
+        hash.inject({}) do |_hash, (key, value)|
+          new_key = key.to_s.send(method)
+          _hash[new_key] = value
+          _hash
+        end
+      end
+    end
+
+    attr_accessor :attributes, :persisted
+
+    def initialize(_attributes = nil)
+      @attributes = ActiveSupport::HashWithIndifferentAccess.new(_attributes.reverse_merge(persisted: false))
+    end
+
+    def persisted?
+      attributes[:persisted]
+    end
+
+    def save
+      if persisted?
+        response = connection[id].put(formatted_payload)
+      else
+        response = connection.post(formatted_payload)
+      end
+
+      self.attributes = parse_api_json(response).first
+      return true
+    rescue Mailjet::ApiError => e
+      if e.code.to_s == "304"
+        return true # When you save a record twice it should not raise error
+      else
+        raise e
+      end
+    end
+
+    def save!
+      save || raise(StandardError.new("Resource not persisted"))
+    end
+
+    def attributes=(attribute_hash = {})
+      attribute_hash.each do |attribute_name, value|
+        self.send("#{attribute_name}=", value)
+      end
+    end
+
+    def update_attributes(attribute_hash = {})
+      self.attributes = attribute_hash
+      save
+    end
+
+    def delete
+      self.class.delete(id)
+    end
+
+    private
+
+    def connection
+      self.class.connection
+    end
+
+    def formatted_payload
+      payload = attributes.reject { |k,v| v.blank? }
+      payload = payload.slice(*properties)
+      payload = camelcase_keys(payload)
+      payload.inject({}) do |h, (k, v)|
+        v = v.utc.as_json if v.respond_to? :utc
+        h.merge!({k => v})
+      end
+    end
+
+    def camelcase_keys(hash)
+      self.class.camelcase_keys(hash)
+    end
+
+    def underscore_keys(hash)
+      self.class.underscore_keys(hash)
+    end
+
+    def parse_api_json(response_json)
+      self.class.parse_api_json(response_json)
+    end
+
+    def method_missing(method_symbol, *arguments) #:nodoc:
+      method_name = method_symbol.to_s
+
+      if method_name =~ /(=|\?)$/
+        case $1
+        when "="
+          attributes[$`] = arguments.first
+        when "?"
+          attributes[$`]
+        end
+      else
+        return attributes[method_name] if attributes.include?(method_name)
+        # not set right now but we know about it
+        # return nil if known_attributes.include?(method_name)
+        super
+      end
+    end
+  end
+end