contentful-management 0.9.0 → 1.0.0

data/lib/contentful/management/content_type_entry_methods_factory.rb

@@ -1,3 +1,5 @@
+require_relative 'resource_requester'
+
 module Contentful
   module Management
     # Wrapper for Entry manipulation for a specific Content Type
@@ -21,7 +23,7 @@ module Contentful
       #
       # @return [Contentful::Management::Array<Contentful::Management::Entry>]
       def all(params = {})
-        Entry.all(content_type.space.id, params.merge(content_type: content_type.id))
+        Entry.all(content_type.client, content_type.space.id, params.merge(content_type: content_type.id))
       end
 
       # Creates an entry for a content type.
@@ -30,14 +32,18 @@ module Contentful
       #
       # @return [Contentful::Management::Entry]
       def create(attributes)
-        Entry.create(content_type, attributes)
+        attributes[:content_type] = content_type
+        Entry.create(content_type.client, content_type.space.id, attributes)
       end
 
       # Instantiates an empty entry for a content type.
       #
       # @return [Contentful::Management::Entry]
       def new
-        dynamic_entry_class = content_type.client.register_dynamic_entry(content_type.id, DynamicEntry.create(content_type))
+        dynamic_entry_class = content_type.client.register_dynamic_entry(
+          content_type.id,
+          DynamicEntry.create(content_type, content_type.client)
+        )
         dynamic_entry = dynamic_entry_class.new
         dynamic_entry.content_type = content_type
         dynamic_entry

data/lib/contentful/management/dynamic_entry.rb

@@ -19,48 +19,22 @@ module Contentful
       }
 
       # @private
-      def self.create(content_type)
-        unless content_type.is_a? ContentType
-          content_type = ContentType.new(content_type)
-        end
-
-        fields_coercions = Hash[
-          content_type.fields.map do |field|
-            [field.id.to_sym, KNOWN_TYPES[field.type]]
+      def self.define_singleton_properties(entry_class, content_type, client)
+        entry_class.class_eval do
+          define_singleton_method :content_type do
+            content_type
           end
-        ]
 
-        Class.new DynamicEntry do
-          content_type.fields.each do |field|
-            accessor_name = Support.snakify(field.id)
-            define_method accessor_name do
-              fields[field.id.to_sym]
-            end
-            define_method "#{accessor_name}_with_locales" do
-              fields_for_query[field.id.to_sym]
-            end
-            define_method "#{accessor_name}=" do |value|
-              if localized_or_default_locale(field, locale)
-                @fields[locale] ||= {}
-                @fields[locale][field.id.to_sym] = value
-              end
-            end
-            define_method "#{accessor_name}_with_locales=" do |values|
-              values.each do |locale, value|
-                if localized_or_default_locale(field, locale)
-                  @fields[locale] ||= {}
-                  @fields[locale][field.id.to_sym] = value
-                end
-              end
-            end
+          define_singleton_method :client do
+            client
           end
 
           define_singleton_method :fields_coercions do
-            fields_coercions
-          end
-
-          define_singleton_method :content_type do
-            content_type
+            Hash[
+              content_type.fields.map do |field|
+                [field.id.to_sym, KNOWN_TYPES[field.type]]
+              end
+            ]
           end
 
           define_singleton_method :to_s do
@@ -74,8 +48,15 @@ module Contentful
       end
 
       # @private
-      def localized_or_default_locale(field, locale)
-        field.localized || default_locale == locale
+      def self.create(content_type, client)
+        unless content_type.is_a? ContentType
+          content_type = ContentType.new(content_type)
+        end
+
+        Class.new DynamicEntry do
+          DynamicEntry.define_singleton_properties(self, content_type, client)
+          FieldAware.create_fields_for_content_type(self, :class)
+        end
       end
     end
   end

data/lib/contentful/management/entry.rb

@@ -1,7 +1,12 @@
 require_relative 'resource'
+require_relative 'resource_requester'
+require_relative 'client_entry_methods_factory'
 require_relative 'resource/entry_fields'
 require_relative 'resource/fields'
 require_relative 'resource/field_aware'
+require_relative 'resource/all_published'
+require_relative 'resource/archiver'
+require_relative 'resource/publisher'
 
 module Contentful
   module Management
@@ -12,74 +17,26 @@ module Contentful
       include Contentful::Management::Resource::SystemProperties
       include Contentful::Management::Resource::Refresher
       extend Contentful::Management::Resource::EntryFields
+      extend Contentful::Management::Resource::AllPublished
       include Contentful::Management::Resource::Fields
+      include Contentful::Management::Resource::Archiver
+      include Contentful::Management::Resource::Publisher
 
       attr_accessor :content_type
 
-      # Gets a collection of entries.
-      #
-      # @param [String] space_id
-      # @param [Hash] parameters
-      # @see _ For complete option list: http://docs.contentfulcda.apiary.io/#reference/search-parameters
-      # @option parameters [String] 'sys.id' Entry ID
-      # @option parameters [String] :content_type
-      # @option parameters [Integer] :limit
-      # @option parameters [Integer] :skip
-      #
-      # @return [Contentful::Management::Array<Contentful::Management::Entry>]
-      def self.all(space_id, parameters = {})
-        request = Request.new(
-          "/#{space_id}/entries",
-          parameters
-        )
-        response = request.get
-        result = ResourceBuilder.new(response, {}, {})
-        result.run
-      end
-
-      # Gets a collection of published entries.
-      #
-      # @param [String] space_id
-      # @param [Hash] parameters
-      # @see _ For complete option list: http://docs.contentfulcda.apiary.io/#reference/search-parameters
-      # @option parameters [String] 'sys.id' Entry ID
-      # @option parameters [String] :content_type
-      # @option parameters [Integer] :limit
-      # @option parameters [Integer] :skip
-      #
-      # @return [Contentful::Management::Array<Contentful::Management::Entry>]
-      def self.all_published(space_id, parameters = {})
-        request = Request.new(
-          "/#{space_id}/public/entries",
-          parameters
-        )
-        response = request.get
-        result = ResourceBuilder.new(response, {}, {})
-        result.run
+      # @private
+      def self.endpoint
+        'entries'
       end
 
-      # Gets a specific entry.
-      #
-      # @param [String] space_id
-      # @param [String] entry_id
-      #
-      # @return [Contentful::Management::Entry]
-      def self.find(space_id, entry_id)
-        request = Request.new("/#{space_id}/entries/#{entry_id}")
-        response = request.get
-        result = ResourceBuilder.new(response, {}, {})
-        result.run
+      # @private
+      def self.client_association_class
+        ClientEntryMethodsFactory
       end
 
-      # Creates an entry.
-      #
-      # @param [Contentful::Management::ContentType] content_type
-      # @param [Hash] attributes extracted from Content Type fields
-      #
-      # @return [Contentful::Management::Entry]
-      def self.create(content_type, attributes)
-        custom_id = attributes[:id]
-        locale = attributes[:locale]
+      # @private
+      def self.create_attributes(client, attributes)
+        content_type = attributes[:content_type]
         fields_for_create = if attributes[:fields] # create from initialized dynamic entry via save
                               tmp_entry = new
                               tmp_entry.instance_variable_set(:@fields, attributes.delete(:fields) || {})
@@ -88,21 +45,25 @@ module Contentful
                                 tmp_entry.fields_from_attributes(attributes)
                               )
                             else
-                              fields_with_locale content_type, attributes
+                              fields_with_locale content_type, attributes.clone
                             end
 
-        request = Request.new(
-          "/#{content_type.sys[:space].id}/entries/#{custom_id}",
-          { fields: fields_for_create },
-          nil,
-          content_type_id: content_type.id
-        )
-        response = custom_id.nil? ? request.post : request.put
-        result = ResourceBuilder.new(response, {}, {})
-        client.register_dynamic_entry(content_type.id, DynamicEntry.create(content_type))
-        entry = result.run
-        entry.locale = locale if locale
-        entry
+        client.register_dynamic_entry(content_type.id, DynamicEntry.create(content_type, client))
+
+        { fields: fields_for_create }
+      end
+
+      # @private
+      def self.create_headers(_client, attributes)
+        content_type = attributes[:content_type]
+        content_type_id = content_type.respond_to?(:id) ? content_type.id : content_type[:id]
+
+        { content_type_id: content_type_id }
+      end
+
+      # @private
+      def after_create(attributes)
+        self.locale = attributes[:locale] || client.default_locale
       end
 
       # Gets Hash of fields for the current locale
@@ -118,25 +79,6 @@ module Contentful
         default_fields.merge(@fields[requested_locale])
       end
 
-      # Updates an entry.
-      #
-      # @param [Hash] attributes extracted from Content Type fields
-      #
-      # @return [Contentful::Management::Entry]
-      def update(attributes)
-        fields_for_update = Contentful::Management::Support.deep_hash_merge(fields_for_query, fields_from_attributes(attributes))
-
-        request = Request.new(
-          "/#{space.id}/entries/#{id}",
-          { fields: fields_for_update },
-          nil,
-          version: sys[:version]
-        )
-        response = request.put
-        result = ResourceBuilder.new(response, {}, {}).run
-        refresh_data(result)
-      end
-
       # If an entry is a new object gets created in the Contentful, otherwise the existing entry gets updated.
       # @see _ README for details.
       #
@@ -145,99 +87,16 @@ module Contentful
         if id
           update({})
         else
-          new_instance = Contentful::Management::Entry.create(content_type, fields: instance_variable_get(:@fields))
+          new_instance = Contentful::Management::Entry.create(
+            client,
+            content_type.space.id,
+            content_type: content_type,
+            fields: instance_variable_get(:@fields)
+          )
           refresh_data(new_instance)
         end
       end
 
-      # Publishes an entry.
-      #
-      # @return [Contentful::Management::Entry]
-      def publish
-        request = Request.new(
-          "/#{space.id}/entries/#{id}/published",
-          {},
-          nil,
-          version: sys[:version]
-        )
-        response = request.put
-        result = ResourceBuilder.new(response, {}, {}).run
-        refresh_data(result)
-      end
-
-      # Unpublishes an entry.
-      #
-      # @return [Contentful::Management::Entry]
-      def unpublish
-        request = Request.new(
-          "/#{space.id}/entries/#{id}/published",
-          {},
-          nil,
-          version: sys[:version]
-        )
-        response = request.delete
-        result = ResourceBuilder.new(response, {}, {}).run
-        refresh_data(result)
-      end
-
-      # Archives an entry.
-      #
-      # @return [Contentful::Management::Entry]
-      def archive
-        request = Request.new(
-          "/#{space.id}/entries/#{id}/archived",
-          {},
-          nil,
-          version: sys[:version]
-        )
-        response = request.put
-        result = ResourceBuilder.new(response, {}, {}).run
-        refresh_data(result)
-      end
-
-      # Unarchives an entry.
-      #
-      # @return [Contentful::Management::Entry]
-      def unarchive
-        request = Request.new(
-          "/#{space.id}/entries/#{id}/archived",
-          {},
-          nil,
-          version: sys[:version]
-        )
-        response = request.delete
-        result = ResourceBuilder.new(response, {}, {}).run
-        refresh_data(result)
-      end
-
-      # Destroys an entry.
-      #
-      # @return [true, Contentful::Management::Error] success
-      def destroy
-        request = Request.new("/#{space.id}/entries/#{id}")
-        response = request.delete
-        if response.status == :no_content
-          return true
-        else
-          result = ResourceBuilder.new(response, {}, {})
-          result.run
-        end
-      end
-
-      # Checks if an entry is published.
-      #
-      # @return [Boolean]
-      def published?
-        sys[:publishedAt] ? true : false
-      end
-
-      # Checks if an entry is archived.
-      #
-      # @return [Boolean]
-      def archived?
-        sys[:archivedAt] ? true : false
-      end
-
       # Returns the currently supported local.
       #
       # @return [String] current_locale
@@ -272,6 +131,12 @@ module Contentful
         end
       end
 
+      protected
+
+      def query_attributes(attributes)
+        { fields: Contentful::Management::Support.deep_hash_merge(fields_for_query, fields_from_attributes(attributes)) }
+      end
+
       private
 
       def self.parse_attribute_with_field(attribute, field)
@@ -315,7 +180,7 @@ module Contentful
       end
 
       def fetch_content_type
-        @content_type ||= ::Contentful::Management::ContentType.find(space.id, sys[:contentType].id)
+        @content_type ||= ::Contentful::Management::ContentType.find(client, space.id, sys[:contentType].id)
       end
 
       def self.hash_with_link_object(type, attribute)

data/lib/contentful/management/http_client.rb

@@ -9,8 +9,8 @@ module Contentful
       # @param [Hash] headers
       #
       # @return [HTTP::Response]
-      def get_http(url, query, headers = {})
-        HTTP[headers].get(url, params: query)
+      def get_http(url, query, headers = {}, proxy = {})
+        http_send(:get, url, { params: query }, headers, proxy)
       end
 
       # Post Request
@@ -20,8 +20,8 @@ module Contentful
       # @param [Hash] headers
       #
       # @return [HTTP::Response]
-      def post_http(url, params, headers = {})
-        HTTP[headers].post(url, json: params)
+      def post_http(url, params, headers = {}, proxy = {})
+        http_send(:post, url, { json: params }, headers, proxy)
       end
 
       # Delete Request
@@ -31,8 +31,8 @@ module Contentful
       # @param [Hash] headers
       #
       # @return [HTTP::Response]
-      def delete_http(url, params, headers = {})
-        HTTP[headers].delete(url, params: params)
+      def delete_http(url, params, headers = {}, proxy = {})
+        http_send(:delete, url, { params: params }, headers, proxy)
       end
 
       # Put Request
@@ -42,8 +42,41 @@ module Contentful
       # @param [Hash] headers
       #
       # @return [HTTP::Response]
-      def put_http(url, params, headers = {})
-        HTTP[headers].put(url, json: params)
+      def put_http(url, params, headers = {}, proxy = {})
+        http_send(:put, url, { json: params }, headers, proxy)
+      end
+
+      # Proxy Helper
+      #
+      # @param [Symbol] type
+      # @param [String] url
+      # @param [Hash] params
+      # @param [Hash] headers
+      # @param [Hash] proxy
+      #
+      # @return [HTTP::Response]
+      def proxy_send(type, url, params, headers, proxy)
+        HTTP[headers].via(
+          proxy[:host],
+          proxy[:port],
+          proxy[:username],
+          proxy[:password]
+        ).public_send(type, url, params)
+      end
+
+      # HTTP Helper
+      # Abtracts the Proxy/No-Proxy logic
+      #
+      # @param [Symbol] type
+      # @param [String] url
+      # @param [Hash] params
+      # @param [Hash] headers
+      # @param [Hash] proxy
+      #
+      # @return [HTTP::Response]
+      def http_send(type, url, params, headers, proxy)
+        return proxy_send(type, url, params, headers, proxy) unless proxy[:host].nil?
+        HTTP[headers].public_send(type, url, params)
       end
     end
   end