motor-admin 0.3.16 → 0.4.0

data/lib/generators/motor/upgrade_generator.rb

@@ -15,22 +15,29 @@ module Motor
       source_root File.expand_path('templates', __dir__)
 
       def copy_migration
-        has_api_actions = Motor::Resource.all.any? do |resource|
-          resource.preferences[:actions]&.any? { |action| action[:action_type] == 'api' }
-        end
-
         unless Motor::ApiConfig.table_exists?
           migration_template 'install_api_configs.rb', 'db/migrate/install_motor_api_configs.rb'
         end
 
-        migration_template 'upgrade_motor_api_actions.rb', 'db/migrate/upgrade_motor_api_actions.rb' if has_api_actions
+        if with_api_actions?
+          migration_template 'upgrade_motor_api_actions.rb', 'db/migrate/upgrade_motor_api_actions.rb'
+        end
+
+        migration_template 'install_notes.rb', 'db/migrate/install_motor_notes.rb' unless Motor::Note.table_exists?
 
-        if Motor::ApiConfig.table_exists? && !has_api_actions
+        if Motor::ApiConfig.table_exists? && !with_api_actions? && Motor::Note.table_exists?
           puts 'The latest Motor Admin features are already configured'
         else
           puts 'Run `rake db:migrate` to update DB schema'
         end
       end
+
+      def with_api_actions?
+        @with_api_actions ||=
+          Motor::Resource.all.any? do |resource|
+            resource.preferences[:actions]&.any? { |action| action[:action_type] == 'api' }
+          end
+      end
     end
   end
 end

data/lib/motor/admin.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class Admin < ::Rails::Engine
+    config.custom_html = ''
+
     initializer 'motor.startup_message' do
       config.after_initialize do
         next unless Motor.server?
@@ -48,6 +50,7 @@ module Motor
         next unless Rails.env.production?
 
         Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
+        Motor::Notes::RemindersScheduler::SCHEDULER_TASK.execute
       end
     end
 
@@ -78,6 +81,15 @@ module Motor
       end
     end
 
+    initializer 'action_cable.connection_class' do
+      config.after_initialize do
+        next if defined?(::ApplicationCable::Connection)
+        next unless defined?(::ActionCable)
+
+        ActionCable.server.config.connection_class = -> { Motor::ApplicationCable::Connection }
+      end
+    end
+
     initializer 'motor.active_storage.extensions' do
       config.after_initialize do
         next unless defined?(ActiveStorage::Engine)
@@ -107,7 +119,7 @@ module Motor
           raise
         end
 
-        unless Motor::ApiConfig.table_exists?
+        if !Motor::ApiConfig.table_exists? || !Motor::Note.table_exists?
           puts
           puts '  => Run `rails g motor:upgrade && rake db:migrate`' \
                ' to perform data migration and enable the latest features'

data/lib/motor/alerts/slack_sender.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module SlackSender
+      MARKDOWN_LINK_TRANSFORM_REGEXP = /\[(.+?)\]\((.+?)\)/.freeze
+      MARKDOWN_PATHS_TRANSFORM_REGEXP = /\n\s*\#{1,5}\s*(.*)\n?/.freeze
+      MARKDOWN_HEADING_TRANSFORM_REGEXP = /\n\s*\#{1,5}\s*(.*)\n?/.freeze
+      MARKDOWN_BOLD_TRANSFORM_REGEXP = /[*_]{2}/.freeze
+
+      DEFAULT_FILENAME = 'data.csv'
+
+      module_function
+
+      def call(alert, conversation_id, slack_user: nil)
+        query_result = load_data(alert, slack_user)
+
+        if alert.query.preferences[:visualization] == 'markdown'
+          text = [build_query_link(alert), render_markdown(alert, query_result)].join
+
+          Slack::Client.send_message(channel: conversation_id,
+                                     as_user: slack_user.present?,
+                                     text: text)
+        else
+          Slack::Client.send_message(channel: conversation_id,
+                                     as_user: slack_user.present?,
+                                     text: build_alert_message(alert))
+          Slack::Client.send_file(channels: conversation_id,
+                                  content: generate_csv(query_result),
+                                  filename: DEFAULT_FILENAME)
+        end
+      end
+
+      def build_alert_message(alert)
+        <<~MARKDOWN
+          #{build_query_link(alert)}
+          #{alert.description}
+        MARKDOWN
+      end
+
+      def build_query_link(alert)
+        link = Motor::Admin.routes.url_helpers.motor_ui_query_url(alert.query_id, host: Motor.app_host)
+
+        "*<#{link}|#{alert.name}>*"
+      end
+
+      def render_markdown(alert, query_result)
+        params = query_result.columns.pluck(:name).zip(query_result.data[0]).to_h.symbolize_keys
+
+        markdown =
+          ["\n", Mustache.render(alert.query.preferences[:visualization_options][:markdown], **params)].join
+
+        markdown.gsub(/\((.*)\)/, "(http://#{Motor.app_host}\\1)")
+                .gsub(MARKDOWN_LINK_TRANSFORM_REGEXP, '<\2|\1>')
+                .gsub(MARKDOWN_HEADING_TRANSFORM_REGEXP, "\n\n*\\1*")
+                .gsub(MARKDOWN_BOLD_TRANSFORM_REGEXP, '*')
+      end
+
+      def generate_csv(query_result)
+        rows = [query_result.columns.pluck(:name)] + query_result.data
+
+        rows.map(&:to_csv).join
+      end
+
+      def load_data(alert, slack_user = nil)
+        if slack_user
+          Queries::RunQuery.call(alert.query, variables_hash: { current_user_email: slack_user['email'] })
+        else
+          Queries::RunQuery.call(alert.query)
+        end
+      end
+    end
+  end
+end

data/lib/motor/alerts.rb

@@ -2,9 +2,51 @@
 
 module Motor
   module Alerts
+    module_function
+
+    def send_alert(alert)
+      if alert.preferences[:adapter] == 'slack'
+        send_slack_alert(alert)
+      else
+        send_email_alert(alert)
+      end
+    end
+
+    def send_email_alert(alert)
+      alert.to_emails.split(',').each do |email|
+        if email.include?('@')
+          Motor::AlertsMailer.alert_email(alert, email: email).deliver_now!
+        else
+          send_query_email_alerts(alert, email.gsub(/[{}]/, ''))
+        end
+      end
+    end
+
+    def send_query_email_alerts(alert, column_name)
+      result = Queries::RunQuery.call(alert.query)
+
+      column_index = result.columns.find_index { |c| c[:name] == column_name }
+
+      emails = result.data.map { |row| row[column_index] }.uniq
+
+      emails.each do |email|
+        Motor::AlertsMailer.alert_email(alert, email: email).deliver_now!
+      end
+    end
+
+    def send_slack_alert(alert)
+      slack_users = Slack::Client.load_users(limit: Slack::ITEMS_LIMIT)['members']
+
+      alert.preferences[:slack_conversation_ids].each do |conversation_id|
+        user = slack_users.find { |u| u['id'] == conversation_id }
+
+        Motor::Alerts::SlackSender.call(alert, conversation_id, slack_user: user)
+      end
+    end
   end
 end
 
 require_relative './alerts/scheduler'
 require_relative './alerts/scheduled_alerts_cache'
 require_relative './alerts/persistance'
+require_relative './alerts/slack_sender'

data/lib/motor/api_query/apply_scope.rb

@@ -25,6 +25,7 @@ module Motor
         scope_configs = configs.preferences[:scopes].find { |s| s[:name] == scope }
 
         return rel unless scope_configs
+        return rel unless scope_configs[:preferences]
 
         rel = ApiQuery::Filter.call(rel, scope_configs[:preferences][:filter])
 

data/lib/motor/build_schema/apply_permissions.rb

@@ -14,6 +14,7 @@ module Motor
           model[:associations] = filter_associations(model[:associations], ability)
           model[:columns] = filter_columns(klass, model[:columns], ability)
           model[:actions] = filter_actions(klass, model[:actions], ability)
+          model[:tabs] = filter_tabs(klass, model[:tabs], ability)
 
           model
         end.compact
@@ -27,6 +28,13 @@ module Motor
         end
       end
 
+      def filter_tabs(_model, tabs, ability)
+        tabs = tabs.reject { |t| t[:name] == 'audits' } unless ability.can?(:read, Motor::Audit)
+        tabs = tabs.reject { |t| t[:name] == 'notes' } unless ability.can?(:read, Motor::Note)
+
+        tabs
+      end
+
       def filter_columns(model, columns, ability)
         columns.map do |column|
           next unless ability.can?(:read, model, column[:name])

data/lib/motor/build_schema/defaults.rb

@@ -34,7 +34,6 @@ module Motor
           }
         ].freeze
       end
-      # rubocop:enable Metrics/MethodLength
 
       def tabs
         [
@@ -44,9 +43,24 @@ module Motor
             tab_type: BuildSchema::DEFAULT_TYPE,
             preferences: {},
             visible: true
+          },
+          {
+            name: 'audits',
+            display_name: I18n.t('motor.audits'),
+            tab_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            visible: true
+          },
+          {
+            name: 'notes',
+            display_name: I18n.t('motor.notes'),
+            tab_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            visible: true
           }
         ].freeze
       end
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/motor/build_schema/load_from_rails.rb

@@ -79,7 +79,10 @@ module Motor
           searchable_columns: FindSearchableColumns.call(model),
           custom_sql: nil,
           visible: true,
-          display_primary_key: true
+          display_primary_key: true,
+          preferences: {
+            display_as: 'table'
+          }
         }.with_indifferent_access
       end
       # rubocop:enable Metrics/MethodLength

data/lib/motor/build_schema.rb

@@ -102,6 +102,13 @@ module Motor
 
       ReorderSchema.call(schema, cache_keys)
     end
+
+    def for_model(model)
+      schema = Motor::BuildSchema::LoadFromRails.build_model_schema(model)
+      configs = Motor::Resource.find_by(name: schema[:name]).preferences
+
+      MergeSchemaConfigs.merge_model(schema, configs)
+    end
   end
 end
 

data/lib/motor/configs/build_ui_app_tag.rb

@@ -38,25 +38,25 @@ module Motor
       def build_data(cache_keys = {}, current_user = nil, current_ability = nil)
         configs_cache_key = cache_keys[:configs]
 
-        {
-          version: Motor::VERSION,
-          current_user: current_user&.as_json(only: %i[id email]),
+        { version: Motor::VERSION,
+          current_user: serialize_current_user(current_user),
           current_rules: current_ability.serialized_rules,
           audits_count: Motor::Audit.count,
           i18n: i18n_data,
           base_path: Motor::Admin.routes.url_helpers.motor_path,
+          cabel_path: Motor::Admin.routes.url_helpers.try(:motor_cabel_path),
           admin_settings_path: Rails.application.routes.url_helpers.try(:admin_settings_general_path),
           schema: Motor::BuildSchema.call(cache_keys, current_ability),
-          header_links: header_links_data_hash(configs_cache_key),
+          header_links: header_links_data_hash(current_user, current_ability, configs_cache_key),
           homepage_layout: homepage_layout_data_hash(configs_cache_key),
+          databases: database_names,
           queries: queries_data_hash(build_cache_key(cache_keys, :queries, current_user, current_ability),
                                      current_ability),
           dashboards: dashboards_data_hash(build_cache_key(cache_keys, :dashboards, current_user, current_ability),
                                            current_ability),
           alerts: alerts_data_hash(build_cache_key(cache_keys, :alerts, current_user, current_ability),
                                    current_ability),
-          forms: forms_data_hash(build_cache_key(cache_keys, :forms, current_user, current_ability), current_ability)
-        }
+          forms: forms_data_hash(build_cache_key(cache_keys, :forms, current_user, current_ability), current_ability) }
       end
       # rubocop:enable Metrics/AbcSize
 
@@ -64,15 +64,68 @@ module Motor
         I18n.t('motor', default: I18n.t('motor', locale: :en))
       end
 
+      def serialize_current_user(user)
+        return unless user
+
+        attrs = user.as_json(only: %i[id email first_name last_name])
+
+        attrs['role'] = user.role if user.respond_to?(:role)
+        attrs['role_names'] = user.role_names if user.respond_to?(:role_names)
+
+        attrs
+      end
+
       # @return [String]
       def build_cache_key(cache_keys, key, current_user, current_ability)
         "#{cache_keys[key].hash}#{current_user&.id}#{current_ability&.rules_hash}"
       end
 
-      def header_links_data_hash(cache_key = nil)
+      def header_links_data_hash(current_user, current_ability, cache_key = nil)
         configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
 
-        configs.find { |c| c.key == 'header.links' }&.value || []
+        links = configs.find { |c| c.key == 'header.links' }&.value || []
+        links = add_default_links(links)
+
+        return links unless current_user
+        return links if current_ability.can?(:manage, :all)
+
+        filter_links_for_user(current_user, links)
+      end
+
+      def add_default_links(links)
+        new_links = links.clone
+
+        unless links.find { |l| l['link_type'] == 'forms' }
+          new_links.unshift({ 'name' => I18n.t('motor.forms'), 'link_type' => 'forms' })
+        end
+
+        unless links.find { |l| l['link_type'] == 'reports' }
+          new_links.unshift({ 'name' => I18n.t('motor.reports'), 'link_type' => 'reports' })
+        end
+
+        new_links
+      end
+
+      def filter_links_for_user(current_user, links)
+        links.select do |link|
+          conditions = link['conditions']
+
+          next true if conditions.blank?
+
+          conditions.all? do |cond|
+            field_name =
+              if cond['field'] == 'role' && !current_user.respond_to?(:role)
+                :role_names
+              else
+                cond['field'].to_sym
+              end
+
+            next false unless field_name.in?(%i[email role role_names])
+            next false unless current_user.respond_to?(field_name)
+
+            Array.wrap(current_user.public_send(field_name)).intersection(Array.wrap(cond['value'])).present?
+          end
+        end
       end
 
       def homepage_layout_data_hash(cache_key = nil)
@@ -81,6 +134,18 @@ module Motor
         configs.find { |c| c.key == 'homepage.layout' }&.value || []
       end
 
+      def database_names
+        if defined?(Motor::EncryptedConfig)
+          Motor::DatabaseClasses.constants.map { |e| e.to_s.titleize }
+        elsif ActiveRecord::Base.configurations.try(:configurations)
+          ActiveRecord::Base.configurations.configurations
+                            .select { |c| c.env_name == Rails.env }
+                            .map { |c| c.try(:name) || c.try(:spec_name) }.compact
+        else
+          ['primary']
+        end
+      end
+
       def queries_data_hash(cache_key = nil, current_ability = nil)
         Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key, current_ability: current_ability)
                                      .as_json(only: %i[id name updated_at],

data/lib/motor/configs.rb

@@ -5,8 +5,7 @@ module Motor
     FILE_PATH = 'config/motor.yml'
     SYNC_API_PATH = '/motor_configs_sync'
     SYNC_ACCESS_KEY = ENV.fetch('MOTOR_SYNC_API_KEY', '')
-    MEMFS_PATH = '/__enclose_io_memfs__/'
-    PWD_FILE_NAME = 'motor-admin.yml'
+    WORKDIR_FILE_NAME = 'motor-admin.yml'
 
     module_function
 
@@ -22,8 +21,8 @@ module Motor
 
     # @return [String]
     def file_path
-      if Rails.root.to_s.start_with?(MEMFS_PATH)
-        [ENV['PWD'], PWD_FILE_NAME].join('/')
+      if defined?(MotorAdmin::Application)
+        [ENV['WORKDIR'], WORKDIR_FILE_NAME].compact.join('/')
       else
         Rails.root.join(FILE_PATH).to_s
       end

data/lib/motor/notes/notify_mentions.rb

@@ -0,0 +1,73 @@
+# 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).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('new_mention_for',
+               resource: ["#{configs['display_name'].singularize} ##{note.record[note.record.class.primary_key]}",
+                          display_value].join(' '),
+               scope: :motor)
+      end
+
+      def build_mention_description(note, current_user)
+        I18n.t('user_mentioned_you_with_note',
+               user: current_user&.email || 'Anonymous',
+               note: note.body.truncate(NOTIFICATION_DESCRIPTION_LIMIT),
+               scope: :motor)
+      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,49 @@
+# 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('new_reminder_for',
+               resource: ["#{configs['display_name'].singularize} ##{note.record[note.record.class.primary_key]}",
+                          display_value].join(' '),
+               scope: :motor)
+      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).map { |tag| tag[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 motor_notifications.record_id = 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'