xtify 0.0.1

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "shoulda-context", ">= 0"
+  gem "bundler", "~> 1.2.3"
+  gem "jeweler", "~> 1.8.4"
+  gem "webmock", "~> 1.9.0"
+end
+
+gem 'curb'
+gem 'activesupport'

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.11)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.3.2)
+    crack (0.3.2)
+    curb (0.8.3)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.6)
+    multi_json (1.5.0)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda-context (1.0.2)
+    webmock (1.9.0)
+      addressable (>= 2.2.7)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler (~> 1.2.3)
+  curb
+  jeweler (~> 1.8.4)
+  shoulda-context
+  webmock (~> 1.9.0)

data/README.md

@@ -0,0 +1,2 @@
+xtify
+=====

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "xtify"
+  gem.homepage = "http://github.com/moxiespaces/xtify"
+  gem.license = "MIT"
+  gem.summary = %Q{Client library for Xtify's API}
+  gem.description = gem.summary
+  gem.email = "jbell@moxiesoft.com"
+  gem.authors = ['Jonathan Bell']
+  # Do not add dependencies here because Jewler will add them from the Gemfile
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/xtify.rb

@@ -0,0 +1,24 @@
+require 'curl'
+require 'active_support/all'
+
+module Xtify
+  autoload :Config, 'xtify/config'
+  autoload :Model, 'xtify/model'
+  autoload :Device, 'xtify/device'
+  autoload :Action, 'xtify/action'
+  autoload :Message, 'xtify/message'
+  autoload :Commands, 'xtify/commands'
+
+  def self.config
+    @config
+  end
+  
+  def self.configure(&block)
+    @config = Config.new
+    yield @config
+  end
+
+  extend Commands
+end
+
+require 'xtify/errors'

data/lib/xtify/action.rb

@@ -0,0 +1,24 @@
+module Xtify
+  class Action
+    include Model
+
+    xtify_model :type, :data, :label
+
+    TYPES = {
+      :url => "URL",
+      :rich => "RICH",
+      :custom => "CUSTOM",
+      :phone => "PHONE",
+      :default => "DEFAULT",
+      :none => "NONE"
+    }
+
+    RICH_TYPES = {
+      :web => "WEB",
+      :phone => "PHN",
+      :custom => "CST",
+      :default => "DEFAULT",
+      :none => "NONE"
+    }
+  end
+end

data/lib/xtify/commands.rb

@@ -0,0 +1,149 @@
+module Xtify
+  module Commands
+
+    API_V2 = "http://api.xtify.com/2.0"
+
+    # Register and return a device with the provided details which 
+    # can be used to refer to this device in the Xtify system. 
+    # Calling this endpoint with a device that is already 
+    # registered will result in the existing device being returned.
+    #
+    # Parameters:
+    # - install_id      -> (Required) This id along with your application key will 
+    #                      uniquely identify your user in our system 
+    #                      and is used to manage uninstalls/reinstalls 
+    #                      and mapping registrations to existing users. 
+    #                      It does not have to be the device’s IMEI or 
+    #                      true device identifier. This must be unique 
+    #                      for every user of your application.
+    #
+    #                      Please note: If you use a custom install ID and 
+    #                      call the registration service from the same device 
+    #                      (ie same device token) multiple times with the same 
+    #                      install ID, the user will receive multiple messages.
+    #
+    # - type            -> (Required) The SDK device type you have implemented in your app.
+    #
+    #                      Values restricted to: Xtify::Device::TYPES
+    #
+    # - device_token    -> The Apple provided deviceToken received by registering
+    #                      with APNS
+    #
+    # - registration_id -> The Google provided registrationId received by 
+    #                      registering with google’s cloud to device service.
+    #
+    # - blackberry_pin  -> The RIM provided device PIN received by registering 
+    #                      with the BlackBerry Push service.
+    #
+    # - user_key        -> An optional customer defined key which can be 
+    #                      associated with this user. Available to premium/enterprise 
+    #                      customers.
+    #
+    # - install_date    -> Install date of this user.
+    #
+    # - badge           -> Current badge for iOS only
+    #
+    # - v_os            -> The operating system version of the device.
+    #
+    # - model           -> The model name/number of the device.
+    #
+    # - carrier         -> The carrier in use by the device.
+    #
+    # - Returns a Xtify ID for device
+    def register_device(opts={})
+      validate_arguments('register_device', opts, :install_id, :type)
+      validate_in_set('register_device', :type, opts, Device::TYPES.values)
+    
+      args = convert_to_args(opts,
+        :blackberry_pin => 'blackberryPIN',
+        :v_os => 'vOS'
+      )
+
+      result = post('users/register', args)
+      Device.new(result)
+    end
+
+    # The Xtify Push API allows you to immediately send a message to a set of users that 
+    # you can select by Device, positive or negative tags, or a "send to all" flag. By 
+    # exposing our push interface via API, you can generate timely one-off notifications 
+    # and event-based messages from within your own service either by hand or automatically.
+    #
+    # - devices       -> A device or array of devices to send message to
+    # - has_tags      -> All devices with these tags will receive message
+    # - not_tags      -> All devices without these tags will receive message
+    # - send_all      -> All users of the application will recieve message
+    # - index_only    -> Index only indicator for rich message
+    # - content       -> Message or Hash of message
+    def push(opts={})
+      xids = Array.wrap(opts.delete(:devices)).map {|d| d.is_a?(Device) ? d.xid : d}
+      has_tags = Array.wrap(opts.delete(:has_tags))
+      not_tags = Array.wrap(opts.delete(:not_tags))
+      content = opts.delete(:content)
+      unless content.is_a?(Message)
+        content = Message.new(opts)
+      end
+
+      args = convert_to_args(opts)
+      args[:apiKey] = config.api_key
+      args[:content] = content
+      args[:xids] = xids unless xids.empty?
+      args[:hasTags] = has_tags unless has_tags.empty?
+      args[:notTags] = not_tags unless not_tags.empty?
+
+      post('push', args)
+    end
+
+    protected
+
+    def convert_to_args(opts, mappings={})
+      args = {}
+      opts.each do |key, value|
+        mapped_to = mappings[key]
+        if mapped_to
+          args[mapped_to] = value
+        else
+          camelized = key.to_s.camelcase(:lower).gsub(/Id/, 'ID')
+          args[camelized] = value
+        end
+      end
+      args
+    end
+
+    def validate_arguments(command, args, *keys)
+      missing = []
+
+      keys.each do |key|
+        missing << key unless args[key]
+      end
+
+      raise InvalidRequest.new("Must specify #{missing.join(",")} when requesting #{command}.") unless missing.empty?
+      true
+    end
+
+    def validate_in_set(command, key, opts, set)
+      unless set.include?(opts[key])
+        raise InvalidRequest.new("#{key} must be one of: #{set.join(", ")} when requesting #{command}")
+      end
+    end
+
+    def post(command, opts)
+      args = opts.dup
+      raise ConfigError.new("Must specify app_key in Xtify initializer.") unless Xtify.config.app_key
+      args[:appKey] = Xtify.config.app_key
+
+      response = Curl::Easy.perform(File.join(API_V2, command)) do |curl|
+        curl.verbose = config.verbose
+        curl.headers['Content-Type'] = 'application/json'
+        curl.post_body = args.to_json
+      end
+
+      if response.response_code == 200
+        JSON.parse(response.body_str)
+      elsif response.response_code == 202
+        true
+      else
+        raise CommandFailure.new("Error performing: #{command}: #{response.body_str}")
+      end
+    end
+  end
+end

data/lib/xtify/config.rb

@@ -0,0 +1,5 @@
+module Xtify
+  class Config
+    attr_accessor :app_key, :api_key, :verbose
+  end
+end

data/lib/xtify/device.rb

@@ -0,0 +1,13 @@
+module Xtify
+  class Device
+    include Model
+
+    xtify_model :xid
+
+    TYPES = {
+      :apple => "IOS",
+      :blackberry => "BLACKBERRY",
+      :android => "GCM"
+    }
+  end
+end

data/lib/xtify/errors.rb

@@ -0,0 +1,13 @@
+module Xtify
+  class Error < StandardError
+  end
+
+  class ConfigError < Error
+  end
+
+  class InvalidRequest < Error
+  end
+
+  class CommandFailure < Error
+  end
+end

data/lib/xtify/message.rb

@@ -0,0 +1,15 @@
+module Xtify
+  class Message
+    include Model
+
+    xtify_model :subject, :message, :payload, :sound, :badge
+
+    one :action
+    one :rich, :type => Message
+
+    # See Xtify.push
+    def push(opts={})
+      Xtify.push(opts.merge(:content => self))
+    end
+  end
+end

data/lib/xtify/model.rb

@@ -0,0 +1,59 @@
+module Xtify
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      def self.xtify_model(*fields)
+        @fields = fields
+        attr_accessor *fields
+      end
+
+      def self.one(assoc, opts={})
+        @one_associations ||= {}
+        @one_associations[assoc] = opts
+        attr_accessor assoc
+      end
+
+      def self.fields
+        @fields || []
+      end
+
+      def self.one_associations
+        @one_associations ||= {}
+      end
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def one_associations
+      self.class.one_associations
+    end
+
+    def initialize(opts={})
+      opts = opts.symbolize_keys
+      fields.each do |field|
+        self.send("#{field}=", opts[field])
+      end
+
+      one_associations.each do |assoc, assoc_opts|
+        value = opts[assoc]
+        if value.is_a?(Hash)
+          klass = assoc_opts[:type] || File.join("xtify", assoc.to_s).classify.constantize
+          value = klass.new(value)
+        end
+        self.send("#{assoc}=", value)
+      end
+    end
+
+    def as_json(opts={})
+      json = {}
+      (fields + one_associations.keys).each do |field|
+        value = send(field)
+        json[field] = value unless value.blank?
+      end
+      json
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'webmock/test_unit'
+require 'shoulda-context'
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'xtify'
+
+Xtify.configure do |config|
+  config.app_key = 'FAKE_APP_KEY'
+  config.api_key = 'FAKE_API_KEY'
+  config.verbose = false
+end
+
+class Test::Unit::TestCase
+  def stub_xtify_post(url, data)
+    stub_http_request(:post, File.join(Xtify::Commands::API_V2, url)).
+      with(:body => data)
+  end
+end

data/test/message_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path('../helper', __FILE__)
+
+class MessageTest < Test::Unit::TestCase
+  context "A new message" do
+    setup do
+      @message = Xtify::Message.new(
+        :subject => "Fake Subject",
+        :message => "Fake Message",
+        :action => {
+          :type => Xtify::Action::TYPES[:rich],
+          :data => "fake data",
+          :label => "fake label"
+        },
+        :rich => {
+          :subject => "Fake Rich Subject",
+          :message => "Fake Rich Message",
+          :action => {
+            :type => Xtify::Action::RICH_TYPES[:web],
+            :data => "fake rich data",
+            :label => "fake rich label"
+          }
+        },
+        :payload => {:key1 => 'key2'},
+        :sound => 'default.csf',
+        :badge => "+1"
+      )
+    end
+
+    should "properly set associations" do
+      assert @message.action, "Action is missing"
+      assert_equal "fake data", @message.action.data, "Action's data is wrong"
+
+      assert @message.rich, "Rich is missing"
+      assert @message.rich.action, "Rich action is missing"
+      assert_equal "fake rich data", @message.rich.action.data, "Rich's action's data is wrongs"
+    end
+
+    context "that is pushed" do
+      setup do
+        stub_xtify_post('push', 
+          "apiKey" => "FAKE_API_KEY",
+          "appKey" => "FAKE_APP_KEY",
+          "xids" => ["ABC123"],
+          "hasTags" => ["apple", "banana"],
+          "sendAll" => true,
+          "inboxOnly" => false,
+          "content" => {
+            "subject" => "Fake Subject",
+            "message" => "Fake Message",
+            "action" => {
+              "type" => "RICH",
+              "data" => "fake data",
+              "label" => "fake label"
+            },
+            "rich" => {
+              "subject" => "Fake Rich Subject",
+              "message" => "Fake Rich Message",
+              "action" => {
+                "type" => "WEB",
+                "data" => "fake rich data",
+                "label" => "fake rich label"
+              }
+            },
+            "payload" => {"key1" => "key2"},
+            "sound" => "default.csf",
+            "badge" => "+1"
+          }
+        ).to_return(:status => 202)
+
+        @message.push(
+          :devices => "ABC123",
+          :has_tags => ["apple", "banana"],
+          :send_all => true,
+          :inbox_only => false
+        )
+      end
+
+      should "return success" do
+        true
+      end
+    end
+  end
+end

data/test/registration_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../helper', __FILE__)
+
+class RegistrationTest < Test::Unit::TestCase
+  context "Register an apple device" do
+    setup do
+      @xid = "ABC123"
+
+      stub_xtify_post('users/register',
+        :appKey => 'FAKE_APP_KEY',
+        :installID => 'fake_user',
+        :type => 'IOS',
+        :deviceToken => 'fake_device_token'
+      ).to_return(
+        :status => 200,
+        :body => "{\"xid\":\"#{@xid}\"}"
+      )
+
+      @device = Xtify.register_device(
+        :install_id => 'fake_user', 
+        :type => Xtify::Device::TYPES[:apple],
+        :device_token => 'fake_device_token')
+    end
+
+    should "return expected device" do
+      assert @device, "Device was not returned"
+      assert_equal  @xid, @device.xid, "Unexpected xid returned"
+    end
+  end
+
+  context "Register an google device" do
+    setup do
+      @xid = "ABC123"
+
+      stub_xtify_post('users/register',
+        :appKey => 'FAKE_APP_KEY',
+        :installID => 'fake_user',
+        :type => 'GCM',
+        :registrationID => 'fake_registration_id'
+      ).to_return(
+        :status => 200,
+        :body => "{\"xid\":\"#{@xid}\"}"
+      )
+
+      @device = Xtify.register_device(
+        :install_id => 'fake_user', 
+        :type => Xtify::Device::TYPES[:android],
+        :registration_id => 'fake_registration_id')
+    end
+
+    should "return expected device" do
+      assert @device, "Device was not returned"
+      assert_equal  @xid, @device.xid, "Unexpected xid returned"
+    end
+  end
+
+  context "Register a device with an invalid type" do
+
+    should "raise an InvalidRequest" do
+      assert_raises Xtify::InvalidRequest do
+        @device = Xtify.register_device(
+          :install_id => 'fake_user', 
+          :type => 'FAKE_TYPE',
+          :registration_id => 'fake_registration_id')
+      end
+    end
+  end
+
+  context "Register a device with no install id" do
+
+    should "raise an InvalidRequest" do
+      assert_raises Xtify::InvalidRequest do
+        @device = Xtify.register_device(
+          :type => Xtify::Device::TYPES[:android],
+          :registration_id => 'fake_registration_id')
+      end
+    end
+  end
+end

data/xtify.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "xtify"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jonathan Bell"]
+  s.date = "2013-05-07"
+  s.description = "Client library for Xtify's API"
+  s.email = "jbell@moxiesoft.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/xtify.rb",
+    "lib/xtify/action.rb",
+    "lib/xtify/commands.rb",
+    "lib/xtify/config.rb",
+    "lib/xtify/device.rb",
+    "lib/xtify/errors.rb",
+    "lib/xtify/message.rb",
+    "lib/xtify/model.rb",
+    "test/helper.rb",
+    "test/message_test.rb",
+    "test/registration_test.rb",
+    "xtify.gemspec"
+  ]
+  s.homepage = "http://github.com/moxiespaces/xtify"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Client library for Xtify's API"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<curb>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_development_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.2.3"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<webmock>, ["~> 1.9.0"])
+    else
+      s.add_dependency(%q<curb>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.2.3"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<webmock>, ["~> 1.9.0"])
+    end
+  else
+    s.add_dependency(%q<curb>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<shoulda-context>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.2.3"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<webmock>, ["~> 1.9.0"])
+  end
+end
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: xtify
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Bell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: &70176322612200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176322612200
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70176322611720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176322611720
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: &70176322611240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70176322611240
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70176322610760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: *70176322610760
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70176322610280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: *70176322610280
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70176322609800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *70176322609800
+description: Client library for Xtify's API
+email: jbell@moxiesoft.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- lib/xtify.rb
+- lib/xtify/action.rb
+- lib/xtify/commands.rb
+- lib/xtify/config.rb
+- lib/xtify/device.rb
+- lib/xtify/errors.rb
+- lib/xtify/message.rb
+- lib/xtify/model.rb
+- test/helper.rb
+- test/message_test.rb
+- test/registration_test.rb
+- xtify.gemspec
+homepage: http://github.com/moxiespaces/xtify
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -928513645534341231
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Client library for Xtify's API
+test_files: []