aboutyou-sdk 0.0.1

data/lib/aboutyou-sdk/Model/Variant.rb

@@ -0,0 +1,255 @@
+module AboutYou
+  module SDK
+    module Model
+      
+      class Variant 
+        include AbstractModel
+        
+          attr_accessor :factory
+          attr_accessor :product
+          attr_accessor :id
+          attr_accessor :images
+          attr_accessor :selectedImage
+          attr_accessor :aboutNumber
+          attr_accessor :facetGroups
+          attr_accessor :ean
+          attr_accessor :isDefault
+          attr_accessor :price
+          attr_accessor :oldPrice
+          attr_accessor :retailPrice
+          attr_accessor :additionalInfo
+          attr_accessor :quantity
+          attr_accessor :facetIds
+          attr_accessor :firstActiveDate
+          attr_accessor :firstSaleDate
+          attr_accessor :createdDate
+          attr_accessor :updatedDate
+          attr_accessor :color
+          attr_accessor :length
+          attr_accessor :seasonCode
+        
+           ###
+           # @param \stdClass $jsonObject
+           # @param ModelFactoryInterface $factory
+           # @param Product $product
+           #
+           # @return static
+           ###
+          def self.createFromJson(jsonObject, factory, product)
+          
+            jsonObj = jsonObject
+            if (!jsonObj["id"]) 
+              raise 'MalformedJsonException'
+            end
+
+            variant = self.new
+            variant.factory    = factory;
+            variant.product    = product;
+            
+            
+            variant.parseImages(jsonObj["images"])
+            #free memory
+            jsonObj["images"] = nil
+            
+            variant.id         = jsonObj["id"]       
+            
+            variant.aboutNumber = (jsonObj["about_number"]) ? jsonObj["about_number"] : nil
+            variant.ean = (jsonObj["ean"]) ? jsonObj["ean"] : nil
+            variant.isDefault = (jsonObj["default"]) ? jsonObj["default"] : nil
+            variant.price = (jsonObj["price"]) ? jsonObj["price"] : nil
+            variant.oldPrice = (jsonObj["old_price"]) ? jsonObj["old_price"] : nil
+            variant.retailPrice = (jsonObj["retail_price"]) ? jsonObj["retail_price"] : nil
+            variant.additionalInfo = (jsonObj["additional_info"]) ? jsonObj["additional_info"] : nil
+            variant.quantity = (jsonObj["quantity"]) ? jsonObj["quantity"] : 0
+            variant.firstActiveDate = (jsonObj["first_active_date"]) ? jsonObj["first_active_date"] : nil
+            variant.firstSaleDate = (jsonObj["first_sale_date"]) ? jsonObj["first_sale_date"] : nil
+            variant.createdDate = (jsonObj["created_date"]) ? jsonObj["created_date"] : nil
+            variant.updatedDate = (jsonObj["updated_date"]) ? jsonObj["updated_date"] : nil
+
+            variant.facetIds = variant.parseFacetIds(jsonObj)
+            variant.color = variant.facetGroup(AboutYou::SDK::Constants::FACET_COLOR, jsonObject)
+            variant.length = variant.facetGroup(AboutYou::SDK::Constants::FACET_LENGTH, jsonObject)
+            variant.seasonCode = variant.facetGroup(AboutYou::SDK::Constants::FACET_SEASON_CODE,jsonObject)
+
+
+            return variant
+          end     
+
+          
+          def parseImages(imageObject)
+            if (!self.images)
+              self.images = Array(nil);
+                if(imageObject)
+                  imageObject.each do |image| 
+                      self.images.push(self.factory.createImage(image))
+                  end  
+                end
+            end
+          end
+          
+           ###
+           # Get image by given hash.
+           #
+           # @param string $hash The image hash.
+           #
+           # @return Image
+           ###
+          def imageByHash(hash)
+          
+              self.images.each do |image|
+                  return image if(image.hash == hash)
+              end
+              nil
+          end
+
+           ###
+           # Select a specific image.
+           #
+           # @param string $hash The image hash or null for default image.
+           #
+           # @return void
+           #
+           # @depracted
+           ###
+          def selectImage(hash=nil)
+              if (hash) 
+                  self.selectedImage = imageByHash(hash);
+              else
+                  self.selectedImage = nil;
+              end
+          end
+
+           ###
+           # Get selected or default image.
+           #
+           # @return Image
+           ###
+          def image
+          
+              if (self.selectedImage) 
+                  return self.selectedImage;
+              elsif (self.images[0])
+                  return self.images[0];
+              end
+              return nil;
+          end
+
+
+          def parseFacetIds(jsonObject)
+          
+              ids = Array(nil)
+              if !(jsonObject["attributes"].empty?) 
+                  jsonObject["attributes"].each do |group, aIds|
+                      gid = group[11..group.length] # rm prefix "attributs_"
+                      ids.push(Hash[gid => aIds]);
+                  end
+              end
+
+              return ids;
+          end
+          
+                
+          def generateFacetGroupSet(jsonObject)
+
+              ids = self.parseFacetIds(jsonObject)
+              self.facetGroups= AboutYou::SDK::Model::FacetGroupSet.new(ids)
+          end
+
+
+           ###
+           # @return FacetGroupSet
+           ###
+          def facetGroupSet(jsonObject)
+          
+            if !(self.facetGroups)
+                  self.generateFacetGroupSet(jsonObject);
+              end
+              return self.facetGroups;
+          end
+
+           ###
+           # @param integer $groupId
+           #
+           # @return FacetGroup|null
+           ###
+          def facetGroup(groupId, jsonObject)
+
+            return self.facetGroupSet(jsonObject).group(groupId);
+          end
+
+           ###
+           # @return FacetGroup|null
+           ###
+          def size()
+          
+               ###
+               # @todo: Instance level caching
+               ###
+              groupId = self.sizeGroupId();
+
+              if !(groupId.empty?)
+                  return self.facetGroup(groupId);
+              end
+          end
+
+           ###
+           # @return integer|null
+           ###
+          def sizeGroupId()
+          
+              keys = Hash.new
+
+              groups = self.facetGroupSet().groups();
+
+              if (groups.is_a? Array)
+                  groups.each do |group|
+                      keys[group.name] = group.groupId();
+                  end
+              end
+
+              sizeRun = self.facetGroup(AboutYou::SDK::Constants::FACET_SIZE_RUN);
+
+              if !(sizeRun.empty?)
+                  sizeRun.facets.each do |facet|
+                      groupName = facet.value();
+                      if (keys.key?(groupName))
+                          return keys[groupName];
+                      end
+                  end
+              end
+              if (keys.key?('size'))
+                  return keys['size'];
+              end
+              if (keys.key?('size_run')) 
+                  return keys['size_run'];
+              end
+
+              return nil;
+          end
+
+           ###
+           # Returns the quantity per pack for this variant.
+           # By default, this returns 1. But some items can have a bigger number.
+           #
+           # @return int quantity per pack
+           ###
+          def quantityPerPack()
+          
+              facetGroup = self.facetGroup(AboutYou::SDK::Constants::FACET_QUANTITY_PER_PACK);
+
+              if !(facetGroup)
+                  return 1;
+              end
+
+              facets = facetGroup.facets();
+
+              if !(facets)
+                  return 1;
+              end
+              
+              return facets[0].value();
+          end
+      end
+    end
+  end
+end

data/lib/aboutyou-sdk/Model/VariantsResult.rb

@@ -0,0 +1,102 @@
+module AboutYou
+  module SDK
+    module Model
+      class VariantsResult
+      
+          # @var Variant[] */
+          attr_accessor :variants
+          # @var array */
+          attr_accessor :errors
+          
+           ###
+           # 
+           # @param \stdClass $jsonObject
+           # @param \Collins\ShopApi\Model\ModelFactoryInterface $factory
+           # @param \Collins\ShopApi\Model\ProductSearchResult $productSearchResult
+           # 
+           # @return static
+           ###
+          def self.create(variants, errors = Array(nil), productSearchResult)
+    
+              variantsResult = self.new   
+              variantsResult.variants = Hash.new
+              variantsResult.errors = errors;
+
+              if (productSearchResult == false || variants.count == 0) 
+                  # no variant was found
+                  return variantsResult;
+              end
+
+              # get products from product-search
+              products = productSearchResult.products();
+              variants.each do |variantId, productId|
+                  if !(products[productId])
+                      # product was not delivered                
+                      variantsResult.errors.push(variantId)
+                      next
+                  end
+
+                  product = products[productId];
+                  variant = product.variantById(variantId);
+
+                  if (variant.is_a? AboutYou::SDK::Model::Variant) 
+                      variantsResult.variants[variantId] = variant;                
+                  end
+              end    
+
+              return variantsResult;
+          end
+
+           ###
+           # @return bool
+           ###
+          def hasVariantsFound()
+          
+              self.variants.count > 0;
+          end
+
+           ###
+           # @return bool
+           ###
+          def hasVariantsNotFound()
+          
+              self.errors.count > 0;
+          end
+
+           ###
+           # @return Variant[]
+           ###
+          def variantsFound()
+          
+              self.variants;
+          end
+          
+
+           ###
+           # @param int $id
+           #
+           #
+           # @return Variant|null
+           ###
+          def variantById(id)
+          
+              result = nil;
+
+              if (self.variants[id]) 
+                  result = self.variants[id];
+              end
+
+              return result;
+          end
+
+           ###
+           # @return int[]
+           ###
+          def variantsNotFound()
+          
+              self.errors;
+          end
+      end
+    end
+  end
+end

data/lib/aboutyou-sdk/Query.rb

@@ -0,0 +1,261 @@
+  require_relative 'QueryBuilder.rb'
+module AboutYou
+  module SDK
+    class Query
+      include AboutYou::SDK::QueryBuilder
+      
+        QUERY_TREE   = 'category_tree';
+        QUERY_FACETS = 'facets';
+
+        attr_accessor :client
+        attr_accessor :query
+        attr_accessor :mapping
+        attr_accessor :factory
+        attr_accessor :ghostQuery
+        attr_accessor :allQuery
+        
+
+         ###
+         # @param ShopApiClient $client
+         # @param ModelFactoryInterface $factory
+         # @param EventDispatcher $eventDispatcher
+         ###
+        def initialize(client, factory)
+            self.client = client
+            self.query=Array(nil)
+            self.ghostQuery = Array(nil)
+            self.allQuery = Array(nil)
+            self.factory=factory
+            self.mapping = Hash[
+            'autocompletion' => 'createAutocomplete',
+            'basket'         => 'createBasket',
+            'category'       => 'createCategoriesResult',
+            'category_tree'  => 'createCategoryTree',
+            'facets'         => 'createFacetsList',
+            'facet'          => 'createFacetList',
+            'facet_types'    => 'createFacetTypes',
+            'products'       => 'createProductsResult',
+            'products_eans'  => 'createProductsEansResult',
+            'product_search' => 'createProductSearchResult',
+            'suggest'        => 'createSuggest',
+            'get_order'      => 'createOrder',
+            'initiate_order' => 'initiateOrder',
+            'child_apps'     => 'createChildApps',
+            'live_variant'   => 'createVariantsResult'
+            ]
+        end
+        
+         ###
+         # @param string $searchword The prefix search word to search for.
+         # @param int    $limit      Maximum number of results.
+         # @param array  $types      Array of types to search for (Constants::TYPE_...).
+         #
+         # @return $this
+         #
+         # @throws \InvalidArgumentException
+         ###
+        def fetchAutocomplete(searchword,limit = nil,types = nil)
+          
+          super(searchword, limit, types);
+
+          self.requireCategoryTree;
+          self.requireFacets;
+
+          return self
+        end
+
+         ###
+         # @param string $sessionId Free to choose ID of the current website visitor.
+         #
+         # @return $this
+         ###
+        def fetchBasket(sessionId)
+       
+          super(sessionId);
+
+          self.requireCategoryTree;
+          self.requireFacets;
+
+          return self
+        end
+
+         ###
+         # @param string[]|int[] $ids
+         # @param array $fields
+         #
+         # @return $this
+         ###
+        def fetchProductsByIds(ids,fields = Array(nil))
+          super(ids, fields);
+          if (AboutYou::SDK::Criteria::ProductFields.requiresCategories(fields)) 
+              self.requireCategoryTree();
+          end
+          if (AboutYou::SDK::Criteria::ProductFields.requiresFacets(fields)) 
+              self.requireFacets();
+          end
+
+          return self;
+        end
+
+         ###
+         # @param string[] $eans
+         # @param array $fields
+         #
+         # @return $this
+         ###
+        def fetchProductsByEans(eans,fields = Array(nil))
+          super(eans, fields);
+
+          if (AboutYou::SDK::Criteria::ProductFields.requiresCategories(fields)) 
+              self.requireCategoryTree();
+          end
+          if (AboutYou::SDK::Criteria::ProductFields.requiresFacets(fields)) 
+              self.requireFacets();
+          end
+
+          return self;
+        end
+
+         ###
+         # @param ProductSearchCriteria $criteria
+         #
+         # @return $this
+         ###
+        def fetchProductSearch(criteria)
+
+          super(criteria);
+
+          if (criteria.requiresCategories()) 
+              self.requireCategoryTree();
+          end
+          if (criteria.requiresFacets()) 
+              self.requireFacets();
+          end
+
+          return self
+        end
+
+        def requireCategoryTree(fetchForced = false)
+          if !(fetchForced || self.factory.categoryManager().isEmpty())
+              return self
+          end
+
+          self.ghostQuery.push(Hash[QUERY_TREE => Hash[
+              'category_tree' => Hash['version' => '2']]])
+
+           return self
+        end
+
+        def requireFacets(fetchForced = false)
+          if !(fetchForced || self.factory.facetManager.isEmpty) 
+              return self;
+          end
+          self.ghostQuery.push(Hash[QUERY_FACETS => Hash[
+              'facets' => Hash.new]])
+
+          return self;
+        end
+        
+         ###
+         # @return string
+         ###
+        def queryString()
+            result = Array(nil)
+            self.ghostQuery.each do |ghostQuery|
+              (ghostQuery.is_a? Hash) ? result.push(ghostQuery[ghostQuery.keys[0]]) : nil 
+            end
+            self.allQuery = result + self.query
+            return (result + self.query).to_json
+        end
+
+
+         ###
+         # request the queries and returns an array of the results
+         #
+         # @return array
+         ###
+        def execute()
+          
+            if (self.query.empty? && self.ghostQuery.empty?) 
+                return Array(nil);
+            end
+            queryString = queryString()
+            result = self.client.request(queryString);
+            parseResult(result, self.query.count > 1)
+        end
+
+         ###
+         # request the current query and returns the first result
+         #
+         # @return mixed
+         ###
+        def executeSingle()
+
+            result = execute();
+            result[-1]
+        end
+        
+        def checkResponse(jsonResponse)
+        
+            if (jsonResponse == false || !(jsonResponse.is_a? Array) || jsonResponse.count != self.allQuery.count)
+            
+                raise 'UnexpectedResultException!'
+            end
+
+ 
+            jsonResponse.each_with_index do |responseObject, index|
+                currentQuery = self.allQuery[index];
+                responseKey  = jsonResponse[index].keys[0];
+                queryKey     = currentQuery.keys[0];
+                if (responseKey != queryKey) 
+                    raise 'UnexpectedResultException!
+                        result ' + String(queryKey) + ' expected, but ' + String(responseKey) + ' given on position ' + String(index) +
+                        ' - query: ' + currentQuery.to_json
+                end
+                
+                if !(self.mapping.has_key?(responseKey)) 
+                    raise 'UnexpectedResultException! internal error, ' + String(responseKey) + ' is unknown result'
+                end
+            end
+        end
+        
+        def parseResult(jsonResponse, isMultiRequest=true)
+         
+            self.checkResponse(jsonResponse)
+            results = Array(nil)
+            queryIds = Array(nil)
+            self.allQuery.each do |query|
+              queryIds.push(query.keys[0])
+            end
+            
+            jsonResponse.each_with_index do |responseObject, index|
+                currentQuery   = self.allQuery[index]
+                resultKey      = responseObject.keys[0]
+                jsonObject     = responseObject[resultKey]
+                queryKey       = currentQuery.keys[0]
+                factory        = self.factory
+                if (jsonObject['error_code'])
+                  result = factory.preHandleError(jsonObject, resultKey, isMultiRequest);
+                  if (result != false) 
+                      results.push(Hash[resultKey=> result])
+                      next
+                  end
+                end
+                query   = currentQuery[queryKey];
+                queryId = queryIds[index];
+                if (queryId == QUERY_FACETS)
+                  factory.updateFacetManager(jsonObject, query);
+                elsif (queryId == QUERY_TREE) 
+                  factory.initializeCategoryManager(jsonObject);
+                else 
+                  method  = self.mapping[resultKey];
+                  result = factory.send(method, jsonObject, query)
+                  results.push(result)
+                end
+            end
+
+            return results;
+        end
+    end
+  end
+end