aboutyou-sdk 0.0.1

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

@@ -0,0 +1,21 @@
+module AboutYou
+  module SDK
+    module Model
+      class ImageSize
+        # @var integer */
+        @width;
+        attr_accessor :width
+
+        # @var integer */
+        @height;
+        attr_accessor :height
+
+        def initialize(width, height)
+
+            self.width = width;
+            self.height = height;
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module AboutYou
+  module SDK
+    module Model
+      class InitiateOrder
+      
+          attr_accessor :url
+          attr_accessor :userToken
+          attr_accessor :appToken
+          attr_accessor :errorCode
+          attr_accessor :errorMessage
+
+           ###
+           # @param string $url
+           # @param string $userToken
+           # @param string $appToken
+           ###
+          def initialize(url, userToken, appToken)
+          
+              self.url       = url;
+              self.userToken = userToken;
+              self.appToken  = appToken;
+          end
+
+           ###
+           # @param \stdClass $json
+           #
+           # @return static
+           ###
+          def self.createFromJson(jsonObject)
+          
+              order = self.new(
+                  jsonObject["url"],
+                  jsonObject["user_token"],
+                  jsonObject["app_token"]
+              );
+
+              order.parseErrorResult(jsonObject);
+
+              return order;
+          end
+
+          def parseErrorResult(jsonObject)
+          
+              self.errorCode    = (jsonObject.key?("error_code")) ? jsonObject["error_code"] : 0
+              self.errorCode    = (jsonObject.key?("error_message")) ? jsonObject["error_message"] : nil
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module AboutYou
+  module SDK
+    module Model
+      class Order
+      
+          attr_accessor :id
+          attr_accessor :basket;
+
+          def initialize(id, basket)
+          
+              self.id     = id;
+              self.basket = basket;
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,543 @@
+module AboutYou
+  module SDK
+    module Model
+      class Product
+        include AbstractModel
+
+      attr_accessor :id
+      attr_accessor :factory
+      attr_accessor :name
+      attr_accessor :isSale
+      attr_accessor :isActive
+      attr_accessor :descriptionShort
+      attr_accessor :descriptionLong
+      attr_accessor :minPrice
+      attr_accessor :maxPrice
+      attr_accessor :maxSavingsPrice
+      attr_accessor :maxSavings
+      attr_accessor :maxSavingsPercentage
+      attr_accessor :brandId
+      attr_accessor :merchantId
+      attr_accessor :categoryIdPaths
+      attr_accessor :facetIds
+      attr_accessor :defaultImage
+      attr_accessor :defaultVariant
+      attr_accessor :selectedVariant
+      attr_accessor :variants
+      attr_accessor :inactiveVariants
+      attr_accessor :styles
+      attr_accessor :facetGroups
+      attr_accessor :rootCategories
+      attr_accessor :activeRootCategories
+      attr_accessor :leafCategories
+      attr_accessor :activeLeafCategories
+
+       ###
+       # @param $jsonObject
+       # @param ModelFactoryInterface $factory
+       #
+       # @return static
+       #
+       # @throws \Collins\ShopApi\Exception\MalformedJsonException
+       ###
+      def self.createFromJson(jsonObject, factory, appId)
+
+          product = self.new
+          # these are required fields
+          if (!jsonObject["id"] || !jsonObject["name"]) 
+              raise 'MalformedJsonException'
+          end
+          product.factory = factory
+          
+          product.id   = jsonObject["id"]
+          product.name = jsonObject["name"]
+
+          product.isSale           = jsonObject["sale"] ? jsonObject["sale"] : false;
+          product.descriptionShort = jsonObject["description_short"] ? jsonObject["description_short"] : '';
+          product.descriptionLong  = jsonObject["description_long"] ? jsonObject["description_long"] : '';
+          product.isActive         = jsonObject["active"] ? jsonObject["active"] : true;
+          product.brandId          = jsonObject["brand_id"] ? jsonObject["brand_id"] : nil;
+          product.merchantId       = jsonObject["merchant_id"] ? jsonObject["merchant_id"] : nil;
+
+          product.minPrice         = jsonObject["min_price"] ? jsonObject["min_price"] : nil;
+          product.maxPrice         = jsonObject["max_price"] ? jsonObject["max_price"] : nil;
+          product.maxSavingsPrice  = jsonObject["max_savings"] ? jsonObject["max_savings"] : nil;
+          product.maxSavingsPercentage = jsonObject["max_savings_percentage"] ? jsonObject["max_savings_percentage"] : nil;
+
+          product.defaultImage     = jsonObject["default_image"] ? factory.createImage(jsonObject["default_image"]) : nil
+          product.defaultVariant   = jsonObject["default_variant"] ? factory.createVariant(jsonObject["default_variant"], product) : nil;
+          product.variants         = parseVariants(jsonObject, factory, product);
+          product.inactiveVariants = parseVariants(jsonObject, factory, product, 'inactive_variants');
+          product.styles           = parseStyles(jsonObject, factory);
+
+          key = 'categories.' + String(appId)
+          product.categoryIdPaths  = jsonObject[key] ? jsonObject[key] : Array(nil);
+
+          product.facetIds     = product.parseFacetIds(jsonObject);
+
+          return product;
+      end
+
+      def self.parseVariants(jsonObject, factory, product, attributeName = 'variants')
+
+          variants = Array(nil);
+          if (jsonObject[attributeName]) 
+              jsonObject[attributeName].each do |jsonVariant|
+                  variants.push(factory.createVariant(jsonVariant, product))
+              end
+          end
+
+          return variants;
+      end
+
+      def self.parseStyles(jsonObject, factory)
+
+          styles = Array(nil);
+          if (jsonObject["styles"]) 
+              jsonObject["styles"].each do |style|
+                  styles.push(factory.createProduct(style))
+              end
+          end
+
+          return styles;
+      end
+
+      def parseCategoryIdPaths(jsonObject)
+      
+          paths = Array(nil);
+          
+          jsonObject.each do |name, categoryPaths|
+              if (name.index('categories') == 0) 
+                  paths = categoryPaths;
+                  break;
+              end
+          end
+          return paths;
+     end
+
+      def parseFacetIds(jsonObject)
+
+          ids = self.parseFacetIdsInAttributesMerged(jsonObject);
+          if (ids === nil) 
+              ids = self.parseFacetIdsInVariants(jsonObject);
+          end
+          if (ids === nil) 
+              ids = self.parseFacetIdsInBrand(jsonObject);
+          end
+
+          return (ids != nil) ? ids : Array(nil);
+      end
+
+      def parseFacetIdsInAttributesMerged(jsonObject)
+
+          if (!jsonObject["attributes_merged"])
+              return nil
+          end
+
+          parseAttributesJson(jsonObject["attributes_merged"]);
+      end
+
+      def parseAttributesJson(attributesJsonObject)
+      
+          ids = Hash.new
+     
+          attributesJsonObject.each do |group, facetIds|
+              gid = group[11..group.length] # prefix "attributes"
+     
+              # TODO: Remove Workaround for Ticket ???
+              facetIds = Array(facetIds)
+              ids[gid] = facetIds;
+          end
+     
+      return ids;
+      end
+
+      def parseFacetIdsInVariants(jsonObject)
+
+          if (jsonObject["variants"]) 
+              ids = Array(nil);
+              jsonObject["variants"].each do |variant|
+                  ids.push(parseAttributesJson(variant["attributes"]));
+              end
+              ids = AboutYou::SDK::Model::FacetGroupSet.mergeFacetIds(ids);
+
+              return ids;
+          elsif (jsonObject["default_variant"]) 
+              ids = parseAttributesJson(jsonObject["default_variant"]["attributes"]);
+
+              return ids;
+          end
+
+          return nil;
+      end
+
+      def parseFacetIdsInBrand(jsonObject)
+      
+          if (!jsonObject["brand_id"]) 
+              return nil;
+          end
+  
+          Hash['0' => jsonObject["brand_id"]];
+      end
+  
+  
+      def generateFacetGroupSet()
+      
+          if (self.facetIds.empty?) 
+              raise 'ShopApi\Exception\RuntimeException! To use this method, you must add the field ProductFields::ATTRIBUTES_MERGED to the "product search" or "products by ids"'
+          end
+  
+          self.facetGroups = AboutYou::SDK::Model::FacetGroupSet.new(self.facetIds);
+      end
+  
+       ###
+       # @return FacetGroupSet|null
+       ###
+      def facetGroupSet()
+      
+          if (!self.facetGroups)
+              generateFacetGroupSet
+          end
+  
+          self.facetGroups;
+      end
+  
+       ###
+       # Returns the first active category and, if non active, then it return the first category
+       #
+       # @param bool $activeOnly return only categories that are active
+       #
+       # @return Category|null
+       ###
+      def category(active = true)
+      
+          if (self.categoryIdPaths.empty?) 
+              return;
+          end
+    
+          self.leafCategories(active)[0]
+      end
+  
+       ###
+       # @return Category|null
+       ###
+      def categoryWithLongestActivePath()
+      
+          if (self.categoryIdPaths.empty?) 
+              return nil;
+          end
+
+          sortedArray = self.categoryIdPaths
+          sortedArray.sort!{|x,y| y.count <=> x.count}
+          sortedArray.each do |path|
+            if(self.factory.categoryManager.category(path[-1]).isPathActive) 
+              return self.factory.categoryManager.category(path[-1])
+            end
+          end            
+          return nil;
+      end
+  
+       ###
+       # Returns array of categories without subcategories. E.g. of the product is in the category
+       # Damen > Schuhe > Absatzschuhe and Damen > Schuhe > Stiefelleten then
+       # [Absatzschuhe, Stiefelleten] will be returned
+       #
+       # @param bool $activeOnly return only categories that are active
+       #
+       # @return Category[]
+       ###
+      def leafCategories(activeOnly = true)
+      
+          self.fetchAndParseCategories()
+  
+          activeOnly ? self.activeLeafCategories : self.leafCategories
+      end
+  
+      def categories(activeOnly = true)
+      
+          return self.rootCategories(activeOnly);
+      end
+  
+       ###
+       # @param bool $activeOnly  return only active categories
+       #
+       # @return Category[]
+       ###
+      def rootCategories(activeOnly = true)
+     
+          fetchAndParseCategories();
+  
+          activeOnly ? @activeRootCategories : @rootCategories
+      end
+  
+      def fetchAndParseCategories()
+      
+          if (@rootCategories != nil) 
+              return;
+          end
+  
+          self.rootCategories = Array(nil);
+          self.activeRootCategories = Array(nil);
+          self.leafCategories = Array(nil);
+          self.activeLeafCategories = Array(nil);
+  
+          if (self.categoryIdPaths.empty?) 
+              return;
+          end
+  
+          # put all category ids in an array to fetch by ids
+          categoryIds = self.categoryIdPaths.uniq
+  
+          # fetch all necessary categories from API
+          flattenCategories = self.shopApi().fetchCategoriesByIds(categoryIds).categories;
+  
+          flattenCategories.each do |category|
+              parentId = category.parentId
+              if (parentId != nil && flattenCategories[parentId]) 
+                  category.setParent(flattenCategories[parentId], true);
+              end
+          end
+  
+          self.categoryIdPaths.each do |categoryIdPath|
+              rootId = categoryIdPath[0];
+              rootCategory = flattenCategories[rootId];
+              self.rootCategories[rootId] = rootCategory;
+              if (rootCategory.isActive) 
+                  self.activeRootCategories[rootId] = rootCategory;
+              end
+  
+              leafId = categoryIdPath[-1];
+              leafCategory = flattenCategories[leafId];
+              self.leafCategories[leafId] = leafCategory;
+              if (leafCategory.isActive)
+                  self.activeLeafCategories[leafId] = leafCategory;
+              end
+          end
+      end
+  
+  
+       ###
+       # Get facets of given group id.
+       #
+       # @param integer $groupId The group id.
+       #
+       # @return \Collins\ShopApi\Model\Facet[]
+       ###
+      def groupFacets(groupId)
+      
+          group = self.facetGroupSet.group(groupId);
+          if (group)
+              return group.facets;
+          end
+          return Array(nil);
+      end
+  
+       ###
+       # Returns all unique FacetGroups from all Variants
+       #
+       # @param integer $groupId
+       #
+       # @return FacetGroup[]
+       ###
+      def facetGroups(groupId)
+      
+          allGroups = Array(nil);
+          self.variants.each do |variant|
+              groups = variant.facetGroupSet.groups;
+              groups.each do |group|
+                  if (group.id == groupId) 
+                      allGroups[group.uniqueKey] = group;
+                  end
+              end
+          end
+  
+          return allGroups;
+      end
+  
+       ###
+       # Returns all FacetGroups, which matches the current facet group set
+       # for example:
+       # [['color'] => 'rot'] =>
+       #
+       # @param FacetGroupSet $selectedFacetGroupSet
+       #
+       # @return FacetGroup[][]
+       #
+       # @throws \Collins\ShopApi\Exception\RuntimeException
+       ###
+      def selectableFacetGroups(selectedFacetGroupSet)
+      
+          # @var FacetGroup[] $allGroups */
+          allGroups = Array(nil);
+          selectedGroupIds = selectedFacetGroupSet.groupIds();
+  
+          self.variants.each do |variant|
+              facetGroupSet = variant.facetGroupSet();
+              ids = facetGroupSet.groupIds();
+  
+              if (facetGroupSet.contains(selectedFacetGroupSet))
+                  ids.each do |groupId|
+                      if (selectedGroupIds.include?(groupId))
+                        continue;
+                      end
+  
+                      group = facetGroupSet.group(groupId);
+                      if (group == nil) 
+                          raise 'RuntimeException! group for id ' + String(groupId) + ' not found'
+                      end
+                      allGroups[groupId][group.uniqueKey()] = group;
+                  end
+              end
+          end
+  
+          selectedGroupIds.each do |groupId|
+              ids = selectedFacetGroupSet.ids();
+              ids[groupId] = nil
+              myFacetGroupSet = FacetGroupSet.new(ids);
+              self.variants.each do |variant|
+                  facetGroupSet = variant.facetGroupSet();
+                  if (facetGroupSet.contains(myFacetGroupSet)) 
+                      group = facetGroupSet.group(groupId);
+                      allGroups[groupId][group.uniqueKey()] = group;
+                  end
+              end
+          end
+  
+          return allGroups;
+      end
+  
+       ###
+       # Returns all FacetGroups, which matches the current facet group set
+       # for example:
+       # [['color'] => 'rot'] =>
+       #
+       # @param FacetGroupSet $selectedFacetGroupSet
+       #
+       # @return FacetGroup[]
+       ###
+      def excludedFacetGroups(selectedFacetGroupSet)
+      
+          # @var FacetGroup[] $allGroups */
+          allGroups = Array(nil);
+          selectedGroupIds = selectedFacetGroupSet.groupIds();
+  
+          self.variants.each do |variant|
+              facetGroupSet = variant.facetGroupSet();
+              if (!facetGroupSet.contains(selectedFacetGroupSet)) 
+                  continue;
+              end
+  
+              ids = facetGroupSet.groupIds();
+  
+              ids.each do |groupId|
+                  if (selectedGroupIds.include?(groupId))
+                    continue;
+                  end
+  
+                  group  = facetGroupSet.group(groupId);
+                  if (group == nil) 
+                      raise 'RuntimeException! group for id ' + String(groupId) + ' not found'
+                  end
+                  facets = group.facets();
+                  if (facets.empty?)
+                    continue;
+                  end
+  
+                  if (allGroups[groupId]) 
+                      allGroups[groupId] = FacetGroup.new(group.id(), group.name());
+                  end
+                  allGroups[groupId].addFacets(facets);
+              end
+          end
+  
+          return allGroups;
+      end
+  
+  
+       ###
+       # @return \Collins\ShopApi\Model\Facet
+       ###
+      def brand()
+      
+          self.facetGroupSet().facet(AboutYou::SDK::Constants::FACET_BRAND, self.brandId);
+      end
+  
+       ###
+       # Get variant by id.
+       #
+       # @param integer $variantId The variant id.
+       #
+       # @return Variant
+       ###
+      def variantById(variantId)
+
+          self.variants.each do |variant|
+            if (variant.id==variantId)
+              return variant
+            end
+          end
+  
+          return nil;
+      end
+  
+       ###
+       # @param string $ean
+       #
+       # @return Variant[]
+       ###
+      def variantsByEan(ean)
+      
+          variants = Array(nil);
+          self.variants.each do |variant|
+              if (variant.ean == ean) 
+                  variants.push(variant);
+              end
+          end
+  
+          return variants;
+      end
+  
+       ###
+       # This returns the first variant, which matches exactly the given facet group set
+       #
+       # @param FacetGroupSet $facetGroupSet
+       #
+       # @return Variant|null
+       ###
+      def variantByFacets(facetGroupSet)
+      
+          key = facetGroupSet.uniqueKey();
+          self.variants.each do |variant|
+              if (variant.facetGroupSet().uniqueKey() == key) 
+                return variant;
+              end
+          end
+  
+          return nil;
+      end
+      
+  
+       ###
+       # This returns all variants, which matches some of the given facet
+       #
+       # @param $facetId
+       # @param $groupId
+       #
+       # @return Variant[]
+       ###
+      def variantsByFacetId(facetId, groupId)
+      
+          variants = Array(nil);
+          facet = Facet.new(facetId, '', '', groupId, '');
+          self.variants.each do |variant|
+              if (variant.facetGroupSet().contains(facet)) 
+                  variants.push(variant)
+              end
+          end
+  
+          return variants;
+      end
+      end
+    end
+  end
+end