facebookbusiness 0.7.0.2 → 0.7.0.3

data/lib/facebook_ads/ad_objects/server_side/user_data.rb

@@ -16,8 +16,6 @@
 # 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_relative 'util'
-
 module FacebookAds
   module ServerSide
 
@@ -93,6 +91,24 @@ module FacebookAds
       # The subscription ID for the user in this transaction. This is similar to the order ID for an individual product.
       attr_accessor :subscription_id
 
+      # The first 5 letters of the first name.
+      attr_accessor :f5first
+
+      # The first 5 letters of the last name.
+      attr_accessor :f5last
+
+      # The first initial.
+      attr_accessor :fi
+
+      # The date of birth day.
+      attr_accessor :dobd
+
+      # The date of birth month.
+      attr_accessor :dobm
+
+      # THe date of birth year.
+      attr_accessor :doby
+
       #UserData is a set of identifiers Facebook can use for targeted attribution
       # @param [String] email
       # @param [String] phone
@@ -110,10 +126,17 @@ module FacebookAds
       # @param [String] fbc
       # @param [String] fbp
       # @param [String] subscription_id
+      # @param [String] f5first
+      # @param [String] f5last
+      # @param [String] fi
+      # @param [String] dobd
+      # @param [String] dobm
+      # @param [String] doby
       def initialize(email: nil, phone: nil, gender: nil, date_of_birth: nil,
                      last_name: nil, first_name: nil, city: nil, state: nil,
                      country_code: nil, zip_code: nil, external_id: nil, client_ip_address: nil,
-                     client_user_agent: nil, fbc: nil, fbp: nil, subscription_id: nil)
+                     client_user_agent: nil, fbc: nil, fbp: nil, subscription_id: nil,
+                     f5first: nil, f5last: nil, fi: nil, dobd: nil, dobm: nil, doby: nil)
         unless email.nil?
           self.email = email
         end
@@ -162,6 +185,24 @@ module FacebookAds
         unless subscription_id.nil?
           self.subscription_id = subscription_id
         end
+        unless f5first.nil?
+          self.f5first = f5first
+        end
+        unless f5last.nil?
+          self.f5last = f5last
+        end
+        unless fi.nil?
+          self.fi = fi
+        end
+        unless dobd.nil?
+          self.dobd = dobd
+        end
+        unless dobm.nil?
+          self.dobm = dobm
+        end
+        unless doby.nil?
+          self.doby = doby
+        end
       end
 
       # build the object using the input hash
@@ -232,8 +273,28 @@ module FacebookAds
           self.fbp = attributes[:'fbp']
         end
 
-        if attributes.has_key?(:'subscription_id')
-          self.subscription_id = attributes[:'subscription_id']
+        if attributes.has_key?(:'f5first')
+          self.f5first = attributes[:'f5first']
+        end
+
+        if attributes.has_key?(:'f5last')
+          self.f5last = attributes[:'f5last']
+        end
+
+        if attributes.has_key?(:'fi')
+          self.fi = attributes[:'fi']
+        end
+
+        if attributes.has_key?(:'dobd')
+          self.dobd = attributes[:'dobd']
+        end
+
+        if attributes.has_key?(:'dobm')
+          self.dobm = attributes[:'dobm']
+        end
+
+        if attributes.has_key?(:'doby')
+          self.doby = attributes[:'doby']
         end
       end
 
@@ -256,7 +317,13 @@ module FacebookAds
             client_user_agent == o.client_user_agent &&
             fbc == o.fbc &&
             fbp == o.fbp &&
-            subscription_id == o.subscription_id
+            subscription_id == o.subscription_id &&
+            f5first == o.f5first &&
+            f5last == o.f5last &&
+            fi == o.fi &&
+            dobd == o.dobd &&
+            dobm == o.dobm &&
+            doby == o.doby
       end
 
       # @see the `==` method
@@ -283,7 +350,13 @@ module FacebookAds
             client_user_agent,
             fbc,
             fbp,
-            subscription_id
+            subscription_id,
+            f5first,
+            f5last,
+            fi,
+            dobd,
+            dobm,
+            doby,
         ].hash
 
       end
@@ -340,6 +413,24 @@ module FacebookAds
         unless subscription_id.nil?
           hash['subscription_id'] = subscription_id
         end
+        unless f5first.nil?
+          hash['f5first'] = f5first
+        end
+        unless f5last.nil?
+          hash['f5last'] = f5last
+        end
+        unless fi.nil?
+          hash['fi'] = fi
+        end
+        unless dobd.nil?
+          hash['dobd'] = dobd
+        end
+        unless dobm.nil?
+          hash['dobm'] = dobm
+        end
+        unless doby.nil?
+          hash['doby'] = doby
+        end
         hash.to_s
       end
 
@@ -348,34 +439,34 @@ module FacebookAds
       def normalize
         hash = {}
         unless email.nil?
-          hash['em'] = FacebookAds::ServerSide::normalize(email, 'em')
+          hash['em'] = FacebookAds::ServerSide::Util.normalize(email, 'em')
         end
         unless phone.nil?
-          hash['ph'] = FacebookAds::ServerSide::normalize(phone, 'ph')
+          hash['ph'] = FacebookAds::ServerSide::Util.normalize(phone, 'ph')
         end
         unless gender.nil?
-          hash['ge'] = FacebookAds::ServerSide::normalize(gender, 'ge')
+          hash['ge'] = FacebookAds::ServerSide::Util.normalize(gender, 'ge')
         end
         unless date_of_birth.nil?
-          hash['db'] = FacebookAds::ServerSide::normalize(date_of_birth, 'db')
+          hash['db'] = FacebookAds::ServerSide::Util.normalize(date_of_birth, 'db')
         end
         unless last_name.nil?
-          hash['ln'] = FacebookAds::ServerSide::normalize(last_name, 'ln')
+          hash['ln'] = FacebookAds::ServerSide::Util.normalize(last_name, 'ln')
         end
         unless first_name.nil?
-          hash['fn'] = FacebookAds::ServerSide::normalize(first_name, 'fn')
+          hash['fn'] = FacebookAds::ServerSide::Util.normalize(first_name, 'fn')
         end
         unless city.nil?
-          hash['ct'] = FacebookAds::ServerSide::normalize(city, 'ct')
+          hash['ct'] = FacebookAds::ServerSide::Util.normalize(city, 'ct')
         end
         unless country_code.nil?
-          hash['country'] = FacebookAds::ServerSide::normalize(country_code, 'country')
+          hash['country'] = FacebookAds::ServerSide::Util.normalize(country_code, 'country')
         end
         unless state.nil?
-          hash['st'] = FacebookAds::ServerSide::normalize(state, 'st')
+          hash['st'] = FacebookAds::ServerSide::Util.normalize(state, 'st')
         end
         unless zip_code.nil?
-          hash['zp'] = FacebookAds::ServerSide::normalize(zip_code, 'zp')
+          hash['zp'] = FacebookAds::ServerSide::Util.normalize(zip_code, 'zp')
         end
         unless external_id.nil?
           hash['external_id'] = external_id
@@ -395,6 +486,24 @@ module FacebookAds
         unless subscription_id.nil?
           hash['subscription_id'] = subscription_id
         end
+        unless f5first.nil?
+          hash['f5first'] = FacebookAds::ServerSide::Util.normalize(f5first, 'f5first')
+        end
+        unless f5last.nil?
+          hash['f5last'] = FacebookAds::ServerSide::Util.normalize(f5last, 'f5last')
+        end
+        unless fi.nil?
+          hash['fi'] = FacebookAds::ServerSide::Util.normalize(fi, 'fi')
+        end
+        unless dobd.nil?
+          hash['dobd'] = FacebookAds::ServerSide::Util.normalize(dobd, 'dobd')
+        end
+        unless dobm.nil?
+          hash['dobm'] = FacebookAds::ServerSide::Util.normalize(dobm, 'dobm')
+        end
+        unless doby.nil?
+          hash['doby'] = FacebookAds::ServerSide::Util.normalize(doby, 'doby')
+        end
         hash
       end
     end

data/lib/facebook_ads/ad_objects/server_side/util.rb

@@ -19,210 +19,264 @@
 require 'digest'
 require 'countries'
 require 'money'
+require 'time'
 
 module FacebookAds
 	module ServerSide
+		class Util
+			PHONE_NUMBER_IGNORE_CHAR_SET = /[\-\s\(\)]+/
+			PHONE_NUMBER_DROP_PREFIX_ZEROS = /^\+?0{0,2}/
+			US_PHONE_NUMBER_REGEX = /^1\(?\d{3}\)?\d{7}$/
+			INTL_PHONE_NUMBER_REGEX = /^\d{1,4}\(?\d{2,3}\)?\d{4,}$/
+
+			# RFC 2822 for email format
+			EMAIL_REGEX = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+
+			# Normalizes the input string given the field_type
+			# @param [String] input Input string that needs to be normalized
+			# @param [String] field_type Type/Key for the value provided
+			# @return [String] Normalized value for the input and field_type.
+			def self.normalize(input, field_type)
+
+				if input.nil? or field_type.nil?
+					return nil;
+				end
+
+				input = input.strip.downcase
+
+				# If the data is already hashed, we by-pass input normalization
+				if is_already_hashed?(input) == true
+					return input
+				end
+
+				normalized_input = input;
+
+				case field_type
+				when 'country'
+					normalized_input = normalize_country input
+				when 'ct'
+					normalized_input = normalize_city input
+				when 'currency'
+					return normalize_currency input
+				when 'em'
+					normalized_input = normalize_email input
+				when 'ge'
+					normalized_input = normalize_gender input
+				when 'ph'
+					normalized_input = normalize_phone input
+				when 'st'
+					normalized_input = normalize_state input
+				when 'zp'
+					normalized_input = normalize_zip input
+				when 'f5first'
+					normalized_input = normalize_f5 input
+				when 'f5last'
+					normalized_input = normalize_f5 input
+				when 'fi'
+					normalized_input = normalize_fi input
+				when 'dobd'
+					normalized_input = normalize_dobd input
+				when 'dobm'
+					normalized_input = normalize_dobm input
+				when 'doby'
+					normalized_input = normalize_doby input
+				end
+
+				normalized_input = sha256Hash normalized_input
+
+				return normalized_input
+			end
 
-		PHONE_NUMBER_IGNORE_CHAR_SET = /[\-\s\(\)]+/
-		PHONE_NUMBER_DROP_PREFIX_ZEROS = /^\+?0{0,2}/
-		US_PHONE_NUMBER_REGEX = /^1\(?\d{3}\)?\d{7}$/
-		INTL_PHONE_NUMBER_REGEX = /^\d{1,4}\(?\d{2,3}\)?\d{4,}$/
-
-		# RFC 2822 for email format
-		EMAIL_REGEX = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-
-		# @return [String] SHA 256 hash of input string
-		def self.sha256Hash(input)
-			unless input.nil?
-				Digest::SHA256.hexdigest input
+			# @return [String] SHA 256 hash of input string
+			def self.sha256Hash(input)
+				unless input.nil?
+					Digest::SHA256.hexdigest input
+				end
 			end
-		end
 
-		# Normalizes the input string given the field_type
-		# @param [String] input Input string that needs to be normalized
-		# @param [String] field_type Type/Key for the value provided
-		# @return [String] Normalized value for the input and field_type.
-		def self.normalize(input, field_type)
-
-			if input.nil? or field_type.nil?
-				return nil;
-			end
-
-			input = input.strip.downcase
-
-			# If the data is already hashed, we by-pass input normalization
-			if FacebookAds::ServerSide::is_already_hashed?(input) == true
-				return input
-      end
-
-			normalized_input = input;
-
-			case field_type
-			when 'country'
-				normalized_input = FacebookAds::ServerSide::normalize_country input
-			when 'ct'
-        normalized_input = FacebookAds::ServerSide::normalize_city input
-      when 'currency'
-        return FacebookAds::ServerSide::normalize_currency input
-			when 'em'
-				normalized_input = FacebookAds::ServerSide::normalize_email input
-			when 'ge'
-				normalized_input = FacebookAds::ServerSide::normalize_gender input
-			when 'ph'
-				normalized_input = FacebookAds::ServerSide::normalize_phone input
-			when 'st'
-				normalized_input = FacebookAds::ServerSide::normalize_state input
-			when 'zp'
-				normalized_input = FacebookAds::ServerSide::normalize_zip input
-      end
-
-      normalized_input = FacebookAds::ServerSide::sha256Hash normalized_input
-
-			return normalized_input
-		end
+			# Boolean method which checks if a input is already hashed with MD5 or SHA256
+			# @param [String] input Input string that is to be validated
+			# @return [TrueClass|FalseClass] representing whether the value is hashed
+			def self.is_already_hashed?(input)
 
-    # Boolean method which checks if a input is already hashed with MD5 or SHA256
-		# @param [String] input Input string that is to be validated
-		# @return [TrueClass|FalseClass] representing whether the value is hashed
-    def self.is_already_hashed?(input)
+				# We support Md5 and SHA256, and highly recommend users to use SHA256 for hashing PII keys.
+				md5_match = /^[a-f0-9]{32}$/.match(input)
+				sha256_match = /^[a-f0-9]{64}$/.match(input)
 
-			# We support Md5 and SHA256, and highly recommend users to use SHA256 for hashing PII keys.
-			md5_match = /^[a-f0-9]{32}$/.match(input)
-      sha256_match = /^[a-f0-9]{64}$/.match(input)
+				if md5_match != nil or sha256_match != nil
+					return true
+				end
 
-			if md5_match != nil or sha256_match != nil
-				return true
+				return false
 			end
 
-			return false
-		end
+			# Normalizes the given country code and returns acceptable hashed country ISO code
+			def self.normalize_country(country)
 
-		# Normalizes the given country code and returns acceptable hashed country ISO code
-		def self.normalize_country(country)
+				# Replace unwanted characters and retain only alpha characters bounded for ISO code.
+				country = country.gsub(/[^a-z]/,'')
+				iso_country = ISO3166::Country.search(country)
+				if iso_country == nil
+					raise ArgumentError, "Invalid format for country:'" + country + "'.Please follow ISO 2-letter ISO 3166-1 standard for representing country. eg: us"
+				end
 
-			# Replace unwanted characters and retain only alpha characters bounded for ISO code.
-			country = country.gsub(/[^a-z]/,'')
-			iso_country = ISO3166::Country.search(country)
-			if iso_country == nil
-				raise ArgumentError, "Invalid format for country:'" + country + "'.Please follow ISO 2-letter ISO 3166-1 standard for representing country. eg: us"
+				return  country
 			end
 
-			return  country
-		end
+			# Normalizes the given city and returns acceptable hashed city value
+		    def self.normalize_city(city)
 
-		# Normalizes the given city and returns acceptable hashed city value
-    def self.normalize_city(city)
+		      # Remove commonly occuring characters from city name.
+				city = city.gsub(/[0-9.\s\-()]/,'')
 
-      # Remove commonly occuring characters from city name.
-		city = city.gsub(/[0-9.\s\-()]/,'')
+				return city
+			end
 
-		return city
-	end
+			# Normalizes the given currency code and returns acceptable hashed currency ISO code
+			def self.normalize_currency(currency)
 
-	# Normalizes the given currency code and returns acceptable hashed currency ISO code
-	def self.normalize_currency(currency)
+				# Retain only alpha characters bounded for ISO code.
+				currency = currency.gsub(/[^a-z]/,'')
 
-		# Retain only alpha characters bounded for ISO code.
-		currency = currency.gsub(/[^a-z]/,'')
+				iso_currency = Money::Currency.find(currency)
+				if iso_currency == nil
+					raise ArgumentError, "Invalid format for currency:'" + currency + "'.Please follow ISO 3-letter ISO 4217 standard for representing currency. Eg: usd"
+				end
 
-		iso_currency = Money::Currency.find(currency)
-		if iso_currency == nil
-			raise ArgumentError, "Invalid format for currency:'" + currency + "'.Please follow ISO 3-letter ISO 4217 standard for representing currency. Eg: usd"
-		end
+				return currency;
+			end
 
-		return currency;
-	end
+			# Normalizes the given email and returns acceptable hashed email value
+			def self.normalize_email(email)
 
-	# Normalizes the given email and returns acceptable hashed email value
-	def self.normalize_email(email)
+				if EMAIL_REGEX.match(email) == nil
+					return ArgumentError, "Invalid email format for the passed email:' + email + '.Please check the passed email format."
+				end
 
-		if EMAIL_REGEX.match(email) == nil
-			return ArgumentError, "Invalid email format for the passed email:' + email + '.Please check the passed email format."
-		end
+				return email
+			end
 
-		return email
-	end
+			# Normalizes the given gender and returns acceptable hashed gender value
+		    def self.normalize_gender(gender)
 
-		# Normalizes the given gender and returns acceptable hashed gender value
-    def self.normalize_gender(gender)
+				# Replace extra characters with space, to bound under alpha characters set.
+				gender = gender.gsub(/[^a-z]/,'')
 
-      # Replace extra characters with space, to bound under alpha characters set.
-      gender = gender.gsub(/[^a-z]/,'')
+				case gender
+				when 'female' , 'f'
+					gender = 'f'
+				when 'male' , 'm'
+					gender = 'm'
+				else
+					return nil
+				end
 
-			case gender
-			when 'female' , 'f'
-				gender = 'f'
-			when 'male' , 'm'
-				gender = 'm'
-			else
-				return nil
+				return gender
 			end
 
-			return gender
-		end
+			# Normalizes the given phone and returns acceptable hashed phone value
+			def self.normalize_phone(phone)
 
-		# Normalizes the given phone and returns acceptable hashed phone value
-		def self.normalize_phone(phone)
+				# Drop the spaces, hyphen and parenthesis from the Phone Number
+				normalized_phone = phone.gsub(PHONE_NUMBER_IGNORE_CHAR_SET, '')
 
-			# Drop the spaces, hyphen and parenthesis from the Phone Number
-			normalized_phone = phone.gsub(PHONE_NUMBER_IGNORE_CHAR_SET, '')
+				if(is_international_number?(normalized_phone))
+					normalized_phone = normalized_phone.gsub(PHONE_NUMBER_DROP_PREFIX_ZEROS, '')
+				end
 
-			if(FacebookAds::ServerSide::is_international_number?(normalized_phone))
-				normalized_phone = normalized_phone.gsub(PHONE_NUMBER_DROP_PREFIX_ZEROS, '')
-			end
+				if normalized_phone.length < 7 || normalized_phone.length > 15
+					return nil;
+				end
 
-			if normalized_phone.length < 7 || normalized_phone.length > 15
-				return nil;
+				return normalized_phone
 			end
 
-			return normalized_phone
-		end
+			# Normalizes the given state and returns acceptable hashed state value
+			def self.normalize_state(state)
+				state = state.gsub(/[0-9.\s\-()]/,'')
 
-		# Normalizes the given city and returns acceptable hashed city value
-		def self.normalize_state(state)
-			state = state.gsub(/[0-9.\s\-()]/,'')
+				return state
+			end
 
-			return state
-		end
+			# Normalizes the given zip and returns acceptable hashed zip code value
+			def self.normalize_zip(zip)
 
-		# Normalizes the given zip and returns acceptable hashed zip code value
-		def self.normalize_zip(zip)
+				# Remove spaces from the Postal code
+				zip = zip.gsub(/[\s]/,'')
 
-			# Remove spaces from the Postal code
-			zip = zip.gsub(/[\s]/,'')
+				# If the zip code '-', we retain just the first part alone.
+				zip = zip.split('-')[0]
 
-      # If the zip code '-', we retain just the first part alone.
-			zip = zip.split('-')[0]
+				if zip.length < 2
+					return nil
+				end
 
-			if zip.length < 2
-				return nil
+				return zip
 			end
 
-			return zip
-		end
+			# Boolean method which checks if a given number is represented in international format
+			# @param [String] phone_number that has to be tested.
+			# @return [TrueClass | FalseClass] boolean value representing if a number is international
+			def self.is_international_number?(phone_number)
+
+				# Drop upto 2 leading 0s from the number
+				phone_number = phone_number.gsub(PHONE_NUMBER_DROP_PREFIX_ZEROS, '')
 
-    # Boolean method which checks if a given number is represented in international format
-    # @param [String] phone_number that has to be tested.
-		# @return [TrueClass | FalseClass] boolean value representing if a number is international
-		def self.is_international_number?(phone_number)
+				if phone_number.start_with?('0')
+					return false;
+				end
 
-			# Drop upto 2 leading 0s from the number
-			phone_number = phone_number.gsub(PHONE_NUMBER_DROP_PREFIX_ZEROS, '')
+				if phone_number.start_with?('1') && US_PHONE_NUMBER_REGEX.match(phone_number) != nil
+					return false;
+				end
+
+				if INTL_PHONE_NUMBER_REGEX.match(phone_number) != nil
+					return true;
+				end
 
-			if phone_number.start_with?('0')
 				return false;
 			end
 
-			if phone_number.start_with?('1') && US_PHONE_NUMBER_REGEX.match(phone_number) != nil
-				return false;
+			def self.normalize_f5(input)
+				input[0, 5]
 			end
 
-			if INTL_PHONE_NUMBER_REGEX.match(phone_number) != nil
-				return true;
+			def self.normalize_fi(fi)
+				fi[0, 1]
 			end
 
-			return false;
-		end
+			def self.normalize_dobd(dobd)
+				if dobd.length == 1
+					dobd = '0' + dobd
+				end
+
+				dobd_int = dobd.to_i
+				if dobd.length > 2 or dobd_int < 1 or dobd_int > 31
+					raise ArgumentError.new("Invalid dobd format: '#{dobd}'. Please pass in a valid date of birth day in 'DD' format.")
+				end
 
+				return dobd
+			end
+
+			def self.normalize_dobm(dobm)
+				if dobm.length == 1
+					dobm = '0' + dobm
+				end
+
+				dobm_int = dobm.to_i
+				if dobm.length > 2 or dobm_int < 1 or dobm_int > 12
+					raise ArgumentError.new("Invalid dobm format: '#{dobm}'. Please pass in a valid date of birth month in 'MM' format.")
+				end
+
+				return dobm
+			end
+
+			def self.normalize_doby(doby)
+				unless doby.match("^[0-9]{4}$")
+					raise ArgumentError.new("Invalid doby format: '#{doby}'. Please pass in a valid birth year in 'YYYY' format.")
+				end
+				doby
+			end
+		end
 	end
 end