Class: Contentstack::Entry

Inherits:
Object
  • Object
show all
Defined in:
lib/contentstack/entry.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attrs, content_type_uid = nil) ⇒ Entry

Returns a new instance of Entry.



6
7
8
 
# File 'lib/contentstack/entry.rb', line 6

def initialize(attrs, content_type_uid=nil)
  setup(attrs, content_type_uid)
end

Instance Attribute Details

#content_type ⇒ Object (readonly)

Returns the value of attribute content_type.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def content_type
  @content_type
end

#fields ⇒ Object (readonly)

Returns the value of attribute fields.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def fields
  @fields
end

#owner ⇒ Object (readonly)

Returns the value of attribute owner.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def owner
  @owner
end

#query ⇒ Object (readonly)

Returns the value of attribute query.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def query
  @query
end

#schema ⇒ Object (readonly)

Returns the value of attribute schema.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def schema
  @schema
end

#uid ⇒ Object (readonly)

Returns the value of attribute uid.



5
6
7
 
# File 'lib/contentstack/entry.rb', line 5

def uid
  @uid
end

Instance Method Details

#except(fields, fields_with_base = nil) ⇒ Contentstack::Entry

Specifies list of field uids that would be ‘excluded’ from the response.

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'])

Parameters:

  • fields (Array) —

    Array of field uid which get ‘excluded’ from the response.

  • fields_with_base (Array) (defaults to: nil) —

    Can be used to denote ‘except’ fields of the reference class

Returns:



70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/contentstack/entry.rb', line 70

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

#fetch ⇒ Contentstack::EntryCollection

Execute entry

Example

@entry = @stack.content_type('product').entry(entry_uid)
@entry.fetch

Returns:



172
173
174
175
176
177
178
 
# File 'lib/contentstack/entry.rb', line 172

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

#get(field_uid) ⇒ Object 



180
181
182
183
 
# File 'lib/contentstack/entry.rb', line 180

def get(field_uid)
  raise Contentstack::Error("Please send a valid Field UID") if field_uid.class != String
  @fields[field_uid.to_sym]
end

#include(field_uids) ⇒ Contentstack::Query

Returns:



157
158
159
160
161
162
 
# File 'lib/contentstack/entry.rb', line 157

def include(field_uids)
  field_uids = [field_uids] if field_uids.class == String
  @query[:include] ||= []
  @query[:include] = @query[:include] | field_uids
  self
end

#include_content_type(flag = true) ⇒ Contentstack::Entry

Include object’s content_type in response

Example

@entry = @stack.content_type('product').entry(entry_uid)
@entry.include_content_type

Returns:



137
138
139
140
 
# File 'lib/contentstack/entry.rb', line 137

def include_content_type(flag=true)
  @query[:include_content_type] = flag
  self
end

#include_fallback(flag = true) ⇒ Contentstack::Entry

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

Returns:



150
151
152
153
 
# File 'lib/contentstack/entry.rb', line 150

def include_fallback(flag=true)
  @query[:include_fallback] = flag
  self
end

#include_owner(flag = true) ⇒ Contentstack::Entry

Include object owner’s profile in the objects data.

Example

@entry = @stack.content_type('product').entry(entry_uid)
@entry.include_owner

Returns:



124
125
126
127
 
# File 'lib/contentstack/entry.rb', line 124

def include_owner(flag=true)
  @query[:include_owner] = flag
  self
end

#include_reference(reference_field_uids) ⇒ Contentstack::Entry

Add a constraint that requires a particular reference key details.

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'])

Parameters:

  • reference_field_uids (String/Array) —

    Pass string or array of reference fields that must be included in the response

Returns:



99
100
101
 
# File 'lib/contentstack/entry.rb', line 99

def include_reference(reference_field_uids)
  self.include(reference_field_uids)
end

#include_schema(flag = true) ⇒ Contentstack::Entry

Include schemas of all returned objects along with objects themselves.

Example

@entry = @stack.content_type('product').entry(entry_uid)
@entry.include_schema

Returns:



111
112
113
114
 
# File 'lib/contentstack/entry.rb', line 111

def include_schema(flag=true)
  @query[:include_schema] = flag
  self
end

#locale(code) ⇒ Contentstack::Entry

Get entries from the specified locale.

Example

@entry = @stack.content_type('category').entry(entry_uid)
@entry.locale('en-us')

Parameters:

  • code (String) —

    The locale code of the entry

Returns:



19
20
21
22
 
# File 'lib/contentstack/entry.rb', line 19

def locale(code)
  @query[:locale] = code
  self
end

#only(fields, fields_with_base = nil) ⇒ Contentstack::Entry

Specifies an array of ‘only’ keys in BASE object that would be ‘included’ in the response.

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'])

Parameters:

  • fields (Array) —

    Array of the ‘only’ reference keys to be included in response.

  • fields_with_base (Array) (defaults to: nil) —

    Can be used to denote ‘only’ fields of the reference class

Returns:



40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/contentstack/entry.rb', line 40

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