ezii-postgres 0.0.1

data/natural-backend/app/controllers/queries_controller.rb

@@ -0,0 +1,59 @@
+class QueriesController < ApplicationController
+  skip_before_action :authenticate_user
+  before_action :authenticate_project
+  before_action :fetch_database
+  before_action :fetch_query, only: [:index, :show, :destroy]
+
+  # GET /queries
+  def index
+    @queries = @database.queries.all
+
+    render json: @queries
+  end
+
+  def show
+    render json: { result: @query.response_data }
+  end
+
+  def create
+    @query = @database.queries.build(request_data: params[:sql])
+    @query.instant_execution = !(params[:async] == '1')
+    if @query.save
+      if @query.instant_execution
+        render json: { result: @query.run_query }
+      else
+        render json: { id: @query.id }, status: :created, location: [@database, @query]
+      end
+    else
+      render json: @query.errors, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @query.destroy
+  end
+
+  private
+
+    # TODO: check if project provided by authentication token matches project of queried database
+    def authenticate_project
+      command = DecodeProjectAuthenticationTokenCommand.call(request.headers)
+      @project = command.result
+      unless @project
+        render json: { error: 'Not Authenticated' }, status: 403
+      end
+    end
+
+    def fetch_database
+      @database = @project.databases.find(params[:database_id])
+    end
+
+    def fetch_query
+      @query = @database.queries.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def query_params
+      params.require(:query).permit(:sql)
+    end
+end

data/natural-backend/app/controllers/row_values_controller.rb

@@ -0,0 +1,51 @@
+class RowValuesController < ApplicationController
+  before_action :set_row_value, only: [:show, :update, :destroy]
+
+  # GET /row_values
+  def index
+    @row_values = current_user.row_values.all
+
+    render json: @row_values
+  end
+
+  # GET /row_values/1
+  def show
+    render json: @row_value
+  end
+
+  # POST /row_values
+  def create
+    @row_value = current_user.row_values.build(row_value_params)
+
+    if @row_value.save
+      render json: @row_value, status: :created, location: @row_value
+    else
+      render json: @row_value.errors, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /row_values/1
+  def update
+    if @row_value.update(row_value_params)
+      render json: @row_value
+    else
+      render json: @row_value.errors, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /row_values/1
+  def destroy
+    @row_value.destroy
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_row_value
+      @row_value = current_user.row_values.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def row_value_params
+      ActiveModelSerializers::Deserialization.jsonapi_parse(params, only: [:column, :row, :value])
+    end
+end

data/natural-backend/app/controllers/rows_controller.rb

@@ -0,0 +1,56 @@
+class RowsController < ApplicationController
+  before_action :set_row, only: [:show, :update, :destroy]
+
+  # GET /rows
+  def index
+    @rows = current_user
+      .tables
+      .find(params[:table_id])
+      .rows
+      .page(params[:page] || 1)
+      .per(params[:per_page] || 12)
+
+    render json: @rows, meta: { total_pages: @rows.total_pages }
+  end
+
+  # GET /rows/1
+  def show
+    render json: @row
+  end
+
+  # POST /rows
+  def create
+    @row = current_user.rows.build(row_params)
+
+    if @row.save
+      render json: @row, status: :created, location: @row
+    else
+      render json: @row.errors, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /rows/1
+  def update
+    if @row.update(row_params)
+      render json: @row
+    else
+      render json: @row.errors, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /rows/1
+  def destroy
+    @row.destroy
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_row
+      @row = current_user.rows.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def row_params
+      ActiveModelSerializers::Deserialization.jsonapi_parse(params, only: [:table])
+    end
+end

data/natural-backend/app/controllers/tables_controller.rb

@@ -0,0 +1,55 @@
+class TablesController < ApplicationController
+  before_action :set_table, only: [:show, :update, :destroy]
+  before_action :get_tables, only: [:index]
+
+  # GET /tables
+  def index
+    render json: @tables
+  end
+
+  # GET /tables/1
+  def show
+    render json: @table
+  end
+
+  # POST /tables
+  def create
+    @table = current_user.tables.build(table_params)
+
+    if @table.save
+      render json: @table, status: :created, location: @table
+    else
+      render json: @table.errors, status: :unprocessable_entity
+    end
+  end
+
+  # PATCH/PUT /tables/1
+  def update
+    if @table.update(table_params)
+      render json: @table
+    else
+      render json: @table.errors, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /tables/1
+  def destroy
+    @table.destroy
+  end
+
+  private
+
+    # Get tables associated with a particular db
+    def get_tables
+      @tables = Table.for_database_id(params[:db_id])
+    end
+    # Use callbacks to share common setup or constraints between actions.
+    def set_table
+      @table = current_user.tables.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def table_params
+      ActiveModelSerializers::Deserialization.jsonapi_parse(params, only: [:name, :database])
+    end
+end

data/natural-backend/app/jobs/application_job.rb

@@ -0,0 +1,2 @@
+class ApplicationJob < ActiveJob::Base
+end

data/natural-backend/app/jobs/create_column_job.rb

@@ -0,0 +1,10 @@
+class CreateColumnJob < ApplicationJob
+  queue_as :default
+
+  def perform(column)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(column.table.database.database_identifier)
+    table = db.table(column.table.name)
+    table.add_column(column.name)
+  end
+end

data/natural-backend/app/jobs/create_database_job.rb

@@ -0,0 +1,11 @@
+class CreateDatabaseJob < ApplicationJob
+  queue_as :default
+
+  def perform(database)
+    db_manager = ::Natural::DatabaseManager.new
+    db_user = db_manager.database_user(database.project.db_username,
+                                       database.project.db_password)
+    db = db_manager.create_database(database.database_identifier)
+    db_user.grant(db)
+  end
+end

data/natural-backend/app/jobs/create_database_user_job.rb

@@ -0,0 +1,8 @@
+class CreateDatabaseUserJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_username, db_password)
+    db_manager = ::Natural::DatabaseManager.new
+    db_manager.create_user(db_username, db_password)
+  end
+end

data/natural-backend/app/jobs/create_table_job.rb

@@ -0,0 +1,21 @@
+class CreateTableJob < ApplicationJob
+  queue_as :default
+
+  def perform(table)
+    db_user = ::Natural::DatabaseUser.new(table.database.project.db_username,
+                                          table.database.project.db_password)
+    database = ::Natural::Database.new(table.database.database_identifier)
+    connection = ::Natural::Connection.new
+    connection.db_user = db_user
+    connection.database = database
+
+    connection.establish_connection
+
+    table = ::Natural::Table.new(table.name)
+    table.connection = connection
+
+    table.create
+
+    connection.close
+  end
+end

data/natural-backend/app/jobs/delete_row_job.rb

@@ -0,0 +1,12 @@
+class DeleteRowJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_uuid, table_name, id)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(db_uuid)
+    table = db.table(table_name)
+    if id.present?
+      table.delete_row(id)
+    end
+  end
+end

data/natural-backend/app/jobs/delete_value_job.rb

@@ -0,0 +1,10 @@
+class DeleteValueJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_uuid, table_name, column_name, id)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(db_uuid)
+    table = db.table(table_name)
+    table.delete_value(column_name, id)
+  end
+end

data/natural-backend/app/jobs/destroy_column_job.rb

@@ -0,0 +1,10 @@
+class DestroyColumnJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_uuid, table_name, column_name)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(db_uuid)
+    table = db.table(table_name)
+    table.destroy_column(column_name)
+  end
+end

data/natural-backend/app/jobs/destroy_database_job.rb

@@ -0,0 +1,8 @@
+class DestroyDatabaseJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_uuid)
+    db_manager = ::Natural::DatabaseManager.new
+    db_manager.destroy_database(db_uuid)
+  end
+end

data/natural-backend/app/jobs/destroy_database_user_job.rb

@@ -0,0 +1,8 @@
+class DestroyDatabaseUserJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_username)
+    db_manager = ::Natural::DatabaseManager.new
+    db_manager.destroy_user(db_username)
+  end
+end

data/natural-backend/app/jobs/destroy_table_job.rb

@@ -0,0 +1,9 @@
+class DestroyTableJob < ApplicationJob
+  queue_as :default
+
+  def perform(db_uuid, table_name)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(db_uuid)
+    db.destroy_table(table_name)
+  end
+end

data/natural-backend/app/jobs/insert_value_job.rb

@@ -0,0 +1,11 @@
+class InsertValueJob < ApplicationJob
+  queue_as :default
+
+  def perform(row_value)
+    db_manager = ::Natural::DatabaseManager.new
+    db = db_manager.database(row_value.column.table.database.database_identifier)
+    table = db.table(row_value.column.table.name)
+    id = table.insert_value(row_value.column.name, row_value.value)
+    row_value.row.update_attribute(:db_id, id)
+  end
+end

data/natural-backend/app/jobs/run_query_job.rb

@@ -0,0 +1,35 @@
+class RunQueryJob < ApplicationJob
+  queue_as :default
+  
+  def exceptions_matching(&block)
+    Class.new do
+      def self.===(other)
+        @block.call(other)
+      end
+    end.tap do |c|
+      c.instance_variable_set(:@block, block)
+    end
+  end
+
+  def perform(query)
+    db_user = ::Natural::DatabaseUser.new(query.database.project.db_username,
+                                        query.database.project.db_password)
+    db = ::Natural::Database.new(query.database.database_identifier)
+
+    connection = ::Natural::Connection.new
+    connection.db_user = db_user
+    connection.database = db
+
+    connection.establish_connection
+
+    begin
+      result = connection.exec(query.request_data).values
+      query.update_attribute(:response_data, result)
+    rescue exceptions_matching { |e| e.class.name.split('::')[0] == 'PG' } => e
+      # TODO: Add error field to query and render a 500 + error message in queries#create in case of an error
+      query.update_attribute(:response_data, {error: e.message})
+    ensure
+      connection.close
+    end
+  end
+end

data/natural-backend/app/jobs/sync_db_job.rb

@@ -0,0 +1,80 @@
+#   class SyncDbJob < ApplicationJob
+#     queue_as :default
+    
+#     def sync_tables
+#       db_manager = ::Natural::DatabaseManager.new
+#       Database.all.each do |database|
+#         next if database.name.blank?
+  
+#         db_manager.connect_to_database(database.database_identifier)
+        
+#         existing_tables = database.tables.map(&:database_identifier)
+#         db_manager.tables.each do |table|
+#           unless existing_tables.include?(table.name)
+#             table = database.tables.build(database_identifier: table.name, name: table.name)
+#             table.save!
+#           end
+#         end  
+#       end
+#     end
+    
+#     def sync_rows_and_columns(table_name = nil)
+#       db_manager = ::Natural::DatabaseManager.new
+#       (table_name ? Table.where(name: table_name) : Table.all).each do |table|
+#         next if table.name.blank?
+  
+#         db_manager.connect_to_database(table.database.database_identifier)
+#         to_be_removed_ids = table.rows.pluck(:db_id)
+  
+#         query = <<-SQL
+#           SELECT *
+#           FROM \"#{table.name}\"
+#         SQL
+  
+#         db_manager.connection.exec(query).each do |row|
+#           row_db_id = row.values_at('id')[0].to_i
+  
+#           to_be_removed_ids.delete(row_db_id)
+  
+#           if app_layer_row = Row.find_by(db_id: row_db_id)
+#             table.columns.each do |column|
+#               value = row.values_at(column.name)[0]
+#               row_value = RowValue.find_or_create_by(row: app_layer_row, column: column, user: table.user)
+#               # TODO: find a more elegant solution than update_columns
+#               # * updates_at/update_on are not updated
+#               # last resort: set updated_at/update_on manually here
+#               # reason for using update_columns in the first place: callback skipping
+#               row_value.update_columns(value: value)
+#             end
+#           else
+#             puts "why tho?"
+#             app_layer_row = Row.create(db_id: row.values_at('id')[0], table: table, user: table.user)
+#             table.columns.each do |column|
+#               value = row.values_at(column.name)[0]
+#               puts column.name
+#               puts value
+#               RowValue.create(row: app_layer_row, column: column, value: value, user: table.user)
+#             end
+#           end
+  
+#         end
+#         #
+#         Row.where(db_id: to_be_removed_ids).destroy_all
+#       end
+  
+#       return nil
+#     end
+  
+#     def perform
+#       %I[sync_rows_and_columns sync_tables].each do |method_name|
+#         RedisMutex.with_lock(method_name) do
+#           ActiveRecord::Base.logger.silence do
+#             public_send(method_name)
+#           end
+#         rescue RedisMutex::LockError
+#           Rails.logger.debug "Another job is running, exiting ..."
+#         end
+#       end
+#     end
+#   end
+