shutterstock-v2 0.0.1

data/lib/client/image_assets.rb

@@ -0,0 +1,56 @@
+module Shutterstock
+	class ImageAssets < Driver
+    attr_reader :hash, :small_jpg, :medium_jpg, :huge_jpg, :supersize_jpg, :huge_tiff, :supersize_tiff, :vector_eps, :small_thumb, :large_thumb,
+                 :preview, :preview_1000, :preview_1500
+
+		def initialize(params = {})
+      @hash                       = params
+      @small_jpg                  = ImageSizeDetails.new(params["small_jpg"]) if params["small_jpg"]           # (ImageSizeDetails, optional),
+      @medium_jpg                 = ImageSizeDetails.new(params["medium_jpg"]) if params["medium_jpg"]         # (ImageSizeDetails, optional),
+      @huge_jpg                   = ImageSizeDetails.new(params["huge_jpg"]) if params["huge_jpg"]             # (ImageSizeDetails, optional),
+      @supersize_jpg              = ImageSizeDetails.new(params["supersize_jpg"]) if params["supersize_jpg"]   # (ImageSizeDetails, optional),
+      @huge_tiff                  = ImageSizeDetails.new(params["huge_tiff"]) if params["huge_tiff"]           # (ImageSizeDetails, optional),
+      @supersize_tiff             = ImageSizeDetails.new(params["supersize_tiff"]) if params["supersize_tiff"] # (ImageSizeDetails, optional),
+      @vector_eps                 = ImageSizeDetails.new(params["vector_eps"]) if params["vector_eps"]         # (ImageSizeDetails, optional),
+      @small_thumb                = Thumbnail.new(params["small_thumb"]) if params["small_thumb"]              # (Thumbnail, optional),
+      @large_thumb                = Thumbnail.new(params["large_thumb"]) if params["large_thumb"]              # (Thumbnail, optional),
+      @preview                    = Thumbnail.new(params["preview"]) if params["preview"]                      # (Thumbnail, optional),
+      @preview_1000               = Thumbnail.new(params["preview_1000"]) if params["preview_1000"]            # (Thumbnail, optional),
+      @preview_1500               = Thumbnail.new(params["preview_1500"]) if params["preview_1500"]            # (Thumbnail, optional)
+    end
+
+    alias_method :small, :small_jpg
+    alias_method :medium, :medium_jpg
+    alias_method :huge, :huge_jpg
+    alias_method :supersize, :supersize_jpg
+
+    def count
+      @hash.keys.count
+    end
+
+    def largest_preview
+      [preview_1500, preview_1000, preview].compact.first
+    end
+
+    def largest_jpg
+      [supersize_jpg, huge_jpg, medium_jpg, small_jpg].compact.first
+    end
+
+    def largest_tiff
+      [supersize_tiff, huge_tiff].compact.first
+    end
+
+	end
+end
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/client/image_size_details.rb

@@ -0,0 +1,26 @@
+module Shutterstock
+	class ImageSizeDetails < Driver
+    attr_reader :hash, :height, :width, :file_size, :display_name, :dpi, :format, :is_licensable
+
+     # {"display_name":"Huge","dpi":300,"file_size":1103872,"format":"jpg","height":5000,"is_licensable":false,"width":5000}
+
+		def initialize(params = {})
+      @hash                       = params
+      @height                     = params["height"].to_i if params["height"]       # (integer, optional),
+      @width                      = params["width"].to_i if params["width"]         # (integer, optional),
+      @file_size                  = params["file_size"].to_i if params["file_size"] # (integer, optional),
+      @display_name               = params["display_name"]                          # (string, optional),
+      @dpi                        = params["dpi"].to_i if params["dpi"]             # (integer, optional),
+      @format                     = params["format"]                                # (string, optional),
+      @is_licensable              = json_true? params["is_licensable"]              # (boolean, optional)
+    end
+
+    alias_method :name, :display_name
+
+    def licensable?
+      @is_licensable
+    end
+
+
+	end
+end

data/lib/client/images.rb

@@ -0,0 +1,27 @@
+module Shutterstock
+	class Images < Array
+		attr_reader :raw_data, :page, :total_count, :sort_method, :search_id
+		def initialize(raw_data)
+			@raw_data = raw_data
+
+			if raw_data.kind_of? Hash
+				super(@raw_data["data"].map{ |image| Image.new(image) })
+
+				@total_count   = raw_data["total_count"].to_i
+				@page          = raw_data["page"].to_i
+				# @sort_method   = raw_data["sort_method"]
+				@search_id     = raw_data["search_id"]
+			elsif raw_data.kind_of? Array
+				super( @raw_data.map{ |image| Image.new(image) } )
+			end
+
+			self
+		end
+
+    # Fill each image in array
+    def fill
+      self.each {|image| image.fill}
+    end
+
+	end
+end

data/lib/client/license.rb

@@ -0,0 +1,67 @@
+module Shutterstock
+	class License < Driver
+		attr_reader :image_id, :allotment_charge, :price, :download, :error
+
+    include Equalizer.new(:id)
+
+		def initialize(params={})
+			@hash                 = params
+      @image_id             = params["image_id"].to_i                                       # (string),
+      @allotment_charge     = params["allotment_charge"].to_i if params["allotment_charge"] # (integer, optional),
+      @price                = SubscriptionPrice.new(params["price"]) if params["price"]     # (Price, optional): Wholesale price information, (for rev-share partners only),
+      @download             = params["download"]["url"] if params["download"]               # (Url, optional): Information needed to download the image,
+      @error                = params["error"] if params["error"]                            # (string, optional)
+		end
+
+    alias_method :id, :image_id
+
+    # image_id is an array of either
+    #  - integer (which is translated to {image_id: "999"} for call)
+    #  - Image object (which is translated to {image_id: "999"} for call)
+    #  - hash (passed straight through - used when including metadata: {image_id: "999", metadata: {}}
+    def self.license_multiple(subscription_id:, image_id:, format: nil, size: nil, editorial_acknowledgement: nil)
+
+      raise ArgumentError, "format of 'eps' must correspond with size of 'vector'" if format=='eps' and size != 'vector'
+
+      params = {}
+      params[:subscription_id] = subscription_id
+      params[:format] = format if format
+      params[:size] = size if size
+
+      resp = client.request do |r|
+        r.path            "/v2/images/licenses?subscription_id=#{subscription_id}"
+        r.method          :post
+        r.params          params
+        r.body            ({images: image_ids_to_array_of_hash(image_id, editorial_acknowledgement)})
+      end
+      Licenses.new(resp.body)
+    end
+
+
+		def self.license(subscription_id:, image_id:, format: nil, size: nil, editorial_acknowledgement: nil)
+      return license_multiple(subscription_id: subscription_id, image_id: [image_id], format: format, size: size, editorial_acknowledgement: editorial_acknowledgement).first
+    end
+
+
+    private
+
+    # for post request
+    # image_id from [1,Image.new("id" => 2), {"image_id" => 3, "metadata": {}}] => [{image_id: "1"},{image_id: "2"},{image_id: "3", metadata: {}}]
+    def self.image_ids_to_array_of_hash(image_ids, editorial_acknowledgement)
+      Array(image_ids).map do |iid|
+        hash = case iid
+                when Image
+                  hash = { "image_id" => iid.id.to_s }
+                when Integer
+                  { "image_id" => iid.to_s }
+                when Hash
+                  iid
+                end
+        hash["editorial_acknowledgement"] = true if editorial_acknowledgement
+        hash
+      end
+    end
+
+
+	end
+end

data/lib/client/licenses.rb

@@ -0,0 +1,23 @@
+module Shutterstock
+	class Licenses < Array
+		attr_reader :raw_data, :total_count, :page, :per_page, :message, :errors
+		def initialize(raw_data)
+			@raw_data = raw_data
+
+			if raw_data.kind_of? Hash
+				super(@raw_data["data"].map{ |license| License.new(license) })
+
+        @total_count   = raw_data["total_count"].to_i
+        @page          = raw_data["page"].to_i
+        @per_page          = raw_data["per_page"].to_i
+        @message     = raw_data["message"]
+        @errors     = raw_data["errors"]
+
+			elsif raw_data.kind_of? Array
+				super( @raw_data.map{ |license| License.new(license) } )
+			end
+
+			self
+		end
+	end
+end

data/lib/client/model.rb

@@ -0,0 +1,15 @@
+module Shutterstock
+	class Model < Driver
+		attr_reader :id
+
+    include Equalizer.new(:id)
+
+		def initialize(params={})
+			@hash         = params
+			@id           = params["id"].to_i
+		end
+
+    # TODO API calls
+
+	end
+end

data/lib/client/models.rb

@@ -0,0 +1,11 @@
+module Shutterstock
+	class Models < Array
+		attr_reader :raw_data
+		def initialize(raw_data)
+			@raw_data = raw_data
+  		super( @raw_data.map{ |model| Model.new(model) } )
+			self
+		end
+
+	end
+end

data/lib/client/request.rb

@@ -0,0 +1,41 @@
+module Shutterstock
+  class Request
+
+    attr_writer   :method,          # :post, :get etc
+                  :path,            # request path /v2/images
+                  :success_status,  # response code signifying success. Defaults to 200
+                  :send_authorization, # default true. Set to false when requesting credentials
+                  :content_type,    # default 'application/json'
+                  :body,            # hash of parameters for request body (usually for :post)
+                  :params           # hash of parameters for url params section (usually for :get or :delete)
+
+    def initialize(&block)
+      @success_status = 200
+      @send_authorization = true
+      @content_type = 'application/json'
+
+      # Handle both forms of config:
+      # Request.new { |r| r.method=... }
+      # Request.new { method=... }
+      if block_given?
+        if block.arity == 1
+          yield self
+        else
+          instance_eval(&block)
+
+        end
+      end
+    end
+
+    # DSL
+    %w[method path success_status params body options send_authorization content_type].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(new_value = nil)
+          @#{method} = new_value unless new_value.nil?
+          @#{method}
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/client/subscription.rb

@@ -0,0 +1,35 @@
+require 'date'
+
+module Shutterstock
+	class Subscription < Driver
+		attr_reader :id, :description, :expiration_time, :price_per_download, :license, :allotment, :formats, :metadata
+
+    include Equalizer.new(:id)
+
+		def initialize(params={})
+			@hash                   = params
+      @id                     = params["id"]                                                          # (string),
+      @description            = params["description"] if params["description"]                        # (string, optional),
+      @expiration_time        = to_date params["expiration_time"] if params["expiration_time"]        # (string, optional),
+      @price_per_download     = SubscriptionPrice.new(params["price_per_download"]) if params["price_per_download"]     # (Price, optional),
+      @license                = params["license"] if params["license"]                                # (string, optional),
+      @allotment              = SubscriptionAllotment.new(params["allotment"]) if params["allotment"] # (Allotment, optional),
+      @formats                = SubscriptionLicenseFormats.new(params["formats"]) if params["formats"] # (LicenseFormat[], optional),
+      @metadata               = params["metadata"] if params["metadata"]                              # (SubscriptionMetadata, optional)
+		end
+
+    def expired?
+      @expiration_time<DateTime.now
+    end
+
+    # True if this subscription can handle the size passed eg "small"
+    def allows_image_size_download?(size)
+      !!(!expired? && formats.find {|format| format.size == size})
+    end
+
+    def has_downloads_left?
+      allotment && allotment.has_downloads_left?
+    end
+
+  end
+end

data/lib/client/subscription_allotment.rb

@@ -0,0 +1,19 @@
+module Shutterstock
+	class SubscriptionAllotment < Driver
+		attr_reader :downloads_left, :downloads_limit, :start_time, :end_time
+
+		def initialize(params={})
+			@hash                   = params
+
+      @downloads_left         = params["downloads_left"].to_i if params["downloads_left"]             # (integer, optional),
+      @downloads_limit        = params["downloads_limit"].to_i if params["downloads_limit"]           # (integer, optional),
+      @start_time             = to_date params["start_time"] if params["start_time"]                  # (string, optional),
+      @end_time               = to_date params["end_time"] if params["end_time"]                      # (string, optional)
+		end
+
+    def has_downloads_left?
+      @downloads_left>0
+    end
+
+  end
+end

data/lib/client/subscription_license_format.rb

@@ -0,0 +1,16 @@
+module Shutterstock
+	class SubscriptionLicenseFormat < Driver
+		attr_reader :description, :min_resolution, :media_type, :format, :size
+
+		def initialize(params={})
+			@hash                   = params
+
+      @description            = params["description"] if params["description"]                        # (string, optional),
+      @min_resolution         = params["min_resolution"].to_i if params["min_resolution"]             # (integer, optional),
+      @media_type             = params["media_type"] if params["media_type"]                          # (string, optional),
+      @format                 = params["format"] if params["format"]                                  # (string, optional),
+      @size                   = params["size"] if params["size"]                                      # (string, optional)
+		end
+
+  end
+end

data/lib/client/subscription_license_formats.rb

@@ -0,0 +1,12 @@
+module Shutterstock
+	class SubscriptionLicenseFormats < Array
+		attr_reader :raw_data
+		def initialize(raw_data)
+			@raw_data = raw_data
+
+      super( @raw_data.map{ |slf| SubscriptionLicenseFormat.new(slf) } )
+
+			self
+		end
+	end
+end

data/lib/client/subscription_price.rb

@@ -0,0 +1,13 @@
+module Shutterstock
+	class SubscriptionPrice < Driver
+		attr_reader :local_amount, :local_currency
+
+		def initialize(params={})
+			@hash                   = params
+
+      @local_amount           = params["local_amount"].to_f if params["local_amount"]                 # (number, optional),
+      @local_currency         = params["local_currency"] if params["local_currency"]                  # (string, optional)
+		end
+
+  end
+end

data/lib/client/subscriptions.rb

@@ -0,0 +1,37 @@
+module Shutterstock
+  class Subscriptions < Array
+    attr_reader :raw_data, :page, :total_count, :sort_method, :search_id
+    def initialize(raw_data)
+      @raw_data = raw_data
+
+      if raw_data.kind_of? Hash
+        super(@raw_data["data"].map{ |subscription| Subscription.new(subscription) })
+
+        @total_count   = raw_data["total_count"].to_i
+        @page          = raw_data["page"].to_i
+      elsif raw_data.kind_of? Array
+        super( @raw_data.map{ |subscription| Subscription.new(subscription) } )
+      end
+
+      self
+    end
+
+    def find_subscription_for_image_size(size = nil)
+      size = "huge" if !size
+      self.active.select{|sub| sub.has_downloads_left? && sub.allows_image_size_download?(size)}.first
+    end
+
+    def downloads_left
+      self.select{|sub| sub.has_downloads_left?}
+    end
+
+    def expired
+      self.select{|sub| sub.expired?}
+    end
+
+    def active
+      self.reject{|sub| sub.expired?}
+    end
+
+  end
+end

data/lib/client/thumbnail.rb

@@ -0,0 +1,17 @@
+module Shutterstock
+	class Thumbnail < Driver
+    attr_reader :hash, :url, :height, :width
+
+    include Equalizer.new(:url)
+
+     # {"display_name":"Huge","dpi":300,"file_size":1103872,"format":"jpg","height":5000,"is_licensable":false,"width":5000}
+
+		def initialize(params = {})
+      @hash                       = params
+      @url                        = params["url"]         # (string),
+      @height                     = params["height"].to_i # (integer),
+      @width                      = params["width"].to_i  # (integer)
+    end
+
+	end
+end

data/lib/client/user.rb

@@ -0,0 +1,68 @@
+module Shutterstock
+	class User < Driver
+		attr_reader :id, :contributor_id, :customer_id, :email, :first_name, :full_name, :id, :last_name, :language,
+                :organization_id, :username, :is_premier, :is_premier_parent, :premier_permissions, :only_sensitive_use,
+                :only_enhanced_license
+
+    include Equalizer.new(:id)
+
+		def initialize(params={})
+			@hash                   = params
+      @contributor_id         = params["contributor_id"] if params["contributor_id"]                  # (string, optional),
+      @customer_id            = params["customer_id"] if params["customer_id"]                        # (string, optional),
+      @email                  = params["email"] if params["email"]                                    # (string, optional),
+      @first_name             = params["first_name"] if params["first_name"]                          # (string, optional),
+      @full_name              = params["full_name"] if params["full_name"]                            # (string, optional),
+      @id                     = params["id"] if params["id"]                                          # (string, optional),
+      @last_name              = params["last_name"] if params["last_name"]                            # (string, optional),
+      @language               = params["language"] if params["language"]                              # (string, optional),
+      @organization_id        = params["organization_id"] if params["organization_id"]                # (string, optional),
+      @username               = params["username"] if params["username"]                              # (string, optional),
+      @is_premier             = json_true? params["is_premier"] if params["is_premier"]               # (boolean, optional),
+      @is_premier_parent      = json_true? params["is_premier_parent"] if params["is_premier_parent"] # (boolean, optional),
+      @premier_permissions    = params["premier_permissions"] if params["premier_permissions"]        # (string[], optional),
+      @only_sensitive_use     = json_true? params["only_sensitive_use"] if params["only_sensitive_use"]          # (boolean, optional),
+      @only_enhanced_license  = json_true? params["only_enhanced_license"] if params["only_enhanced_license"]    # (boolean, optional)
+		end
+
+    # boolean readers
+    def premier?
+      @is_premier
+    end
+
+    # boolean readers
+    def premier_parent?
+      @is_premier_parent
+    end
+
+    # boolean readers
+    def sensitive_use?
+      @only_sensitive_use
+    end
+
+    # boolean readers
+    def enhanced_license?
+      @only_enhanced_license
+    end
+
+
+    # Currently logged in user
+		def self.find
+      resp = client.request do
+        path            "/v2/user"
+        method          :get
+      end
+      User.new(resp.body)
+		end
+
+    # Subscriptions for current user
+    def self.subscriptions
+      resp = client.request do |r|
+        r.path            "/v2/user/subscriptions"
+        r.method          :get
+      end
+      Subscriptions.new(resp.body)
+    end
+
+  end
+end