sunil 0.0.2

data/lib/contentstack/api.rb

@@ -0,0 +1,191 @@
+require 'uri'
+require 'net/http'
+require 'active_support'
+require 'active_support/json'
+require 'open-uri'
+require 'util'
+module Contentstack
+  class API
+    using Utility
+    def self.init_api(api_key, delivery_token, environment, host, branch, live_preview, proxy, retry_options)
+      @host = host
+      @api_version = '/v3'
+      @environment = environment
+      @api_key = api_key
+      @access_token = delivery_token
+      @branch = branch
+      @headers = {environment: @environment}
+      @live_preview = live_preview
+      @proxy_details = proxy
+      @timeout = retry_options["timeout"]
+      @retryDelay = retry_options["retryDelay"]
+      @retryLimit = retry_options["retryLimit"]
+      @errorRetry = retry_options["errorRetry"]
+    end
+
+    def self.live_preview_query(query= {})
+      @live_preview[:content_type_uid] = query[:content_type_uid] || query["content_type_uid"]
+      @live_preview[:live_preview] = query[:live_preview] || query["live_preview"]
+      @live_preview[:entry_uid] = query[:entry_uid] || query["entry_uid"]
+      if @live_preview[:content_type_uid].present? && @live_preview[:entry_uid].present?
+        path = "/content_types/#{@live_preview[:content_type_uid]}/entries/#{@live_preview[:entry_uid]}"
+        @live_preview_response = send_preview_request(path)
+      end 
+    end
+
+    def self.fetch_content_types(uid="")
+      if !uid.nil? && !uid.empty?
+        path = "/content_types/#{uid}"
+      else
+        path = "/content_types"
+      end
+      fetch_retry(path, {})
+    end
+
+    def self.fetch_entries(content_type, query)
+      if  @live_preview[:enable] && @live_preview[:content_type_uid] == content_type
+        path = "/content_types/#{content_type}/entries"
+        send_preview_request(path, query)  
+      else
+        path = "/content_types/#{content_type}/entries"
+        fetch_retry(path, query)
+      end
+    end
+
+    def self.fetch_entry(content_type, entry_uid, query)
+      if  @live_preview[:enable] && @live_preview[:content_type_uid] == content_type
+        path = "/content_types/#{content_type}/entries/#{entry_uid}"
+        send_preview_request(path, query)  
+      else
+        path = "/content_types/#{content_type}/entries/#{entry_uid}"
+        fetch_retry(path, query)
+      end
+    end
+
+    def self.get_assets(asset_uid=nil)
+      path = "/assets"
+      path += "/#{asset_uid}" if !asset_uid.nil?
+      fetch_retry(path)
+    end
+
+    def self.get_sync_items(query)
+      path = "/stacks/sync"
+      fetch_retry(path, query)
+    end
+
+    private
+    def self.fetch_retry(path, query=nil, count=0)
+      response = send_request(path, query)
+      if @errorRetry.include?(response["status_code"].to_i)
+        if count < @retryLimit
+          retryDelay_in_seconds = @retryDelay / 1000 #converting retry_delay from milliseconds into seconds
+          sleep(retryDelay_in_seconds.to_i) #sleep method requires time in seconds as parameter
+          response = fetch_retry(path, query, (count + 1))
+        else
+         raise Contentstack::Error.new(response) #Retry Limit exceeded
+        end  
+      else
+        to_render_content(response)
+      end
+    end
+
+    def self.send_request(path, q=nil)
+      q ||= {}
+
+      q.merge!(@headers)
+
+      query = "?" + q.to_query
+      # puts "Request URL:- #{@host}#{@api_version}#{path}#{query} \n\n"
+      params = {
+        "api_key" =>  @api_key,
+        "access_token"=>  @access_token,
+        "user_agent"=> "ruby-sdk/#{Contentstack::VERSION}",
+        "x-user-agent" => "ruby-sdk/#{Contentstack::VERSION}",
+        "read_timeout" => @timeout
+      }
+      if !@branch.nil? && !@branch.empty?
+        params["branch"] = @branch
+      end
+
+      if @proxy_details.present? && @proxy_details[:url].present? && @proxy_details[:port].present? && @proxy_details[:username].empty? && @proxy_details[:password].empty?
+        params["proxy"] = URI.parse("http://#{@proxy_details[:url]}:#{@proxy_details[:port]}/").to_s
+      end
+
+      if @proxy_details.present? && @proxy_details[:url].present? && @proxy_details[:port].present? && @proxy_details[:username].present? && @proxy_details[:password].present?
+        proxy_uri = URI.parse("http://#{@proxy_details[:url]}:#{@proxy_details[:port]}/").to_s
+        params[:proxy_http_basic_authentication] = [proxy_uri, @proxy_details[:username], @proxy_details[:password]]
+      end
+
+      begin
+        ActiveSupport::JSON.decode(URI.open("#{@host}#{@api_version}#{path}#{query}", params).read)
+      rescue OpenURI::HTTPError => error
+        response = error.io
+        #response.status
+        # => ["503", "Service Unavailable"] 
+        error_response = JSON.parse(response.string)
+        error_status = {"status_code" => response.status[0], "status_message" => response.status[1]}
+        error = error_response.merge(error_status)
+        raise Contentstack::Error.new(error.to_s)
+      end
+    end
+
+    def self.send_preview_request(path, q=nil)
+      q ||= {}
+
+      q.merge!({live_preview: (!@live_preview.key?(:live_preview) ? 'init' : @live_preview[:live_preview]),})
+
+      query = "?" + q.to_query
+      preview_host = @live_preview[:host]
+      params = {
+        "api_key" =>  @api_key,
+        "authorization" => @live_preview[:management_token],
+        "user_agent"=> "ruby-sdk/#{Contentstack::VERSION}",
+        "x-user-agent" => "ruby-sdk/#{Contentstack::VERSION}",
+        "read_timeout" => @timeout
+      }
+      if !@branch.nil? && !@branch.empty?
+        params["branch"] = @branch
+      end
+
+      if @proxy_details.present? && @proxy_details[:url].present? && @proxy_details[:port].present? && @proxy_details[:username].empty? && @proxy_details[:password].empty?
+        params["proxy"] = URI.parse("http://#{@proxy_details[:url]}:#{@proxy_details[:port]}/").to_s
+      end
+
+      if @proxy_details.present? && @proxy_details[:url].present? && @proxy_details[:port].present? && @proxy_details[:username].present? && @proxy_details[:password].present?
+        proxy_uri = URI.parse("http://#{@proxy_details[:url]}:#{@proxy_details[:port]}/").to_s
+        params[:proxy_http_basic_authentication] = [proxy_uri, @proxy_details[:username], @proxy_details[:password]]
+      end
+
+      begin
+        ActiveSupport::JSON.decode(URI.open("#{preview_host}#{@api_version}#{path}#{query}",params).read)
+      rescue OpenURI::HTTPError => error
+        response = error.io
+        #response.status
+        # => ["503", "Service Unavailable"] 
+        error_response = JSON.parse(response.string)
+        error_status = {"status_code" => response.status[0], "status_message" => response.status[1]}
+        error = error_response.merge(error_status)
+        raise Contentstack::Error.new(error.to_s)
+      end
+    end
+
+    def self.to_render_content(resp)
+      if resp.class == Hash
+        if resp.key?('uid') && resp['uid'] == @live_preview[:entry_uid]
+          resp = resp.merge(@live_preview_response)
+        else
+          resp_keys = resp.keys
+            resp_keys.each {|key|
+              resp[key] = to_render_content(resp[key])
+            } 
+        end
+      elsif resp.class == Array
+        resp.each_with_index {|value, index|
+          resp[index] = to_render_content(value)
+        } 
+      end
+      resp
+    end
+    
+  end
+end

data/lib/contentstack/asset.rb

@@ -0,0 +1,69 @@
+require 'util'
+module Contentstack
+
+  # Asset class to fetch file details on Conentstack server.
+  class Asset
+    using Utility
+    attr_reader :uid, :content_type, :filename, :file_size, :tags, :url
+
+    # @!attribute [r] uid
+    #   Contentstack Asset UID for this asset
+
+    # @!attribute [r] content_type
+    #   Content Type for the asset. image/png, image/jpeg, application/pdf, video/mp4 etc.
+
+    # @!attribute [r] filename
+    #   Name of the asset.
+
+    # @!attribute [r] file_size
+    #   Size of the asset.
+
+    # @!attribute [r] tags
+    #   Array of tags assigned to the asset.
+
+    # @!attribute [r] url
+    #   URL to fetch/render the asset
+
+    # Create instance of an Asset. Accepts either a uid of asset (String) or a complete asset JSON
+    # @param [String/Hash] attrs
+    # Usage for String parameter
+    #   @asset = @stack.asset("some_asset_uid")
+    #   @asset.fetch
+    #
+    # Usage for Hash parameter
+    #   @asset = @stack.asset({
+    #     :uid          => "some_asset_uid",
+    #     :content_type => "file_type", # image/png, image/jpeg, application/pdf, video/mp4 etc.
+    #     :filename    => "some_file_name",
+    #     :file_size    => "some_file_size",
+    #     :tags         => ["tag1", "tag2", "tag3"],
+    #     :url          => "file_url"
+    #   })
+    #   @asset.fetch
+    def initialize(attrs)
+      if attrs.class == String
+        @uid = attrs
+      else
+        attrs = attrs.symbolize_keys
+        @uid = attrs[:uid]
+        @content_type = attrs[:content_type]
+        @filename = attrs[:filename]
+        @file_size = attrs[:file_size]
+        @tags = attrs[:tags]
+        @url = attrs[:url]
+      end
+
+      self
+    end
+
+    # Fetch a particular asset using uid.
+    #   @asset = @stack.asset('some_asset_uid')
+    #   @asset.fetch
+    #   puts @asset.url
+    def fetch
+      json = API.get_assets(@uid)
+      # puts "json -- #{json}"
+      self.class.new(json["asset"])
+    end
+  end
+end

data/lib/contentstack/asset_collection.rb

@@ -0,0 +1,28 @@
+require 'contentstack/asset'
+require 'util'
+
+module Contentstack
+  # Asset class to fetch details of files on Conentstack server.
+  class AssetCollection
+    using Utility
+    attr_reader :assets
+
+    def initialize(assets_array=nil)
+      if assets_array.nil?
+        @assets = []
+        return self
+      else
+        @assets = assets_array.collect{|a| Asset.new(a)}
+      end
+    end
+
+    # Fetch assets uploaded to Contentstack
+    #
+    # Example:
+    #    @assets = @stack.assets.fetch
+    def fetch
+      json = API.get_assets
+      self.class.new(json["assets"])
+    end
+  end
+end

data/lib/contentstack/client.rb

@@ -0,0 +1,92 @@
+require 'contentstack/api'
+require 'contentstack/content_type'
+require 'contentstack/asset_collection'
+require 'contentstack/sync_result'
+require 'util'
+require 'contentstack/error'
+module Contentstack
+  class Client
+    using Utility
+    attr_reader :region, :host
+    # Initialize "Contentstack" Client instance
+    def initialize(api_key, delivery_token, environment, options={})
+      raise Contentstack::Error.new("Api Key is not valid") if api_key.class != String
+      raise Contentstack::Error.new("Api Key Field Should not be Empty") if api_key.empty?
+      raise Contentstack::Error.new("Delivery Token is not valid") if delivery_token.class != String
+      raise Contentstack::Error.new("Delivery Token Field Should not be Empty") if delivery_token.empty?
+      raise Contentstack::Error.new("Envirnoment Field is not valid") if environment.class != String
+      raise Contentstack::Error.new("Envirnoment Field Should not be Empty") if environment.empty?
+      @region = options[:region].nil? ? Contentstack::Region::US : options[:region]
+      @host = options[:host].nil? ? get_default_region_hosts(@region) : options[:host]
+      @live_preview = !options.key?(:live_preview) ? {} : options[:live_preview]
+      @branch = options[:branch].nil? ? "" : options[:branch]
+      @proxy_details = options[:proxy].nil? ? "" : options[:proxy]
+      @timeout = options[:timeout].nil? ? 3000 : options[:timeout]
+      @retryDelay = options[:retryDelay].nil? ? 3000 : options[:retryDelay]
+      @retryLimit = options[:retryLimit].nil? ? 5 : options[:retryLimit]
+      @errorRetry = options[:errorRetry].nil? ? [408, 429] : options[:errorRetry]
+      retry_options = {
+        "timeout" =>  @timeout.to_s,
+        "retryDelay"=>  @retryDelay,
+        "retryLimit"=> @retryLimit,
+        "errorRetry" => @errorRetry
+      }
+      raise Contentstack::Error.new("Proxy URL Should not be Empty") if @proxy_details.present? && @proxy_details[:url].empty?
+      raise Contentstack::Error.new("Proxy Port Should not be Empty") if @proxy_details.present? && @proxy_details[:port].empty?
+      API.init_api(api_key, delivery_token, environment,  @host, @branch, @live_preview, @proxy_details, retry_options)
+    end
+    
+    def content_types
+      ContentType.all
+    end
+
+    def content_type(uid)
+      ContentType.new({uid: uid})
+    end
+
+    def assets
+      AssetCollection.new
+    end
+
+    def asset(uid)
+      Asset.new(uid)
+    end
+
+    def live_preview_query(query={})
+      API.live_preview_query(query)
+    end
+    
+    # Syncs your Contentstack data with your app and ensures that the data is always up-to-date by providing delta updates
+    # 
+    #   Stack.sync({'init': true})        // For initializing sync
+    # 
+    #   Stack.sync({'init': true, 'locale': 'en-us'})     //For initializing sync with entries of a specific locale
+    # 
+    #   Stack.sync({'init': true, 'start_date': '2018-10-22'})    //For initializing sync with entries published after a specific date
+    # 
+    #   Stack.sync({'init': true, 'content_type_uid': 'session'})   //For initializing sync with entries of a specific content type
+    # 
+    #   Stack.sync({'init': true, 'type': 'entry_published'})   // Use the type parameter to get a specific type of content.Supports 'asset_published', 'entry_published', 'asset_unpublished', 'entry_unpublished', 'asset_deleted', 'entry_deleted', 'content_type_deleted'.
+    # 
+    #   Stack.sync({'pagination_token': '<pagination>'})    // For fetching the next batch of entries using pagination token
+    # 
+    #   Stack.sync({'sync_token': '<sync>'})    // For performing subsequent sync after initial sync
+    #
+    # @param params [Hash] params is an object that supports ‘locale’, ‘start_date’, ‘content_type_uid’, and ‘type’ queries.
+    def sync(params)
+      sync_result = API.get_sync_items(params)
+      SyncResult.new(sync_result)
+    end
+
+    private
+    def get_default_region_hosts(region='us')
+      case region
+      when "us"
+        host = "https://cdn.contentstack.io"
+      when "eu"
+        host = "https://eu-cdn.contentstack.com"
+      end
+      host
+    end
+  end
+end

data/lib/contentstack/content_type.rb

@@ -0,0 +1,54 @@
+require 'contentstack/query'
+require 'util'
+
+module Contentstack
+  class ContentType
+    using Utility
+    [:title, :uid, :created_at, :updated_at, :attributes].each do |method_name|
+      if [:created_at, :updated_at].include?(method_name)
+        define_method method_name do
+          return Time.parse(@attributes[method_name]) if @attributes[method_name] && !@attributes[method_name].nil?
+        end
+      elsif :attributes == method_name
+        define_method :attributes do
+          {
+            title: self.title,
+            uid: self.uid,
+            created_at: self.created_at,
+            updated_at: self.updated_at,
+            schema: @attributes[:schema]
+          }
+        end 
+      else
+        define_method method_name do
+          return @attributes[method_name]
+        end
+      end
+    end
+
+    def initialize(object)
+      @attributes = object.symbolize_keys
+    end
+
+    def query
+      Query.new(self.uid)
+    end
+
+    def entry(entry_uid)
+      Entry.new({uid: entry_uid}, self.uid)
+    end
+
+
+    def self.all
+      content_types = API.fetch_content_types["content_types"]
+      content_types.map do |content_type|
+        ContentType.new(content_type.inject({}){|clone,(k,v)| clone[k.to_sym] = v; clone})
+      end
+    end
+
+    def fetch
+      content_type = API.fetch_content_types(uid)["content_type"]
+      ContentType.new(content_type.inject({}){|clone,(k,v)| clone[k.to_sym] = v; clone})
+    end
+  end
+end

data/lib/contentstack/entry.rb

@@ -0,0 +1,222 @@
+require 'active_support/core_ext'
+require 'util'
+
+module Contentstack
+  class Entry
+    using Utility
+    attr_reader :fields, :content_type, :uid, :owner, :query, :schema, :content_type
+    def initialize(attrs, content_type_uid=nil)
+      setup(attrs, content_type_uid)
+    end
+
+    # Get entries from the specified locale. 
+    #
+    # @param [String] code The locale code of the entry
+    #
+    # Example
+    #    @entry = @stack.content_type('category').entry(entry_uid)
+    #    @entry.locale('en-us')
+    #
+    # @return [Contentstack::Entry]
+    def locale(code)
+      @query[:locale] = code
+      self
+    end
+
+    # Specifies an array of 'only' keys in BASE object that would be 'included' in the response.
+    #
+    # @param [Array] fields Array of the 'only' reference keys to be included in response.
+    # @param [Array] fields_with_base Can be used to denote 'only' fields of the reference class
+    #
+    # Example
+    #    # Include only title and description field in response
+    #    @entry = @stack.content_type('category').entry(entry_uid)
+    #    @entry.only(['title', 'description'])
+    #
+    #    # Query product and include only the title and description from category reference
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_reference('category')
+    #          .only('category', ['title', 'description'])
+    #
+    # @return [Contentstack::Entry]
+    def only(fields, fields_with_base=nil)
+      q = {}
+      if [Array, String].include?(fields_with_base.class)
+        fields_with_base = [fields_with_base] if fields_with_base.class == String
+        q[fields.to_sym] = fields_with_base
+      else
+        fields = [fields] if fields.class == String
+        q = {BASE: fields}
+      end
+
+      @query[:only] = q
+      self
+    end
+
+    # Specifies list of field uids that would be 'excluded' from the response.
+    #
+    # @param [Array] fields Array of field uid which get 'excluded' from the response.
+    # @param [Array] fields_with_base Can be used to denote 'except' fields of the reference class
+    #
+    # Example
+    #    # Exclude 'description' field in response
+    #    @entry = @stack.content_type('category').entry(entry_uid)
+    #    @entry.except(['description'])
+    #
+    #    # Query product and exclude the 'description' from category reference
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_reference('category')
+    #          .except('category', ['description'])
+    #
+    # @return [Contentstack::Entry]
+    def except(fields, fields_with_base=nil)
+      q = {}
+      if [Array, String].include?(fields_with_base.class)
+        fields_with_base = [fields_with_base] if fields_with_base.class == String
+        q[fields.to_sym] = fields_with_base
+      else
+        fields = [fields] if fields.class == String
+        q = {BASE: fields}
+      end
+
+      @query[:except] = q
+      self
+    end
+
+    # Add a constraint that requires a particular reference key details.
+    #
+    # @param [String/Array] reference_field_uids Pass string or array of reference fields that must be included in the response
+    #
+    # Example
+    #
+    #    # Include reference of 'category'
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_reference('category')
+    #
+    #    # Include reference of 'category' and 'reviews'
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_reference(['category', 'reviews'])
+    #
+    # @return [Contentstack::Entry]
+    def include_reference(reference_field_uids)
+      self.include(reference_field_uids)
+    end
+
+    # Include schemas of all returned objects along with objects themselves.
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_schema
+    #
+    # @return [Contentstack::Entry]
+    def include_schema(flag=true)
+      @query[:include_schema] = flag
+      self
+    end
+
+    # Include object owner's profile in the objects data.
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_owner
+    #
+    # @return [Contentstack::Entry]
+    def include_owner(flag=true)
+      @query[:include_owner] = flag
+      self
+    end
+
+    # Include object's content_type in response
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_content_type
+    #
+    # @return [Contentstack::Entry]
+    def include_content_type(flag=true)
+      @query[:include_content_type] = flag
+      self
+    end
+
+    # Include the fallback locale publish content, if specified locale content is not publish.
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_fallback
+    #
+    # @return [Contentstack::Entry]
+    def include_fallback(flag=true)
+      @query[:include_fallback] = flag
+      self
+    end
+
+    # Include the branch for publish content.
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_branch
+    #
+    # @return [Contentstack::Entry]
+    def include_branch(flag=true)
+      @query[:include_branch] = flag
+      self
+    end
+
+    # Include Embedded Objects (Entries and Assets) along with entry/entries details.
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.include_embedded_items
+    #
+    # @return [Contentstack::Query]
+    def include_embedded_items()
+      @query[:include_embedded_items] = ['BASE']
+      self
+    end
+
+    #
+    # @return [Contentstack::Query]
+    def include(field_uids)
+      field_uids = [field_uids] if field_uids.class == String
+      @query[:include] ||= []
+      @query[:include] = @query[:include] | field_uids
+      self
+    end
+
+    # Execute entry
+    #
+    # Example
+    #
+    #    @entry = @stack.content_type('product').entry(entry_uid)
+    #    @entry.fetch
+    #
+    # @return [Contentstack::EntryCollection]
+    def fetch
+      entry = API.fetch_entry(@content_type, self.fields[:uid], @query)
+      setup(entry["entry"])
+      @schema       = entry["schema"].symbolize_keys if entry["schema"]
+      @content_type = entry["content_type"].symbolize_keys if entry["content_type"]
+      self
+    end
+
+    def get(field_uid)
+      raise Contentstack::Error("Please send a valid Field UID") if field_uid.class != String
+      @fields[field_uid.to_sym]
+    end
+
+    private
+    def setup(attrs, content_type_uid=nil)
+      @fields       = attrs.symbolize_keys
+      @content_type = content_type_uid if !content_type_uid.blank?
+      @owner        = attrs[:_owner] if attrs[:_owner]
+      @uid          = attrs[:uid]
+      @query        = {}
+    end
+  end
+end