govdelivery-tms 0.8.0

data/lib/govdelivery-tms/link_header.rb

@@ -0,0 +1,223 @@
+# link_header, Copyright (c) 2009 Mike Burrows
+ 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+ 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+ 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "strscan"
+
+#
+# Represents an HTTP link header of the form described in the draft spec http://tools.ietf.org/id/draft-nottingham-http-link-header-06.txt.
+# It is simply a list of LinkHeader::Link objects and some conversion functions.
+#
+class LinkHeader
+ 
+  # An array of Link objects
+  attr_reader :links
+  
+  #
+  # Initialize from a collection of either LinkHeader::Link objects or data from which Link objects can be created.
+  #
+  # From a list of LinkHeader::Link objects:
+  #
+  #   LinkHeader.new([
+  #     LinkHeader::Link.new("http://example.com/foo", [["rel", "self"]]),
+  #     LinkHeader::Link.new("http://example.com/",    [["rel", "up"]])])
+  #
+  # From the equivalent JSON-friendly raw data:
+  #
+  #   LinkHeader.new([
+  #     ["http://example.com/foo", [["rel", "self"]]],
+  #     ["http://example.com/",    [["rel", "up"]]]]).to_s
+  #
+  # See also LinkHeader.parse
+  #
+  def initialize(links=[])
+    if links
+      @links = links.map{|l| l.kind_of?(Link) ? l : Link.new(*l)}
+    else
+      @links = []
+    end
+  end
+  
+  #
+  # Convert to a JSON-friendly array
+  #
+  #   LinkHeader.parse('<http://example.com/foo>; rel="self", <http://example.com/>; rel = "up"').to_a
+  #   #=> [["http://example.com/foo", [["rel", "self"]]],
+  #        ["http://example.com/", [["rel", "up"]]]]
+  #
+  def to_a
+    links.map{|l| l.to_a}
+  end
+  
+  #
+  # Convert to string representation as per the link header spec
+  #
+  #   LinkHeader.new([
+  #     ["http://example.com/foo", [["rel", "self"]]],
+  #     ["http://example.com/",    [["rel", "up"]]]]).to_s
+  #   #=> '<http://example.com/foo>; rel="self", <http://example.com/>; rel = "up"'
+  #
+  def to_s
+    links.join(', ')
+  end
+  
+  #
+  # Regexes for link header parsing.  TOKEN and QUOTED in particular should conform to RFC2616.
+  #
+  # Acknowledgement: The QUOTED regexp is based on
+  # http://stackoverflow.com/questions/249791/regexp-for-quoted-string-with-escaping-quotes/249937#249937
+  #
+  HREF   = / *< *([^>]*) *> *;? */                  #:nodoc: note: no attempt to check URI validity
+  TOKEN  = /([^()<>@,;:\"\[\]?={}\s]+)/             #:nodoc: non-empty sequence of non-separator characters
+  QUOTED = /"((?:[^"\\]|\\.)*)"/                    #:nodoc: double-quoted strings with backslash-escaped double quotes
+  ATTR   = /#{TOKEN} *= *(#{TOKEN}|#{QUOTED}) */    #:nodoc:
+  SEMI   = /; */                                    #:nodoc:
+  COMMA  = /, */                                    #:nodoc:
+
+  #
+  # Parse a link header, returning a new LinkHeader object
+  #
+  #   LinkHeader.parse('<http://example.com/foo>; rel="self", <http://example.com/>; rel = "up"').to_a
+  #   #=> [["http://example.com/foo", [["rel", "self"]]],
+  #        ["http://example.com/", [["rel", "up"]]]]
+  #
+  def self.parse(link_header)
+    return new unless link_header
+    
+    scanner = StringScanner.new(link_header)
+    links = []
+    while scanner.scan(HREF)
+      href = scanner[1]
+      attrs = []
+      while scanner.scan(ATTR)
+        attr_name, token, quoted = scanner[1], scanner[3], scanner[4].gsub(/\\"/, '"')
+        attrs.push([attr_name, token || quoted])
+        break unless scanner.scan(SEMI)
+      end
+      links.push(Link.new(href, attrs))
+      break unless scanner.scan(COMMA)
+    end
+
+    new(links)
+  end
+  
+  #
+  # Find a member link that has the given attributes
+  #
+  def find_link(*attr_pairs)
+    links.detect do |link|
+      !attr_pairs.detect do |pair|
+        !link.attr_pairs.include?(pair)
+      end
+    end 
+  end
+  
+  #
+  # Render as a list of HTML link elements
+  #
+  def to_html(separator="\n")
+    links.map{|link| link.to_html}.join(separator)
+  end
+
+  #
+  # Represents a link - an href and a list of attributes (key value pairs)
+  #
+  #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"]]).to_s
+  #   => '<http://example.com/foo>; rel="self"'
+  #
+  class Link
+    #
+    # The link's URI string
+    #
+    #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"]]).href
+    #   => 'http://example.com/foo>'
+    #
+    attr_reader :href
+    
+    #
+    # The link's attributes, an array of key-value pairs
+    #
+    #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"], ["rel", "canonical"]]).attr_pairs
+    #   => [["rel", "self"], ["rel", "canonical"]]
+    #
+    attr_reader :attr_pairs
+    
+    #
+    # Initialize a Link from an href and attribute list
+    #
+    #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"]]).to_s
+    #   => '<http://example.com/foo>; rel="self"'
+    #
+    def initialize(href, attr_pairs)
+      @href, @attr_pairs = href, attr_pairs
+    end
+    
+    #
+    # Lazily convert the attribute list to a Hash
+    #
+    # Beware repeated attribute names (it's safer to use #attr_pairs if this is risk):
+    #
+    #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"], ["rel", "canonical"]]).attrs
+    #   => {"rel" =>"canonical"}
+    #
+    def attrs
+      @attrs ||= Hash[*attr_pairs.flatten]
+    end
+    
+    #
+    # Access #attrs by key
+    #
+    def [](key)
+      attrs[key]
+    end
+    
+    #
+    # Convert to a JSON-friendly Array
+    #
+    #   LinkHeader::Link.new("http://example.com/foo", [["rel", "self"], ["rel", "canonical"]]).to_a
+    #   => ["http://example.com/foo", [["rel", "self"], ["rel", "canonical"]]]
+    #
+    def to_a
+      [href, attr_pairs]
+    end
+    
+    #
+    # Convert to string representation as per the link header spec.  This includes backspace-escaping doublequote characters in
+    # quoted attribute values.
+    #
+    # Convert to string representation as per the link header spec
+    #
+    #   LinkHeader::Link.new(["http://example.com/foo", [["rel", "self"]]]).to_s
+    #   #=> '<http://example.com/foo>; rel="self"'
+    #
+    def to_s
+      (["<#{href}>"] + attr_pairs.map{|k, v| "#{k}=\"#{v.gsub(/"/, '\"')}\""}).join('; ')
+    end
+    
+    #
+    # Bonus!  Render as an HTML link element
+    #
+    #   LinkHeader::Link.new(["http://example.com/foo", [["rel", "self"]]]).to_html
+    #   #=> '<link href="http://example.com/foo" rel="self">'
+    def to_html
+      ([%Q(<link href="#{href}")] + attr_pairs.map{|k, v| "#{k}=\"#{v.gsub(/"/, '\"')}\""}).join(' ')
+    end
+  end
+end

data/lib/govdelivery-tms/logger.rb

@@ -0,0 +1,36 @@
+module TMS #:nodoc:
+  class Logger < Faraday::Response::Middleware #:nodoc:
+    extend Forwardable
+
+    def initialize(app, logger = nil)
+      super(app)
+      @logger = logger || begin
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+    def call(env)
+      debug "performing #{env[:method].to_s.upcase.ljust(7)} #{env[:url]}"
+
+      start = Time.now
+
+      # In order to log request duration in a threadsafe way, `start` must be a local variable instead of instance variable.
+      @app.call(env).on_complete do |environment|
+        on_complete(environment)
+        log_stuff(start, environment)
+      end
+    end
+
+    private
+
+    def log_stuff(start, environment)
+      duration = Time.now - start
+      info "#{environment[:method].to_s.upcase.ljust(7)}#{environment[:status].to_s.ljust(4)}#{environment[:url]} (#{duration} seconds)"
+      debug('response headers') { JSON.pretty_generate environment[:response_headers] }
+      debug('response body') { environment[:body] }
+    end
+  end
+end

data/lib/govdelivery-tms/mail/delivery_method.rb

@@ -0,0 +1,63 @@
+require 'govdelivery-tms'
+require 'mail'
+require 'mail/check_delivery_params'
+module TMS
+  module Mail
+    # Use TMS from the mail gem or ActionMailer as a delivery method.
+    #
+    #   # Gemfile
+    #   gem 'govdelivery-tms', :require=>'govdelivery-tms/mail/delivery_method'
+    #
+    #   # config/environment.rb
+    #   config.action_mailer.delivery_method = :govdelivery_tms
+    #   config.action_mailer.govdelivery_tms_settings = {
+    #     :auth_token=>'auth_token',
+    #     :api_root=>'https://stage-tms.govdelivery.com'
+    #     }
+    class DeliveryMethod
+      include ::Mail::CheckDeliveryParams
+
+      def initialize(values)
+        self.settings = values
+      end
+
+      attr_accessor :settings
+
+      def deliver!(mail)
+        raise TMS::Errors::NoRelation.new('email_messages', client) unless client.respond_to?(:email_messages)
+
+        envelope_from = mail.return_path || mail.sender || mail.from_addrs.first
+
+        body = case
+                 when mail.html_part
+                   mail.html_part.body
+                 when mail.text_part
+                   mail.text_part.body
+                 else
+                   mail.body
+               end.decoded
+
+        tms_message = client.email_messages.build(
+          :from_name => mail[:from].display_names.first,
+          :subject => mail.subject,
+          :body => body
+        )
+
+        mail.to.each { |recip| tms_message.recipients.build(:email => recip) }
+        tms_message.post!
+        tms_message
+      end
+
+      def client
+        @client ||= TMS::Client.new(settings[:auth_token], settings)
+      end
+    end
+  end
+end
+
+if defined?(ActionMailer)
+  ActionMailer::Base.add_delivery_method :govdelivery_tms, TMS::Mail::DeliveryMethod, {
+    :auth_token => nil,
+    :logger => ActionMailer::Base.logger,
+    :api_root => TMS::Client::DEFAULTS[:api_root]}
+end

data/lib/govdelivery-tms/resource/collections.rb

@@ -0,0 +1,98 @@
+class TMS::Emails
+  include TMS::CollectionResource
+end
+
+class TMS::SmsMessages
+  include TMS::CollectionResource
+end
+
+class TMS::EmailMessages
+  include TMS::CollectionResource
+end
+
+class TMS::Recipients
+  include TMS::CollectionResource
+end
+
+class TMS::EmailRecipients
+  include TMS::CollectionResource
+end
+
+class TMS::EmailRecipientOpens
+  include TMS::CollectionResource
+end
+
+class TMS::EmailRecipientClicks
+  include TMS::CollectionResource
+end
+
+# A collection of Keyword objects.
+#
+# @example
+#    keywords = client.keywords.get
+#
+class TMS::Keywords
+  include TMS::CollectionResource
+end
+
+class TMS::InboundSmsMessages
+  include TMS::CollectionResource
+end
+
+# A collection of CommandType instances.
+# This resource changes infrequently.  It may be used to dynamically construct a
+# user interface for configuring arbitrary SMS keywords for an account.
+#
+# This resource is read-only.
+#
+# @example
+#    client.command_types.get
+#    client.command_types.collection.each {|at| ... }
+class TMS::CommandTypes
+  include TMS::CollectionResource
+end
+
+class TMS::Commands
+  include TMS::CollectionResource
+end
+
+class TMS::CommandActions
+  include TMS::CollectionResource
+end
+
+class TMS::IpawsEventCodes
+  include TMS::CollectionResource
+end
+
+class TMS::IpawsCategories
+  include TMS::CollectionResource
+end
+
+class TMS::IpawsResponseTypes
+  include TMS::CollectionResource
+end
+
+class TMS::IpawsAlerts
+  include TMS::CollectionResource
+end
+
+class TMS::IpawsNwemAreas
+  include TMS::CollectionResource
+end
+
+class TMS::Webhooks
+  include TMS::CollectionResource
+end
+
+# A collection of Email Template objects.
+#
+# @example
+#    email_template = client.email_template.get
+#
+class TMS::EmailTemplates
+  include TMS::CollectionResource
+end
+
+class TMS::FromAddresses
+  include TMS::CollectionResource
+end

data/lib/govdelivery-tms/resource/command.rb

@@ -0,0 +1,25 @@
+module TMS #:nodoc:
+  # A command is a combination of behavior and parameters that should be executed 
+  # when an incoming SMS message matches the associated Keyword.
+  #
+  # @attr name [String] The name of the command.  This will default to the command_type if not supplied. 
+  # @attr command_type [String] The type of this command.  A list of valid types can be found by querying the CommandType list. 
+  # @attr params [Hash] A Hash of string/string pairs used as configuration for this command.  
+  # 
+  # @example
+  #    command = keyword.commands.build(:name => "subscribe to news", :command_type => "dcm_subscribe", :dcm_account_code => "NEWS", :dcm_topic_codes => "NEWS_1, NEWS_2")
+  #    command.post
+  #    command.dcm_topic_codes += ", NEWS_5"
+  #    command.put
+  #    command.delete
+  class Command
+    include InstanceResource
+
+    # @!parse attr_accessor :name, :command_type, :params
+    writeable_attributes :name, :command_type, :params
+    
+    # @!parse attr_reader :created_at, :updated_at
+    readonly_attributes :created_at, :updated_at
+
+  end
+end