datawow 1.2.0

data/lib/datawow/client_response.rb

@@ -0,0 +1,18 @@
+module Datawow
+  class Response
+    attr_reader :total, :message, :status
+    attr_accessor :data, :meta
+
+    def initialize(data, response_code = '', response_message = 'success', meta = nil, total = 0)
+      @data = data
+      @status = response_code.to_i
+      @message = response_message
+      @meta = meta
+      @total = total unless total.nil?
+    end
+
+    def successful?
+      [200, 201].include? status
+    end
+  end
+end

data/lib/datawow/connection.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require File.expand_path('faraday/raise_http_exception.rb', __dir__)
+require File.expand_path('client_response.rb', __dir__)
+
+module Datawow
+  # :nodoc:
+  class Connection
+    def initialize(model:, version_api: 'v1')
+      @model = model
+      @version_api = version_api
+    end
+
+    def get(path, options = {})
+      @response = connection.get do |request|
+        request.url("#{@version_api}#{path}")
+        request.headers['Content-Type'] = 'application/json'
+        request.headers['Authorization'] = options[:token] unless options[:token].nil?
+        request.params = options[:path_param] ? params_url_options(options) : options
+      end
+      Response.new(data, status_code, message, meta, total)
+    rescue Error, Faraday::Error => e
+      handle_error(e)
+    end
+
+    def post(path, options = {}, query_params = {})
+      @response = connection.post do |request|
+        request.url("#{@version_api}#{path}")
+        request.headers['Content-Type'] = 'application/json'
+        request.headers['Authorization'] = options[:token] unless options[:token].nil?
+        request.params = query_params
+        request.body = options unless options.nil?
+      end
+      Response.new(data, status_code, message, meta, nil)
+    rescue Error, Faraday::Error => e
+      handle_error(e)
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday::Connection.new(base_point) do |connection|
+        connection.request :url_encoded
+        connection.request :json
+        connection.response :json
+        connection.use Datawow::FaradayMiddleware::RaiseHttpException
+        connection.use :gzip
+        connection.adapter Faraday.default_adapter
+      end
+    end
+
+    def data
+      @response.body['data']
+    end
+
+    def meta
+      @response.body['meta']
+    end
+
+    def status_code
+      meta['code'] unless meta.nil?
+    end
+
+    def message
+      meta['message'] unless meta.nil?
+    end
+
+    def total
+      meta['total_count'] unless meta.nil?
+    end
+
+    def handle_error(exception)
+      if exception.is_a?(Faraday::ConnectionFailed)
+        code = 599
+        message = 'Connection Failed'
+      else
+        code = exception.to_s.partition(':').first
+        message = exception.to_s.partition(':').last
+      end
+
+      Response.new(nil, code, message, nil)
+    end
+
+    def params_url_options(options)
+      %i[id path_param].each { |e| options.delete(e) }
+      options
+    end
+
+    def base_point
+      options = {
+        image: 'https://kiyo-image.datawow.io/api/',
+        ai: 'https://kiyo-image.datawow.io/api/',
+        text: 'https://kiyo-text.datawow.io/api/',
+        video: 'https://kiyo-image.datawow.io/api/'
+      }
+      options[@model]
+    end
+  end
+end

data/lib/datawow/connector.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+require File.expand_path('client_response.rb', __dir__)
+
+module Datawow
+  # :nodoc:
+  class Connector
+    def initialize(path, type, token: '', version_api: 'v1')
+      @version_api = version_api
+      @type = type
+      @path = path
+      @token = token
+      @method = :GET
+    end
+
+    def post(data = {})
+      @method = :POST
+      response = send_request(data)
+
+      body = JSON.parse response.body
+
+      Response.new(body['data'], response.code, body['meta']['message'], body['meta'], 1)
+    end
+
+    def get(data = {}, query_str = true)
+      @method = :GET
+      response = send_request(data, query_str)
+      body = JSON.parse response.body
+
+      Response.new(body['data'], response.code, body['meta']['message'], body['meta'], body['meta']['total_count'])
+    end
+
+    def put(data = {})
+      @method = :PUT
+      response = send_request(data)
+      body = JSON.parse response.body
+
+      Response.new(body['data'], response.code, body['meta']['message'], body['meta'], 1)
+    end
+
+    def delete(data = {}, query_str = true)
+      @method = :DELETE
+      response = send_request(data, query_str)
+      body = JSON.parse response.body
+
+      Response.new(body['data'], response.code, body['meta']['message'], body['meta'], body['meta']['total_count'])
+    end
+
+    private
+
+    def send_request(data = {}, query_str = true)
+      base_uri = base_point(@type)
+      url_base = "#{base_uri}/#{@version_api}/#{@path}"
+      uri = URI.parse(url_base)
+
+      if @method == :GET
+        if query_str
+          uri.query = URI.encode_www_form(data)
+        else
+          url_base = "#{url_base}/#{data[:id]}"
+          uri = URI.parse(url_base)
+        end
+      end
+
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = true
+      request = build_request(uri)
+      request.set_form_data(data)
+      response = https.request(request)
+    end
+
+    def build_request(uri)
+      request = {}
+      token = if Datawow.project_key
+                Datawow.project_key
+              else
+                @token
+              end
+
+      if (token || '').empty?
+        raise ArgumentError, 'project\'s token has missed. To config about token check our document'
+      end
+
+      case @method
+      when :POST
+        request = Net::HTTP::Post.new(uri.request_uri)
+      when :GET
+        request = Net::HTTP::Get.new(uri.request_uri)
+      when :PUT
+        request = Net::HTTP::Put.new(uri.request_uri)
+      when :DELETE
+        request = Net::HTTP::Delete.new(uri.request_uri)
+      else
+        raise ArgumentError, 'HTTP method is not exist, We allowed GET, POST, PUT, DELET only'
+      end
+
+      request['User-Agent'] = 'Datawow Ruby gem client'
+      request['Accept'] = 'application/json'
+      request['Content-Type'] = 'application/json'
+      request['Authorization'] = token
+
+      request
+    end
+
+    def base_point(type)
+      {
+        image: 'https://kiyo-image.datawow.io/api',
+        ai:    'https://kiyo-image.datawow.io/api',
+        text:  'https://kiyo-text.datawow.io/api',
+        video: 'https://kiyo-image.datawow.io/api'
+      }[type]
+    end
+  end
+end

data/lib/datawow/error.rb

@@ -0,0 +1,15 @@
+module Datawow
+
+  # Custom error class for rescuing from all API errors
+  class Error < StandardError; end
+
+  # Raised when API returns the HTTP status code 400
+  class BadRequest < Error; end
+
+  # Raised when API returns the HTTP status code 403
+  class NotPermitted < Error; end
+
+  # Raised when API returns the HTTP status code 404
+  class NotFound < Error; end
+
+end

data/lib/datawow/faraday/raise_http_exception.rb

@@ -0,0 +1,40 @@
+require 'faraday_middleware'
+
+module Datawow
+  module FaradayMiddleware
+    class RaiseHttpException < Faraday::Middleware
+      def call(request_env)
+        @app.call(request_env).on_complete do |response|
+          case response[:status].to_i
+          when 200, 201
+            # nothing to do here
+          when 400
+            error_message = error_message(response[:body])
+            raise BadRequest, "#{response[:status]}: #{error_message}"
+          when 403
+            error_message = error_message(response[:body])
+            raise NotPermitted, "#{response[:status]}: #{error_message}"
+          when 404
+            error_message = error_message(response[:body])
+            raise NotFound, "#{response[:status]}: #{error_message}"
+          else
+            request_method = response[:method].to_s.upcase
+            request_url = response[:url].to_s
+            response_status = response[:status]
+            error_message = error_message(response[:body])
+            raise Error, "#{response_status}: #{request_method} #{request_url} #{error_message}"
+          end
+        end
+      end
+
+      private
+
+      def error_message(response_body)
+        if !response_body.nil? && response_body.is_a?(String)
+          response_body = JSON.parse(response_body)
+          response_body['message']
+        end
+      end
+    end
+  end
+end

data/lib/datawow/models/images/image_choices.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class ImageChoice
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :image
+      @path = 'images/choices'
+    end
+  end
+end

data/lib/datawow/models/images/image_closed_questions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class ImageClosedQuestion
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :image
+      @path = 'images/closed_questions'
+    end
+  end
+end

data/lib/datawow/models/images/image_messages.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class ImageMessage
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :image
+      @path = 'images/messages'
+    end
+  end
+end

data/lib/datawow/models/images/image_photo_tags.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class ImagePhotoTag
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :image
+      @path ='images/photo_tags'
+    end
+  end
+end

data/lib/datawow/models/images/nanameue_human.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class NanameueHuman
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize(token = nil)
+      @token = token
+      @type = :image
+      @path = 'jobs/nanameue/consensuses'
+    end
+  end
+end

data/lib/datawow/models/interface.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datawow
+  module Models
+    module Interface
+      def all(options = {})
+        connector.get(options)
+      end
+
+      def create(options)
+        connector.post(options)
+      end
+
+      def find_by(options = {})
+        @query_str = true if @query_str.nil?
+        connector.get(options, @query_str)
+      end
+
+      private
+
+      def connector
+        @connection ||= Connector.new(@path, @type, token: @token)
+      end
+    end
+  end
+end

data/lib/datawow/models/predictions/predictors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class Predictor
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :ai
+      @query_str = false
+
+      @path = 'prime/predictions'
+    end
+  end
+end

data/lib/datawow/models/texts/text_categories.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class TextCategory
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :text
+      @path = 'text/text_categories'
+    end
+  end
+end

data/lib/datawow/models/texts/text_closed_questions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class TextClosedQuestion
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :text
+      @path = 'text/text_closed_questions'
+    end
+  end
+end

data/lib/datawow/models/texts/text_conversations.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class TextConversation
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :text
+      @path = 'text/text_conversations'
+    end
+  end
+end

data/lib/datawow/models/videos/video_classifications.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datawow
+  # :nodoc:
+  class VideoClassification
+    include Datawow::Models::Interface
+
+    attr_writer :token
+
+    def initialize
+      @token = nil
+      @type = :video
+      @query_str = false
+      @path = 'videos/closed_questions'
+    end
+  end
+end

data/lib/datawow/version.rb

@@ -0,0 +1,3 @@
+module Datawow
+  VERSION = '1.2.0'.freeze
+end

data/lib/datawow.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'pry-byebug'
+
+require_relative 'datawow/client_response'
+require_relative 'datawow/connection'
+require_relative 'datawow/connector'
+require_relative 'datawow/error'
+require_relative 'datawow/version'
+require_relative 'datawow/models/interface'
+
+require_relative 'datawow/models/images/image_closed_questions'
+require_relative 'datawow/models/images/image_photo_tags'
+require_relative 'datawow/models/images/image_choices'
+require_relative 'datawow/models/images/image_messages'
+require_relative 'datawow/models/images/nanameue_human'
+require_relative 'datawow/models/predictions/predictors'
+
+require_relative 'datawow/models/texts/text_categories'
+require_relative 'datawow/models/texts/text_closed_questions'
+require_relative 'datawow/models/texts/text_conversations'
+
+require_relative 'datawow/models/videos/video_classifications'
+
+# :nodoc:
+module Datawow
+  extend self
+
+  attr_accessor :project_key
+
+  class << self
+    def setup
+      yield self
+    end
+
+    def video_classification
+      VideoClassification.new
+    end
+
+    def text_closed_question
+      TextClosedQuestion.new
+    end
+
+    def text_category
+      TextCategory.new
+    end
+
+    def text_conversation
+      TextConversation.new
+    end
+
+    def image_closed_question
+      ImageClosedQuestion.new
+    end
+
+    def image_photo_tag
+      ImagePhotoTag.new
+    end
+
+    def image_choice
+      ImageChoice.new
+    end
+
+    def image_message
+      ImageMessage.new
+    end
+
+    def prediction
+      Predictor.new
+    end
+
+    def nanameue_human
+      NanameueHuman.new
+    end
+  end
+end

data/lib/generators/datawow/install_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators/base'
+require 'securerandom'
+
+module Datawow
+  module Generators
+    # :nodoc:
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../templates', __FILE__)
+
+      desc 'Creates a Datawow initializer
+       and copy locale files to your application.'
+
+      def copy_initializer
+        template 'datawow_api.rb', 'config/initializers/datawow_api.rb'
+      end
+    end
+  end
+end

data/lib/generators/templates/datawow_api.rb

@@ -0,0 +1,5 @@
+Datawow.setup do |config|
+  # ==> Secret key Configuration
+  # You can change it below and use your own secret key.
+  config.project_key = 'Project token key'
+end

data/test/datawow/client_response_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class ResponseTest < Minitest::Test
+    def test_new_success_response
+      response = Response.new('response', 200, 'success', 'meta', 5)
+      refute_nil(response)
+      refute_nil(response.data)
+      assert_equal(true, response.successful?)
+      assert_equal('response', response.data)
+      assert_equal('success', response.message)
+      assert_equal('meta', response.meta)
+      assert_equal(5, response.total)
+    end
+
+    def test_failure_response
+      response = Response.new('response', 500, 'failure', 'meta')
+      refute_nil(response)
+      refute_nil(response.data)
+      assert_equal(false, response.successful?)
+      assert_equal('response', response.data)
+      assert_equal('failure', response.message)
+      assert_equal('meta', response.meta)
+      assert_equal(0, response.total)
+    end
+  end
+end