aboutyou-sdk 0.0.1

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

@@ -0,0 +1,15 @@
+module AboutYou
+  module SDK
+    module Model
+      class CategoriesResult
+        attr_accessor :categories
+        attr_accessor :categoriesNotFound
+
+        def initialize(categoryManager, ids)
+            @ids = ids
+            @categories = categoryManager.categories(ids, AboutYou::SDK::Model::Category::ALL)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module AboutYou
+  module SDK
+    module Model
+      class Category 
+          ALL = false;
+          ACTIVE_ONLY = true;
+
+          # @var integer */
+          @id;
+          attr_accessor :id
+
+          # @var string */
+          @name;
+          attr_accessor :name
+
+          # @var boolean */
+          @isActive;
+          attr_accessor :isActive
+
+          # @var integer */
+          @position;
+          attr_accessor :position
+
+          # @var Category */
+          @parentId;
+          attr_accessor :parentId
+
+          # @var Category[] */
+          @allsubcategories;
+          attr_accessor :allsubcategories
+
+          # @var Category[] */
+          @activesubcategories;
+          attr_accessor :activesubcategories
+
+          # @var integer */
+          @productCount;
+          attr_accessor :productCount
+          
+          @categoryManager
+          attr_accessor :categoryManager
+
+          def initialize()
+          
+              self.allsubcategories = Array(nil);
+              self.activesubcategories = Array(nil);
+          end
+
+           ###
+           # @param object        $jsonObject  json as object tree
+           # @param ModelFactoryInterface $factory
+           # @param Category|null $parent
+           #
+           # @return static
+           ###
+          def self.createFromJson(jsonObject, catManager)
+              category = self.new
+              
+              category.parentId = jsonObject["parent"];
+              category.id       = jsonObject["id"];
+              category.name     = jsonObject["name"];
+              category.isActive = jsonObject["active"];
+              category.position = jsonObject["position"];
+              category.categoryManager = catManager
+              
+              return category;
+          end
+
+          
+           ###
+           # @return boolean
+           ###
+          def isPathActive()
+          
+              parent = self.parent();
+
+              return self.isActive && (parent == nil || parent.isPathActive());
+          end
+
+           
+           ###
+           # @return Category|null
+           ###
+          def parent
+          
+            if (!self.parentId) 
+                return nil;
+            end
+
+            return self.categoryManager.category(self.parentId);
+          end
+
+           ###
+           # @param bool $activeOnly
+           #
+           # @return Category[]
+           ###
+          def subcategories(activeOnly = ACTIVE_ONLY)
+            subcategories = self.categoryManager.subcategories(self.id, activeOnly);
+            if (activeOnly == ALL)
+                return subcategories;
+            end
+            result = Hash.new
+
+            subcategories.each do |key,subcat|
+                if subcat.isActive
+                    result[key] = subcat
+                end
+            end;
+
+            return result
+          end
+
+           ###
+           # @return Category[]
+           ###
+          def breadcrumb()
+              breadcrumb = self.parent() ? self.parent().breadcrumb() : Array(nil);
+              breadcrumb.push(self)
+
+              return breadcrumb;
+          end
+      end
+    end
+  end
+end

data/lib/aboutyou-sdk/Model/CategoryManager/DefaultCategoryManager.rb

@@ -0,0 +1,172 @@
+module AboutYou
+  module SDK
+    module Model
+      module CategoryManager
+        class DefaultCategoryManager
+        
+            DEFAULT_CACHE_DURATION = 7200;
+
+            # @var Category[] */
+            @categories;
+            attr_accessor :categories
+
+            # @var integer[] */
+            @parentChildIds;
+            attr_accessor :parentChildIds
+
+            # @var Cache */
+            @cache;
+            attr_accessor :cache
+
+            @cacheKey;
+            attr_accessor :cacheKey
+
+             ###
+             # @param string $appId  This must set, when you use more then one instances with different apps
+             # @param CacheProvider $cache
+             ###
+            def initialize(cache = nil, appId = '')
+            
+                self.cache    = cache;
+                self.cacheKey = 'AY:SDK:' + String(appId) + ':categories';
+
+                self.loadCachedCategories();
+            end
+
+            def loadCachedCategories()
+            
+                if (self.cache) 
+                    self.categories = self.cache.fetch(self.cacheKey) ? self.cache.fetch(self.cacheKey): nil;
+                end
+            end
+
+            def cacheCategories()
+            
+                if (self.cache) 
+                    self.cache.save(self.cacheKey, self.categories,DEFAULT_CACHE_DURATION);
+                end
+            end
+
+            def clearCache()
+            
+                if (self.cache) 
+                    self.cache.delete(self.cacheKey);
+                end
+            end
+
+             ###
+             # @param \stdObject $jsonObject
+             # @param ModelFactoryInterface $factory
+             #
+             # @return $this
+             ###
+            def parseJson(jsonObject, factory)
+                self.categories = Hash.new
+                self.parentChildIds = jsonObject["parent_child"]
+
+                jsonObject["ids"].each do |id, jsonCategory|
+                    @categories[id] = factory.createCategory(jsonCategory, self);
+                end
+                self.cacheCategories();
+
+                return self
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def isEmpty()
+            
+                return (@categories == nil);
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def categoryTree(activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+            
+                return self.subcategories(0, activeOnly);
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def category(id)
+                if !(self.categories[String(id)])
+                    return nil;
+                end
+
+                return self.categories[String(id)];
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def categories(ids=nil, activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+              if (ids == nil)
+                  return @categories
+                end
+                if !(@categories) 
+                    return Hash.new;
+                end
+                categories = Hash.new
+                ids.each do |id|
+                    if (@categories[id])
+                        category = @categories[id];
+                        if (activeOnly == AboutYou::SDK::Model::Category::ALL || category.isActive)
+                            categories[id] = category;
+                        end
+                    end
+                end
+                return categories;
+            end
+            
+            def allCategories()
+            
+                return self.categories;
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def subcategories(id, activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+                if !(self.parentChildIds.key?(String(id)))
+                    return Array(nil);
+                end
+
+                ids = self.parentChildIds[String(id)];
+                return self.categories(ids, activeOnly);
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def firstCategoryByName(name, activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+            
+                self.categories.each do |category|
+                    if (category.name == name && (activeOnly == AboutYou::SDK::Model::Category::ACTIVE_ONLY || category.isActive))
+                        return category;
+                    end
+                end
+
+                return nil;
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def categoriesByName(name, activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+                
+                resultCategories = Array(nil)
+                self.categories.each do |category|
+                    if(category.name == name && (activeOnly == AboutYou::SDK::Model::Category::ALL || category.isActive))
+                        resultCategories.push(category)
+                    end
+                end
+                return resultCategories;
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+  module AboutYou
+    module SDK
+      module Model
+      class CategoryTree
+        # @var CategoryManagerInterface */
+        attr_accessor :categoryManager;
+
+        def initialize(categoryManager)
+
+            self.categoryManager = categoryManager;
+        end
+
+         ###
+         # @param bool $activeOnly if true, then only active categories will returned, otherwise all categories
+         #
+         # @return array|Category[]
+         ###
+        def categories(activeOnly = AboutYou::SDK::Model::Category::ACTIVE_ONLY)
+
+            return self.categoryManager.categoryTree(activeOnly);
+        end
+
+         ###
+         # Count active root all categories
+         #
+         # {@inheritdoc}
+         ###
+        def count()
+
+            return self.categories(true).count;
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module AboutYou
+  module SDK
+    module Model
+      class Facet
+      
+          @jsonObject
+          attr_accessor :jsonObject
+
+          # @var integer */
+          @id;
+          attr_accessor :id
+
+          # @var string */
+          @name;
+          attr_accessor :name
+
+          # @var string */
+          @value;
+          attr_accessor :value
+
+          # @var integer */
+          @groupId;
+          attr_accessor :groupId
+
+          # @var string */
+          @groupName;
+          attr_accessor :groupName
+
+          # @var array */
+          @options;
+          attr_accessor :options
+
+           ###
+           # @param integer $id
+           # @param string  $name
+           # @param string  $value
+           # @param integer $groupId
+           # @param string  $groupName
+           # @param array   $options
+           ###
+          def initialize(id, name, value, groupId, groupName, options = nil)
+          
+              self.id        = id;
+              self.name        = name;
+              self.value        = value;
+              self.groupId        = groupId;
+              self.groupName        = groupName;
+              self.options        = options;
+          end
+          
+          
+           ###
+           # @param $jsonObject
+           #
+           # @return static
+           ###
+          def self.createFromJson(jsonObject)
+
+            return self.new(
+                jsonObject["facet_id"],
+                jsonObject["name"],
+                (jsonObject["value"]) ? jsonObject["value"] : nil,
+                jsonObject["id"],
+                jsonObject["group_name"],
+                jsonObject["options"] ? jsonObject["options"] : nil
+              )
+          end
+
+
+           ###
+           # a facet is unique with the combination about id and group id
+           #
+           # @return string
+           ###
+          def uniqueKey(groupId = nil, facetId = nil)
+          
+              return String(self.groupId) + ':' + String(self.id) if(groupId == nil && facetId == nil)
+              return String(groupId) + ':' + String(facetId) if(groupId != nil && facetId != nil)
+              return nil
+          end
+          
+
+           ###
+           # Get option value.
+           #
+           # @param string $key The option key.
+           #
+           # @return mixed
+           ###
+          def option(key)
+          
+              if (self.options) 
+                  self.options.each do |option|
+                      if (option["key"] == key) 
+                          return option["value"];
+                      end
+                  end
+              end
+
+              return nil;
+          end
+      end      
+    end
+  end
+end