contentful-management 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46acf87204ed06a260240bf8d5e8d2c82d10e24b
-  data.tar.gz: a67f9c680391f7c6fe02d8a2c2ec22e0062095ec
+  metadata.gz: fb5ebdbf246240b9eeaf315eb01fd8950cce67a4
+  data.tar.gz: bb20ddab6ba4bd2ee7353e2d9c5eb841027955b3
 SHA512:
-  metadata.gz: 97075bc41a91528d432fdeaa9cae8fa1344223912df5f20d9648e2c76e91d9f463fecd3e73c61a5ad36e9f8718db96c63140ba8c4fcf2405706ab1fdc622a0c4
-  data.tar.gz: 408b3cd6e123d7a2cc7f5cc284a84fed774b57cb84b53e93b1ef6814ff14797d38c3305c41199b0cf56dfe04b20920ff44feef6ceff3d3f54e9af4650cd6bd6f
+  metadata.gz: a365765f6243235b658fc34e692939687e44d7d679fde7c3a93417c64d63bb0421d5fe128d9d5df831d3370d055ae7ff7ca7530892bfdc7962a68d57b1cf1139
+  data.tar.gz: 978075d563968f6cca95c76d0a96ab15fb4068c13e9f7f1f8c395a93ab9ae04103760647ce21c0c4f0aaf672eb7daa1a63699b3bf032b1ff1f53798daabf8b2c

data/.rubocop.yml

@@ -20,7 +20,7 @@ Metrics/LineLength:
   Max: 135
 
 Metrics/ClassLength:
-  Max: 300
+  Max: 350
 
 Style/SignalException:
   EnforcedStyle: 'semantic'

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Master
 
+## 1.9.0
+### Added
+* Added option to disable Content Type caching completely.
+* Added UI Extension Endpoint.
+* Added Space Memberships Endpoint.
+* Added Webhook Calls Endpoint.
+* Added Webhook Health Endpoint.
+* Added Content Type Snapshots Endpoint.
+* Added Organizations Endpoint.
+* Added User Endpoint.
+* Added Personal Access Tokens Endpoint.
+
+### Changed
+* Rewrote HTTP internals in order to allow base-level resources and simplified Client.
+
 ## 1.8.1
 ### Added
 * Added missing validation property for assets [#121](https://github.com/contentful/contentful-management.rb/pull/121)

data/README.md

@@ -8,8 +8,9 @@ Contentful is a content management platform for web applications, mobile apps an
 ## Setup
 
 Add this line to your application's Gemfile:
-
-    gem 'contentful-management'
+```ruby
+gem 'contentful-management'
+```
 
 ## Usage
 
@@ -21,6 +22,8 @@ Some examples can be found in the ```examples/``` directory or you take a look a
 At the beginning the API client instance should be created for each thread that is going to be used in your application:
 
 ```ruby
+require 'contentful/management'
+
 client = Contentful::Management::Client.new('access_token')
 ```
 
@@ -34,7 +37,7 @@ Retrieving all spaces:
 spaces = client.spaces.all
 ```
 
-Retrieving one space by id:
+Retrieving one space by ID:
 
 ```ruby
 blog_space = client.spaces.find('blog_space_id')
@@ -137,7 +140,7 @@ asset.file_with_locales= {'en-US' => en_file, 'pl' => pl_file}
 asset.save
 ```
 
-Process an Asset file after create:
+Process an asset file after create:
 ```ruby
 asset.process_file
 ```
@@ -218,7 +221,7 @@ Finding an upload:
 upload = client.uploads.find('space_id', 'upload_id')
 ```
 
-Deleting an upload
+Deleting an upload:
 
 ```ruby
 upload.destroy
@@ -267,7 +270,7 @@ or
 entries = content_type.entries.all
 ```
 
-Retrieving an entry by id:
+Retrieving an entry by ID:
 
 ```ruby
 entry = blog_space.entries.find('entry_id')
@@ -348,11 +351,11 @@ Checking if the entry is published:
 my_entry.published?
 ```
 
-> Entries created with *empty fields*, will not return those fields in the response. Therefore, Entries that don't have Cache enabled, will need to
-> make an extra request to fetch the Content Type and fill the missing fields.
-> To allow for Content Type Caching:
->   * Enable [Content Type Cache](#content-type-cache) at Client Instantiation time
->   * Query Entries through `space.entries.find` instead of `Entry.find(space_id, entry_id)`
+> Entries created with *empty fields*, will not return those fields in the response. Therefore, entries that don't have cache enabled, will need to
+> make an extra request to fetch the content type and fill the missing fields.
+> To allow for content type caching:
+>   * Enable [content type cache](#content-type-cache) at client instantiation time
+>   * Query entries through `space.entries.find` instead of `Entry.find(space_id, entry_id)`
 
 ### Content Types
 
@@ -368,7 +371,7 @@ Retrieving all published content types from a space:
 blog_post_content_types = blog_space.content_types.all_published
 ```
 
-Retrieving one content type by id from a space:
+Retrieving one content type by ID from a space:
 
 ```ruby
 blog_post_content_type = blog_space.content_types.find(id)
@@ -540,23 +543,26 @@ Retrieving all locales from the space:
 blog_post_locales = blog_space.locales.all
 ```
 
-Retrieving one locale by the locale-id from the space:
+Retrieving one locale by ID from the space:
 
 ```ruby
 blog_post_locale = blog_space.locales.find(locale_id)
 ```
 
-Creating a locale
+Creating a locale:
+
 ```ruby
 blog_space.locales.create(name: 'German', code: 'de-DE')
 ```
 
-Updating a locale
+Updating a locale:
+
 ```ruby
 blog_post_locale.update(name: 'German', code: 'de-DE')
 ```
 
-Destroying a locale
+Destroying a locale:
+
 ```ruby
 blog_post_locale.destroy
 ```
@@ -569,13 +575,14 @@ Retrieving all roles from the space:
 blog_post_roles = blog_space.roles.all
 ```
 
-Retrieving one role by the locale-id from the space:
+Retrieving one role by ID from the space:
 
 ```ruby
 blog_post_role = blog_space.role.find(role_id)
 ```
 
-Creating a role
+Creating a role:
+
 ```ruby
 role_attributes = {
   name: 'My Role',
@@ -611,12 +618,14 @@ role_attributes = {
 blog_space.roles.create(role_attributes)
 ```
 
-Updating a role
+Updating a role:
+
 ```ruby
 blog_post_role.update(name: 'Some Other Role') # Can change any attribute here
 ```
 
-Destroying a role
+Destroying a role:
+
 ```ruby
 blog_post_role.destroy
 ```
@@ -628,13 +637,13 @@ Retrieving all webhooks from the space:
 ```ruby
 webhooks = blog_space.webhooks.all
 ```
-Retrieving one webhook by the webhook-id from the space:
+Retrieving one webhook by ID from the space:
 
 ```ruby
 blog_post_webhook = blog_space.webhooks.find(webhook_id)
 ```
 
-Creating a webhook
+Creating a webhook:
 
 ```ruby
 blog_space.webhooks.create(
@@ -645,19 +654,19 @@ blog_space.webhooks.create(
 )
 ```
 
-Updating a webhook
+Updating a webhook:
 
 ```ruby
 blog_post_webhook.update(url: 'https://www.newlink.com')
 ```
 
-Destroying webhook:
+Destroying a webhook:
 
 ```ruby
 blog_post_webhook.destroy
 ```
 
-Creating a Webhook with Custom Headers and Custom Topics:
+Creating a webhook with custom headers and custom topics:
 
 ```ruby
 blog_space.webhooks.create(
@@ -673,25 +682,163 @@ blog_space.webhooks.create(
 )
 ```
 
-### Api Keys
+#### Webhook Calls
 
-Retrieving all api keys from the space:
+Retrieving all webhook call details from a webhook:
+
+```ruby
+all_call_details = my_webhook.webhook_calls.all
+```
+Retrieving one webhook call detail by ID from a webhook:
+
+```ruby
+call_details = my_webhook.webhook_calls.find(call_id)
+```
+
+#### Webhook Health
+
+Retrieving webhook health details from a webhook:
+
+```ruby
+health_details = my_webhook.webhook_health.find
+```
+
+### Space Memberships
+
+Retrieving all space memberships from the space:
+
+```ruby
+memberships = blog_space.space_memberships.all
+```
+Retrieving one space membership by ID from the space:
+
+```ruby
+blog_post_membership = blog_space.space_memberships.find(membership_id)
+```
+
+Creating a space membership:
+
+```ruby
+blog_space.space_memberships.create(
+  admin: false,
+  roles: [
+    {
+      'sys' => {
+        'type' => 'Link',
+        'linkType' => 'Role',
+        'id' => 'my_role_id'
+      }
+    }
+  ],
+  email: 'foobar@example.com'
+)
+```
+
+Updating a space membership:
+
+```ruby
+blog_post_membership.update(admin: true)
+```
+
+Destroying a space membership:
+
+```ruby
+blog_post_membership.destroy
+```
+
+### Organizations
+
+Retrieving all organization details:
+
+```ruby
+organizations = client.organizations.all
+```
+
+### Users
+
+Retrieving current user details:
+
+```ruby
+user = client.users.me
+```
+
+### UI Extensions
+
+Retrieving all UI extensions from the space:
+
+```ruby
+extensions = blog_space.ui_extensions.all
+```
+Retrieving one UI extension by ID from the space:
+
+```ruby
+blog_post_extension = blog_space.ui_extensions.find(extension_id)
+```
+
+Creating a UI extension:
+
+```ruby
+blog_space.ui_extensions.create(
+  extension: {
+    'name' => 'My extension',
+    'src' => 'https://www.example.com',
+    'fieldTypes' => [{"type": "Symbol"}],
+    'sidebar' => false
+  }
+)
+```
+
+Destroying a UI extension:
+
+```ruby
+blog_post_extension.destroy
+```
+
+### API Keys
+
+Retrieving all API keys from the space:
 
 ```ruby
 blog_post_api_keys = blog_space.api_keys.all
 ```
 
-Retrieving one api key by the api-key-id from the space:
+Retrieving one API key by ID from the space:
 
 ```ruby
 blog_post_api_key = blog_space.api_keys.find(api_key_id)
 ```
 
-Creating an api key
+Creating an API key:
 ```ruby
 blog_space.api_keys.create(name: 'foobar key', description: 'key for foobar mobile app')
 ```
 
+### Personal Access Tokens
+
+Retrieving all personal access tokens:
+
+```ruby
+tokens = client.personal_access_tokens.all
+```
+
+Retrieving one personal access token by ID:
+
+```ruby
+token = client.personal_access_tokens.find(token_id)
+```
+
+Creating a personal access token:
+
+```ruby
+client.personal_access_tokens.create(name: 'foobar key', scopes: ['content_management_manage'])
+```
+
+Revoking a personal access token:
+
+```ruby
+token.revoke
+```
+
 ### Editor Interface
 
 Retrieving editor interface for a content type:
@@ -700,26 +847,40 @@ Retrieving editor interface for a content type:
 blog_post_editor_interface = blog_post_content_type.editor_interface.default
 ```
 
-You can call the EditorInterface API from any level within the Content Model Hierarchy, take into account that you'll need to
-pass the ids of the levels below it.
+You can call the EditorInterface API from any level within the content model hierarchy, take into account that you'll need to
+pass the IDs of the levels below it.
 
 > Hierarchy is as follows:
 > `No Object -> Space -> ContentType -> EditorInterface`
 
-### Snapshots
+### Entry Snapshots
 
-Retrieving all Snapshot for a given Entry:
+Retrieving all snapshots for a given entry:
 
 ```ruby
 snapshots = entry.snapshots.all
 ```
 
-Retrieving a Snapshot for a given Entry:
+Retrieving a snapshot for a given entry:
 
 ```ruby
 snapshot = entry.snapshots.find('some_snapshot_id')
 ```
 
+### Content Type Snapshots
+
+Retrieving all snapshots for a given content type:
+
+```ruby
+snapshots = content_type.snapshots.all
+```
+
+Retrieving a snapshot for a given content type:
+
+```ruby
+snapshot = content_type.snapshots.find('some_snapshot_id')
+```
+
 ### Pagination
 
 ```ruby
@@ -757,33 +918,40 @@ client = Contentful::Management::Client.new('access_token', raise_errors: true)
 
 ### Content Type Cache
 
-This allows for fetching Content Types for your Space at Client instantiation time, which prevents extra requests per Entry.
-To enable this, in your Client instantiation do:
+This allows for fetching content types for your space at client instantiation time, which prevents extra requests per entry.
+To enable this, in your client instantiation do:
 
 ```ruby
 client = Contentful::Management::Client.new(token, dynamic_entries: ['my_space_id'])
 ```
 
-You can enable the Cache for as many Spaces as you want.
+You can enable the cache for as many spaces as you want. If no space is added, content types will be fetched upon space find.
+
+To completely disable this feature, upon client instantiation do:
+
+```ruby
+client = Contentful::Management::Client.new(token, disable_content_type_caching: true)
+```
 
 ### Proxy Support
 
 This allows for using the CMA SDK through a proxy, for this, your proxy must support HTTPS and your server must have a valid signed certificate.
 
-To enable this, in your Client instantiation do:
+To enable this, in your client instantiation do:
+
 
 ```ruby
 PROXY_HOST = 'localhost'
 PROXY_PORT = 8888
 
-# Just Host/Port
+# Just host/port
 client = Contributing::Management::Client.new(
   token,
   proxy_host: PROXY_HOST,
   proxy_port: PROXY_PORT
 )
 
-# With Username/Password
+# With username/password
 client = Contributing::Management::Client.new(
   token,
   proxy_host: PROXY_HOST,
@@ -793,7 +961,7 @@ client = Contributing::Management::Client.new(
 )
 ```
 
-# Rate Limit Management
+# Rate limit management
 
 With the following configuration options you can handle how rate limits are handled within your applications.