aboutyou-sdk 0.0.1

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

@@ -0,0 +1,110 @@
+module AboutYou
+  module SDK
+    module Model
+      class FacetGroup
+      
+          # @var Facet[] */
+          @facets;
+          attr_accessor :facets
+
+          # @var integer */
+          @id;
+          attr_accessor :id
+
+          # @var string */
+          @name;
+          attr_accessor :name
+          
+          @groupId
+          attr_accessor :groupId
+
+           ###
+           # @param integer $id
+           # @param string  $name
+           ###
+          def initialize(id, name)
+          
+              self.id = id;
+              self.name = name;
+              self.facets = Hash.new
+          end
+
+           ###
+           # @param Facet $facet
+           ###
+          def addFacet(facet)
+          
+              self.facets[facet.id] = facet;
+          end
+
+           ###
+           # @param Facet[] $facet
+           ###
+          def addFacets(facets)
+          
+              facets.each do |facet| 
+                  self.addFacet(facet);
+              end
+          end
+
+
+           ###
+           # Returns all facet names separated with the given parameter
+           # eg. for size with to size facets "36" and "37" -> "36/37"
+           #
+           # @param string $separator
+           #
+           # @return string
+           ###
+          def facetNames(separator = '/')
+          
+              names = Array(nil);
+              self.facets.each do |facet|
+                  names.push(facetname());
+              end
+
+              return name.join(seperator)
+          end
+
+           ###
+           # facet groups are equal, if the ids and all child ids are equal
+           #
+           # @param FacetGroup $facetGroup
+           #
+           # @return boolean
+           ###
+          def isEqual(facetGroup)
+          
+              return false if (self.id != facetGroup.id) 
+
+              return self.uniqueKey() == facetGroup.uniqueKey();
+          end
+
+           ###
+           # @see isEqual
+           #
+           # @return string
+           ###
+          def uniqueKey()
+          
+              facetIds = self.facets.keys
+              facetIds.sort
+
+              return String(self.id) + ':' + String(facetIds.join(','))
+          end
+
+          def ids()
+          
+              return Hash[self.id => self.facets.keys]
+              
+          end
+
+
+          def contains(facet)
+          
+              return self.facets[facet.id].defined?
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+module AboutYou
+  module SDK
+    module Model
+      class FacetGroupSet
+      
+          # @var array */
+          attr_accessor :ids;
+
+          # @var FacetGroup[] */
+          attr_accessor :groups;
+
+          # @var Facet[] */
+          attr_accessor :facets;
+
+          # @var FacetManagerInterface */
+          class << self
+            attr_accessor :facetManager
+          end
+
+           ###
+           # @param array $ids two dimensional array of group ids and array ids
+           #
+           # @throws \InvalidArgumentException
+           ###
+          def initialize(ids)
+              self.facets = Hash.new
+              self.groups = Hash.new
+              ids.each do |facetIds|
+                  if !(facetIds.is_a? Hash)
+                      raise '\InvalidArgumentException! ids must be an associative array of array: [$groupId => [$facetId,...],...]'
+                  end
+              end
+
+              self.ids = ids;
+          end
+
+           ###
+           # @return boolean
+           ###
+          def isEmpty()
+          
+              return self.ids.empty?
+          end
+
+          def genLazyGroups()
+          
+              groups = Hash.new
+              self.ids.each do |groupId, facetIds| 
+                  group = AboutYou::SDK::Model::FacetGroup.new(groupId, nil);
+                  facetIds.each do |facetId|
+                      facet = AboutYou::SDK::Model::Facet.new(facetId, nil, nil, groupId, nil);
+                      group.addFacet(facet);
+                  end
+                  groups[groupId] = group;
+              end
+
+              return groups;
+          end
+
+          def lazyGroups()
+          
+              if !(self.facets.empty?)
+                  return self.groups;
+              else
+                  return self.genLazyGroups();
+              end
+          end
+
+          def fetch()
+          
+              if !(self.facets.empty?) 
+                return;
+              end
+              self.ids.each do |idPair|
+
+                  idPair.each do |groupId, facetIds|
+                      facet = self.class.facetManager.facet(groupId, facetIds);
+
+                      if !(facet)
+                          # TODO: error handling
+                          next
+                      end
+
+                      if (self.groups[groupId]) 
+                          group = self.groups[groupId];
+                      else
+                          group = AboutYou::SDK::Model::FacetGroup.new(groupId, facet.groupName());
+                          self.groups[groupId] = group;
+                      end
+
+                      group.addFacet(facet);
+                      self.facets[facet.uniqueKey] = facet;
+                  end
+              end
+          end
+
+           ###
+           # @return FacetGroup[]
+           ###
+          def groups()
+          
+              if (@groups.empty?)
+                  self.fetch();
+              end
+
+              return(@groups);
+          end
+
+           ###
+           # @param $groupId
+           #
+           # @return FacetGroup|null
+           ###
+          def group(groupId)
+            
+              groups = self.groups();
+              if (groups["groupId"]) 
+                  return groups[groupId];
+              end
+
+              return nil;
+          end
+
+           ###
+           # @param $groupId
+           #
+           # @return bool
+           ###
+          def hasGroup(groupId)
+          
+              return !(self.ids[groupId].empty?);
+          end
+
+
+           ###
+           # @param string $key
+           #
+           # @return Facet|null
+           ###
+          def facetByKey(key)
+          
+              self.fetch();
+
+              self.facets[key] ? self.facets[key] : nil
+          end
+
+          
+          def facet(facetGroupId, facetId)
+
+              if (self.facets.empty?) 
+                  self.fetch();
+              end
+
+              if (self.facets[String(facetGroupId)+':'+String(facetId)])
+                  return(self.facets[String(facetGroupId)+':'+String(facetId)]);
+              end
+          end
+
+#           ###
+#           # set are equal, if all groups are equal
+#           # which means, that all included facet ids per group must be the same
+#           #
+#           # @return string
+#           ###
+#          def uniqueKey()
+#          
+#              ids = self.ids;
+#              asort($ids);
+#              array_walk($ids, 'sort');
+#
+#              return json_encode($ids);
+#          end
+
+           ###
+           # @param FacetUniqueKeyInterface $facetCompable
+           #
+           # @return boolean
+           ###
+          def contains(facetCompable)
+          
+              if (facetCompable.is_a? self.class) 
+                  return self.containsFacetGroupSet(facetCompable);
+              end
+
+#              if (facetCompable.is_a? AboutYou::SDK::Model::FacetGetGroupInterface)
+#                  return $this->containsFacetGetGroupInterface($facetCompable);
+#              }
+
+              return false;
+          end
+
+#          private function containsFacetGetGroupInterface(FacetGetGroupInterface $facet)
+#          {
+#              $myLazyGroups = $this->getLazyGroups();
+#              $id = $facet->getGroupId();
+#
+#              if (isset($myLazyGroups[$id])) {
+#                  return $myLazyGroups[$id]->getUniqueKey() === $facet->getUniqueKey();
+#              }
+#
+#              return false;
+#          }
+
+          def containsFacetGroupSet(facetGroupSet)
+          
+              if (self.uniqueKey() == facetGroupSet.uniqueKey()) 
+                  return true;
+              end
+
+              myLazyGroups = self.lazyGroups();
+              self.facetGroupSet.lazyGroups.each do |id, group|
+                  if ((myLazyGroups["id"]) || myLazyGroups[id].uniqueKey() != group.uniqueKey())
+                      return false;
+                  end
+              end
+
+              return true;
+          end
+
+          def self.mergeFacetIds(facetIdsArray)
+          
+              ids = Array(nil);
+              facetIdsArray.each do |facetIds|
+                  facetIds.each do |groupId,facetIds|
+                      if (ids[Integer(groupId)]) 
+                          ids[Integer(groupId)] = ids[Integer(groupId)] + facetIds;
+                      else 
+                          ids[Integer(groupId)] = facetIds;
+                      end
+                  end
+              end
+
+              return ids;
+          end
+
+           ###
+           # @return array
+           ###
+          def groupIds()
+          
+              return self.ids.keys
+          end
+      
+      end
+    end
+  end
+end

data/lib/aboutyou-sdk/Model/FacetManager/DefaultFacetManager.rb

@@ -0,0 +1,79 @@
+module AboutYou
+  module SDK
+    module Model
+      module FacetManager
+        class DefaultFacetManager
+        
+            DEFAULT_CACHE_DURATION = 7200;
+
+            # @var Facet[][] */
+            @facets
+            attr_accessor :facets
+
+            # @var Cache */
+            @cache;
+            attr_accessor :cache
+            
+            # @var string */
+            @cacheKey;
+            attr_accessor :cacheKey
+
+             ###
+             # @param Cache $cache
+             # @param string $appId
+             ###
+            def initialize(cache = nil, appId = '')
+            
+                self.cache    = cache;
+                self.cacheKey = 'AY:SDK:' + String(appId) + ':facets';
+                self.facets = Hash.new
+
+                self.loadCachedFacets();
+            end
+
+            def loadCachedFacets()
+            
+                if (self.cache) 
+                  self.facets = (self.cache.fetch(self.cacheKey)) ? self.cache.fetch(self.cacheKey): nil;
+                end
+            end
+
+            def cacheFacets()
+            
+                if (self.cache) 
+                    self.cache.save(self.cacheKey, self.facets, DEFAULT_CACHE_DURATION);
+                end
+            end
+
+            def clearCache()
+            
+                if (self.cache)
+                    self.cache.delete(self.cacheKey);
+                end
+            end
+
+            def isEmpty()
+            
+                return (self.facets.empty?);
+            end
+
+            def facets=(facets)
+            
+                @facets = facets;
+                self.cacheFacets();
+            end
+
+             ###
+             # {@inheritdoc}
+             ###
+            def facet(groupId, id)
+            
+                lookupKey = AboutYou::SDK::Model::Facet.new(0, "", [], 0, "").uniqueKey(groupId, id);
+
+                return (self.facets[lookupKey]) ? self.facets[lookupKey] : nil;
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module AboutYou
+  module SDK
+    module Model
+      class Image
+          MIN_WIDTH  = 50;
+          MIN_HEIGHT = 50;
+          MAX_WIDTH  = 1400;
+          MAX_HEIGHT = 2000;
+          
+          @@baseUrl
+          class << self
+          attr_accessor :baseUrl
+          end
+          
+          # @var null|string[] */
+          @additionalItems;
+          attr_accessor :additionalItems
+
+          # @var null|string */
+          @angle;
+          attr_accessor :angle
+
+          # @var null|string */
+          @background;
+          attr_accessor :background
+
+          # @var null|string[] */
+          @color;
+          attr_accessor :color
+
+          # @var null|string */
+          @ext;
+          attr_accessor :ext
+
+          # @var null|string */
+          @gender;
+          attr_accessor :gender
+
+          # @var string */
+          @hash;
+          attr_accessor :hash
+
+          # @var ImageSize */
+          @imageSize;
+          attr_accessor :imageSize
+
+          # @var integer */
+          @fileSize;
+          attr_accessor :fileSize
+
+          # @var null|string */
+          @focus;
+          attr_accessor :focus
+
+          # @var string */
+          @mimeType;
+          attr_accessor :mimeType
+
+          # @var null|\stdClass */
+          @modelData;
+          attr_accessor :modelData
+
+          # @var null|integer */
+          @nextDetailLevel;
+          attr_accessor :nextDetailLevel
+
+          # @var null|string */
+          @preparation;
+          attr_accessor :preparation
+
+          # @var null|array */
+          @tags;
+          attr_accessor :tags
+
+          # @var null|string */
+          @type;
+          attr_accessor :type
+
+          # @var string */
+          @view;
+          attr_accessor :view
+
+
+           ###
+           # @param \stdClass $jsonObject
+           #
+           # @return static
+           ###
+          def self.createFromJson(jsonObject)
+
+              image = self.new
+
+              image.additionalItems = (jsonObject["additional_items"]) ? jsonObject["additional_items"] : nil;
+              image.angle           = (jsonObject["angle"]) ? jsonObject["angle"] : nil;
+              image.background      = (jsonObject["background"]) ? jsonObject["background"] : nil;
+              image.color           = (jsonObject["color"]) ? jsonObject["color"] : nil;
+              image.ext             = (jsonObject["ext"]) ? jsonObject["ext"] : nil;
+              image.fileSize        = (jsonObject["size"]) ? jsonObject["size"] : 0;
+              image.focus           = (jsonObject["focus"]) ? jsonObject["focus"] : nil;
+              image.gender          = (jsonObject["gender"]) ? jsonObject["gender"] : nil;
+              image.hash            = (jsonObject["hash"]) ? jsonObject["hash"] : nil;
+              image.mimeType        = (jsonObject["mime"]) ? jsonObject["mime"] : nil;
+              image.modelData       = (jsonObject["model_data"]) ? jsonObject["model_data"] : nil;
+              image.nextDetailLevel = (jsonObject["next_detail_level"]) ? jsonObject["next_detail_level"] : nil;
+              image.preparation     = (jsonObject["preparation"]) ? jsonObject["preparation"] : nil;
+              image.tags            = (jsonObject["tags"]) ? jsonObject["tags"] : nil;
+              image.type            = (jsonObject["type"]) ? jsonObject["type"] : nil;
+              image.view            = (jsonObject["view"]) ? jsonObject["view"] : nil;
+
+
+              image.imageSize = ImageSize.new(Integer(jsonObject["image"]["width"]), Integer(jsonObject["image"]["height"]));
+
+              return image;
+          end
+
+
+
+           ###
+           # @param int $width
+           # @param int $height
+           #
+           # @return string returns the relative url
+           ###
+          def url(width = 200, height = 200)
+
+              width = [[width, MAX_WIDTH].min, MIN_WIDTH].max;
+              height = [[height, MAX_HEIGHT].min, MIN_HEIGHT].max;
+
+              self.class.baseUrl + '/' + self.hash + '?width=' + String(width) + '&height=' + String(height);
+          end
+      end         
+    end
+  end
+end