terrier-engine 4.13.1 → 4.13.2

package/app/assets/stylesheets/terrier/tt-toasts.scss

@@ -0,0 +1,40 @@
+@import "tt-mixins";
+
+#tt-toasts {
+	position: fixed;
+	pointer-events: none;
+	top: 0;
+	right: 0;
+	z-index: 10002;
+	max-width: var(--tt-phone-breakpoint);
+
+	.tt-toast {
+		@include tt-bubble;
+		pointer-events: initial;
+		cursor: pointer;
+		transform: translate(120%, 0);
+		transition: transform var(--tt-animation-duration) ease;
+		display: flex;
+		align-items: center;
+		gap: calc(var(--tt-gap)/2);
+
+		&.show {
+			transform: translate(0);
+		}
+		&.success {
+			background-color: var(--tt-success-color);
+		}
+		&.primary {
+			background-color: var(--tt-primary-color);
+		}
+		&.secondary {
+			background-color: var(--tt-secondary-color);
+		}
+		&.alert {
+			background-color: var(--tt-alert-color);
+		}
+		&.pending {
+			background-color: var(--tt-pending-color);
+		}
+	}
+}

package/app/assets/stylesheets/terrier/tt-toolstrip.scss

@@ -0,0 +1,19 @@
+@import "tt-mixins";
+
+// a strip of tools (mainly icon-only buttons)
+.tt-toolstrip {
+	display: flex;
+	align-items: center;
+	justify-content: start;
+	&.column {
+		flex-direction: column;
+	}
+	--tt-toolstrip-size: 24px; // override on individual strips to change the sizing
+	a {
+		display: flex;
+		@include tt-scale-push;
+		padding: 0.1em;
+		line-height: 1;
+		font-size: var(--tt-toolstrip-size);
+	}
+}

package/app/assets/stylesheets/terrier/tt-tooltips.scss

@@ -0,0 +1,34 @@
+@import "tt-mixins";
+
+#tooltip {
+	position: fixed;
+	font-size: 90%;
+	padding: calc(var(--tt-pad)/2) var(--tt-pad);
+	border-top: 1px solid var(--content-bg);
+	background-color: var(--tt-tooltip-background);
+	@include tt-rounded-corners;
+	@include tt-box-shadow;
+	z-index: 10001;
+	max-width: 300px;
+	transform: scale(0);
+	transition: transform ease 0.2s;
+	pointer-events: none;
+	text-align: center;
+	color: var(--tt-tooltip-foreground);
+
+	&.show {
+		transform: scale(1);
+	}
+
+	ol, ul {
+		margin: 0.5em 0;
+	}
+
+	li {
+		text-align: left;
+	}
+
+	p:last-child {
+		margin: 0;
+	}
+}

package/app/assets/stylesheets/terrier/tt-typography.scss

@@ -0,0 +1,85 @@
+@import "tt-mixins";
+
+// Apply this class to any container where you want
+// sane typography defaults for common elements
+.tt-typography {
+	font-size: var(--tt-body-font-size);
+	p, h1, h2, h3, h4, h5 {
+		margin: 0;
+	}
+	p {
+		line-height: 1.4;
+		&.caption {
+			font-size: var(--tt-caption-font-size);
+		}
+	}
+	label {
+		font-size: var(--tt-label-font-size);
+	}
+	h1, h2, h3, h4, h5 {
+		display: flex;
+		align-items: center;
+		gap: 0.5em;
+		font-weight: normal;
+		i {
+			display: block;
+			line-height: 1;
+			transform: scale(1.25);
+		}
+		@include tt-flex-utils;
+		&.centered {
+			justify-content: center;
+		}
+		&.large-top-padding {
+			padding-top: 2em;
+		}
+	}
+	h1 {
+		font-size: 26px;
+	}
+	h2 {
+		font-size: 22px;
+	}
+	h3 {
+		font-size: 18px;
+	}
+	label {
+		text-transform: none;
+		margin-bottom: 0;
+	}
+
+	// override clypboard's default icon margin
+	[class*='glyp-']::before, [class^='glyp-']::before {
+		margin: 0;
+	}
+
+	// foundation...
+	.column, .columns {
+		width: initial;
+		float: none;
+	}
+	.column + .column:last-child, .column + .columns:last-child, .columns + .column:last-child, .columns + .columns:last-child {
+		float: none;
+	}
+	.left {
+		float: none !important;
+	}
+}
+
+
+.tt-button {
+	@include tt-button;
+}
+
+.tt-bubble {
+	@include tt-bubble;
+}
+
+.tt-inset-box {
+	@include tt-inset-box;
+	@include tt-inset-box-shadow;
+}
+
+.tt-padded {
+	padding: var(--tt-pad);
+}

package/app/assets/stylesheets/terrier.css

@@ -0,0 +1,3 @@
+/**
+ *= require_tree ./terrier
+ */

package/app/controllers/concerns/data_dive/endpoints.rb

@@ -0,0 +1,74 @@
+require_relative '../../../../test/data/test_dive'
+require 'terrier/data_dive'
+
+module DataDive::Endpoints
+  extend ActiveSupport::Concern
+
+  included do
+
+    # all pages use the same entrypoint action on the server,
+    # the routing is done on the client side
+    def entrypoint
+      @title = "Data Dive"
+      @entrypoint = 'data-dive'
+      render layout: _terrier_layout
+    end
+
+    # authentication and option data for the session
+    def user_session
+      user = _terrier_change_user
+      raise "Must be logged in!" unless user
+      user = user.attributes.slice *%w[first_name last_name name id role]
+
+      groups = DdDiveGroup.where(_state: 0)
+                          .order(name: :asc)
+      render_api_success user: user, groupMap: groups.index_by(&:id)
+    end
+
+    # get all dives associated with the current user
+    def list
+      user = _terrier_change_user
+      dives = DdDive.where(_state: 0)
+                    .where("owner_id = ? OR visibility = 'public'", user.id)
+                    .order(name: :asc)
+
+      render_api_success dives: dives
+    end
+
+    def test_dive
+      dive = TestDive.get
+      render_api_success dive: dive
+    end
+
+    # validates the query and computes the raw SQL for it if it's valid
+    def validate_query
+      query = required_param :query
+      engine = DataDive::QueryEngine.new query
+      res = engine.validate
+      render_api_success res
+    rescue => ex
+      render_exception ex
+    end
+
+    # executes the query for a small limit to preview on the client
+    def preview_query
+      query = required_param :query
+      engine = DataDive::QueryEngine.new query
+      res = engine.execute! limit: 100
+      render_api_success res
+    rescue => ex
+      render_exception ex
+    end
+
+    def stream_run
+      run = DdDiveRun.find required_param(:run_id)
+      dive = run.dd_dive
+      stream_response do |stream|
+        engine = DataDive::DiveEngine.new dive, _terrier_change_user
+        engine.stream_run! stream, run, params
+      end
+    end
+
+  end
+
+end

package/app/controllers/concerns/terrier/rendering_base.rb

@@ -0,0 +1,168 @@
+# include in all controllers
+module Terrier::RenderingBase
+  extend ActiveSupport::Concern
+
+  included do
+
+    ## Rendering
+
+    def init_request_time
+      @request_start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    before_action :init_request_time
+
+    # renders a successful response, either in json to CSV
+    # if CSV, you must pass exactly one key into data, which contains an array of hashes
+    def render_success(message, data={})
+      data[:status] = 'success'
+      data[:message] = message
+      data[:exec_time] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @request_start_time
+      respond_to do |format|
+        format.json do
+          render json: data
+        end
+        format.csv do
+          keys = data.keys.dup
+          Rails.logger.debug "--keys: #{keys}"
+          keys.delete(:status)
+          keys.delete(:message)
+          keys.delete(:exec_time)
+          if keys.length != 1
+            return error "There must be exactly one additional argument to render_success (besides status and message) - found [#{keys.join(', ')}]"
+          end
+          return render plain: TabularIo.serialize_csv(data[keys.first])
+        end
+        format.html do
+          if params[:modal]&.is_true?
+            data[:layout] ||= 'modal'
+          end
+          render data
+        end
+      end
+    end
+
+    # sick of passing empty messages
+    def render_api_success(data)
+      render_success '', data
+    end
+
+    def render_error(message, options={})
+      @message = message
+      respond_to do |format|
+        format.html do
+          options[:template] = 'application/error'
+          if params[:modal]&.is_true?
+            options[:layout] ||= 'modal'
+          end
+          render options
+        end
+        format.json do
+          options[:status] = 'error'
+          options[:message] = message
+          render json: options
+        end
+        format.csv {render plain: "error\n#{message}"}
+      end
+    end
+
+    # logs the exception message and backtrace
+    # options can contain `full: true` to log the entire backtrace instead of just the first part
+    def log_exception(ex, options={})
+      Rails.logger.warn ex.message
+      lines = options[:full].is_true? ? ex.backtrace : ex.backtrace[0..16]
+      lines.filter_backtrace.each do |line|
+        Rails.logger.warn line
+      end
+    end
+
+    def render_exception(ex, options={})
+      log_exception ex, options
+      @message = ex.message
+      @backtrace = ex.backtrace
+      respond_to do |format|
+        format.json {render json: {status: 'error', message: @message, backtrace: ex.backtrace}}
+        format.csv {render plain: "error\n#{@message}"}
+        format.html do
+          options[:template] = 'application/error'
+          render options
+        end
+        format.svg do
+          render plain: "<svg width='640px' height='640px' viewBox='0 0 640 640' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'>" +
+            "<text fill='red' x='20' y='20'>#{@message}</text></svg>"
+
+        end
+      end
+    end
+
+  end
+
+
+  ## Params
+
+  def required_param(name)
+    val = params[name]
+    if val.blank?
+      raise "Missing required parameter '#{name}'"
+    end
+    val
+  end
+
+  def form_params(name)
+    params[name.to_sym].permit!
+  end
+
+  def true_param?(name)
+    params[name] && params[name].downcase == 'true'
+  end
+
+  def array_param(name)
+    value = params[name]
+    if value.is_a? Hash
+      return value.values
+    end
+    if value.is_a? Array
+      return value
+    end
+    if value.is_a? String
+      return value.split(',')
+    end
+    value.to_h.values
+  end
+
+  def required_array_param(name)
+    value = array_param(name)
+    if value.blank?
+      raise "Must provide non-empty #{name} parameter"
+    end
+    value
+  end
+
+  # @return A new URL string based on the current one except with the new params set
+  def change_url_params(url, new_params)
+    uri = URI.parse url
+    query = Rack::Utils.parse_query uri.query
+    query.merge! new_params
+    uri.query = Rack::Utils.build_query query
+    uri.to_s
+  end
+
+
+  ## Streaming
+
+  # Pass a block that will receive the streamer object used to stream the response:
+  #   stream_response do |stream|
+  #     stream.write 'foo'
+  #   end
+  def stream_response
+    ResponseStreamer.new(self).run do |stream|
+      begin
+        yield stream
+      rescue => ex
+        log_exception ex
+        stream.error ex
+      end
+    end
+  end
+
+end

package/app/controllers/concerns/terrier/script_crud.rb

@@ -0,0 +1,216 @@
+require 'parser/current'
+require 'terrier/scripts/script_config'
+
+# include in the regular scripts controller
+module Terrier::ScriptCrud
+  extend ActiveSupport::Concern
+
+  included do
+
+    def constants
+      render_success "Got Constants", {
+          constants: {
+            category_options: Terrier::ScriptConfig.category_options,
+            report_type_options: Terrier::ScriptConfig.report_type_options,
+            visibility_options: Script.visibility_options,
+            schedule_time_options: Script.schedule_time_options,
+            field_type_options: ScriptField.field_type_options,
+            fields_help: Terrier::ScriptConfig.fields_help,
+            month_groups: ScheduleRule.month_groups,
+            days: ScheduleRule.days,
+            weeks: ScheduleRule.weeks
+          }
+      }
+    end
+
+
+    def check
+      body = params[:body]
+
+      begin
+        Parser::CurrentRuby.parse(body)
+        render_success 'Successfully parsed script'
+      rescue => ex
+        Rails.logger.debug "message: #{ex.message}, diagnostic: #{ex.diagnostic}"
+        Rails.logger.debug ex.diagnostic.location
+        render json: {status: 'Error', message: "Error parsing script: #{ex.message}", diagnostic: ex.diagnostic}
+      end
+    end
+
+
+    def compute_field_values
+      fields = JSON.parse params[:script_fields_json]
+      script = Script.new
+      script.script_fields = fields
+
+      values = script.compute_field_values
+      options = script.compute_field_options
+
+      override_fields script, values, options
+
+      render_success 'Successfully Computed Field Values', field_values: values, field_options: options
+    end
+
+    # subclasses can implement this to override the values and options
+    def override_fields(script, values, options)
+    end
+
+    def show
+      @script = Script.find params[:id]
+      render_success "Showing script #{@script.title}", script: @script
+    end
+
+
+    def runs
+      begin
+        script = Script.find params[:script_id]
+        runs = script.script_runs.where(_state: 0).order(created_at: :desc)
+        render_success "Got #{runs.count} runs", {runs: runs.as_json(methods: %i(log_url))}
+      rescue => ex
+        render_exception ex
+      end
+    end
+
+    # Returns a json response containing an array of action log entries
+    # The entity changes should already be formatted
+    def action_log
+      raise "Subclasses must override action_log!"
+    end
+
+    def clear_run
+      begin
+        script = Script.find params[:script_id]
+        run = script.script_runs.where(id: params[:run_id]).first
+        unless run
+          raise "No script run with id #{params[:run_id]}"
+        end
+        unless run.status == 'running'
+          raise "Run has status '#{run.status}', so can't be cleared!"
+        end
+        run.status = 'cleared'
+        save_run? run
+        render_success "Marked run as cleared", run: run
+      rescue => ex
+        render_exception ex
+      end
+    end
+
+
+    def save_script?(script)
+      raise "Concrete classes must implement save_script?"
+    end
+
+    def save_run?(script)
+      raise "Concrete classes must implement save_run?"
+    end
+
+    def create
+      begin
+        @script = Script.new script_params
+        if save_script? @script
+          render_success "Created Script", script: @script
+        else
+          render_error "Error Creating Script", script: @script, errors: @script.errors
+        end
+      rescue => ex
+        render_exception ex
+      end
+    end
+
+    def update
+      begin
+        @script = Script.find params[:id]
+        @script.assign_attributes script_params
+        if save_script? @script
+          render_success "Updated Script", script: @script
+        else
+          render_error "Error Updating Script", script: @script, errors: @script.errors
+        end
+      rescue => ex
+        render_exception ex
+      end
+    end
+
+
+    def list_query(user_id)
+      created_by_clause = user_id ? "or s.created_by_id = '#{user_id}'" : ''
+      <<SQL
+select
+    a.created_by_name
+    ,a.id
+    ,a.created_at
+    ,a.updated_at
+    ,a.report_category
+    ,a.title
+    ,a.visibility
+    ,a.schedule_rules
+    ,a.schedule_rule_summaries
+    ,a.schedule_time
+    ,a.email_recipients
+    ,case when b.num_runs is null then 0 else b.num_runs end as num_runs
+    ,b.last_run
+FROM
+  (
+    SELECT
+      s.id,
+      s.created_by_name,
+      s.created_at,
+      s.updated_at,
+      s.report_category,
+      s.title,
+      s._state,
+      s.visibility,
+      s.schedule_rules,
+      s.schedule_rule_summaries,
+      s.schedule_time,
+      s.email_recipients
+    FROM
+      scripts s
+    WHERE
+      s._state = 0 and 
+      (s.visibility = 'public' #{created_by_clause})
+
+  ) a
+
+left outer JOIN
+  (
+    SELECT
+      s.id,
+      count(sr.id)       AS num_runs,
+      max(sr.created_at) AS last_run
+    FROM
+      script_runs sr,
+      scripts s
+    WHERE
+      sr.script_id = s.id
+      AND s._state = 0
+    GROUP BY s.id
+  ) b
+  on a.id = b.id
+order by a.updated_at DESC
+SQL
+    end
+
+
+    def search_results
+      key = params[:key]
+      query = params[:query]
+      begin
+        searcher = ScriptSearcher.new
+        result = searcher.search query
+        scripts = Script.where(_state: 0).where("id IN #{result.ids.to_postgres_array}")
+        render_success "Found #{scripts.count} scripts", {scripts: scripts, key: key, elapsed_time: result.took, total: result.total}
+      rescue => ex
+        render_exception ex
+      end
+
+    end
+
+
+    def script_params
+      params[:script].permit!
+    end
+
+  end
+
+end