agave-client 0.1.0

data/lib/agave/local/json_api_entity.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+module Agave
+  module Local
+    class JsonApiEntity
+      attr_reader :payload, :data_source
+
+      def initialize(payload, data_source)
+        @payload = payload
+        @data_source = data_source
+      end
+
+      def id
+        @payload[:id]
+      end
+
+      def type
+        @payload[:type]
+      end
+
+      def ==(other)
+        if other.is_a? JsonApiEntity
+          id == other.id && type == other.type
+        else
+          false
+        end
+      end
+
+      def to_s
+        "#<JsonApiEntity id=#{id} type=#{type} payload=#{payload}>"
+      end
+      alias inspect to_s
+
+      def [](key)
+        attributes[key]
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if attributes.key?(method) || relationships.key?(method)
+          true
+        else
+          super
+        end
+      end
+
+      private
+
+      def attributes
+        @payload.fetch(:attributes, {})
+      end
+
+      def relationships
+        @payload.fetch(:relationships, {})
+      end
+
+      def dereference_linkage(linkage)
+        if linkage.is_a? Array
+          linkage.map do |item|
+            data_source.find_entity(item[:type], item[:id])
+          end
+        elsif linkage.is_a? Hash
+          data_source.find_entity(linkage[:type], linkage[:id])
+        end
+      end
+
+      def method_missing(method, *arguments, &block)
+        return super unless arguments.empty?
+
+        if attributes.key?(method)
+          attributes[method]
+        elsif relationships.key?(method)
+          dereference_linkage(relationships[method][:data])
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/agave/local/loader.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'agave/local/entities_repo'
+require 'agave/local/items_repo'
+
+module Agave
+  module Local
+    class Loader
+      attr_reader :client
+      attr_reader :entities_repo
+      attr_reader :items_repo
+      attr_reader :preview_mode
+
+      def initialize(client, preview_mode = false)
+        @client = client
+        @preview_mode = preview_mode
+        @entities_repo = EntitiesRepo.new
+        @items_repo = ItemsRepo.new(@entities_repo)
+      end
+
+      def load
+        threads = [
+          Thread.new { Thread.current[:output] = site },
+          Thread.new { Thread.current[:output] = all_items },
+          Thread.new { Thread.current[:output] = all_uploads }
+        ]
+
+        results = threads.map do |t|
+          t.join
+          t[:output]
+        end
+
+        @entities_repo = EntitiesRepo.new(*results)
+        @items_repo = ItemsRepo.new(@entities_repo)
+      end
+
+      private
+
+      def site
+        include = ['item_types', 'item_types.fields']
+        client.request(:get, '/api/site', include: include)
+      end
+
+      def all_items
+        client.items.all(
+          { version: preview_mode ? 'latest' : 'published' },
+          deserialize_response: false,
+          all_pages: true
+        )
+      end
+
+      def all_uploads
+        client.uploads.all(
+          { "filter[type]" => "used" },
+          deserialize_response: false,
+          all_pages: true
+        )
+      end
+    end
+  end
+end

data/lib/agave/local/site.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'active_support/inflector/transliterate'
+require 'active_support/hash_with_indifferent_access'
+require 'agave/utils/locale_value'
+
+module Agave
+  module Local
+    class Site
+      extend Forwardable
+
+      attr_reader :entity
+      def_delegators :entity, :id, :name, :locales, :domain,
+                     :no_index, :production_frontend_url
+
+      def initialize(entity, items_repo)
+        @entity = entity
+        @items_repo = items_repo
+      end
+
+      def global_seo
+        read_attribute(:global_seo, FieldType::GlobalSeo, locales.size > 1)
+      end
+
+      def theme
+        read_attribute(:theme, FieldType::Theme, false)
+      end
+
+      def favicon
+        read_attribute(:favicon, FieldType::File, false)
+      end
+
+      def to_s
+        "#<Site id=#{id} site_name=#{name}>"
+      end
+      alias inspect to_s
+
+      def favicon_meta_tags(theme_color = nil)
+        Utils::FaviconTagsBuilder.new(self, theme_color).meta_tags
+      end
+
+      def to_hash
+        attributes = [
+          :id, :name, :locales, :theme, :domain,
+          :no_index, :global_seo, :favicon, :production_frontend_url
+        ]
+
+        attributes.each_with_object({}) do |attribute, result|
+          value = send(attribute)
+          result[attribute] = if value.respond_to?(:to_hash)
+                                value.to_hash
+                              else
+                                value
+                              end
+        end
+      end
+
+      private
+
+      def read_attribute(method, type_klass, localized)
+        value = if localized
+                  obj = entity.send(method) || {}
+
+                  Utils::LocaleValue.find(obj)
+                else
+                  entity.send(method)
+                end
+
+        type_klass.parse(value, @items_repo)
+      end
+    end
+  end
+end

data/lib/agave/paginator.rb

@@ -0,0 +1,33 @@
+module Agave
+  class Paginator
+    def initialize(client, base_endpoint, filters)
+      @client, @base_endpoint, @filters = client, base_endpoint, filters
+    end
+
+    def response
+      items_per_page = 100
+
+      base_response = @client.request(
+        :get, @base_endpoint, @filters.dup.merge('page[limit]' => items_per_page)
+      )
+
+      extra_pages = (
+        base_response[:meta][:total_count] / items_per_page.to_f
+      ).ceil - 1
+
+      extra_pages.times do |page|
+        base_response[:data] += @client.request(
+          :get,
+          @base_endpoint,
+          @filters.dup.merge(
+            'page[offset]' => items_per_page * (page + 1),
+            'page[limit]' => items_per_page
+          )
+        )[:data]
+      end
+
+      base_response
+    end
+  end
+end
+

data/lib/agave/repo.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require 'agave/json_api_serializer'
+require 'agave/json_api_deserializer'
+require 'agave/paginator'
+
+module Agave
+  class Repo
+    attr_reader :client, :type, :schema
+
+    IDENTITY_REGEXP = /\{\(.*?definitions%2F(.*?)%2Fdefinitions%2Fidentity\)}/
+
+    METHOD_NAMES = {
+      "instances" => :all,
+      "self" => :find,
+    }
+
+    def initialize(client, type, schema)
+      @client = client
+      @type = type
+      @schema = schema
+
+      schema.links.each do |link|
+        method_name = METHOD_NAMES.fetch(link.rel, link.rel)
+
+        self.define_singleton_method(method_name) do |*args|
+          min_arguments_count = [
+            link.href.scan(IDENTITY_REGEXP).size,
+            link.schema && link.method != :get ? 1 : 0
+          ].reduce(0, :+)
+
+          args.size >= min_arguments_count or
+            raise ArgumentError.new(
+              "wrong number of arguments (given #{args.size}, expected #{min_arguments_count})"
+          )
+
+          placeholders = []
+
+          url = link["href"].gsub(IDENTITY_REGEXP) do |_stuff|
+            placeholder = args.shift.to_s
+            placeholders << placeholder
+            placeholder
+          end
+
+          response = if %i(post put).include?(link.method)
+            body = if link.schema
+              unserialized_body = args.shift
+
+              JsonApiSerializer.new(type, link).serialize(
+                unserialized_body,
+                link.method == :post ? nil : placeholders.last
+              )
+            else
+              {}
+            end
+
+            client.request(link.method, url, body)
+
+          elsif link.method == :delete
+            client.request(:delete, url)
+
+          elsif link.method == :get
+            query_string = args.shift
+
+            all_pages = (args[0] || {}).
+              symbolize_keys.
+              fetch(:all_pages, false)
+
+            is_paginated_endpoint = link.schema &&
+              link.schema.properties.has_key?("page[limit]")
+
+            if is_paginated_endpoint && all_pages
+              Paginator.new(client, url, query_string).response
+            else
+              client.request(:get, url, query_string)
+            end
+          end
+
+          options = if args.any?
+                      args.shift.symbolize_keys
+                    else
+                      {}
+                    end
+
+          if options.fetch(:deserialize_response, true)
+            JsonApiDeserializer.new.deserialize(response)
+          else
+            response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/agave/site/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'agave/api_client'
+require 'agave/upload/file'
+require 'agave/upload/image'
+
+module Agave
+  module Site
+    class Client
+      include ApiClient
+
+      json_schema 'site-api'
+
+      def upload_file(path_or_url)
+        file = Upload::File.new(self, path_or_url)
+        file.upload
+      end
+
+      def upload_image(path_or_url)
+        file = Upload::Image.new(self, path_or_url)
+        file.upload
+      end
+    end
+  end
+end

data/lib/agave/upload/file.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require 'downloadr'
+require 'tempfile'
+require 'addressable'
+require 'net/http'
+require 'fastimage'
+
+module Agave
+  module Upload
+    class File
+      IMAGE_FORMATS = %w(png jpg jpeg gif)
+
+      attr_reader :client, :source
+
+      def initialize(client, source)
+        @client = client
+        @source = source
+      end
+
+      def file
+        @file ||= if http_source?
+                    uri = Addressable::URI.parse(source)
+                    ext = ::File.extname(uri.path)
+                    Tempfile.new(['file', ext]).tap do |file|
+                      Downloadr::HTTP.new(source, file).download
+                    end
+                  else
+                    ::File.new(::File.expand_path(source))
+                  end
+      end
+
+      def http_source?
+        uri = Addressable::URI.parse(source)
+        uri.scheme == 'http' || uri.scheme == 'https'
+      rescue Addressable::URI::InvalidURIError
+        false
+      end
+
+      def filename
+        if http_source?
+          ::File.basename(source)
+        else
+          ::File.basename(file.path)
+        end
+      end
+
+      def upload
+        upload_request = client.upload_request.create(filename: filename)
+        uri = URI.parse(upload_request[:url])
+
+        request = Net::HTTP::Put.new(
+          uri,
+          'x-amz-acl' => 'public-read'
+        )
+        request.body = file.read
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        http.request(request)
+
+        uploads = client.uploads.create(
+          format_resource(upload_request)
+        )
+
+        uploads["id"]
+      end
+
+      def format_resource(upload_request)
+        extension = ::File.extname(::File.basename(file.path)).delete('.')
+
+        base_format = {
+          path: upload_request[:id],
+          size: ::File.size(file.path),
+          format: extension
+        }
+
+        if IMAGE_FORMATS.include?(extension)
+          width, height = FastImage.size(file.path)
+
+          base_format.merge(
+            width: width,
+            height: height,
+            format: FastImage.type(file.path).to_s
+          )
+        else
+          base_format
+        end
+      end
+    end
+  end
+end