motor-admin-cstham8 0.4.35

data/lib/motor/dashboards/persistance.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Motor
+  module Dashboards
+    module Persistance
+      TitleAlreadyExists = Class.new(StandardError)
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        dashboard = assign_attributes(Dashboard.new, params)
+
+        dashboard.author = current_user
+
+        dashboard
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise TitleAlreadyExists if Dashboard.exists?(title: params[:title])
+
+        dashboard = build_from_params(params, current_user)
+
+        ApplicationRecord.transaction do
+          dashboard.save!
+        end
+
+        dashboard
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(dashboard, params, force_replace: false)
+        tag_ids = dashboard.tags.ids
+
+        dashboard = assign_attributes(dashboard, params)
+
+        raise TitleAlreadyExists if !force_replace && title_already_exists?(dashboard)
+
+        ApplicationRecord.transaction do
+          archive_with_existing_name(dashboard) if force_replace
+
+          dashboard.save!
+        end
+
+        dashboard.touch if tag_ids.sort != dashboard.tags.reload.ids.sort && params[:updated_at].blank?
+
+        dashboard
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(dashboard, params)
+        dashboard.assign_attributes(params.slice(:title, :description, :preferences))
+        dashboard.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
+
+        Motor::Tags.assign_tags(dashboard, params[:tags])
+      end
+
+      def archive_with_existing_name(dashboard)
+        Motor::Dashboard.where(['title = ? AND id != ?', dashboard.title, dashboard.id])
+                        .update_all(deleted_at: Time.current)
+      end
+
+      def title_already_exists?(dashboard)
+        if dashboard.new_record?
+          Motor::Dashboard.exists?(title: dashboard.title, deleted_at: nil)
+        else
+          Motor::Dashboard.exists?(['title = ? AND id != ? AND deleted_at IS NULL', dashboard.title, dashboard.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/dashboards.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Motor
+  module Dashboards
+  end
+end
+
+require_relative 'dashboards/persistance'

data/lib/motor/forms/persistance.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Motor
+  module Forms
+    module Persistance
+      NameAlreadyExists = Class.new(StandardError)
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        form = assign_attributes(Form.new, params)
+
+        form.author = current_user
+
+        form
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise NameAlreadyExists if Form.exists?(name: params[:name])
+
+        form = build_from_params(params, current_user)
+
+        ApplicationRecord.transaction do
+          form.save!
+        end
+
+        form
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(form, params, force_replace: false)
+        tag_ids = form.tags.ids
+
+        form = assign_attributes(form, params)
+
+        raise NameAlreadyExists if !force_replace && name_already_exists?(form)
+
+        ApplicationRecord.transaction do
+          archive_with_existing_name(form) if force_replace
+          find_or_assign_api_config(form)
+
+          form.save!
+        end
+
+        form.touch if tag_ids.sort != form.tags.reload.ids.sort && params[:updated_at].blank?
+
+        form
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(form, params)
+        form.assign_attributes(params.slice(:name, :description, :api_path, :http_method, :preferences,
+                                            :api_config_name))
+        form.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
+
+        find_or_assign_api_config(form)
+
+        Motor::Tags.assign_tags(form, params[:tags])
+      end
+
+      def find_or_assign_api_config(form)
+        return if form.api_config.present?
+
+        config = Motor::ApiConfig.find_by(url: [form.api_config_name, form.api_config_name.delete_suffix('/')])
+
+        if config
+          config.update!(deleted_at: nil)
+
+          form.api_config_name = config.name
+        else
+          form.api_config = Motor::ApiConfig.new(url: form.api_config_name.delete_suffix('/')).tap do |c|
+            c.name = c.url.sub(%r{\Ahttps?://}, '').delete_suffix('/')
+          end
+        end
+      end
+
+      def archive_with_existing_name(form)
+        Motor::Form.where(['name = ? AND id != ?', form.name, form.id])
+                   .update_all(deleted_at: Time.current)
+      end
+
+      def name_already_exists?(form)
+        if form.new_record?
+          Motor::Form.exists?(['name = ? AND deleted_at IS NULL', form.name])
+        else
+          Motor::Form.exists?(['name = ? AND id != ? AND deleted_at IS NULL', form.name, form.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/forms.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Motor
+  module Forms
+  end
+end
+
+require_relative 'forms/persistance'

data/lib/motor/hash_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Motor
+  class HashSerializer
+    def self.dump(hash)
+      hash.to_json
+    end
+
+    def self.load(hash)
+      return hash unless hash
+
+      hash = JSON.parse(hash.presence || '{}') if hash.is_a?(String)
+
+      if hash.is_a?(Hash)
+        hash.with_indifferent_access
+      else
+        hash.is_a?(FalseClass) ? hash : hash || {}
+      end
+    end
+  end
+end

data/lib/motor/net_http_utils.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Motor
+  module NetHttpUtils
+    module_function
+
+    def get(url, params = {}, headers = {}, _body = nil)
+      request = build_request(Net::HTTP::Get, url, params, headers, nil)
+
+      execute_request(request)
+    end
+
+    def post(url, params = {}, headers = {}, body = '')
+      request = build_request(Net::HTTP::Post, url, params, headers, body)
+
+      execute_request(request)
+    end
+
+    def put(url, params = {}, headers = {}, body = '')
+      request = build_request(Net::HTTP::Put, url, params, headers, body)
+
+      execute_request(request)
+    end
+
+    def delete(url, params = {}, headers = {}, body = '')
+      request = build_request(Net::HTTP::Delete, url, params, headers, body)
+
+      execute_request(request)
+    end
+
+    def build_request(method_class, url, params, headers, body)
+      uri = URI(url)
+      uri.query = params.to_query if params.present?
+
+      request = method_class.new(uri)
+      request.body = body if body.present?
+      headers.each { |key, value| request[key] = value }
+
+      request
+    end
+
+    def execute_request(request)
+      uri = request.uri
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.port == 443) do |http|
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/motor/notes/notify_mentions.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+    module NotifyMentions
+      EMAIL_REGEXP =
+        /[a-z0-9][.']?(?:(?:[a-z0-9_-]++[.'])*[a-z0-9_-]++)*@(?:[a-z0-9]++[.-])*[a-z0-9]++\.[a-z]{2,}/i.freeze
+      NOTIFICATION_DESCRIPTION_LIMIT = 100
+
+      module_function
+
+      def call(note, current_user)
+        users_class = fetch_users_class(current_user)
+
+        return unless users_class
+
+        emails  = note.body.scan(EMAIL_REGEXP)
+        emails -= [current_user&.email]
+
+        users_class.where(email: emails).find_each do |user|
+          notification = find_or_build_notification(note, user, current_user)
+
+          next if notification.persisted?
+
+          notification.save!
+
+          Motor::NotificationsMailer.notify_mention_email(notification).deliver_later!
+          Motor::NotificationsChannel.broadcast_to(user, ['notify', notification.as_json(include: %i[record])])
+        end
+      end
+
+      def find_or_build_notification(note, user, current_user)
+        notification = note.notifications.find { |e| e.recipient_id == user.id && e.recipient_type == user.class.name }
+
+        return notification if notification
+
+        Motor::Notification.new(
+          title: build_mention_title(note),
+          description: build_mention_description(note, current_user),
+          recipient: user,
+          record: note
+        )
+      end
+
+      def build_mention_title(note)
+        configs = Motor::BuildSchema.for_model(note.record.class)
+
+        display_value = note.record.attributes[configs['display_column']]
+
+        I18n.t('motor.new_mention_for',
+               resource: ["#{configs['display_name'].singularize} ##{note.record[note.record.class.primary_key]}",
+                          display_value].join(' '))
+      end
+
+      def build_mention_description(note, current_user)
+        I18n.t('motor.user_mentioned_you_with_note',
+               user: current_user&.email || 'Anonymous',
+               note: note.body.truncate(NOTIFICATION_DESCRIPTION_LIMIT))
+      end
+
+      def fetch_users_class(current_user)
+        return current_user.class if current_user
+        return Motor::AdminUser if defined?(Motor::AdminUser)
+        return AdminUser if defined?(AdminUser)
+        return User if defined?(User)
+
+        nil
+      end
+    end
+  end
+end

data/lib/motor/notes/notify_reminder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+    module NotifyReminder
+      NOTIFICATION_DESCRIPTION_LIMIT = 100
+
+      module_function
+
+      def call(reminder)
+        notification = find_or_build_notification(reminder)
+
+        return if notification.persisted?
+
+        notification.save!
+
+        Motor::NotificationsMailer.notify_reminder_email(notification).deliver_later!
+        Motor::NotificationsChannel.broadcast_to(reminder.recipient,
+                                                 ['notify', notification.as_json(include: %i[record])])
+      end
+
+      def find_or_build_notification(reminder)
+        notification = reminder.notifications.take
+
+        return notification if notification
+
+        note = reminder.record
+
+        Motor::Notification.new(
+          title: build_notification_title(note),
+          description: note.body.truncate(NOTIFICATION_DESCRIPTION_LIMIT),
+          recipient: reminder.recipient,
+          record: reminder
+        )
+      end
+
+      def build_notification_title(note)
+        configs = Motor::BuildSchema.for_model(note.record.class)
+
+        display_value = note.record.attributes[configs['display_column']]
+
+        I18n.t('motor.new_reminder_for',
+               resource: ["#{configs['display_name'].singularize} ##{note.record[note.record.class.primary_key]}",
+                          display_value].join(' '))
+      end
+    end
+  end
+end

data/lib/motor/notes/persist.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+    module Persist
+      TAG_REGEXP = /#\w+?\b/.freeze
+
+      module_function
+
+      def call(note, current_user)
+        note.author ||= current_user
+
+        tags = parse_tag_names(note)
+
+        Motor::Notes::Tags.assign_tags(note, tags)
+
+        note.save!
+
+        broadcast_note(note)
+
+        note
+      end
+
+      def broadcast_note(note)
+        Motor::NotesChannel.broadcast_to(
+          note.values_at(:record_type, :record_id).join(':'),
+          ['update', note.as_json(include: %i[author tags reminders])]
+        )
+      end
+
+      def parse_tag_names(note)
+        note.body.scan(TAG_REGEXP).pluck(1..)
+      end
+    end
+  end
+end

data/lib/motor/notes/reminders_scheduler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+    module RemindersScheduler
+      SCHEDULER_INTERVAL = 1.minute
+      CHECK_BEHIND_DURATION = 6.hours
+
+      SCHEDULER_TASK = Concurrent::TimerTask.new(
+        execution_interval: SCHEDULER_INTERVAL
+      ) { Motor::Notes::RemindersScheduler.call }
+
+      REMINDER_NOTIFICATIONS_JOIN_SQL = <<~SQL.squish
+        LEFT JOIN motor_notifications
+        ON cast(motor_notifications.record_id as int) = motor_reminders.id
+        AND motor_notifications.record_type = 'Motor::Reminder'
+      SQL
+
+      module_function
+
+      def call
+        ActiveRecord::Base.logger.silence do
+          load_reminders.each do |reminder|
+            ::Motor::NotifyReminderJob.perform_later(reminder)
+          rescue StandardError => e
+            Rails.logger.error(e)
+          end
+        end
+      end
+
+      def load_reminders
+        ::Motor::Reminder
+          .joins(REMINDER_NOTIFICATIONS_JOIN_SQL)
+          .where(scheduled_at: CHECK_BEHIND_DURATION.ago..Time.current.end_of_minute)
+          .where(motor_notifications: { id: nil })
+      end
+    end
+  end
+end

data/lib/motor/notes/tags.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+    module Tags
+      module_function
+
+      def assign_tags(note, tags)
+        return note if tags.blank?
+
+        tags.each do |tag_name|
+          next if note.note_tag_tags.find { |tt| tt.tag.name.casecmp(tag_name).zero? }
+
+          tag = NoteTag.find_or_initialize_by(name: tag_name)
+
+          note.note_tag_tags.new(tag: tag)
+        end
+
+        remove_missing_tags(note, tags) if note.persisted?
+
+        note
+      end
+
+      def remove_missing_tags(note, tags)
+        downcase_tags = tags.map(&:downcase)
+        tags_to_remove = note.tags.reject { |tt| tt.name.downcase.in?(downcase_tags) }
+
+        note.tags -= tags_to_remove
+
+        note
+      end
+    end
+  end
+end

data/lib/motor/notes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Motor
+  module Notes
+  end
+end
+
+require_relative 'notes/tags'
+require_relative 'notes/persist'
+require_relative 'notes/notify_mentions'
+require_relative 'notes/notify_reminder'
+require_relative 'notes/reminders_scheduler'

data/lib/motor/queries/persistance.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+    module Persistance
+      NameAlreadyExists = Class.new(StandardError)
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        query = assign_attributes(Query.new, params)
+
+        query.author = current_user
+
+        query
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise NameAlreadyExists if Query.exists?(name: params[:name])
+
+        query = build_from_params(params, current_user)
+
+        ApplicationRecord.transaction do
+          query.save!
+        end
+
+        query
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(query, params, force_replace: false)
+        tag_ids = query.tags.ids
+
+        query = assign_attributes(query, params)
+
+        raise NameAlreadyExists if !force_replace && name_already_exists?(query)
+
+        ApplicationRecord.transaction do
+          archive_with_existing_name(query) if force_replace
+          assign_or_create_api_config!(query)
+
+          query.save!
+        end
+
+        query.touch if tag_ids.sort != query.tags.reload.ids.sort && params[:updated_at].blank?
+
+        query
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(query, params)
+        query.assign_attributes(params.slice(:name, :description, :sql_body, :preferences))
+        query.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
+
+        Motor::Tags.assign_tags(query, params[:tags])
+      end
+
+      def archive_with_existing_name(query)
+        Motor::Query.where(['name = ? AND id != ?', query.name, query.id])
+                    .update_all(deleted_at: Time.current)
+      end
+
+      def assign_or_create_api_config!(query)
+        api_config_name = query.preferences[:api_config_name]
+
+        return if api_config_name.blank?
+        return if Motor::ApiConfig.find_by(name: api_config_name)
+
+        config = Motor::ApiConfig.find_by(url: [api_config_name, api_config_name.delete_suffix('/')])
+
+        config&.update!(deleted_at: nil)
+
+        config ||= Motor::ApiConfig.create!(name: api_config_name.sub(%r{\Ahttps?://}, '').delete_suffix('/'),
+                                            url: api_config_name.delete_suffix('/'))
+
+        query.preferences[:api_config_name] = config.name
+      end
+
+      def name_already_exists?(query)
+        if query.new_record?
+          Query.exists?(name: query.name, deleted_at: nil)
+        else
+          Query.exists?(['name = ? AND id != ? AND deleted_at IS NULL', query.name, query.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/queries/postgresql_exec_query.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+    module PostgresqlExecQuery
+      module_function
+
+      def call(conn, statement)
+        conn.send(:execute_and_clear, *statement) do |result|
+          types = {}
+          fields = result.fields
+
+          fields.each_with_index do |fname, i|
+            ftype = result.ftype i
+            fmod  = result.fmod i
+            types[fname] = conn.send(:get_oid_type, ftype, fmod, fname)
+          end
+
+          if conn.respond_to?(:build_result, true)
+            conn.send(:build_result, columns: fields, rows: result.values, column_types: types)
+          else
+            ActiveRecord::Result.new(fields, result.values, types)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/motor/queries/render_sql_template.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+    module RenderSqlTemplate
+      SECTION_OPEN_REGEXP = /{{([#^])\s*(\w+)}}.*\z/m.freeze
+      VARIABLE_REGEXP = /{{\s*(\w+)\s*}}/m.freeze
+
+      module_function
+
+      def call(sql, variables)
+        result = render_sections(sql, variables)
+
+        interpolate_variables(result, variables)
+      end
+
+      def interpolate_variables(sql, variables)
+        selected_variables = []
+
+        rendered =
+          sql.gsub(VARIABLE_REGEXP) do
+            variable_name = Regexp.last_match[1]
+
+            index = selected_variables.index { |name, _| name == variable_name }
+            variable_values = variables[variable_name]
+
+            if variable_values.is_a?(Array)
+              first_variable_index = selected_variables.size + 1
+
+              variable_values.each { |value| selected_variables << [variable_name, value] } unless index
+
+              (first_variable_index..selected_variables.size).map { |i| "$#{i}" }.join(', ')
+            else
+              selected_variables << [variable_name, variables[variable_name]] unless index
+
+              "$#{selected_variables.size}"
+            end
+          end
+
+        [rendered, selected_variables]
+      end
+
+      def render_sections(sql, variables)
+        sql.sub(SECTION_OPEN_REGEXP) do |e|
+          variable_name = Regexp.last_match[2]
+          is_negative = Regexp.last_match[1] == '^'
+
+          _, content, rest = e.split(build_section_close_regexp(variable_name), 3)
+
+          is_present = variables[variable_name].present?
+
+          render_sections(is_present ^ is_negative ? content + rest.to_s : rest, variables)
+        end
+      end
+
+      def build_section_close_regexp(variable_name)
+        %r{{{[#^/]s*#{Regexp.escape(variable_name)}\s*}}}m
+      end
+    end
+  end
+end