wildcard-pair 0.3.1

data/lib/wildcard-pair/Price.rb

@@ -0,0 +1,44 @@
+
+require_relative 'hash_mappable.rb'
+require 'active_model'
+
+module WildcardPair  
+  class Price
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include WildcardPair::HashMappable
+
+    attr_accessor :price, :currency
+
+    validates :price, presence: true, numericality: {greater_than_or_equal_to: 0}
+ 
+    def initialize(attributes = {})
+
+      #let's set currency to USD by default
+      @currency = "USD"
+
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end 
+    end
+
+    def attributes
+      instance_values
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+
+
+    def to_json(options = {})
+      if self.valid?
+        super(options)
+      else
+        raise "Price is not valid - please remedy the following errors:" << self.errors.messages.to_s
+      end   
+    end 
+
+  end
+end

data/lib/wildcard-pair/Product.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby -wKU
+
+require 'active_model'
+require_relative 'hash_mappable.rb'
+
+module WildcardPair
+  class Product
+
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include WildcardPair::HashMappable
+
+    attr_accessor :name, :merchant, :brand, :description, :gender, :rating, :rating_scale, :rating_count, :sizes, :model, :app_link_ios, :app_link_android
+    attr_reader :colors, :images, :related_items, :referenced_items, :options
+
+    validates :name, presence: true
+    validates :description, presence: true
+    validates :gender, allow_nil: true, inclusion: {in: %w(male female unisex) }
+
+    validate :validateColors
+    validate :validateImages
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      instance_values
+    end
+
+    def metatags=(metatags)
+      if metatags.nil? || !metatags.is_a?(Hash)
+        return
+      end
+
+      #see what you can set based on metatags
+      self.name=metatags['title']
+      self.description=metatags['description']
+      self.images=metatags['image_url']
+      self.app_link_ios=metatags['applink_ios']
+      self.app_link_android=metatags['applink_android']
+    end
+
+    def colors=(colors)
+      @colors ||= Array.new
+
+      if colors.is_a?(Array)
+        colors.each do |color|
+          @colors << map_hash(color, Color.new)
+        end
+      elsif colors.is_a?(Color)
+          @colors << colors
+      else
+        @colors << map_hash(colors, Color.new)
+      end
+    end
+
+    def images=(images)
+      @images ||= Array.new
+
+      if images.is_a?(Array)
+        @images = images
+      else
+        @images << images
+      end
+    end
+
+    def related_items=(related_items)
+      @related_items ||= Array.new
+
+      if related_items.is_a?(Array)
+        @related_items = related_items
+      else
+        @related_items << related_items
+      end
+    end
+
+    def referenced_items=(referenced_items)
+      @referenced_items ||= Array.new
+
+      if referenced_items.is_a?(Array)
+        @referenced_items = referenced_items
+      else
+        @referenced_items << referenced_items
+      end
+    end
+
+    def options=(options)
+      @options ||= Array.new
+
+      if options.is_a?(Array)
+        @options = options
+      else
+        @options << options
+      end
+    end
+
+    def validateColors
+      if (!@colors.nil? && @colors.any?)
+        @colors.each do |color|
+          if (!color.is_a?(Color) || !color.valid?)
+            errors.add(:colors, "At least one of the colors is an invalid color object")
+            return
+          end
+        end
+      end
+    end
+
+    def validateImages
+      if @images.nil? || (@images.is_a?(Array) && !@images.any?)
+        errors.add(:images, 'A product image is required')
+        return
+      end
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+
+    def to_json(options={})
+      if self.valid?
+        super(options)
+      else
+        raise "Product is not valid - please remedy the following errors:" << self.errors.messages.to_s
+      end    
+    end 
+
+  end
+end

data/lib/wildcard-pair/ProductCard.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby -wKU
+
+require 'active_model'
+require_relative 'hash_mappable.rb'
+
+module WildcardPair
+  class ProductCard
+    private
+
+    attr_accessor :offers, :product, :card_type, :pair_version
+
+    public
+
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include WildcardPair::HashMappable
+
+    attr_accessor :web_url
+    attr_reader :offers, :card_type, :pair_version, :product
+
+    validates :web_url, presence: true
+    validate :validateOffers
+    validate :validateProduct
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+
+      @card_type = 'product'
+
+      if !Gem.loaded_specs['wildcard-pair'].nil?
+        @pair_version = Gem.loaded_specs['wildcard-pair'].version.to_s
+      else
+        @pair_version = "unknown"
+      end
+    end
+
+    def attributes
+      instance_values
+    end
+
+    def populate_from_metatags(web_url)
+      @web_url=web_url
+      metatags = WildcardPair::ExtractMetaTags.extract(@web_url)
+
+      ##now that we've extracted metatags, create a Product and Offer object with it
+      self.product=WildcardPair::Product.new metatags: metatags
+      self.offers=WildcardPair::Offer.new metatags: metatags
+    end
+
+    def offers=(offers)
+      @offers ||= Array.new
+
+      if offers.is_a?(Array)
+        offers.each do |offer|
+          @offers << map_hash(offer, Offer.new)
+        end
+      elsif offers.is_a?(Offer)
+          @offers << offers
+      else
+        @offers << map_hash(offers, Offer.new)
+      end
+    end
+
+    def product=(product)
+      @product = map_hash(product, WildcardPair::Product.new)
+    end
+
+    def validateOffers
+      if @offers.nil? || (@offers.is_a?(Array) && !@offers.any?)
+        errors.add(:offers, 'At least one offer is required')
+        return
+      end
+
+      @offers.each do |offer|
+        if !offer.is_a?(Offer)
+          errors.add(:offers, "At least one of the offers is invalid")
+        elsif !offer.valid?
+          offer.errors.each do |error, msg|
+            errors["offer[%s]" % error] = msg
+          end
+        end
+      end
+    end
+
+    def validateProduct
+      if @product.nil? || !@product.is_a?(Product)
+        errors.add(:product, "A product is required")
+        return
+      end
+
+      if !@product.nil?
+        if !@product.valid?
+          @product.errors.each do |error, msg|
+            errors["product[%s]" % error] = msg
+          end
+        end
+      end
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+
+    def to_json(options={})
+      if self.valid?
+        super(options)
+      else
+        raise "Product Card is not valid - please remedy the following errors:" << self.errors.messages.to_s
+      end    
+    end 
+
+  end
+end
+

data/lib/wildcard-pair/ProductSearchCard.rb

@@ -0,0 +1,89 @@
+#ProductCard
+#!/usr/bin/env ruby -wKU
+
+require 'active_model'
+require_relative 'hash_mappable.rb'
+
+module WildcardPair
+  class ProductSearchCard
+
+    private
+
+    attr_accessor :products, :card_type, :pair_version
+
+    public
+
+      include ActiveModel::Validations
+      include ActiveModel::Serializers::JSON
+      include WildcardPair::HashMappable
+
+    attr_accessor :total_results
+
+    attr_reader :products, :card_type, :pair_version
+
+    validates :total_results, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validate :validateSearchResults
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end 
+
+      @card_type = 'product_search'
+      
+      if !Gem.loaded_specs['wildcard-pair'].nil?
+        @pair_version = Gem.loaded_specs['wildcard-pair'].version.to_s
+      else
+        @pair_version = "unknown"
+      end
+    end
+
+    def attributes
+      instance_values
+    end
+
+     def products=(products)
+      @products ||= Array.new
+      
+      if products.is_a?(Array)
+        products.each do |product|
+          @products << map_hash(product, ProductSearchResult.new)
+        end
+      elsif products.is_a?(ProductSearchResult)
+          @products << products
+      else
+        @products << map_hash(products, ProductSearchResult.new)
+      end
+    end
+
+    def validateSearchResults
+      if @products.nil?
+        errors.add(:products, "Products can be empty, but must exist")
+        return
+      end
+
+      @products.each do |product|
+        if (!product.is_a?(ProductSearchResult)  || !product.valid?)
+          errors.add(:products, "One of the products in the search result is invalid")
+          return
+        end
+      end
+
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+    
+    def to_json(options={})
+      if self.valid?
+        super(options)
+      else
+        raise "Product Search Card is not valid - please remedy below errors:" << self.errors.messages.to_s
+      end    
+    end 
+
+  end
+end
+

data/lib/wildcard-pair/ProductSearchResult.rb

@@ -0,0 +1,54 @@
+require 'active_model'
+require_relative 'hash_mappable.rb'
+
+module WildcardPair
+  class ProductSearchResult
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include WildcardPair::HashMappable
+
+    attr_accessor :name, :price, :product_card_address, :image_url
+
+    validates :name, presence: true
+    validates :price, presence: true
+    validates :product_card_address, presence: true
+    validates :image_url, presence: true
+
+    validate :validatePrice
+        
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end 
+    end
+
+    def attributes
+      instance_values
+    end
+
+    def price=(price)
+      @price = map_hash(price, WildcardPair::Price.new)
+    end
+
+    def validatePrice
+      if @price.nil? || !@price.is_a?(Price) || !@price.valid?
+        errors.add(:price, 'Price does not exist or is invalid')
+        return
+      end
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+
+    def to_json(options={})
+      if self.valid?
+        super(options)
+      else
+        raise "ProductSearchResult is not valid - please remedy the following errors:" << self.errors.messages.to_s
+      end   
+    end 
+
+  end
+end

data/lib/wildcard-pair/Rating.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby -wKU
+
+require 'active_model'
+require_relative 'hash_mappable.rb'
+
+module WildcardPair
+  class Rating
+
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include WildcardPair::HashMappable
+
+    # required fields
+    attr_accessor :rating, :minimum_rating, :maximum_rating
+    # optional fields
+    attr_accessor :number_of_ratings
+
+    validates :rating, presence: true, numericality: {greater_than_or_equal_to: 0}
+    validates :minimum_rating, presence: true, numericality: {greater_than_or_equal_to: 0}
+    validates :maximum_rating, presence: true, numericality: {greater_than_or_equal_to: 0}
+    validates :number_of_ratings, allow_nil: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      instance_values
+    end
+
+    #exclude validation fields in the JSON output
+    def as_json(options={})
+      super(options.merge({:except => [:errors, :validation_context]}))
+    end
+
+    def to_json(options={})
+      if self.valid?
+        super(options)
+      else
+        raise "Video is not valid - please remedy the following errors:" << self.errors.messages.to_s
+      end    
+    end 
+
+  end
+end