miiCardConsumers 1.0.0

data/lib/miiCardConsumers.rb

@@ -0,0 +1,377 @@
+require "oauth"
+require "json"
+
+# Describes the overall status of an API call.
+module MiiApiCallStatus
+	# The API call succeeded - the associated result information can be found
+	# in the data property of the response object.
+	SUCCESS = 0
+	# The API call failed. You can get more information about the nature of
+	# the failure by examining the error_code property.
+	FAILURE = 1
+end
+
+# Details a specific problem that occurred when accessing the API.
+module MiiApiErrorCode
+	# The API call succeeded.
+	SUCCESS = 0
+	# The user has revoked access to your application. The user would
+	# have to repeat the OAuth authorisation process before access would be
+	# restored to your application.
+	ACCESS_REVOKED = 100
+	# The user's miiCard subscription has elapsed. Only users with a current
+	# subscription can share their data with other applications and websites.	
+    USER_SUBSCRIPTION_LAPSED = 200
+	# A general exception occurred during processing - details may be available
+	# in the error_message property of the response object depending upon the
+	# nature of the exception.
+    EXCEPTION = 10000
+end
+
+# Describes the overall status of an API call.
+module WebPropertyType
+	# Indicates that the WebProperty relates to a domain name.
+	DOMAIN = 0
+	# Indicates that the WebProperty relates to a website.
+	WEBSITE = 1
+end
+
+# Base class for most verifiable identity data.
+class Claim
+	attr_accessor :verified
+	
+	def initialize(verified)
+		@verified = verified
+	end
+end
+
+class Identity < Claim
+	attr_accessor :source, :user_id, :profile_url
+	
+	def initialize(verified, source, user_id, profile_url)
+		super(verified)
+		
+		@source = source
+		@user_id = user_id
+		@profile_url = profile_url
+	end
+	
+	def self.from_hash(hash)
+		return Identity.new(
+			hash["Verified"], 
+			hash["Source"], 
+			hash["UserId"], 
+			hash["ProfileUrl"]
+		)
+	end
+end
+
+class EmailAddress < Claim
+	attr_accessor :display_name, :address, :is_primary
+	
+	def initialize(verified, display_name, address, is_primary)
+		super(verified)
+		
+		@display_name = display_name
+		@address = address
+		@is_primary = is_primary
+	end
+	
+	def self.from_hash(hash)
+		return EmailAddress.new(
+			hash["Verified"], 
+			hash["DisplayName"], 
+			hash["Address"], 
+			hash["IsPrimary"]
+		)
+	end
+end
+
+class PhoneNumber < Claim
+	attr_accessor :display_name, :country_code, :national_number, :is_mobile, :is_primary
+	
+	def initialize(verified, display_name, country_code, national_number, is_mobile, is_primary)
+		super(verified)
+		
+		@display_name = display_name
+		@country_code = country_code
+		@national_number = national_number
+		@is_mobile = is_mobile
+		@is_primary = is_primary
+	end
+	
+	def self.from_hash(hash)
+		return PhoneNumber.new(
+			hash["Verified"], 
+			hash["DisplayName"], 
+			hash["CountryCode"], 
+			hash["NationalNumber"], 
+			hash["IsMobile"], 
+			hash["IsPrimary"]
+		)
+	end
+end
+
+class PostalAddress < Claim
+	attr_accessor :house, :line1, :line2, :city, :region, :code, :country, :is_primary
+	
+	def initialize(verified, house, line1, line2, city, region, code, country, is_primary)
+		super(verified)
+		
+		@house = house
+		@line1 = line1
+		@line2 = line2
+		@city = city
+		@region = region
+		@code = code
+		@country = country
+		@is_primary = is_primary
+	end
+	
+	def self.from_hash(hash)
+		return PostalAddress.new(
+			hash["Verified"], 
+			hash["House"], 
+			hash["Line1"], 
+			hash["Line2"], 
+			hash["City"], 
+			hash["Region"], 
+			hash["Code"], 
+			hash["Country"], 
+			hash["IsPrimary"]
+		)
+	end
+end
+
+class WebProperty < Claim
+	attr_accessor :display_name, :identifier, :type
+	
+	def initialize(verified, display_name, identifier, type)
+		super(verified)
+		
+		@display_name = display_name
+		@identifier = identifier
+		@type = type
+	end
+	
+	def self.from_hash(hash)
+		return WebProperty.new(
+			hash["Verified"],
+			hash["DisplayName"], 
+			hash["Identifier"], 
+			hash["Type"]
+		)
+	end
+end
+
+class MiiUserProfile
+	attr_accessor :username, :salutation, :first_name, :middle_name, :last_name
+	attr_accessor :previous_first_name, :previous_middle_name, :previous_last_name
+	attr_accessor :last_verified, :profile_url, :profile_short_url, :card_image_url, :email_addresses, :identities, :postal_addresses
+	attr_accessor :phone_numbers, :web_properties, :identity_assured, :has_public_profile
+	attr_accessor :public_profile
+	
+	def initialize(
+		username,
+		salutation,
+        first_name,
+        middle_name,
+        last_name,
+        previous_first_name,
+        previous_middle_name,
+        previous_last_name,
+        last_verified,
+        profile_url,
+        profile_short_url,
+        card_image_url,
+        email_addresses,
+        identities,
+        phone_numbers,
+        postal_addresses,
+        web_properties,
+        identity_assured,
+        has_public_profile,
+        public_profile
+		)
+		
+		@username= username
+		@salutation = salutation
+        @first_name = first_name
+        @middle_name = middle_name
+        @last_name = last_name
+        @previous_first_name = previous_first_name
+        @previous_middle_name = previous_middle_name
+        @previous_last_name = previous_last_name
+        @last_verified = last_verified
+        @profile_url = profile_url
+        @profile_short_url = profile_short_url
+        @card_image_url = card_image_url
+        @email_addresses = email_addresses
+        @identities = identities
+        @phone_numbers = phone_numbers
+        @postal_addresses = postal_addresses
+        @web_properties = web_properties
+        @identity_assured = identity_assured
+        @has_public_profile = has_public_profile
+        @public_profile = public_profile
+	end
+	
+	def self.from_hash(hash)
+		emails = hash["EmailAddresses"]
+		emails_parsed = nil
+		unless (emails.nil? || emails.empty?)
+			emails_parsed = emails.map{|item| EmailAddress::from_hash(item)}
+		end
+		
+		identities = hash["Identities"]
+		identities_parsed = nil
+		unless (identities.nil? || identities.empty?)
+			identities_parsed = identities.map{|item| Identity::from_hash(item)}
+		end
+		
+		phone_numbers = hash["PhoneNumbers"]
+		phone_numbers_parsed = nil
+		unless (phone_numbers.nil? || phone_numbers.empty?)
+			phone_numbers_parsed = phone_numbers.map{|item| PhoneNumber::from_hash(item)}
+		end		
+		
+		postal_addresses = hash["PostalAddresses"]
+		postal_addresses_parsed = nil
+		unless (postal_addresses.nil? || postal_addresses.empty?)
+			postal_addresses_parsed = postal_addresses.map{|item| PostalAddress::from_hash(item)}
+		end
+		
+		web_properties = hash["WebProperties"]
+		web_properties_parsed = nil
+		unless (web_properties.nil? || web_properties.empty?)
+			web_properties_parsed = web_properties.map{|item| WebProperty::from_hash(item)}
+		end
+		
+		public_profile = hash["PublicProfile"]
+		public_profile_parsed = nil
+		unless public_profile.nil?
+			public_profile_parsed = MiiUserProfile::from_hash(public_profile)
+		end
+		
+		return MiiUserProfile.new(
+			hash['Username'],
+			hash['Salutation'],
+			hash['FirstName'],
+			hash['MiddleName'],
+			hash['LastName'],
+			hash['PreviousFirstName'],
+			hash['PreviousMiddleName'],
+			hash['PreviousLastName'],
+			hash['LastVerified'],
+			hash['ProfileUrl'],
+			hash['ProfileShortUrl'],
+			hash['CardImageUrl'],
+			emails_parsed,
+			identities_parsed,
+			phone_numbers_parsed,
+			postal_addresses_parsed,
+			web_properties_parsed,
+			hash['IdentityAssured'],
+			hash['HasPublicProfile'],
+			public_profile_parsed
+			)			
+	end
+end
+
+class MiiApiResponse
+	attr_accessor :status, :error_code, :error_message, :data
+	
+	def initialize(status, error_code, error_message, data)
+		@status = status
+		@error_code = error_code
+		@error_message = error_message
+		@data = data
+	end
+	
+	def self.from_hash(hash, data_processor)
+		payload_json = hash["Data"]
+		
+		if payload_json && !data_processor.nil?
+			payload = data_processor.call(payload_json)
+		elsif !(payload_json.nil?)
+			payload = payload_json
+		else
+			payload = nil
+		end
+			
+		return MiiApiResponse.new(
+			hash["Status"], 
+			hash["ErrorCode"],
+			hash["ErrorMessage"],
+			payload
+		)
+	end
+end
+
+class MiiCardOAuthServiceBase
+	attr_accessor :consumer_key, :consumer_secret, :access_token, :access_token_secret
+	
+	def initialize(consumer_key, consumer_secret, access_token, access_token_secret)
+		if consumer_key.nil? || consumer_secret.nil? || access_token.nil? || access_token_secret.nil?
+			raise ArgumentError
+		end 
+
+		@consumer_key = consumer_key
+		@consumer_secret = consumer_secret
+		@access_token = access_token
+		@access_token_secret = access_token_secret
+	end
+end
+
+class MiiCardOAuthClaimsService < MiiCardOAuthServiceBase
+	def initialize(consumer_key, consumer_secret, access_token, access_token_secret)
+		super(consumer_key, consumer_secret, access_token, access_token_secret)
+	end
+	
+	def get_claims
+		return make_request(MiiCardServiceUrls.get_method_url('GetClaims'), nil, MiiUserProfile.method(:from_hash), true)
+	end
+	
+	def is_social_account_assured(social_account_id, social_account_type)
+		params = Hash["socialAccountId", social_account_id, "socialAccountType", social_account_type]
+		
+		return make_request(MiiCardServiceUrls.get_method_url('IsSocialAccountAssured'), params, nil, true)
+	end
+	
+	def is_user_assured
+		return make_request(MiiCardServiceUrls.get_method_url('IsUserAssured'), nil, nil, true)
+	end
+	
+	def assurance_image(type)
+		params = Hash["type", type]
+		
+		return make_request(MiiCardServiceUrls.get_method_url('AssuranceImage'), params, nil, false)
+	end
+	
+	private
+	def make_request(url, post_data, payload_processor, wrapped_response)
+		consumer = OAuth::Consumer.new(@consumer_key, @consumer_secret, {:site => MiiCardServiceUrls::STS_SITE, :request_token_path => MiiCardServiceUrls::OAUTH_ENDPOINT, :access_token_path => MiiCardServiceUrls::OAUTH_ENDPOINT, :authorize_path => MiiCardServiceUrls::OAUTH_ENDPOINT })
+		access_token = OAuth::AccessToken.new(consumer, @access_token, @access_token_secret)
+				
+		response = access_token.post(url, post_data.to_json(), { 'Content-Type' => 'application/json' })
+		
+		if wrapped_response
+			return MiiApiResponse::from_hash(JSON.parse(response.body), payload_processor)
+		elsif !payload_processor.nil?
+			return payload_processor.call(response.body)
+		else
+			return response.body
+		end
+	end
+end
+
+class MiiCardServiceUrls
+	OAUTH_ENDPOINT = "https://sts.miicard.com/auth/OAuth.ashx"
+	STS_SITE = "https://sts.miicard.com"
+    CLAIMS_SVC = "https://sts.miicard.com/api/v1/Claims.svc/json"
+	
+	def self.get_method_url(method_name)
+		return MiiCardServiceUrls::CLAIMS_SVC + "/" + method_name
+	end
+end
+

data/test/test_miiCardConsumers.rb

@@ -0,0 +1,137 @@
+require 'json'
+require 'miiCardConsumers'
+require 'test/unit'
+
+class TestSomething < Test::Unit::TestCase
+	def setup
+		@jsonBody = '{"CardImageUrl":"https:\/\/my.miicard.com\/img\/test.png","EmailAddresses":[{"Verified":true,"Address":"test@example.com","DisplayName":"testEmail","IsPrimary":true},{"Verified":false,"Address":"test2@example.com","DisplayName":"test2Email","IsPrimary":false}],"FirstName":"Test","HasPublicProfile":true,"Identities":null,"IdentityAssured":true,"LastName":"User","LastVerified":"\/Date(1345812103)\/","MiddleName":"Middle","PhoneNumbers":[{"Verified":true,"CountryCode":"44","DisplayName":"Default","IsMobile":true,"IsPrimary":true,"NationalNumber":"7800123456"},{"Verified":false,"CountryCode":"44","DisplayName":"Default","IsMobile":false,"IsPrimary":false,"NationalNumber":"7800123457"}],"PostalAddresses":[{"House":"Addr1 House1","Line1":"Addr1 Line1","Line2":"Addr1 Line2","City":"Addr1 City","Region":"Addr1 Region","Code":"Addr1 Code","Country":"Addr1 Country","IsPrimary":true,"Verified":true},{"House":"Addr2 House1","Line1":"Addr2 Line1","Line2":"Addr2 Line2","City":"Addr2 City","Region":"Addr2 Region","Code":"Addr2 Code","Country":"Addr2 Country","IsPrimary":false,"Verified":false}],"PreviousFirstName":"PrevFirst","PreviousLastName":"PrevLast","PreviousMiddleName":"PrevMiddle","ProfileShortUrl":"http:\/\/miicard.me\/123456","ProfileUrl":"https:\/\/my.miicard.com\/card\/test","PublicProfile":{"CardImageUrl":"https:\/\/my.miicard.com\/img\/test.png","FirstName":"Test","HasPublicProfile":true,"IdentityAssured":true,"LastName":"User","LastVerified":"\/Date(1345812103)\/","MiddleName":"Middle","PreviousFirstName":"PrevFirst","PreviousLastName":"PrevLast","PreviousMiddleName":"PrevMiddle","ProfileShortUrl":"http:\/\/miicard.me\/123456","ProfileUrl":"https:\/\/my.miicard.com\/card\/test","PublicProfile":null,"Salutation":"Ms","Username":"testUser"},"Salutation":"Ms","Username":"testUser","WebProperties":[{"Verified":true,"DisplayName":"example.com","Identifier":"example.com","Type":0},{"Verified":false,"DisplayName":"2.example.com","Identifier":"http:\/\/www.2.example.com","Type":1}]}'
+		@jsonResponseBody = '{"ErrorCode":0,"Status":0,"ErrorMessage":"A test error message","Data":true}'
+	end
+
+	def test_can_deserialise_user_profile
+		o = MiiUserProfile.from_hash(JSON.parse(@jsonBody))
+
+        assertBasics(o)
+
+        # Email addresses
+        email1 = o.email_addresses[0]
+        assert_equal(true, email1.verified)
+        assert_equal("test@example.com", email1.address)
+        assert_equal("testEmail", email1.display_name)
+        assert_equal(true, email1.is_primary)
+
+        email2 = o.email_addresses[1]
+        assert_equal(false, email2.verified)
+        assert_equal("test2@example.com", email2.address)
+        assert_equal("test2Email", email2.display_name)
+        assert_equal(false, email2.is_primary)
+
+        # Phone numbers
+        phone1 = o.phone_numbers[0]
+        assert_equal(true, phone1.verified)
+        assert_equal("44", phone1.country_code)
+        assert_equal("Default", phone1.display_name)
+        assert_equal(true, phone1.is_mobile)
+        assert_equal(true, phone1.is_primary)
+        assert_equal("7800123456", phone1.national_number)
+
+        phone2 = o.phone_numbers[1]
+        assert_equal(false, phone2.verified)
+        assert_equal("44", phone2.country_code)
+        assert_equal("Default", phone2.display_name)
+        assert_equal(false, phone2.is_mobile)
+        assert_equal(false, phone2.is_primary)
+        assert_equal("7800123457", phone2.national_number)
+
+        # Web properties
+        prop1 = o.web_properties[0]
+        assert_equal(true, prop1.verified)
+        assert_equal("example.com", prop1.display_name)
+        assert_equal("example.com", prop1.identifier)
+        assert_equal(WebPropertyType::DOMAIN, prop1.type)
+
+        prop2 = o.web_properties[1]
+        assert_equal(false, prop2.verified)
+        assert_equal("2.example.com", prop2.display_name)
+        assert_equal("http://www.2.example.com", prop2.identifier)
+        assert_equal(WebPropertyType::WEBSITE, prop2.type) 
+
+        # Postal addresses
+        addr1 = o.postal_addresses[0]
+        assert_equal("Addr1 House1", addr1.house)
+        assert_equal("Addr1 Line1", addr1.line1)
+        assert_equal("Addr1 Line2", addr1.line2)
+        assert_equal("Addr1 City", addr1.city)
+        assert_equal("Addr1 Region", addr1.region)
+        assert_equal("Addr1 Code", addr1.code)
+        assert_equal("Addr1 Country", addr1.country)
+        assert_equal(true, addr1.is_primary)
+        assert_equal(true, addr1.verified)
+
+        addr2 = o.postal_addresses[1]
+        assert_equal("Addr2 House1", addr2.house)
+        assert_equal("Addr2 Line1", addr2.line1)
+        assert_equal("Addr2 Line2", addr2.line2)
+        assert_equal("Addr2 City", addr2.city)
+        assert_equal("Addr2 Region", addr2.region)
+        assert_equal("Addr2 Code", addr2.code)
+        assert_equal("Addr2 Country", addr2.country)
+        assert_equal(false, addr2.is_primary)
+        assert_equal(false, addr2.verified)
+
+        assert_equal(true, o.has_public_profile)
+        
+        pp = o.public_profile
+        assertBasics(pp)
+        assert_equal("testUser", pp.username)
+	end
+
+	def assertBasics(obj)
+		assert_not_nil(obj)
+		        
+        assert_equal("https://my.miicard.com/img/test.png", obj.card_image_url)
+        assert_equal("Test", obj.first_name)
+        assert_equal("Middle", obj.middle_name)
+        assert_equal("User", obj.last_name)
+        
+        assert_equal("PrevFirst", obj.previous_first_name)
+        assert_equal("PrevMiddle", obj.previous_middle_name)
+        assert_equal("PrevLast", obj.previous_last_name)
+
+        assert_equal(true, obj.identity_assured)
+        assert_equal("/Date(1345812103)/", obj.last_verified)
+
+        assert_equal(true, obj.has_public_profile)
+        assert_equal("http://miicard.me/123456", obj.profile_short_url)
+        assert_equal("https://my.miicard.com/card/test", obj.profile_url)
+        assert_equal("Ms", obj.salutation)
+        assert_equal("testUser", obj.username)
+	end
+
+	def test_can_deserialise_boolean
+        o = MiiApiResponse.from_hash(JSON.parse(@jsonResponseBody), nil)
+
+        assert_equal(MiiApiCallStatus::SUCCESS, o.status)
+        assert_equal(MiiApiErrorCode::SUCCESS, o.error_code)
+        assert_equal("A test error message", o.error_message)
+        assert_equal(true, o.data)
+	end
+
+	def test_wrapper_throws_on_null_consumer_key
+		assert_raise ArgumentError do
+			MiiCardOAuthClaimsService.new(nil, "ConsumerSecret", "AccessToken", "AccessTokenSecret")
+		end
+
+		assert_raise ArgumentError do
+			MiiCardOAuthClaimsService.new("ConsumerKey", nil, "AccessToken", "AccessTokenSecret")
+		end
+
+		assert_raise ArgumentError do
+			MiiCardOAuthClaimsService.new("ConsumerKey", "ConsumerSecret", nil, "AccessTokenSecret")
+		end
+
+		assert_raise ArgumentError do
+			MiiCardOAuthClaimsService.new("ConsumerKey", "ConsumerSecret", "AccessToken", nil)
+		end
+	end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: miiCardConsumers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Paul O'Neill
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: &27018276 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *27018276
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &27018012 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *27018012
+description: A simple wrapper library around the miiCard API that makes calling into
+  it easier - just new up a MiiApiOAuthClaimsService with your consumer key, secret,
+  access token and secret and start calling methods.
+email: paul.oneill@miicard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/miiCardConsumers.rb
+- test/test_miiCardConsumers.rb
+homepage: http://www.miicard.com/developers
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Wrapper library around the miiCard API.
+test_files:
+- test/test_miiCardConsumers.rb