contentful-management 0.0.1.pre

data/lib/contentful/management/client.rb

@@ -0,0 +1,160 @@
+# -*- encoding: utf-8 -*-
+require 'contentful/management'
+require 'contentful/management/response'
+require 'contentful/management/resource_builder'
+
+require 'contentful/management/version'
+require 'contentful/management/http_client'
+
+require_relative 'request'
+require 'http'
+require 'json'
+
+module Contentful
+  module Management
+    class Client
+      extend Contentful::Management::HTTPClient
+
+      attr_reader :access_token, :configuration
+      attr_accessor :organization_id, :version, :zero_length, :content_type_id, :dynamic_entry_cache
+
+      DEFAULT_CONFIGURATION = {
+          api_url: 'api.contentful.com',
+          api_version: '1',
+          secure: true,
+          default_locale: 'en-US',
+      }
+
+      def initialize(access_token = nil, configuration = {})
+        @configuration = default_configuration.merge(configuration)
+        @access_token = access_token
+        @dynamic_entry_cache = {}
+        Thread.current[:client] = self
+      end
+
+
+      def update_dynamic_entry_cache_for_spaces!(spaces)
+        spaces.each do |space|
+          update_dynamic_entry_cache_for_space!(space)
+        end
+      end
+
+      # Use this method together with the client's :dynamic_entries configuration.
+      # See README for details.
+      def update_dynamic_entry_cache_for_space!(space)
+        update_dynamic_entry_cache!(space.content_types)
+      end
+
+      def update_dynamic_entry_cache!(content_types)
+        @dynamic_entry_cache = Hash[
+            content_types.map do |ct|
+              [
+                  ct.id.to_sym,
+                  DynamicEntry.create(ct)
+              ]
+            end
+        ]
+      end
+
+      def api_version
+        configuration[:api_version]
+      end
+
+      def default_configuration
+        DEFAULT_CONFIGURATION.dup
+      end
+
+      def register_dynamic_entry(key, klass)
+        @dynamic_entry_cache[key.to_sym] = klass
+      end
+
+      def execute_request(request)
+        request_url = request.url
+        url = request.absolute? ? request_url : base_url + request_url
+        raw_response = yield(url)
+        Response.new(raw_response, request)
+      end
+
+      def delete(request)
+        execute_request(request) do |url|
+          self.class.delete_http(url, {}, request_headers)
+        end
+      end
+
+      def get(request)
+        execute_request(request) do |url|
+          self.class.get_http(url, {}, request_headers)
+        end
+      end
+
+      def post(request)
+        execute_request(request) do |url|
+          self.class.post_http(url, request.query, request_headers)
+        end
+      end
+
+      def put(request)
+        execute_request(request) do |url|
+          self.class.put_http(url, request.query, request_headers)
+        end
+      end
+
+      def base_url
+        "#{ protocol }://#{ configuration[:api_url]}/spaces"
+      end
+
+      def default_locale
+        configuration[:default_locale]
+      end
+
+      def protocol
+        configuration[:secure] ? 'https' : 'http'
+      end
+
+      def authentication_header
+        Hash['Authorization', "Bearer #{ access_token }"]
+      end
+
+      def api_version_header
+        Hash['Content-Type', "application/vnd.contentful.management.v#{ api_version }+json"]
+      end
+
+      def user_agent
+        Hash['User-Agent', "RubyContenfulManagementGem/#{ Contentful::Management::VERSION }"]
+      end
+
+      def organization_header(organization_id)
+        Hash['X-Contentful-Organization', organization_id]
+      end
+
+      def version_header(version)
+        Hash['X-Contentful-Version', version]
+      end
+
+      def content_type_header(content_type_id)
+        Hash['X-Contentful-Content-Type', content_type_id]
+      end
+
+      def zero_length_header
+        Hash['Content-Length', 0]
+      end
+
+      # XXX: headers should be supplied differently, maybe through the request object.
+      def request_headers
+        headers = {}
+        headers.merge! user_agent
+        headers.merge! authentication_header
+        headers.merge! api_version_header
+        headers.merge! organization_header(organization_id) if organization_id
+        headers.merge! version_header(version) if version
+        headers.merge! zero_length_header if zero_length
+        headers.merge! content_type_header(content_type_id) if content_type_id
+        headers
+      end
+
+      def self.shared_instance
+        Thread.current[:client]
+      end
+    end
+  end
+end

data/lib/contentful/management/content_type.rb

@@ -0,0 +1,180 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+require_relative 'field'
+
+module Contentful
+  module Management
+    class ContentType
+
+      FIELD_TYPES = [
+          SYMBOL = 'Symbol',
+          TEXT = 'Text',
+          INTEGER = 'Integer',
+          FLOAT = 'Number',
+          DATE = 'Date',
+          BOOLEAN = 'Boolean',
+          LINK = 'Link',
+          ARRAY = 'Array',
+          OBJECT = 'Object',
+          LOCATION = 'Location'
+      ]
+
+      include Contentful::Management::Resource
+      include Contentful::Management::Resource::SystemProperties
+      include Contentful::Management::Resource::Refresher
+
+      property :name, :string
+      property :description, :string
+      property :fields, Field
+      property :displayField, :string
+
+      def self.all(space_id)
+        request = Request.new("/#{ space_id }/content_types")
+        response = request.get
+        result = ResourceBuilder.new(self, response, {}, {})
+        content_types = result.run
+        Contentful::Management::Client.shared_instance.update_dynamic_entry_cache!(content_types)
+        content_types
+      end
+
+      def self.find(space_id, content_type_id)
+        request = Request.new("/#{ space_id }/content_types/#{ content_type_id }")
+        response = request.get
+        result = ResourceBuilder.new(self, response, {}, {})
+        content_type = result.run
+        Contentful::Management::Client.shared_instance.register_dynamic_entry(content_type.id, DynamicEntry.create(content_type)) if content_type.is_a?(self)
+        content_type
+      end
+
+      def destroy
+        request = Request.new("/#{ space.id }/content_types/#{ id }")
+        response = request.delete
+        if response.status == :no_content
+          return true
+        else
+          result = ResourceBuilder.new(self, response, {}, {})
+          result.run
+        end
+      end
+
+      def activate
+        request = Request.new("/#{ space.id }/content_types/#{ id }/published", {}, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(self, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def deactivate
+        request = Request.new("/#{ space.id }/content_types/#{ id }/published")
+        response = request.delete
+        result = ResourceBuilder.new(self, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def active?
+        !sys[:publishedAt].nil?
+      end
+
+      def self.create(space_id, attributes)
+        fields = fields_to_nested_properties_hash(attributes[:fields] || [])
+        request = Request.new("/#{ space_id }/content_types/#{ attributes[:id] || ''}", { name: attributes.fetch(:name),
+                                                                                      description: attributes[:description],
+                                                                                      fields: fields })
+        response = attributes[:id].nil? ? request.post : request.put
+        result = ResourceBuilder.new(self, response, {}, {}).run
+        Contentful::Management::Client.shared_instance.register_dynamic_entry(result.id, DynamicEntry.create(result)) if result.is_a?(self.class)
+        result
+      end
+
+      def update(attributes)
+        parameters = {}
+        parameters.merge!(name: (attributes[:name] || name))
+        parameters.merge!(description: (attributes[:description] || description))
+        parameters.merge!(fields: self.class.fields_to_nested_properties_hash(attributes[:fields] || fields))
+        request = Request.new("/#{ space.id }/content_types/#{ id }", parameters, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(self, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def save
+        if id.nil?
+          new_instance = self.class.create(space.id, @properties)
+          refresh_data(new_instance)
+        else
+          update(@properties)
+        end
+      end
+
+      def merged_fields(new_field)
+        field_ids = []
+        merged_fields = fields.each_with_object([]) do |field, fields|
+          field.deep_merge!(new_field) if field.id == new_field.id
+          fields << field
+          field_ids << field.id
+        end
+        merged_fields << new_field unless field_ids.include?(new_field.id)
+        merged_fields
+      end
+
+      alias_method :orig_fields, :fields
+
+      def fields
+        fields = orig_fields
+
+        fields.instance_exec(self) do |content_type|
+
+          fields.define_singleton_method(:add) do |field|
+            content_type.update(fields: content_type.merged_fields(field))
+          end
+
+          fields.define_singleton_method(:create) do |params|
+            field = Contentful::Management::Field.new
+            field.id = params.fetch(:id)
+            field.name = params[:name] if params[:name]
+            field.type = params[:type] if params[:type]
+            field.link_type = params[:link_type] if params[:link_type]
+            field.required = params[:required] if params[:required]
+            field.localized = params[:localized] if params[:localized]
+            field.items = params[:items] if params[:items]
+            content_type.update(fields: content_type.merged_fields(field))
+          end
+
+          fields.define_singleton_method(:destroy) do |id|
+            fields = content_type.fields.select { |field| field.id != id }
+            content_type.update(fields: fields)
+          end
+
+        end
+
+        fields
+      end
+
+      #TODO refactor and move
+      def entries
+        entries = []
+        entries.instance_exec(self) do |content_type|
+          define_singleton_method(:create) do |params|
+            Entry.create(content_type, params)
+          end
+          define_singleton_method(:new) do
+            dynamic_entry_class =   Contentful::Management::Client.shared_instance.register_dynamic_entry(content_type.id, DynamicEntry.create(content_type))
+            dynamic_entry = dynamic_entry_class.new
+            dynamic_entry.content_type = content_type
+            dynamic_entry
+          end
+        end
+        entries
+      end
+
+      private
+
+      def self.fields_to_nested_properties_hash(fields)
+        fields.map do |field|
+          field.properties.replace(field.properties_to_hash)
+        end
+      end
+
+    end
+  end
+end

data/lib/contentful/management/dynamic_entry.rb

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+require_relative 'resource/fields'
+require_relative 'location'
+
+module Contentful
+  module Management
+    class DynamicEntry < Contentful::Management::Entry
+      KNOWN_TYPES = {
+          'String' => :string,
+          'Text' => :string,
+          'Symbol' => :string,
+          'Integer' => :integer,
+          'Float' => :float,
+          'Boolean' => :boolean,
+          'Date' => :date,
+          'Location' => Location
+      }
+
+      def self.create(content_type)
+        unless content_type.is_a? ContentType
+          content_type = ContentType.new(content_type)
+        end
+
+        # TODO no support for an empty content type (undefined method map for Field)
+        fields_coercions = Hash[
+            content_type.fields.map do |field|
+              [field.id.to_sym, KNOWN_TYPES[field.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|
+              fields[field.id.to_sym] = value
+            end
+            define_method "#{ accessor_name }_with_locales=" do |values|
+              values.each do |locale, value|
+                @fields[locale] = {} if @fields[locale].nil?
+                @fields[locale][field.id.to_sym] = value
+              end
+            end
+          end
+
+          define_singleton_method :fields_coercions do
+            fields_coercions
+          end
+
+          define_singleton_method :content_type do
+            content_type
+          end
+
+          define_singleton_method :to_s do
+            "Contentful::Management::DynamicEntry[#{ content_type.id }]"
+          end
+
+          define_singleton_method :inspect do
+            "Contentful::Management::DynamicEntry[#{ content_type.id }]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful/management/entry.rb

@@ -0,0 +1,213 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+require_relative 'resource/fields'
+
+module Contentful
+  module Management
+    class Entry
+
+      def self.fields_coercions
+        {}
+      end
+
+      include Contentful::Management::Resource
+      include Contentful::Management::Resource::SystemProperties
+      include Contentful::Management::Resource::Refresher
+      include Contentful::Management::Resource::Fields
+
+      attr_accessor :content_type
+
+      def self.all(space_id)
+        request = Request.new("/#{ space_id }/entries")
+        response = request.get
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {})
+        result.run
+      end
+
+      def self.find(space_id, entry_id)
+        request = Request.new("/#{ space_id }/entries/#{ entry_id }")
+        response = request.get
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {})
+        result.run
+      end
+
+      def self.create(content_type, attributes)
+        fields_for_create = if attributes[:fields] #create from initialized dynamic entry via save
+                              tmp_entry = self.new
+                              tmp_entry.instance_variable_set(:@fields, attributes.delete(:fields) || {})
+                              Contentful::Management::Support.deep_hash_merge(tmp_entry.fields_for_query, tmp_entry.fields_from_attributes(attributes))
+                            else
+                              fields_with_locale content_type, attributes
+                            end
+
+        request = Request.new("/#{ content_type.sys[:space].id  }/entries/#{ attributes[:id] || ''}", { fields: fields_for_create }, nil, content_type_id: content_type.id)
+
+        response = attributes[:id].nil? ? request.post : request.put
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {})
+        result.run
+      end
+
+      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 }, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def save
+        if id.nil?
+          new_instance = Contentful::Management::Entry.create(content_type, { fields: instance_variable_get(:@fields) })
+          refresh_data(new_instance)
+        else
+          update({})
+        end
+      end
+
+      def publish
+        request = Request.new("/#{ space.id }/entries/#{ id }/published", {}, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def unpublish
+        request = Request.new("/#{ space.id }/entries/#{ id }/published", {}, id = nil, version: sys[:version])
+        response = request.delete
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def archive
+        request = Request.new("/#{ space.id }/entries/#{ id }/archived", {}, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def unarchive
+        request = Request.new("/#{ space.id }/entries/#{ id }/archived", {}, id = nil, version: sys[:version])
+        response = request.delete
+        result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {}).run
+        refresh_data(result)
+      end
+
+      def destroy
+        request = Request.new("/#{ space.id }/entries/#{ id }")
+        response = request.delete
+        if response.status == :no_content
+          return true
+        else
+          result = ResourceBuilder.new(Contentful::Management::Client.shared_instance, response, {}, {})
+          result.run
+        end
+      end
+
+      def published?
+        !sys[:publishedAt].nil?
+      end
+
+      def archived?
+        !sys[:archivedAt].nil?
+      end
+
+      def locale
+        sys[:locale] || default_locale
+      end
+
+      def fields_for_query
+        raw_fields = self.instance_variable_get(:@fields)
+        fields_names = raw_fields.first[1].keys
+        fields_names.each_with_object({}) do |field_name, results|
+          results[field_name] = raw_fields.each_with_object({}) do |(locale, fields), field_results|
+            # field_results[locale] = fields[field_name]
+            field_results[locale] = parse_update_attribute(fields[field_name])
+          end
+        end
+      end
+
+      def fields_from_attributes(attributes)
+        attributes.each do |id, value|
+          attributes[id] = { locale => parse_update_attribute(value) }
+        end
+      end
+
+      private
+
+      def self.parse_attribute_with_field(attribute, field)
+        case field.type
+          when ContentType::LINK then
+            { sys: { type: field.type, linkType: field.link_type, id: attribute.id }}
+          when ContentType::ARRAY then
+            parse_fields_array(attribute)
+          when ContentType::LOCATION then
+            { lat: attribute.properties[:lat], lon: attribute.properties[:lon]}
+          else
+            attribute
+        end
+      end
+
+      #TODO refactor
+      def parse_update_attribute(attribute)
+        if attribute.is_a? Asset
+          { sys: { type: 'Link', linkType: 'Asset', id: attribute.id } }
+        elsif attribute.is_a? Entry
+          { sys: { type: 'Link', linkType: 'Entry', id: attribute.id } }
+        elsif attribute.is_a? Location
+          { lat: attribute.properties[:lat], lon: attribute.properties[:lon] }
+        elsif attribute.is_a? ::Array
+          parse_update_fields_array(attribute)
+        else
+          attribute
+        end
+      end
+
+      #TODO refactor
+      def parse_update_fields_array(attributes)
+        type = attributes.first.class.to_s
+        unless type == 'String'
+          attributes.each_with_object([]) do |attr, arr|
+            arr << case type
+                     when /Entry/ then
+                       { sys: { type: 'Link', linkType: 'Entry', id: attr.id } }
+                     when /Asset/ then
+                       { sys: { type: 'Link', linkType: 'Asset', id: attr.id } }
+                   end
+          end
+        else
+          attributes
+        end
+      end
+
+      def self.parse_fields_array(attributes)
+        if attributes.is_a? ::Array
+          type = attributes.first.class
+          attributes.each_with_object([]) do |attr, arr|
+            arr << case type.to_s
+                     when /Entry/ then
+                       { sys: { type: 'Link', linkType: 'Entry', id: attr.id } }
+                     when /Asset/ then
+                       { sys: { type: 'Link', linkType: 'Asset', id: attr.id } }
+                   end
+          end
+        else
+          [attributes]
+        end
+      end
+
+      def self.fields_with_locale(content_type, attributes)
+        locale = content_type.sys[:space].default_locale
+        fields = content_type.properties[:fields]
+        field_names = fields.map { |f| f.id.to_sym }
+        attributes.keep_if { |key| field_names.include?(key) }
+
+        attributes.each do |id, value|
+          field = fields.select { |f| f.id.to_sym == id.to_sym }.first
+          attributes[id] = { locale => parse_attribute_with_field(value, field) }
+        end
+      end
+
+    end
+  end
+end