mail2cb 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33aab03227466886d6226040f67f9fae5e3e6257
-  data.tar.gz: fc394d4cf8701deb082584652ef5000f9f76a5eb
+  metadata.gz: 03e52a01d9c2465caaeb3874951ce00a3f0b3647
+  data.tar.gz: e055dcdc4ea7f9b5bd89ef1678549e499fda2cea
 SHA512:
-  metadata.gz: 8aa7c084a6643350703598e925ab60763f8d495b80770eb49ce4bd975f15c79ab584e0b8fc4f2c5f024ec22e49b524faf9861aa11c312dfb52366f27afa07daa
-  data.tar.gz: e5d63b2a62b9c42d5e13832e64ab0ad5c5b5cf141ae99497e07dbe35efab2cdf656ef3a94a289166e09ea7973265cadec62d89f23a7f4e131629a2f44df603a9
+  metadata.gz: 9e5d2e47b37b64fd4e7a31897d7d779cc47bb771ca9bab299dcfad554393e1411077ce0a4414d40ca0b8c81a2690444b8d42099ca067ef0639f3d4f5a3f3d886
+  data.tar.gz: edd382fae7014b10ed07ecdc3b61b094207c37659b3eb1d34d1f4163659f14b492818c66170ae78d5841b6d40090f15b5d5db9509ce43fa8b5dfb63fedd28ed7

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Dockerfile

@@ -0,0 +1,37 @@
+# CaseBlocks Mail2cb Daemon
+#
+# VERSION               0.0.1
+
+FROM caseblocks/ruby_node
+MAINTAINER support@caseblocks.com
+
+RUN apt-get update -y && apt-get install -y build-essential libmysqlclient-dev vim git-core ca-certificates && mkdir -p /var/www/mail2cb
+
+RUN gem update bundler
+
+ADD . /var/www/mail2cb
+WORKDIR /var/www/mail2cb
+
+
+RUN /usr/sbin/useradd --create-home --home-dir /usr/local/nonroot --shell /bin/bash nonroot
+RUN /usr/sbin/adduser nonroot sudo
+
+RUN groupadd mail2cb
+RUN usermod -a -G mail2cb nonroot
+RUN usermod -a -G mail2cb root
+
+
+RUN chown -R nonroot /usr/local/
+RUN chown -R nonroot /usr/lib/
+RUN chown -R nonroot /usr/bin/
+RUN chgrp -R mail2cb /var/lib/gems
+RUN chmod -R g+w /var/lib/gems
+RUN chown -R nonroot /var/www/mail2cb
+
+USER nonroot
+
+RUN cd /var/www/mail2cb
+RUN bundle install
+
+EXPOSE 8016
+CMD bin/run

data/README.md

@@ -38,6 +38,19 @@ Ensure the following environment variables are set:
     CB_API_ENDPOINT=https://login.caseblocks.com
     CB_API_TOKEN=...
 
+    MYSQL_HOST
+    MYSQL_PORT
+    MYSQL_DATABASE
+    MYSQL_USERNAME
+    MYSQL_PASSWORD
+    FAYE_HOST
+    FAYE_PORT
+    DEBUG
+    AWS_ACCESS_KEY
+    AWS_SECRET_KEY
+    AWS_MAILROOM_BUCKET
+    CRYPT_API_ENDPOINT
+
 And run the daemon from the CLI
 
     mail2cb

data/Rakefile

@@ -1,2 +1,13 @@
 require "bundler/gem_tasks"
 
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'mail2cb' # You know what to do.
+  ARGV.clear
+
+  @sample_reply = File.read("samples/reply.txt")
+  @sample_reply_with_cc = File.read("samples/reply_with_cc.txt")
+
+  IRB.start
+end

data/bin/mail2cb

@@ -5,12 +5,31 @@ require 'bundler/setup'
 # its dependencies:
 require 'mail2cb'
 
-ENV["REDIS_URL"] = "redis://localhost:6379" unless ENV["REDIS_URL"]
-ENV["MYSQL_HOST"] = "localhost" unless ENV["MYSQL_HOST"]
-ENV["MYSQL_PORT"] = "3306"
-ENV["MYSQL_DATABASE"] = "caseblocks_dev"
+if ENV["MYSQL_PORT_3306_TCP_ADDR"].nil? or ENV["MYSQL_PORT_3306_TCP_PORT"].nil?
+  ENV["MYSQL_HOST"] = "localhost" unless ENV["MYSQL_HOST"]
+  ENV["MYSQL_PORT"] = "3306"
+  ENV["MYSQL_DATABASE"] = "caseblocks_dev" unless ENV["MYSQL_DATABASE"]
+  ENV["MYSQL_USERNAME"] = "root" unless ENV["MYSQL_USERNAME"]
+  ENV["MYSQL_PASSWORD"] = "" unless ENV["MYSQL_PASSWORD"]
+else
+  ENV["MYSQL_HOST"] = ENV["MYSQL_PORT_3306_TCP_ADDR"]
+  ENV["MYSQL_PORT"] = ENV["MYSQL_PORT_3306_TCP_PORT"]
+  ENV["MYSQL_USERNAME"] =  ENV["MYSQL_USER"]
+end
 
-ENV["MYSQL_USERNAME"] = "root"
-ENV["MYSQL_PASSWORD"] = ""
+puts "Connecting to MySQL: #{ENV["MYSQL_USERNAME"]}@#{ENV["MYSQL_HOST"]}:#{ENV["MYSQL_PORT"]}/#{ENV["MYSQL_DATABASE"]}"
+
+if ENV["REDIS_PORT_6379_TCP_ADDR"].nil? or ENV["REDIS_PORT_6379_TCP_PORT"].nil?
+	ENV["REDIS_URL"] = "redis://localhost:6379" unless ENV["REDIS_URL"]
+else
+	ENV["REDIS_URL"] = "redis://#{ENV["REDIS_PORT_6379_TCP_ADDR"]}:#{ENV["REDIS_PORT_6379_TCP_PORT"]}"
+end
+
+puts "Connecting to Redis: #{ENV["REDIS_URL"]}"
+
+ENV["FAYE_HOST"] = "http://localhost"
+ENV["FAYE_PORT"] = "9292"
+
+ENV["DEBUG"] = "false"
 
 oh = Mail2cb::Handler.new

data/bin/run

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'bundler/setup'
+# Prepares the $LOAD_PATH by adding to it lib directories of the gem and
+# its dependencies:
+require 'mail2cb'
+
+if ENV["MYSQL_PORT_3306_TCP_ADDR"].nil? or ENV["MYSQL_PORT_3306_TCP_PORT"].nil?
+  ENV["MYSQL_HOST"] = "localhost" unless ENV["MYSQL_HOST"]
+  ENV["MYSQL_PORT"] = "3306"
+  ENV["MYSQL_DATABASE"] = "caseblocks_dev" unless ENV["MYSQL_DATABASE"]
+  ENV["MYSQL_USERNAME"] = "root" unless ENV["MYSQL_USERNAME"]
+  ENV["MYSQL_PASSWORD"] = "" unless ENV["MYSQL_PASSWORD"]
+else
+  ENV["MYSQL_HOST"] = ENV["MYSQL_PORT_3306_TCP_ADDR"]
+  ENV["MYSQL_PORT"] = ENV["MYSQL_PORT_3306_TCP_PORT"]
+  ENV["MYSQL_USERNAME"] =  ENV["MYSQL_USER"]
+end
+
+puts "Connecting to MySQL: #{ENV["MYSQL_USERNAME"]}@#{ENV["MYSQL_HOST"]}:#{ENV["MYSQL_PORT"]}/#{ENV["MYSQL_DATABASE"]}"
+
+if ENV["REDIS_PORT_6379_TCP_ADDR"].nil? or ENV["REDIS_PORT_6379_TCP_PORT"].nil?
+	ENV["REDIS_URL"] = "redis://localhost:6379" unless ENV["REDIS_URL"]
+else
+	ENV["REDIS_URL"] = "redis://#{ENV["REDIS_PORT_6379_TCP_ADDR"]}:#{ENV["REDIS_PORT_6379_TCP_PORT"]}"
+end
+
+puts "Connecting to Redis: #{ENV["REDIS_URL"]}"
+
+ENV["FAYE_HOST"] = "http://localhost"
+ENV["FAYE_PORT"] = "9292"
+
+ENV["DEBUG"] = "false"
+
+oh = Mail2cb::Handler.new

data/lib/mail2cb/{email_body_parser.rb → email_body_cleanser.rb}

@@ -1,7 +1,7 @@
 require 'open3'
 
 module Mail2cb
-  class EmailBodyParser
+  class EmailBodyCleanser
     def self.parse(text, type="text/plain")
 
       data_hash = {:body => text, :type => type}

data/lib/mail2cb/email_content.rb

@@ -0,0 +1,44 @@
+module Mail2cb
+  class EmailContent
+
+    def initialize(email)
+      @email = email
+
+      if @email.multipart?
+        parse_parts(@email.parts)
+      else
+        @text_body = @email.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
+      end
+      @body = @html_body || @text_body
+    end
+
+    def parse_parts(parts)
+      parts.each do |part|
+        content_type = part.content_type.split(";")[0]
+        if content_type == "text/html"
+          @html_body = part.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
+        elsif content_type == "text/plain"
+          @text_body = part.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
+        elsif content_type == "multipart/related"
+          parse_parts(part.parts)
+        end
+      end
+    end
+
+    def html
+      @html_body
+    end
+
+    def text
+      @text_body
+    end
+
+    def body
+      @body
+    end
+    def body=(value)
+      @body = value
+    end
+
+  end
+end

data/lib/mail2cb/email_handler.rb

@@ -1,113 +1,141 @@
 require 'fileutils'
 require 'mail'
-require_relative "email_body_parser"
 require 'nokogiri'
 require 'sanitize'
+require 'aws/s3'
+
+include Mail::Utilities
 
 module Mail2cb
   class EmailHandler
+
+    TWENTYFOUR_HOURS = 60 * 60 * 24
+
     def initialize(options)
       @options = options
+
+      raise "Require :inbound_message to be passed in" unless options.has_key?(:inbound_message)
+      raise "Require :mailbox to be passed in" unless options.has_key?(:mailbox)
+
       @email = Mail.read_from_string(options[:inbound_message])
 
-      puts "Handling inbound email from #{@email.from}"
-
-      if @email.multipart?
-        @email.parts.each do |part|
-          content_type = part.content_type.split(";")[0]
-          if content_type[0..3] == "text"
-            if content_type == "text/html"
-              @html_body = part.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
-            elsif content_type == "text/plain"
-              @text_body = part.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
-            end
-          end
-        end
-      else
-        @text_body = @email.body.decoded.force_encoding("ASCII-8BIT").encode('UTF-8', undef: :replace, replace: '')
-      end
+      puts "Inbound email from #{@email.from.join(", ")}"
+      @content = EmailContent.new(@email)
+    end
 
-      @body = @html_body || @text_body
+    def email
+      @email
     end
 
     def generate_message_hash
-
       message_hash = {
-        "from" => @email.from,
-        "to" => @email.to,
+        "from" => format_recipient(Mail::Address.new(@email[:from].value)),
         "subject" => @email.subject,
-        "date" => @email.date,
-        "body" => @body,
-        "attachements" => prepare_attachments,
+        "sent_at" => @email.date.rfc3339,
+        "received_at" => DateTime.now.rfc3339,
+        "body" => @content.body,
+        "attachments" => prepare_attachments,
         "metadata" => fetch_metadata
       }
+      message_hash["to"] = format_recipients(@email[:to].address_list.addresses) if @email[:to]
+      message_hash["cc"] = format_recipients(@email[:cc].address_list.addresses) if @email[:cc]
+
       message_hash.delete(:inbound_message)
       message_hash
     end
 
+    def format_recipients(recipients)
+      recipients.map{|recipient| format_recipient(recipient)}
+    end
+    def format_recipient(recipient)
+      {:email => recipient.address, :display_name => recipient.display_name, :account_code => @options[:mailbox][:account_code]}
+    end
+
     def fetch_metadata
-      fetch_fingerprints.merge({
+      id_parser = MessageIdHandler.new(@email)
+      {
         "has_bounced" => @email.bounced?,
         "in_reply_to" => @email.in_reply_to,
         "message_id" => @email.message_id,
-        "references" => references
-      })
-    end
-
-    def references
-      @email.header["References"] ? @email.header["References"].field.element.message_ids : []
-    end
-
-    def fetch_fingerprints
-      previous_id = references.last
-      match = /(.*?)\.(.*?)@emergeadapt.com/.match(previous_id)
-      if match
-        if match[2] == "case"
-          {"case_id" => match[1]}
-        else
-          {"message_id" => match[1]}
-        end
-      else
-        {}
-      end
+        "account_code" => @options[:mailbox][:account_code],
+        "references" => id_parser.references
+      }.merge(id_parser.hash)
     end
 
     def prepare_attachments
       attachments = []
-      @email.attachments.each do | attachment |
-        filename = attachment.filename
-        random_tag = Random.rand(100000000000)
-        attachment_folder = File.join(["/", "tmp", "caseblocks", @options[:mailbox][:account_code], "attachments"])
-        FileUtils::mkdir_p(attachment_folder)
-        file_path = File.join([attachment_folder, "#{random_tag}.#{filename}"])
-        File.open(file_path, "w+b", 0644) {|f| f.write attachment.body.decoded}
-        attachments << {
-          "filename" => attachment.filename,
-          "filepath" => file_path
-        }
+      if ENV["AWS_ACCESS_KEY"] && ENV["AWS_SECRET_KEY"] && ENV["AWS_MAILROOM_BUCKET"]
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => ENV["AWS_ACCESS_KEY"],
+          :secret_access_key => ENV["AWS_SECRET_KEY"]
+        )
+        @email.attachments.each do |attachment|
+          filename = attachment.filename
+          bucket_name = ENV["AWS_MAILROOM_BUCKET"]
+          path = ["", "attachments", @options[:mailbox][:account_code], unique_email_code, filename].join("/")
+          AWS::S3::S3Object.store(path, attachment.body.decoded, bucket_name)
+          url = AWS::S3::S3Object.url_for("#{path}", bucket_name, :expires_in => EmailHandler::TWENTYFOUR_HOURS)
+
+          attachments << {
+            "storage_type" => "S3",
+            "filename" => attachment.filename,
+            "filepath" => "/#{bucket_name}#{path}",
+            "url" => url
+          }
+        end
+      else
+        @email.attachments.each do | attachment |
+          filename = attachment.filename
+          random_tag = Random.rand(100000000000)
+          attachment_folder = File.join(["/", "tmp", "caseblocks", "attachments", @options[:mailbox][:account_code], unique_email_code])
+          FileUtils::mkdir_p(attachment_folder)
+          file_path = File.join([attachment_folder, "#{random_tag}.#{filename}"])
+          File.open(file_path, "w+b", 0644) {|f| f.write attachment.body.decoded}
+          attachments << {
+            "storage_type" => "FILE",
+            "filename" => attachment.filename,
+            "filepath" => file_path
+          }
+        end
       end
       attachments
     end
 
+    def unique_email_code
+      md5 = Digest::MD5.new
+      md5.update @email.raw_source
+
+      md5.hexdigest
+    end
 
     def content_type
-      @html_body.nil? ? "text/plain" : "text/html"
+      @content.html.nil? ? "text/plain" : "text/html"
     end
 
     def sanitize!
-      @body = Sanitize.fragment(@body, Sanitize::Config::RELAXED)
+      @content.body = Sanitize.fragment(@content.body, Sanitize::Config::RELAXED)
     end
 
     def clean_replies!
-      @body = Mail2cb::EmailBodyParser.parse(@body, content_type)
+      @content.body = Mail2cb::EmailBodyCleanser.parse(@content.body, content_type)
     end
 
     def queue!
-      $redis
+      # puts "___________________________________________________________________________"
+      puts "Queueing on redis #{redis_key(@options)}"
+      ap generate_message_hash
+      # puts "___________________________________________________________________________"
+      $redis.lpush(redis_key(@options), generate_message_hash.to_json)
     end
 
     def body
-      @body
+      @content.body
     end
+
+    private
+    def redis_key(options)
+      "cb:comms:#{options[:mailbox][:account_code]}:inbox"
+    end
+
   end
 end

data/lib/mail2cb/email_watcher.rb

@@ -1,6 +1,7 @@
 require 'redis'
 require 'ap'
 require 'mysql2'
+require 'faye'
 
 module Mail2cb
   class EmailWatcher
@@ -13,8 +14,14 @@ module Mail2cb
       raise "MYSQL_USERNAME environment variable is required" unless ENV["MYSQL_USERNAME"]
       raise "MYSQL_PASSWORD environment variable is required" unless ENV["MYSQL_PASSWORD"]
 
+      unless ENV["AWS_ACCESS_KEY"] && ENV["AWS_SECRET_KEY"] && ENV["AWS_MAILROOM_BUCKET"]
+        puts "WARNING: Attachments will store to local file system as AWS keys not provided"
+      end
+
+
       ENV["MYSQL_PASSWORD"] = "" unless ENV["MYSQL_PASSWORD"]
       ENV["MYSQL_PORT"] = "3306"
+      @debug = ENV["DEBUG"] == "true"
 
       redis_url = URI.parse(ENV["REDIS_URL"])
 
@@ -28,7 +35,7 @@ module Mail2cb
         Thread.new {self.stop}.join
       }
 
-      @daemon = MailDaemon::Handler.new(:connections => configuration)
+      @daemon = MailDaemon::Handler.new(:connections => configuration, :debug => @debug)
     end
 
     def start
@@ -46,12 +53,39 @@ module Mail2cb
     def configuration
       mailboxes = []
       mysql_client do |mysql|
-        statement = mysql.prepare("SELECT case_blocks_email_accounts.id, case_blocks_accounts.nickname, case_blocks_email_accounts.imap_username, case_blocks_email_accounts.imap_encrypted_password, case_blocks_email_accounts.imap_host, case_blocks_email_accounts.imap_port, case_blocks_email_accounts.imap_ssl, case_blocks_email_accounts.imap_start_tls, case_blocks_email_accounts.imap_folder_name, case_blocks_email_accounts.imap_search_command, case_blocks_email_accounts.imap_messages_processed, case_blocks_email_accounts.imap_last_processed_at FROM case_blocks_email_accounts JOIN case_blocks_accounts ON case_blocks_email_accounts.account_id = case_blocks_accounts.id where imap_enabled=1")
+        sql=<<EOS
+        SELECT case_blocks_email_accounts.id,
+          case_blocks_accounts.id as account_id,
+          case_blocks_accounts.nickname,
+          case_blocks_email_accounts.imap_username,
+          case_blocks_email_accounts.imap_encrypted_password,
+          case_blocks_email_accounts.imap_host,
+          case_blocks_email_accounts.imap_port,
+          case_blocks_email_accounts.imap_ssl,
+          case_blocks_email_accounts.imap_start_tls,
+          case_blocks_email_accounts.imap_folder_name,
+          case_blocks_email_accounts.imap_search_command,
+          case_blocks_email_accounts.imap_messages_processed,
+          case_blocks_email_accounts.imap_last_processed_at,
+          u.authentication_token
+        FROM case_blocks_email_accounts
+        JOIN case_blocks_accounts
+        ON case_blocks_email_accounts.account_id = case_blocks_accounts.id
+        JOIN case_blocks_users u
+        ON u.account_id = case_blocks_accounts.id
+        where imap_enabled=1
+        and u.is_bot=1
+        and u.is_account_admin=1
+EOS
+        statement = mysql.prepare(sql)
         result = statement.execute()
         result.each do |row|
           ssl_options = row["imap_ssl"]==1 ? {:verify_mode => OpenSSL::SSL::VERIFY_NONE} : false
-          decrypted_password = Encryption.new.decrypt(row["imap_encrypted_password"])
-          mailboxes << {:id => row["id"], :account_code => row["nickname"], :username => row["imap_username"], :host => row["imap_host"], :port => row["imap_port"], :password => decrypted_password, :ssl_options => ssl_options, :start_tls => row["imap_start_tls"]==1, :name => row["imap_folder_nam"], :search_command => row["imap_search_command"], :message_count => row["imap_messages_processed"], :last_delivered_at => row["imap_last_processed_at"]}
+
+          auth_token = row["authentication_token"]
+          decrypted_password = Encryption.new(auth_token).decrypt(row["imap_encrypted_password"])
+          puts "decrypted password: #{decrypted_password}"
+          mailboxes << {:id => row["id"], :account_code => row["nickname"], :account_id => row["account_id"], :username => row["imap_username"], :host => row["imap_host"], :port => row["imap_port"], :password => decrypted_password, :ssl_options => ssl_options, :start_tls => row["imap_start_tls"]==1, :name => row["imap_folder_nam"], :search_command => row["imap_search_command"], :message_count => row["imap_messages_processed"], :last_delivered_at => row["imap_last_processed_at"]}
         end
       end
       mailboxes
@@ -62,26 +96,56 @@ module Mail2cb
     end
 
     def handle_incoming_message(options)
+      update_message_counts(options)
       @handler = Mail2cb::EmailHandler.new(options)
       @handler.sanitize!
       # @handler.clean_replies!
+      @handler.queue!
 
-      hash = @handler.generate_message_hash
-
-      $redis.lpush(redis_key(options), hash)
       puts "Queued."
     end
 
-    def redis_key(options)
-      "cb:comms:#{options[:mailbox][:account_code]}:inbox"
+    def update_message_counts(options)
+      begin
+        options[:mailbox][:message_count] = options[:mailbox][:message_count] + 1
+        options[:mailbox][:last_delivered_at] = DateTime.now
+
+        if (ENV["FAYE_HOST"])
+          Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+          Thread.pass until EventMachine.reactor_running?
+          client = Faye::Client.new("#{ENV["FAYE_HOST"]}:#{ENV["FAYE_PORT"]}/faye")
+          client.publish("/case_blocks/account/#{options[:mailbox][:account_id]}/imap_server_new_message/#{options[:mailbox][:id]}", {'message_count' => options[:mailbox][:message_count], 'last_delivered_at' => options[:mailbox][:last_delivered_at]})
+          client.disconnect
+        end
+        mysql_client do |mysql|
+          status_message = options[:status]
+          statement = mysql.prepare("UPDATE case_blocks_email_accounts SET imap_messages_processed='#{options[:mailbox][:message_count]}', imap_last_processed_at='#{options[:mailbox][:last_delivered_at]}' where id=?")
+          statement.execute(options[:mailbox][:id])
+        end
+      rescue => e
+        puts e.message
+        puts e.backtrace.join("\n")
+      end
     end
 
     def update_status(options)
-      puts "Status Update: #{options[:status]} for #{options[:mailbox][:username]}"
-      mysql_client do |mysql|
-        status_message = options[:status]
-        statement = mysql.prepare("UPDATE case_blocks_email_accounts SET imap_status='#{options[:status]}', imap_status_message='#{status_message}' where id=?")
-        statement.execute(options[:mailbox][:id])
+      begin
+        puts "Status Update: #{options[:status]} for #{options[:mailbox][:username]}"
+        if (ENV["FAYE_HOST"])
+          Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+          Thread.pass until EventMachine.reactor_running?
+          client = Faye::Client.new("#{ENV["FAYE_HOST"]}:#{ENV["FAYE_PORT"]}/faye")
+          client.publish("/case_blocks/account/#{options[:mailbox][:account_id]}/imap_server_status_updated/#{options[:mailbox][:id]}", {'status' => options[:status].gsub("_", " ")})
+          client.disconnect
+        end
+        mysql_client do |mysql|
+          status_message = options[:status]
+          statement = mysql.prepare("UPDATE case_blocks_email_accounts SET imap_status='#{options[:status]}', imap_status_message='#{status_message}' where id=?")
+          statement.execute(options[:mailbox][:id])
+        end
+      rescue => e
+        puts e.message
+        puts e.backtrace.join("\n")
       end
     end
 

data/lib/mail2cb/encryption.rb

@@ -1,37 +1,56 @@
 require 'base64'
+require 'rest-client'
 
 module Mail2cb
   class Encryption
 
-    def initialize()
-      @key = ENV["CASEBLOCKS_ENCRYPTION_KEY"] || "YLX0IBT+OXaO4mP2bVYqzMPbrrss8eUcX1XtgLxlVH8="
-      @iv = ENV["CASEBLOCKS_ENCRYPTION_IV"] || "vvSVfoWvZQ3T/DfjsjO/9w=="
-    end
-
-    def encrypt(data)
-      unless data.nil?
-        cipher = OpenSSL::Cipher::AES.new(128, :CBC)
-        cipher.encrypt
-        cipher.key = Base64.decode64(@key)
-        cipher.iv = Base64.decode64(@iv)
-        encrypted = cipher.update(data) + cipher.final
-
-        # [0..-2] strip off trailing carriage return
-        Base64.encode64(encrypted)[0..-2]
-      else
-        data
-      end
+    # def initialize()
+    #   @key = ENV["CASEBLOCKS_ENCRYPTION_KEY"] || "YLX0IBT+OXaO4mP2bVYqzMPbrrss8eUcX1XtgLxlVH8="
+    #   @iv = ENV["CASEBLOCKS_ENCRYPTION_IV"] || "vvSVfoWvZQ3T/DfjsjO/9w=="
+    # end
+    #
+    # def encrypt(data)
+    #   unless data.nil?
+    #     cipher = OpenSSL::Cipher::AES.new(128, :CBC)
+    #     cipher.encrypt
+    #     cipher.key = Base64.decode64(@key)
+    #     cipher.iv = Base64.decode64(@iv)
+    #     encrypted = cipher.update(data) + cipher.final
+    #
+    #     # [0..-2] strip off trailing carriage return
+    #     Base64.encode64(encrypted)[0..-2]
+    #   else
+    #     data
+    #   end
+    # end
+    #
+    # def decrypt(value)
+    #   unless value.nil?
+    #     decipher = OpenSSL::Cipher::AES.new(128, :CBC)
+    #     decipher.decrypt
+    #     decipher.key = Base64.decode64(@key)
+    #     decipher.iv = Base64.decode64(@iv)
+    #
+    #     encrypted = Base64.decode64(value)
+    #     decipher.update(encrypted) + decipher.final
+    #   else
+    #     value
+    #   end
+    # end
+
+    def initialize(auth_token)
+      # @current_user = current_user
+      # config = YAML.load_file(File.join(Rails.root, "config", "secret_keys.yml"))[Rails.env.to_sym]
+      # @key = config[:key]
+      # @iv = config[:iv]
+      @auth_token = auth_token
     end
 
     def decrypt(value)
       unless value.nil?
-        decipher = OpenSSL::Cipher::AES.new(128, :CBC)
-        decipher.decrypt
-        decipher.key = Base64.decode64(@key)
-        decipher.iv = Base64.decode64(@iv)
-
-        encrypted = Base64.decode64(value)
-        decipher.update(encrypted) + decipher.final
+        url = "#{ENV["CRYPT_API_ENDPOINT"]}/decrypt?auth_token=#{@auth_token}"
+        result = ::RestClient.post url, {base64ciphertext: value}.to_json, :content_type => :json, :accept => :json
+        JSON.parse(result)["plaintext"]
       else
         value
       end