simpleadmin 1.4.0 → 1.5.0

data/Rakefile

@@ -1,6 +1,4 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
+# frozen_string_literal: true
 
+require 'bundler/gem_tasks'
 task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "simpleadmin"
+require 'bundler/setup'
+require 'simpleadmin'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "simpleadmin"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/simpleadmin.rb

@@ -1,7 +1,109 @@
+# frozen_string_literal: true
+
+require 'rack/app'
+require 'sequel'
+require 'bcrypt'
+
 require 'simpleadmin/version'
-require 'simpleadmin/engine'
+require 'simpleadmin/config'
+require 'simpleadmin/database_connector'
 
-require 'simpleadmin/application'
+# Administrative dashboard without wasting time
+#
+# @since 1.0.0
+#
+# @see https://getsimpleadmin.com
 
 module Simpleadmin
+  # API endpoints for integration with cloud version of getsimpleadmin.com
+  #
+  # This is used, Rack conception to connect it in any popular web frameworks
+  # like Ruby on Rails, Hanami, Sinatra and etc.
+  #
+  # @since 1.0.0
+  #
+  # @example
+  #
+  #  # config/routes.rb
+  #  Rails.application.routes.draw do
+  #    mount Simpleadmin::Application, at: 'simpleadmin'
+  #  end
+  class Application < Rack::App
+    WIDGETS = %w[quantity week_statistic].freeze
+
+    before { respond_forbidden! if secret_key_invalid? }
+    before { respond_forbidden! unless current_path?('/v1/tables') || allowed_table? }
+
+    namespace '/v1' do
+      get '/widgets/:widget_name' do
+        respond_forbidden!(message: 'Nonexistent widget') unless WIDGETS.include?(params['widget_name'])
+
+        client.public_send(params['widget_name'], params['table_name'])
+      end
+
+      get '/tables' do
+        client.tables
+      end
+
+      get '/tables/:table_name' do
+        client.table_columns(params['table_name'])
+      end
+
+      get '/resources' do
+        client.resources(params.values_at('table_name', 'table_fields', 'per_page',
+                                          'page', 'query', 'model_attributes', 'sort'))
+      end
+
+      get '/resources/:id' do
+        client.resource(params['id'], params['table_name'], params['table_fields'])
+      end
+
+      post '/resources' do
+        client.create_resource(request_body_params['table_name'], request_body_params['resource'])
+      end
+
+      patch '/resources/:id' do
+        client.update_resource(request_body_params['table_name'], params['id'], request_body_params['resource'])
+      end
+
+      delete '/resources/:id' do
+        client.destroy_resouce(request_body_params['table_name'], params['id'])
+      end
+    end
+
+    private
+
+    def client
+      @client ||= connector.client
+    end
+
+    def respond_forbidden!(message: 'Forbidden')
+      response.status = 403
+      response.write(message)
+
+      finish!
+    end
+
+    def request_body_params
+      @request_body_params ||= Rack::Utils.parse_nested_query(request.body.read)
+    end
+
+    def connector
+      @connector ||= DatabaseConnector.new(
+        database_credentials: Config.database_credentials
+      )
+    end
+
+    def allowed_table?
+      Config.allowed_table?(params['table_name'] || request_body_params['table_name'])
+    end
+
+    def secret_key_invalid?
+      BCrypt::Password.new(request.get_header('HTTP_SIMPLEADMIN_SECRET_KEY')) != ENV['SIMPLE_ADMIN_SECRET_KEY']
+    end
+
+    def current_path?(path)
+      request.path_info == path
+    end
+  end
 end

data/lib/simpleadmin/adapters/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'simpleadmin/decorators/fields_decorator'
+
+module Simpleadmin
+  module Adapters
+    # Base class to provide a unified interface for each adapter
+    #
+    # @since 1.0.0
+    class Base
+      def initialize(database_credentials:)
+        @database_credentials = database_credentials
+      end
+
+      def tables
+        raise NotImplementedError, 'Please follow the unified interface, add method #tables'
+      end
+
+      def table_columns(*_args)
+        raise NotImplementedError, 'Please follow the unified interface, add method #table_columns'
+      end
+
+      def resources(*_args)
+        raise NotImplementedError, 'Please follow the unified interface, add method #resources'
+      end
+
+      private
+
+      attr_reader :database_credentials
+
+      def order_asc?(order)
+        order == 'asc'
+      end
+
+      def order_desc?(order)
+        order == 'desc'
+      end
+
+      def model_class_by_table_name(name)
+        name.classify.safe_constantize
+      end
+
+      def table_names
+        return client.tables if Config.allowed_tables.include?(:all)
+
+        Config.allowed_tables
+      end
+    end
+  end
+end

data/lib/simpleadmin/adapters/postgres.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Simpleadmin
+  module Adapters
+    # Postgres adapter for API endpoints
+    #
+    # @since 1.0.0
+    class Postgres < Base
+      def tables
+        table_names.map do |table_name|
+          {
+            table_name: table_name,
+            table_columns: columns_by_table_name(table_name)
+          }
+        end.to_json
+      end
+
+      def table_columns(table_name)
+        columns_by_table_name(table_name).to_json
+      end
+
+      def resources(permitted_params_values)
+        table_name, table_fields, per_page, page, query, model_attributes, sort = *permitted_params_values
+
+        per_page = per_page.to_i
+        page = page.to_i
+
+        table_fields_names = table_fields.map { |field| field['field_name'].to_sym }
+
+        total = client.from(table_name).count
+        resources = client.from(table_name).limit(per_page)
+
+        resources, total = *search(query, table_name, model_attributes) unless query.nil? || query.empty?
+
+        resources = resources.offset((per_page * page) - per_page).select(*table_fields_names)
+
+        if order_asc?(sort['order'])
+          resources = resources.order(Sequel.asc(sort['column_name'].to_sym))
+        elsif order_desc?(sort['order'])
+          resources = resources.order(Sequel.desc(sort['column_name'].to_sym))
+        end
+
+        {
+          resources: Decorators::FieldDecorator.call(resources, table_name, table_fields),
+          total: total
+        }.to_json
+      end
+
+      def resource(resource_id, table_name, table_fields)
+        client.from(table_name).first(id: resource_id).slice(*table_fields.map(&:to_sym)).to_json
+      end
+
+      def create_resource(table_name, resource_params)
+        Config.on_create.call(model_class_by_table_name(table_name), resource_params)
+      end
+
+      def update_resource(table_name, resource_id, resource_params, _primary_key=:id)
+        Config.on_update.call(model_class_by_table_name(table_name), resource_id, resource_params)
+      end
+
+      def destroy_resouce(table_name, resource_id, _primary_key=:id)
+        Config.on_destroy.call(model_class_by_table_name(table_name), resource_id)
+      end
+
+      def quantity(table_name)
+        {
+          widget_name: :quantity,
+          result: client.from(table_name).count
+        }.to_json
+      end
+
+      def week_statistic(table_name)
+        result = 6.downto(0).map do |day|
+          current_date_time = DateTime.now - day
+
+          client.from(table_name).where(
+            created_at: beggining_of_day(current_date_time)..at_end_of_day(current_date_time)
+          ).count
+        end
+
+        {
+          widget_name: :week_statistic,
+          result: result
+        }.to_json
+      end
+
+      private
+
+      def client
+        @client ||= Sequel.connect(database_credentials)
+      end
+
+      def beggining_of_day(date)
+        DateTime.new(date.year, date.month, date.day, 0, 0, 0, 0)
+      end
+
+      def at_end_of_day(date)
+        DateTime.new(date.year, date.month, date.day, 23, 59, 59, 59)
+      end
+
+      def columns_by_table_name(name)
+        client.schema(name).map do |column_attributes|
+          column_name, column_information = *column_attributes
+
+          {
+            column_name: column_name,
+            data_type: column_information[:db_type]
+          }
+        end
+      end
+
+      def search(search_query, table_name, model_attributes)
+        query_expressions = model_attributes.map do |model_attribute|
+          Sequel.like(model_attribute.to_sym, "%#{search_query}%")
+        end
+
+        query = query_expressions.first if query_expressions.one?
+
+        query_expressions.each_cons(2) do |current_value, next_value|
+          query = query.nil? ? current_value | next_value : query | (current_value | next_value)
+        end
+
+        [
+          client.from(table_name).where(query),
+          client.from(table_name).where(query).count
+        ]
+      end
+    end
+  end
+end

data/lib/simpleadmin/config.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Simpleadmin
+  # Configuration storage to customize allowed tables, to choose a database adapter and name
+  #
+  # @since 1.0.0
+  #
+  # @example
+  #
+  #   Simpleadmin::Config.setup do |config|
+  #      config.database_credentials = {
+  #        adapter: :postgres,
+  #        database: 'squiz_development'
+  #      }
+  #
+  #     config.allowed_tables = ['users']          # Allowed tables
+  #     # config.allowed_tables = [:all]           # Allow all tables
+  #
+  #     config.on_create = lambda do |model_class, resource_params|
+  #       model_class.create(resource_params)
+  #     end
+  #
+  #     config.on_update = lambda do |model_class, resource_id, resource_params|
+  #       model_class.find(resource_id).update(resource_params)
+  #     end
+  #
+  #     config.on_destroy = lambda do |model_class, resource_id|
+  #       model_class.find(resource_id).destroy
+  #     end
+  #   end
+  class Config
+    DEFAULT_TABLE_SCHEMAS = ['public'].freeze
+
+    include Singleton
+
+    attr_accessor :table_schemas, :database_credentials, :allowed_tables, :client
+    attr_accessor :on_create, :on_update, :on_destroy
+
+    class << self
+      def setup
+        yield(instance)
+      end
+
+      def allowed_table?(table_name)
+        return true if instance.allowed_tables.include?(:all)
+
+        instance.allowed_tables.include?(table_name)
+      end
+
+      def allowed_tables
+        instance.allowed_tables || []
+      end
+
+      def database_credentials
+        instance.database_credentials
+      end
+
+      def on_create
+        raise NotImplementedError, 'Please define #on_create in an initializer to use gem' if instance.on_create.nil?
+
+        instance.on_create
+      end
+
+      def on_update
+        raise NotImplementedError, 'Please define #on_update in an initializer to use gem' if instance.on_update.nil?
+
+        instance.on_update
+      end
+
+      def on_destroy
+        raise NotImplementedError, 'Please define #on_destroy in an initializer to use gem' if instance.on_destroy.nil?
+
+        instance.on_destroy
+      end
+
+      def table_schemas
+        instance.table_schemas || DEFAULT_TABLE_SCHEMAS
+      end
+    end
+  end
+end

data/lib/simpleadmin/database_connector.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'simpleadmin/adapters/base'
+require 'simpleadmin/adapters/postgres'
+
+module Simpleadmin
+  # Connector service that handles different databases to provide unified API endpoints
+  #
+  # @since 1.0.0
+  #
+  class DatabaseConnector
+    ADAPTERS_MAPPER = {
+      postgres: Adapters::Postgres
+    }.freeze
+
+    def initialize(database_credentials:)
+      @database_credentials = database_credentials
+    end
+
+    def client
+      adapter.new(database_credentials: database_credentials)
+    end
+
+    private
+
+    attr_reader :database_credentials
+
+    def adapter
+      adapter_class = ADAPTERS_MAPPER[database_credentials[:adapter]]
+      raise ArgumentError, 'Invalid adapter name or adapter not exist' if adapter_class.nil?
+
+      adapter_class
+    end
+  end
+end

data/lib/simpleadmin/decorators/fields/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Simpleadmin
+  module Decorators
+    module Fields
+      class Base
+        def initialize(table_name, table_field_name, resource)
+          @table_name = table_name
+          @table_field_name = table_field_name
+
+          @resource = resource
+        end
+
+        def call
+          raise NotImplementedError, 'Please follow the unified interface, add method #call'
+        end
+
+        private
+
+        attr_reader :table_name, :table_field_name, :resource
+
+        def model
+          model_class = table_name.classify.safe_constantize
+
+          if model_class.nil?
+            raise ArgumentError, "The model (#{table_name.classify}) does not exist"
+          else
+            model_class
+          end
+        end
+      end
+    end
+  end
+end