rails_execution 0.1.1

data/app/views/rails_execution/tasks/_tips.html.haml

@@ -0,0 +1,18 @@
+%h5.section-title.text-muted
+  %i.bi.bi-lightbulb
+  %strong ProTip:
+  %span#all-tips
+    %span.tip
+      Use
+      %code Rails.logger.info 'message...'
+      to add a message into log file
+    - if RailsExecution.configuration.file_upload
+      %span.tip
+        Call
+        %code file('name')
+        to read the file IO
+:javascript
+  var tipsCount = $('#all-tips span.tip').length;
+  var displayIndex = Math.floor(Math.random() * tipsCount);
+  $($('#all-tips span.tip')[displayIndex]).show();
+

data/app/views/rails_execution/tasks/closed.html.haml

@@ -0,0 +1,12 @@
+= re_card_content do
+  %h5.section-title Closed
+  %ul.list-unstyled
+    - if @tasks.empty?
+      %li
+        %p.mt-4.fs-5.text-center.text-muted
+          %i.bi.bi-journal-code.me-2
+          Welcome to add new Task
+    - else
+      = render partial: 'task', collection: @tasks
+
+= re_render_paging(@tasks)

data/app/views/rails_execution/tasks/completed.html.haml

@@ -0,0 +1,12 @@
+= re_card_content do
+  %h5.section-title Completed
+  %ul.list-unstyled
+    - if @tasks.empty?
+      %li
+        %p.mt-4.fs-5.text-center.text-muted
+          %i.bi.bi-journal-code.me-2
+          Welcome to add new Task
+    - else
+      = render partial: 'task', collection: @tasks
+
+= re_render_paging(@tasks)

data/app/views/rails_execution/tasks/edit.html.haml

@@ -0,0 +1,3 @@
+= re_card_content do
+  %h6.border-bottom.pb-2.mb-0 Edit request
+  = render partial: 'form', locals: { task: @task }

data/app/views/rails_execution/tasks/index.html.haml

@@ -0,0 +1,12 @@
+= re_card_content do
+  %h5.section-title In processing
+  %ul.list-unstyled
+    - if @tasks.empty?
+      %li
+        %p.mt-4.fs-5.text-center.text-muted
+          %i.bi.bi-journal-code.me-2
+          Welcome to add new Task
+    - else
+      = render partial: 'task', collection: @tasks
+
+= re_render_paging(@tasks)

data/app/views/rails_execution/tasks/new.html.haml

@@ -0,0 +1,3 @@
+= re_card_content do
+  %h6.border-bottom.pb-2.mb-0 New request
+  = render partial: 'form', locals: { task: @task }

data/app/views/rails_execution/tasks/show.html.haml

@@ -0,0 +1,38 @@
+= re_page_actions do
+  - if can_close_task?(current_task)
+    = link_to 'Close', task_path(current_task), class: 'btn btn-outline-danger', method: :delete, data: { confirm: 'Are you sure?' }
+  - elsif current_task.is_closed? && can_create_task?
+    = link_to 'Re-Open', reopen_task_path(current_task), class: 'btn btn-outline-info', method: :patch, data: { confirm: 'Are you sure?' }
+
+  - if can_edit_task?(current_task)
+    = link_to 'Edit', edit_task_path(current_task), class: 'btn btn-outline-warning me-2'
+
+.row
+  .col-md-8
+    = re_card_content do
+      %h6.border-bottom.pb-2.mb-0
+        = current_task.title
+        %span.float-end.fs-5.text-muted ##{current_task.id}
+      %p.mt-3.description
+        - if current_task.description.present?
+          #description-markdown= current_task.description
+          #description-html.normal-text
+        - else
+          %p.text-muted.text-center No description
+
+    = render partial: 'attachment_files'
+    = render partial: 'script_content'
+    = render partial: 'comments', locals: { new_comment: @new_comment }
+
+  .col-md-4
+    - if display_owner?(current_task.owner)
+      = re_card_content do
+        %h5.section-title.mb-3 Requestor
+        = render_user_info(current_task.owner, avatar_size: '40x40')
+
+    = render partial: 'reviewers'
+    = render partial: 'status'
+    = render partial: 'actions'
+    = render partial: 'activities'
+
+= render partial: 'show_scripts'

data/config/routes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RailsExecution::Engine.routes.draw do
+  root to: 'dashboards#home'
+
+  resource :dashboards, only: [] do
+    get :insights
+  end
+
+  resources :tasks do
+    member do
+      patch :reopen
+      patch :reject
+      patch :approve
+      patch :execute
+    end
+
+    collection do
+      get :completed
+      get :closed
+    end
+
+    resources :comments, only: [:create, :update, :destroy]
+  end
+
+end

data/lib/generators/rails_execution/file_upload_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module RailsExecution
+  module Generators
+    class FileUploadGenerator < Rails::Generators::Base
+
+      source_root File.join(__dir__, 'templates')
+
+      def copy_config
+        template 'file_uploader.rb', 'lib/rails_execution/file_uploader.rb'
+        template 'file_reader.rb', 'lib/rails_execution/file_reader.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/rails_execution/install_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+require 'active_record'
+
+module RailsExecution
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      include ActiveRecord::Generators::Migration
+
+      source_root File.join(__dir__, 'templates')
+
+      def copy_migration
+        migration_template 'install.rb', 'db/migrate/install_execution.rb', migration_version: migration_version
+      end
+
+      def copy_config
+        template 'config.rb', 'config/initializers/rails_execution.rb'
+      end
+
+      def mount_engine
+        route "mount RailsExecution::Engine, at: 'execution'"
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+
+    end
+  end
+end

data/lib/generators/rails_execution/templates/config.rb.tt

@@ -0,0 +1,63 @@
+RailsExecution.configuration do |config|
+
+  config.solo_mode = true # Without reviewing process
+
+  # Owner display
+  # config.owner_model = 'User'
+  # config.owner_method = :current_user
+  # config.owner_name_method = :fullname
+  # config.owner_avatar = lambda do |owner|
+  #   owner.avatar.url(:medium)
+  # end
+
+  # Task control
+  # config.reviewers = lambda do
+  #   [{ name: '', id: '' }]
+  # end
+
+  # Accessible check: Default is TRUE
+  # config.task_editable
+  # config.task_closable
+  # config.task_creatable
+  # config.task_approvable
+  # config.task_executable = lambda do |task, user|
+  #   YourPolicy.new(user, task).executable?
+  # end
+
+  # Advanced
+  # config.file_upload = true
+  # config.file_uploader = ::RailsExecution::FileUploader
+  # config.file_reader = ::RailsExecution::FileReader
+  # Defaults of acceptable_file_types: .png, .gif, .jpg, .jpeg, .pdf, .csv
+  # config.acceptable_file_types = {
+  #   '.jpeg': 'image/jpeg',
+  #   '.pdf': 'application/pdf',
+  #   '.csv': ['text/csv', 'text/plain'],
+  # }
+
+  # Logger
+  # Using Paperclip
+  # config.logging = lambda do |log_file, task|
+  #   YourAttachment.create(file: log_file, task: task)
+  # end
+  # config.logging_files = lambda do |task|
+  #   YourAttachment.where(task: task).map { |item| item.file.url }
+  # end
+  # Using ActiveStorage
+  # config.logging = lambda do |log_file, task|
+  #   attachment = YourAttachment.create!(task: task)
+  #   attachment.file.attach({
+  #     io: log_file,
+  #     filename: Time.current.strftime('%Y%m%d_%H%M%S.log'),
+  #     content_type: 'text/plain',
+  #   })
+  # end
+  # config.logging_files = lambda do |task|
+  #   ActiveStorage::Current.host = 'localhost:3000'
+  #   YourAttachment.where(task: task).map { |item| item.file.url }
+  # end
+
+  # Paging
+  # config.per_page = 30 # Default: 20
+
+end

data/lib/generators/rails_execution/templates/file_reader.rb.tt

@@ -0,0 +1,14 @@
+module RailsExecution
+  class FileReader < RailsExecution::Files::Reader
+
+    # Output: {
+    #   'File1' => 'url',
+    #   'FileZ' => 'url',
+    # }
+    def call
+      # YourAttachment.where(task: task).pluck(:name, :url).to_h
+      return {}
+    end
+
+  end
+end

data/lib/generators/rails_execution/templates/file_uploader.rb.tt

@@ -0,0 +1,11 @@
+module RailsExecution
+  class FileUploader < RailsExecution::Files::Uploader
+
+    def call
+      files.each do |item|
+        # YourAttachment.create!(task: task, name: item.name, file: item.file)
+      end
+    end
+
+  end
+end

data/lib/generators/rails_execution/templates/install.rb.tt

@@ -0,0 +1,48 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+
+  def change
+    create_table :rails_execution_tasks, force: true do |t|
+      t.timestamps null: false
+      t.column :title, :string, null: false
+      t.column :status, :string, null: false
+      t.column :syntax_status, :string, default: 'bad'
+      t.column :description, :text
+      t.column :script, :text
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+    end
+    add_index :rails_execution_tasks, :status
+    add_index :rails_execution_tasks, [:owner_id, :owner_type], name: :owner_index
+
+    create_table :rails_execution_comments, force: true do |t|
+      t.timestamps null: false
+      t.column :task_id, :integer, null: false
+      t.column :content, :text, null: false
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+    end
+    add_index :rails_execution_comments, :task_id
+    add_index :rails_execution_comments, [:owner_id, :owner_type], name: :owner_index
+
+    create_table :rails_execution_activities, force: true do |t|
+      t.timestamps null: false
+      t.column :task_id, :integer, null: false
+      t.column :message, :text, null: false
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+    end
+    add_index :rails_execution_activities, :task_id
+    add_index :rails_execution_activities, [:owner_id, :owner_type], name: :owner_index
+
+    create_table :rails_execution_task_reviews, force: true do |t|
+      t.timestamps null: false
+      t.column :task_id, :integer, null: false
+      t.column :status, :text, null: false
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+    end
+    add_index :rails_execution_task_reviews, :task_id
+    add_index :rails_execution_task_reviews, [:owner_id, :owner_type], name: :owner_index
+  end
+
+end

data/lib/rails_execution/app_model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+model_klass = defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base
+
+class RailsExecution::AppModel < model_klass
+
+  self.abstract_class = true
+
+  belongs_to :owner, polymorphic: true
+
+  scope :descending, -> { order(id: :desc) }
+  scope :ascending, -> { order(id: :asc) }
+
+end

data/lib/rails_execution/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsExecution
+  class Config
+
+    DEFAULT_PER_PAGE = 20
+    DEFAULT_FILE_TYPES = {
+      '.png': 'image/png',
+      '.gif': 'image/gif',
+      '.jpg': 'image/jpg',
+      '.jpeg': 'image/jpeg',
+      '.pdf': 'application/pdf',
+      '.csv': ['text/csv', 'text/plain'],
+    }
+
+    attr_accessor :solo_mode # Solo mode without reviewing process
+
+    # Owner display
+    attr_accessor :owner_model
+    attr_accessor :owner_method
+    attr_accessor :owner_name_method
+    attr_accessor :owner_avatar # lambda
+
+    # Task control
+    attr_accessor :reviewers # lambda
+
+    # Accessible check
+    attr_accessor :task_editable # lambda
+    attr_accessor :task_closable # lambda
+    attr_accessor :task_creatable # lambda
+    attr_accessor :task_approvable # lambda
+    attr_accessor :task_executable # lambda
+
+    # Advanced
+    attr_accessor :file_upload
+    attr_accessor :file_uploader
+    attr_accessor :file_reader
+    attr_accessor :acceptable_file_types
+
+    # Logger
+    attr_accessor :logging # lambda
+    attr_accessor :logging_files
+
+    # Paging
+    attr_accessor :per_page
+
+    def initialize
+      self.solo_mode = true
+
+      self.owner_model = defined?(::User) ? 'User' : nil
+      self.owner_method = :current_user
+      self.owner_name_method = :name
+      self.owner_avatar = ->(_) { nil }
+
+      self.file_upload = false
+      self.acceptable_file_types = DEFAULT_FILE_TYPES
+      self.file_uploader = ::RailsExecution::Files::Uploader
+      self.file_reader = ::RailsExecution::Files::Reader
+      self.per_page = DEFAULT_PER_PAGE
+      self.reviewers = -> { [] }
+
+      self.task_creatable = -> (_user) { true }
+      self.task_editable = -> (_user, _task) { true }
+      self.task_closable = -> (_user, _task) { true }
+      self.task_approvable = -> (_user, _task) { true }
+      self.task_executable = -> (_user, _task) { true }
+
+      self.logging = -> (_log_file, _task) { }
+      self.logging_files = -> (_task) { [] }
+    end
+
+  end
+end

data/lib/rails_execution/engine.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'haml'
+
+module RailsExecution
+  class Engine < ::Rails::Engine
+
+    isolate_namespace ::RailsExecution
+
+    initializer 'execution' do |app|
+      if defined?(Sprockets)
+        app.config.assets.precompile << 'executions/base.js'
+        app.config.assets.precompile << 'executions/base.css'
+        app.config.assets.precompile << 'executions/logo.png'
+        app.config.assets.precompile << 'executions/robot.png'
+        app.config.assets.precompile << 'executions/favicon.png'
+        app.config.assets.precompile << 'executions/rejected.png'
+        app.config.assets.precompile << 'executions/approved.png'
+        app.config.assets.precompile << 'executions/bootstrap-icons.woff' # Icons font
+      end
+    end
+
+  end
+end

data/lib/rails_execution/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RailsExecution
+  class Error < StandardError; end
+  class AccessDeniedError < Error; end
+end

data/lib/rails_execution/files/reader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'tempfile'
+require 'uri'
+
+module RailsExecution
+  module Files
+    class Reader
+
+      def initialize(task)
+        @task = task
+        @tempfile_by_name = {}
+      end
+
+      def call
+        raise ::NotImplementedError, "load_files (Output: { 'file1' => 'file-url', file2 => 'file-url' })"
+      end
+
+      # Return: the Tempfile instance
+      def get_file(name)
+        return nil if name.blank?
+
+        @file_url_by_name ||= call
+        file_url = @file_url_by_name[name]
+        return nil if file_url.blank?
+
+        @tempfile_by_name[name] ||= save_to_tempfile(name, file_url)
+      end
+
+      private
+
+      attr_reader :task
+
+      def save_to_tempfile(file_name, url)
+        file_extension = URI(url).path.split('.').last
+        file_extension = ".#{file_extension}" if file_extension
+        tmp_file = Tempfile.new([file_name, file_extension])
+        tmp_file.binmode
+        open(url) do |url_file|
+          tmp_file.write(url_file.read)
+        end
+
+        return tmp_file
+      end
+
+    end
+  end
+end

data/lib/rails_execution/files/uploader.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RailsExecution
+  module Files
+    class Uploader
+
+      def initialize(task, inputs, owner: nil)
+        @task = task
+        @files = files_filter(inputs).compact
+        @owner = owner
+      end
+
+      def call
+        raise ::NotImplementedError, 'File uploader'
+      end
+
+      private
+
+      attr_reader :task
+      attr_reader :files
+      attr_reader :owner
+
+      def files_filter(inputs)
+        inputs.map do |_multiple, attachment|
+          next if attachment['name'].blank?
+          next if attachment['file'].blank?
+          next unless attachment['file'].content_type.in?(acceptable_file_types)
+
+          OpenStruct.new({
+            name: attachment['name'],
+            file: attachment['file'],
+          })
+        end
+      end
+
+      def acceptable_file_types
+        ::RailsExecution.configuration.acceptable_file_types.values
+      end
+
+    end
+  end
+end

data/lib/rails_execution/services/approvement.rb

@@ -0,0 +1,41 @@
+module RailsExecution
+  module Services
+    class Approvement
+
+      def initialize(task, reviewer: nil)
+        @task = task || (raise 'task is blank')
+        @reviewer = reviewer || (raise 'reviewer is blank')
+      end
+
+      def approve
+        task.update(status: :approved)
+        review.update(status: :approved)
+        add_activity('approved')
+      end
+
+      def reject
+        review.update(status: :rejected)
+        task.update(status: :rejected) if make_task_to_rejected?
+        add_activity('rejected')
+      end
+
+      private
+
+      attr_reader :task
+      attr_reader :reviewer
+
+      def review
+        @review ||= task.task_reviews.find_or_initialize_by(owner: reviewer)
+      end
+
+      def add_activity(status)
+        task.activities.create(owner: reviewer, message: "#{status.titleize} the task")
+      end
+
+      def make_task_to_rejected?
+        task.task_reviews.is_approved.empty?
+      end
+
+    end
+  end
+end

data/lib/rails_execution/services/execution.rb

@@ -0,0 +1,87 @@
+module RailsExecution
+  module Services
+    class Execution
+
+      def self.call(task_id)
+        self.new(::RailsExecution::Task.find(task_id)).call
+      end
+
+      def initialize(task)
+        @task = task
+      end
+
+      def call
+        return if bad_syntax?
+
+        build_execution_file!
+        load_execution_file!
+        is_successful = false
+        begin
+          setup_logger!
+          execute_class!
+          is_successful = true
+        rescue
+          is_successful = false
+        ensure
+          restore_logger!
+          storing_log_file!
+          return is_successful
+        end
+      end
+
+      private
+
+      attr_reader :task
+      attr_reader :class_name
+
+      def bad_syntax?
+        !::RailsExecution::Services::SyntaxChecker.new(task.script).call
+      end
+
+      def build_execution_file!
+        @class_name = "RailsExecutionID#{task.id}Time#{task.updated_at.to_i}Executor"
+        ruby_code = <<~RUBY
+          class #{class_name} < ::RailsExecution::Services::Executor
+            def call
+              task.with_lock do
+                #{task.script}
+              end
+            end
+          end
+        RUBY
+
+        @file = ::Tempfile.new([class_name, '.rb'])
+        @file.binmode
+        @file.write(ruby_code)
+        @file.flush
+        @file
+      end
+
+      def load_execution_file!
+        load @file.path
+      end
+
+      def setup_logger!
+        @model_logger = ::ActiveRecord::Base.logger
+        @rails_logger = ::Rails.logger
+        @tempfile = ::Tempfile.new(["rails_execution_#{Time.current.strftime('%Y%m%d_%H%M%S')}", '.log'])
+        ::ActiveRecord::Base.logger = ::Logger.new(@tempfile.path)
+        ::Rails.logger = ::ActiveRecord::Base.logger
+      end
+
+      def execute_class!
+        class_name.constantize.new(task).call
+      end
+
+      def storing_log_file!
+        ::RailsExecution.configuration.logging.call(@tempfile, task)
+      end
+
+      def restore_logger!
+        ::ActiveRecord::Base.logger = @model_logger
+        ::Rails.logger = @rails_logger
+      end
+
+    end
+  end
+end