email_api 1.0.0

data/Rakefile

@@ -0,0 +1,7 @@
+require 'dotenv/load'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'tests/**/*_tests.rb'
+end

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/config.ru

@@ -0,0 +1,4 @@
+require 'dotenv/load'
+require File.absolute_path('lib/email_api')
+
+run EmailApi

data/email_api.gemspec

@@ -0,0 +1,44 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name    = 'email_api'
+  spec.version = '1.0.0'
+  spec.authors = ['Vasili Moisiadis']
+  spec.email   = ['vasili@moisiadis.com']
+
+  spec.summary     = 'Email API'
+  spec.description = 'Backend Email API that accepts necessary information and sends emails using email service providers'
+  spec.homepage    = 'https://github.com/VasiliMoisiadis/email-api'
+  spec.license     = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  unless spec.respond_to?(:metadata)
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(tests|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'dotenv', '~> 2.2.1'
+  spec.add_development_dependency 'json', '~> 2.1.0'
+  spec.add_development_dependency 'minitest', '~> 5.11.3'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1.19'
+  spec.add_development_dependency 'mocha', '~> 1.4.0'
+  spec.add_development_dependency 'puma', '~> 3.11.3'
+  spec.add_development_dependency 'rack-test', '~> 0.8.3'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rest-client', '~> 2.0.2'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-rails', '~> 3.7.2'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
+  spec.add_development_dependency 'sinatra', '~> 2.0.1'
+  spec.add_development_dependency 'thin', '~> 1.2.5'
+end

data/lib/email_api.rb

@@ -0,0 +1,47 @@
+require 'sinatra/base'
+require 'json'
+require 'date'
+require './lib/email_api/api/api_parser'
+require './lib/email_api/email/client/email_client'
+require './lib/email_api/email/data/email_object'
+
+# Main class of Email API Project
+class EmailApi < Sinatra::Base
+
+  # Ping with current time
+  get '/ping' do
+    puts "Received new Ping Request from #{request.ip}"
+    { time: Time.now.utc }.to_json
+  end
+
+  # Send Email (Supports calling through a web browser)
+  get '/send' do
+    puts "Received new Email Send GET Request from #{request.ip}"
+    handle_api(params).to_hash.to_json
+  end
+
+  # Send Email (Proper usage, as a POST request)
+  post '/send' do
+    puts "Received new Email Send POST Request from #{request.ip}"
+    handle_api(params).to_hash.to_json
+  end
+
+  # Handle request received through API
+  def handle_api(api_params)
+    return nil if !api_params.respond_to?(:[]) && !api_params.is_a?(Hash)
+    from      = api_params['from']
+    to        = api_params['to']
+    cc        = api_params['cc']
+    bcc       = api_params['bcc']
+    subject   = api_params['subject']
+    content   = api_params['content']
+    email_obj = ApiParser.parse_email(from, to, cc, bcc, subject, content)
+    EmailClient.send_email(email_obj)
+  rescue StandardError => e
+    puts "Error: #{e.class}: #{e.message}"
+    response = ClientResponse.new
+    response.set_internal_err
+    response
+  end
+end
+

data/lib/email_api/api/api_parser.rb

@@ -0,0 +1,100 @@
+require './lib/email_api/email/data/email_object'
+require './lib/email_api/email/data/email_address'
+require 'json'
+
+# Parser for Email API
+class ApiParser
+  @email_delim ||= ','
+
+  # Accessor for the supported email delimiter
+  def self.email_delim
+    @email_delim
+  end
+
+  # Parses raw text into custom EmailAddress object
+  #
+  # @param [String] email_text Raw text denoting email
+  # @return [Email Address] email_address
+  def self.parse_email_text(email_text)
+    return nil if email_text.nil? || !email_text.is_a?(String)
+
+    restricted_chars = ',<>'
+
+    # Try to parse correct format: "DISPLAY NAME <EMAIL ADDRESS>"
+    name  = nil
+    email = email_text[/.*<([^>]*)/, 1]
+    name  = email_text.gsub(email, '') unless email.nil?
+    name  = name.delete(restricted_chars).strip unless name.nil?
+    email = email.delete(restricted_chars).strip unless email.nil?
+
+    # If only one or the other found, assign value to both fields
+    name  = email if (!email.nil? && !email.empty?) && (name.nil? || name.empty?)
+    email = name if (!name.nil? && !name.empty?) && (email.nil? || email.empty?)
+
+    # If neither found, take entire String as values
+    name  = email = email_text.delete(restricted_chars).strip if name.nil? && email.nil?
+
+    EmailAddress.new(name, email)
+  end
+
+  # Parse a String[] and returns an EmailAddres[]
+  #
+  # @param [String[]] email_text_arr Array of text, each being an email address
+  # @return [EmailAddress[]] email_arr
+  def self.parse_email_text_arr(email_text_arr)
+    return nil if email_text_arr.nil? || !email_text_arr.is_a?(String)
+
+    email_arr = []
+    # Split on email delimiter, parse each email
+    split_arr = email_text_arr.split(/(?<=[#{email_delim}])/, -1)
+
+    # Push value on through even if empty -> handled further down
+    email_arr.push(parse_email_text(email_text_arr)) if split_arr.empty?
+    split_arr.each do |email_text|
+      email_arr.push(parse_email_text(email_text))
+    end
+
+    email_arr = nil if !email_arr.nil? && email_arr.empty?
+    email_arr
+  end
+
+  # Parses parameter inputs into an EmailObject using the supported notation
+  #
+  # @param [Splat] params Raw Email Attribute Values
+  # @return [EmailObject] email_object Parsed email object
+  def self.parse_email(*params)
+    email_object = EmailObject.new
+
+    return email_object if params.nil? || !params.is_a?(Array) || params.empty?
+
+    to       = cc = bcc = subject = content = nil
+    from     = params[0]
+    to       = params[1] if params.count > 1
+    cc       = params[2] if params.count > 2
+    bcc      = params[3] if params.count > 3
+    subj_raw = params[4] if params.count > 4
+    cont_raw = params[5] if params.count > 5
+
+    subject = nil
+    if !subj_raw.nil? && (subj_raw.is_a?(String) || subj_raw.is_a?(Numeric))
+      subject = subj_raw
+    end
+
+    content = nil
+    if !cont_raw.nil? && (cont_raw.is_a?(String) || cont_raw.is_a?(Numeric))
+      content = cont_raw
+    end
+
+    # Parse and assign Message Attributes
+    email_object.from    = parse_email_text(from)
+    email_object.to      = parse_email_text_arr(to)
+    email_object.cc      = parse_email_text_arr(cc)
+    email_object.bcc     = parse_email_text_arr(bcc)
+    email_object.subject = (subject.nil? || subject.empty? ? nil : subject)
+    email_object.content = (content.nil? || content.empty? ? nil : content)
+
+    email_object
+  end
+
+  private_class_method :parse_email_text_arr, :parse_email_text
+end

data/lib/email_api/email/client/email_client.rb

@@ -0,0 +1,69 @@
+require './lib/email_api/email/client/mailgun_client'
+require './lib/email_api/email/client/sendgrid_client'
+require './lib/email_api/email/data/client_response'
+require 'json'
+
+# General client that sends email utilizing multiple service providers
+class EmailClient
+
+  # Accessor for the OK Code
+  def self.ok_code
+    200
+  end
+
+  # Accessor for the Bad Request Code
+  def self.bad_req_code
+    400
+  end
+
+  # Accessor for the Internal Server Error Code
+  def self.internal_err_code
+    500
+  end
+
+  # Sends email utilizing multiple service providers
+  #
+  # @param [EmailObject] email_object
+  # @return [ClientResponse] response
+  def self.send_email(email_object)
+    return ClientResponse.new if email_object.nil? || !email_object.is_a?(EmailObject)
+
+    puts 'Attempting Email Sending via primary client: SENDGRID'
+    response = use_client_client SendgridClient, email_object
+
+    if response != ok_code
+      puts 'Primary client failed. Attempting secondary client: MAILGUN'
+      response = use_client_client MailgunClient, email_object
+    end
+
+    client_response = ClientResponse.new email_object
+    if response == ok_code
+      client_response.set_ok
+    elsif response == bad_req_code
+      client_response.set_bad_req
+    elsif response == internal_err_code
+      client_response.set_internal_err
+    end
+
+    client_response
+  end
+
+  # Sends email using a single email client
+  #
+  # @param [MailgunClient|SendgridClient] email_client
+  # @param [EmailObject] email_object
+  # @return [Integer] response_code
+  def self.use_client_client(email_client, email_object)
+    begin
+      response = email_client.send_email(email_object)
+      puts 'Successful attempt' if response == ok_code
+      puts 'Bad Request' if response == bad_req_code
+      puts 'Internal Server Error' if response == internal_err_code
+    rescue StandardError => e
+      # Log error and fail send
+      puts "Error: #{e.message}"
+      response = internal_err_code
+    end
+    response
+  end
+end

data/lib/email_api/email/client/mailgun_client.rb

@@ -0,0 +1,123 @@
+require './lib/email_api/email/data/email_address'
+require './lib/email_api/email/data/email_object'
+require 'rest-client'
+require 'json'
+
+# Client for sending email via Mailgun v3 API
+class MailgunClient
+  @exp_msg           ||= 'Queued. Thank you.'
+  @ok_code           ||= 200
+  @bad_req_code      ||= 400
+  @internal_err_code ||= 500
+
+  # Accessor for the expected success message
+  def self.exp_msg
+    @exp_msg
+  end
+
+  # Accessor for the OK Code
+  def self.ok_code
+    @ok_code
+  end
+
+  # Accessor for the Bad Request Code
+  def self.bad_req_code
+    @bad_req_code
+  end
+
+  # Accessor for the Internal Server Error Code
+  def self.internal_err_code
+    @internal_err_code
+  end
+
+  # Sends an email over HTTPS
+  #
+  # @param [EmailObject] email_object
+  # @return [Response] rest_client_response
+  def self.send_email(email_object)
+
+    # Build Mailgun-specific URL and POST data
+    api_key = ENV['MAILGUN_PRIVATE_KEY']
+    domain  = ENV['MAILGUN_DOMAIN']
+    return internal_err_code if api_key.nil? || domain.nil?
+
+    post_data = parse_post_data(email_object, domain)
+    return bad_req_code if post_data.nil?
+
+    url = "https://api:#{api_key}@api.mailgun.net/v3/#{domain}/messages"
+
+    # Send Email, return response
+    begin
+      response = RestClient.post url, post_data
+    rescue StandardError => e
+      # Log error and fail send -> occurs when Code 400 due to implementation
+      puts "Error: #{e.message}"
+      return bad_req_code
+    end
+
+    puts "Secondary Client Response: #{response}"
+
+    # Handle expected output. Note that it is API specific.
+    return ok_code if JSON.parse(response)['message'] == exp_msg
+
+    bad_req_code
+  end
+
+  # Parses email address into proper, supported text format
+  #
+  # @param [EmailAddress] email_address
+  # @return [String] email_address_text
+  def self.parse_addr_text(email_address)
+    return nil if email_address.nil? || !email_address.is_a?(EmailAddress)
+    "#{email_address.name} <#{email_address.email}>"
+  end
+
+  # Parses array of email addresses into proper, supported text format
+  #
+  # @param [EmailAddress[]] email_address_arr
+  # @return [String] email_field
+  def self.parse_addr_arr(email_address_arr)
+    return '' if email_address_arr.nil? || !email_address_arr.is_a?(Array)
+
+    # Convert array of multiple email addresses to proper text format
+    email_field = ''
+    email_address_arr.each do |email_address|
+      addr_text = parse_addr_text(email_address)
+      unless addr_text.nil?
+        email_field += ', ' unless email_field.empty?
+        email_field += addr_text
+      end
+    end
+
+    email_field
+  end
+
+  # Parses an EmailObject into POST data for use in an API call
+  #
+  # @param [EmailObject] email_object
+  # @return [String] post_data
+  def self.parse_post_data(email_object, domain)
+    # Handle missing or unsupported input parameter
+    return nil if email_object.nil? || domain.nil? || !email_object.is_a?(EmailObject)
+
+    # Handle missing mandatory Email Attributes
+    return nil if email_object.from.nil? || email_object.to.nil? ||
+                  email_object.subject.nil? || email_object.content.nil?
+
+    # Parse environment value and build Mailgun-specific FROM email
+    from_email = EmailAddress.new(email_object.from.name, "mailgun@#{domain}")
+
+    # Build Message Attributes
+    post_data           = {}
+    post_data[:from]    = parse_addr_text(from_email)
+    post_data[:to]      = parse_addr_arr(email_object.to)
+    post_data[:cc]      = parse_addr_arr(email_object.cc) unless email_object.cc.nil?
+    post_data[:bcc]     = parse_addr_arr(email_object.bcc) unless email_object.bcc.nil?
+    post_data[:subject] = email_object.subject.to_s
+    post_data[:text]    = email_object.content.to_s
+
+    post_data
+  end
+
+  private_class_method :parse_addr_text, :parse_addr_arr, :parse_post_data
+end

data/lib/email_api/email/client/sendgrid_client.rb

@@ -0,0 +1,115 @@
+require './lib/email_api/email/data/email_object'
+require 'rest-client'
+require 'json'
+
+# Client for sending email via Sendgrid v2 API
+class SendgridClient
+  @exp_msg           ||= 'success'
+  @ok_code           ||= 200
+  @bad_req_code      ||= 400
+  @internal_err_code ||= 500
+
+  # Accessor for the expected success message
+  def self.exp_msg
+    @exp_msg
+  end
+
+  # Accessor for the OK Code
+  def self.ok_code
+    @ok_code
+  end
+
+  # Accessor for the Bad Request Code
+  def self.bad_req_code
+    @bad_req_code
+  end
+
+  # Accessor for the Internal Server Error Code
+  def self.internal_err_code
+    @internal_err_code
+  end
+
+  # Sends an email over HTTPS
+  #
+  # @param [EmailObject] email_object
+  # @return [int] status_code
+  def self.send_email(email_object)
+
+    # Parse Environment Values
+    api_user = ENV['SENDGRID_API_USER']
+    api_key  = ENV['SENDGRID_API_KEY']
+    return internal_err_code if api_user.nil? || api_key.nil?
+
+    # Build Sendgrid-specific URL and POST data
+    url       = 'https://api.sendgrid.com/api/mail.send.json'
+    post_data = parse_post_data(email_object, api_user, api_key)
+    return bad_req_code if post_data.nil?
+
+    # Send Email, return response
+    begin
+      response = RestClient.post url, post_data
+    rescue StandardError => e
+      # Log error and fail send -> occurs when Code 400 due to implementation
+      puts "Error: #{e.message}"
+      return bad_req_code
+    end
+
+    puts "Primary Client Response: #{response}"
+
+    return bad_req_code if response.nil? || !JSON.parse(response).respond_to?(:[])
+
+    # Handle expected output. Note that it is API specific.
+    json_response = JSON.parse(response)
+    if !json_response.key?('message').nil? && json_response['message'] == exp_msg
+      return ok_code
+    end
+
+    internal_err_code # Unhandled response
+  end
+
+  # Parses an EmailObject into POST data for use in an API call
+  #
+  # @param [EmailObject] email_object
+  # @return [String] post_data
+  def self.parse_post_data(email_object, api_user, api_key)
+
+    # Handle missing Environment Variables
+    return nil if api_user.nil? || api_key.nil?
+
+    # Handle missing or unsupported input parameter
+    return nil if email_object.nil? || !email_object.is_a?(EmailObject)
+
+    # Handle missing mandatory Email Attributes
+    return nil if email_object.from.nil? || email_object.to.nil? ||
+                  email_object.subject.nil? || email_object.content.nil?
+
+
+    # Build Message Attributes
+    post_data = "api_user=#{api_user}"
+    post_data += "&api_key=#{api_key}"
+    post_data += "&subject=#{email_object.subject}"
+    post_data += "&text=#{email_object.content}"
+    post_data += "&from=#{email_object.from.email}"
+    post_data += "&fromname[]=#{email_object.from.name}"
+    email_object.to.each do |address|
+      post_data += "&to[]=#{address.email}"
+      post_data += "&toname[]=#{address.name}"
+    end
+    unless email_object.cc.nil?
+      email_object.cc.each do |address|
+        post_data += "&cc[]=#{address.email}"
+        post_data += "&ccname[]=#{address.name}"
+      end
+    end
+    unless email_object.bcc.nil?
+      email_object.bcc.each do |address|
+        post_data += "&bcc[]=#{address.email}"
+        post_data += "&bccname[]=#{address.name}"
+      end
+    end
+
+    post_data
+  end
+
+  private_class_method :parse_post_data
+end