contentstack 0.0.4 → 0.4.0

data/lib/contentstack/client.rb

@@ -1,17 +1,16 @@
 require 'contentstack/api'
 require 'contentstack/content_type'
 require 'contentstack/asset_collection'
-
+require 'contentstack/sync_result'
 module Contentstack
   class Client
     attr_reader :region, :host
-    # Initialize "Built.io Contentstack" Client instance
-    def initialize(api_key, access_token, environment, options={})
+    # Initialize "Contentstack" Client instance
+    def initialize(api_key, delivery_token, environment, options={})
       @region = options[:region].nil? ? Contentstack::Region::US : options[:region]
       @host = options[:host].nil? ? get_default_region_hosts(@region) : options[:host]
-      API.init_api(api_key, access_token, environment,  @host)
+      API.init_api(api_key, delivery_token, environment,  @host)
     end
-
     
     def content_types
       ContentType.all
@@ -29,6 +28,29 @@ module Contentstack
       Asset.new(uid)
     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': '<btlsomething>'})    // For fetching the next batch of entries using pagination token
+    # 
+    #   Stack.sync({'sync_token': '<btlsomething>'})    // 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

data/lib/contentstack/content_type.rb

@@ -44,7 +44,7 @@ module Contentstack
       end
     end
 
-    def self.find_by_uid(uid)
+    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

data/lib/contentstack/entry.rb

@@ -1,13 +1,192 @@
+require 'active_support/core_ext'
+
 module Contentstack
   class Entry
-    attr_reader :fields, :content_type, :uid, :owner
+    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 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])
+      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
 
@@ -22,6 +201,7 @@ module Contentstack
       @content_type = content_type_uid if !content_type_uid.blank?
       @owner        = attrs[:_owner] if attrs[:_owner]
       @uid          = attrs[:uid]
+      @query        = {}
     end
   end
 end

data/lib/contentstack/query.rb

@@ -502,6 +502,33 @@ module Contentstack
       self
     end
 
+
+    # Include the fallback locale publish content, if specified locale content is not publish.
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_fallback
+    #
+    # @return [Contentstack::Query]
+    def include_fallback(flag=true)
+      @query[:include_fallback] = flag
+      self
+    end
+
+    # Include Embedded Objects (Entries and Assets) along with entry/entries details.
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_embedded_items
+    #
+    # @return [Contentstack::Query]
+    def include_embedded_items()
+      @query[:include_embedded_items] = ['BASE']
+      self
+    end
+
     # Include objects in 'Draft' mode in response
     #
     # Example

data/lib/contentstack/sync_result.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext'
+
+module Contentstack
+  class SyncResult
+    attr_reader :items
+    attr_reader :sync_token
+    attr_reader :pagination_token
+    attr_reader :total_count
+    attr_reader :skip
+    attr_reader :limit
+
+    def initialize(sync_result)
+      if sync_result.nil?
+        @items = []
+        @sync_token = nil
+        @pagination_token = nil
+        @total_count = 0
+        @skip = 0
+        @limit = 100
+      else
+        @items = sync_result["items"] || []
+        @sync_token = sync_result["sync_token"] || nil
+        @pagination_token = sync_result["pagination_token"] || nil
+        @total_count = sync_result["total_count"] || 0
+        @skip = sync_result["skip"] || 0
+        @limit = sync_result["limit"] || 100
+      end
+    end
+  end
+end

data/lib/contentstack/version.rb

@@ -1,3 +1,3 @@
 module Contentstack
-  VERSION = "0.0.4"
+  VERSION = "0.4.0"
 end

data/spec/content_type_spec.rb

@@ -3,8 +3,8 @@ require_relative '../lib/contentstack.rb'
 
 describe Contentstack::ContentType do
   let(:client) { create_client }
-  let(:eu_client) { create_client('ACCESS_TOKEN', 'API_KEY', 'STACK_ENV', {region: Contentstack::Region::EU}) }
-  let(:custom_host_client) { create_client('ACCESS_TOKEN', 'API_KEY', 'STACK_ENV', {host: "https://custom-cdn.contentstack.com"}) }
+  let(:eu_client) { create_client('DELIVERY_TOKEN', 'API_KEY', 'STACK_ENV', {region: Contentstack::Region::EU}) }
+  let(:custom_host_client) { create_client('DELIVERY_TOKEN', 'API_KEY', 'STACK_ENV', {host: "https://custom-cdn.contentstack.com"}) }
 
   describe "Fetch data from API" do
     it "has class as Contentstack::ContentType" do
@@ -46,6 +46,11 @@ describe Contentstack::ContentType do
       @data = client.content_types.first
       expect(@data.attributes).not_to be nil
     end
+
+    it "Should get content type from uid" do
+      @data = client.content_type("category").fetch
+      expect(@data.attributes).not_to be nil
+    end
   end
 
   describe "Initialized using class" do

data/spec/contentstack_spec.rb

@@ -3,8 +3,8 @@ require_relative '../lib/contentstack.rb'
 
 describe Contentstack do
   let(:client) { create_client }
-  let(:eu_client) { create_client('ACCESS_TOKEN', 'API_KEY', 'STACK_ENV', {region: Contentstack::Region::EU}) }
-  let(:custom_host_client) { create_client('ACCESS_TOKEN', 'API_KEY', 'STACK_ENV', {host: "https://custom-cdn.contentstack.com"}) }
+  let(:eu_client) { create_client('DELIVERY_TOKEN_TOKEN', 'API_KEY', 'STACK_ENV', {region: Contentstack::Region::EU}) }
+  let(:custom_host_client) { create_client('DELIVERY_TOKEN_TOKEN', 'API_KEY', 'STACK_ENV', {host: "https://custom-cdn.contentstack.com"}) }
 
   it "has a version number" do
     expect(Contentstack::VERSION).not_to be nil

data/spec/entry_spec.rb

@@ -3,6 +3,9 @@ require_relative '../lib/contentstack.rb'
 
 describe Contentstack::Entry do
   let(:client) { create_client }
+  let(:uid) { "blt05056a2f5e0ebf76" }
+  let(:category) {client.content_type("category").entry(uid)}
+  let(:product) {client.content_type("product").entry(uid)}
 
   it "Contentstack::EntryCollection should have Contentstack::Entry instance" do
     data = client.content_type("category").query.fetch
@@ -11,13 +14,81 @@ describe Contentstack::Entry do
   end
 
   it "is an instance of Contentstack::Entry if single entry is fetched" do
-    data = client.content_type("category").entry("blt05056a2f5e0ebf76").fetch
+    data = category.fetch
     expect(data.class).to eq Contentstack::Entry
   end
 
   it 'has a method `get` to get attributes data' do
-    uid = "blt05056a2f5e0ebf76"
-    data = client.content_type("category").entry(uid).fetch
+    data = category.fetch
     expect(data.get('uid')).to eq uid
   end
+
+  it "should set locale the in the request entry" do
+    data = category.locale('en-us')
+    expect(data.query[:locale]).to eq 'en-us'
+  end
+
+  it "should get data using `only` method with string parameter" do
+    data = category.fetch
+    expect(data.fields[:title]).not_to be nil
+    expect(data.fields[:uid]).not_to be nil
+  end
+
+  it "should get data using `only` method with array parameter" do
+    data = category.only(["title"]).fetch
+    expect(data.fields[:title]).not_to be nil
+    expect(data.fields[:uid]).not_to be nil
+  end
+
+  it "should get data using `except` method with string parameter" do
+    data = category.except("category_tags").fetch
+    expect(data.fields[:category_tags]).to be nil
+  end
+
+  it "should get data using `except` method with array parameter" do
+    data = category.except(["description"]).fetch
+    expect(data.fields[:description]).to be nil
+  end
+
+  it "should get data using `only` method for reference fields" do
+    data = product.include_reference('categories').only("categories", ["title", "description"]).fetch
+    expect(data.fields[:categories][0][:title]).to eq "Smartphones"
+  end
+
+  it "should get data using `except` method for reference fields" do
+    data = product.include_reference('categories').except("categories", "title").fetch
+    expect(data.fields[:categories][0][:title]).to eq 'Smartphones'
+  end
+  
+  it "should get data using `include_schema` method" do
+    data = category.include_schema.fetch
+    expect(data.schema).not_to be nil
+  end
+
+  it "should get data using `include_owner` method" do
+    data = product.include_owner.fetch
+    expect(data.fields[:_owner]).not_to be nil
+  end
+
+  it "should get data using `include_owner` method" do
+    data = product.include_fallback.fetch
+    expect(data.fields[:locale]).not_to be nil
+  end
+
+  it "should get data using `include_content_type` method" do
+    data = category.include_content_type.fetch
+    expect(data.content_type).not_to be nil
+  end
+  
+  it "should get data using `include_reference` method" do
+    data = product.include_reference('categories').fetch
+    puts data.get("categories.title")
+    expect(data.fields[:categories][0][:title]).not_to be nil
+  end
+
+  it "should get data using `include_embedded_items` method" do
+    data = product.include_embedded_items().fetch
+    puts data.get("categories.title")
+    expect(data.fields[:categories][0][:title]).not_to be nil
+  end
 end