ruby-grafana-reporter 0.3.0 → 0.4.0

data/lib/grafana_reporter/asciidoctor/show_environment_include_processor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_environment[]
+    #
+    # Shows all available variables, which are accessible during this run of the asciidoctor
+    # grafana reporter in a asciidoctor readable form.
+    #
+    # This processor is very helpful during report template design, to find out the available
+    # variables, that can be accessed.
+    #
+    # == Used document parameters
+    # All, to be listed as the available environment.
+    class ShowEnvironmentIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_environment'
+      end
+
+      # :nodoc:
+      def process(doc, reader, _target, _attrs)
+        # return if @report.cancel
+        @report.next_step
+        @report.logger.debug('Processing ShowEnvironmentIncludeProcessor')
+
+        vars = ['== Accessible Variables',
+                '|===']
+        doc.attributes.sort.each do |k, v|
+          vars << "| `+{#{k}}+` | #{v}"
+        end
+        vars << '|==='
+
+        reader.unshift_lines vars
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(_panel)
+        'include::grafana_environment[]'
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/show_help_include_processor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_help[]
+    #
+    # Shows all available options for the asciidoctor grafana reporter in a asciidoctor readable form.
+    #
+    # == Used document parameters
+    # None
+    class ShowHelpIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_help'
+      end
+
+      # :nodoc:
+      def process(_doc, reader, _target, _attrs)
+        # return if @report.cancel
+        @report.next_step
+        @report.logger.debug('Processing ShowHelpIncludeProcessor')
+
+        reader.unshift_lines GrafanaReporter::Help.new.asciidoctor.split("\n")
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(_panel)
+        'include::grafana_help[]'
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/sql_table_include_processor.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_sql_table:<datasource_id>[<options>]
+    #
+    # Returns the results of the SQL query as a asciidoctor table.
+    #
+    # == Used document parameters
+    # +grafana_default_instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # All other variables starting with +var-+ will be used to replace grafana templating strings
+    # in the given SQL query.
+    #
+    # == Supported options
+    # +sql+ - sql statement (*mandatory*)
+    #
+    # +instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # +format+ - see {QueryMixin#format_columns}
+    #
+    # +replace_values+ - see {QueryMixin#replace_values}
+    #
+    # +filter_columns+ - see {QueryMixin#filter_columns}
+    class SqlTableIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_sql_table:'
+      end
+
+      # :nodoc:
+      def process(doc, reader, target, attrs)
+        return if @report.cancel
+
+        @report.next_step
+        instance = attrs['instance'] || doc.attr('grafana_default_instance') || 'default'
+        attrs['result_type'] = 'sql_table'
+        @report.logger.debug("Processing SqlTableIncludeProcessor (instance: #{instance},"\
+                             " datasource: #{target.split(':')[1]}, sql: #{attrs['sql']})")
+
+        begin
+          # catch properly if datasource could not be identified
+          query = QueryValueQuery.new(@report.grafana(instance))
+          query.datasource = @report.grafana(instance).datasource_by_id(target.split(':')[1].to_i)
+          query.raw_query = attrs['sql']
+          query.merge_hash_variables(doc.attributes, attrs)
+          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+
+          reader.unshift_lines query.execute
+        rescue GrafanaReporterError => e
+          @report.logger.error(e.message)
+          reader.unshift_line "|#{e.message}"
+        rescue StandardError => e
+          @report.logger.fatal(e.message)
+          reader.unshift_line "|#{e.message}"
+        end
+
+        reader
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(panel)
+        return nil unless panel
+        return nil unless panel.model['type'].include?('table')
+
+        ref_id = nil
+        panel.model['targets'].each do |item|
+          if !item['hide'] && !panel.query(item['refId']).to_s.empty?
+            ref_id = item['refId']
+            break
+          end
+        end
+        return nil unless ref_id
+
+        "|===\ninclude::grafana_sql_table:#{panel.dashboard.grafana.datasource_by_name(panel.model['datasource']).id}"\
+        "[sql=\"#{panel.query(ref_id).gsub(/"/, '\"').gsub("\n", ' ').gsub(/\\/, '\\\\')}\",filter_columns=\"time\","\
+        "dashboard=\"#{panel.dashboard.id}\",from=\"now-1h\",to=\"now\"]\n|==="
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/sql_value_inline_macro.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   grafana_sql_value:<datasource_id>[<options>]
+    #
+    # Returns the first value of the resulting SQL query.
+    #
+    # == Used document parameters
+    # +grafana_default_instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # All other variables starting with +var-+ will be used to replace grafana templating strings
+    # in the given SQL query.
+    #
+    # == Supported options
+    # +sql+ - sql statement (*mandatory*)
+    #
+    # +instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # +format+ - see {QueryMixin#format_columns}
+    #
+    # +replace_values+ - see {QueryMixin#replace_values}
+    #
+    # +filter_columns+ - see {QueryMixin#filter_columns}
+    class SqlValueInlineMacro < ::Asciidoctor::Extensions::InlineMacroProcessor
+      include ProcessorMixin
+      use_dsl
+
+      named :grafana_sql_value
+
+      # @see GrafanaReporter::Asciidoctor::SqlFirstValueQuery
+      def process(parent, target, attrs)
+        return if @report.cancel
+
+        @report.next_step
+        instance = attrs['instance'] || parent.document.attr('grafana_default_instance') || 'default'
+        attrs['result_type'] = 'sql_value'
+        @report.logger.debug("Processing SqlValueInlineMacro (instance: #{instance}, datasource: #{target},"\
+                             " sql: #{attrs['sql']})")
+
+        begin
+          # catch properly if datasource could not be identified
+          query = QueryValueQuery.new(@report.grafana(instance))
+          query.datasource = @report.grafana(instance).datasource_by_id(target)
+          query.raw_query = attrs['sql']
+          query.merge_hash_variables(parent.document.attributes, attrs)
+          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+
+          create_inline(parent, :quoted, query.execute)
+        rescue GrafanaReporterError => e
+          @report.logger.error(e.message)
+          create_inline(parent, :quoted, e.message)
+        rescue StandardError => e
+          @report.logger.fatal(e.message)
+          create_inline(parent, :quoted, e.message)
+        end
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(panel)
+        return nil unless panel
+        return nil unless panel.model['type'] == 'singlestat'
+
+        ref_id = nil
+        panel.model['targets'].each do |item|
+          if !item['hide'] && !panel.query(item['refId']).to_s.empty?
+            ref_id = item['refId']
+            break
+          end
+        end
+        return nil unless ref_id
+
+        "grafana_sql_value:#{panel.dashboard.grafana.datasource_by_name(panel.model['datasource']).id}"\
+        "[sql=\"#{panel.query(ref_id).gsub(/"/, '\"').gsub("\n", ' ').gsub(/\\/, '\\\\')}\",from=\"now-1h\","\
+        'to="now"]'
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/value_as_variable_include_processor.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'processor_mixin'
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_value_as_variable[<options>]
+    #
+    # Returns an attribute definition in asciidoctor format. This is needed if you want to refer to values of
+    # a grafana query within a variable in asciidoctor. As this works without this function for the
+    # `IncludeProcessor`s values, it will not work for all the other processors.
+    #
+    # This method is just a proxy for all other hooks and will forward parameters accordingly.
+    #
+    # Example:
+    #
+    #   include:grafana_value_as_variable[call="grafana_sql_value:1",variable_name="my_variable",sql="SELECT 'looks good'",<any_other_option>]
+    #
+    # This will call the {SqlValueInlineMacro} with `datasource_id` set to `1` and store the result in the
+    # variable. The resulting asciidoctor variable definition will be created as:
+    #
+    #   :my_variable: looks good
+    #
+    # and can be refered to in your document easily as
+    #
+    #   {my_variable}
+    #
+    # == Supported options
+    # +call+ - regular call to the reporter hook (*mandatory*)
+    #
+    # +variable_name+ - name of the variable, to which the result shall be assigned (*mandatory*)
+    class ValueAsVariableIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_value_as_variable'
+      end
+
+      # :nodoc:
+      def process(doc, reader, target, attrs)
+        return if @report.cancel
+
+        # increase step for this processor as well as it is also counted in the step counter
+        @report.next_step
+
+        call_attr = attrs.delete('call')
+        call, target = call_attr.split(':') if call_attr
+        attribute = attrs.delete('variable_name')
+        @report.logger.debug("Processing ValueAsVariableIncludeProcessor (call: #{call}, target: #{target},"\
+                             " variable_name: #{attribute}, attrs: #{attrs})")
+        if !call || !attribute
+          @report.logger.error('ValueAsVariableIncludeProcessor: Missing mandatory attribute \'call\' or '\
+                               '\'variable_name\'.')
+          # increase counter, as error occured and no sub call is being processed
+          @report.next_step
+          return reader
+        end
+
+        # TODO: remove dirty hack to allow the document as parameter for other processors
+        def doc.document
+          self
+        end
+
+        # TODO: properly show error messages also in document
+        ext = doc.extensions.find_inline_macro_extension(call) if doc.extensions.inline_macros?
+        if !ext
+          @report.logger.error('ValueAsVariableIncludeProcessor: Could not find inline macro extension for '\
+                               "'#{call}'.")
+          # increase counter, as error occured and no sub call is being processed
+          @report.next_step
+        else
+          @report.logger.debug('ValueAsVariableIncludeProcessor: Calling sub-method.')
+          item = ext.process_method.call(doc, target, attrs)
+          if !item.text.to_s.empty?
+            result = ":#{attribute}: #{item.text}"
+            @report.logger.debug("ValueAsVariableIncludeProcessor: Adding '#{result}' to document.")
+            reader.unshift_line(result)
+          else
+            @report.logger.debug("ValueAsVariableIncludeProcessor: Not adding variable '#{attribute}'"\
+                                 ' as query result was empty.')
+          end
+        end
+
+        reader
+      end
+    end
+  end
+end

data/lib/grafana_reporter/configuration.rb

@@ -56,11 +56,6 @@ module GrafanaReporter
       "#{templates_folder}#{get_config('default-document-attributes:var-template')}.adoc"
     end
 
-    # @return [String] path to ssl certificate file, if manually specified, or nil
-    def ssl_cert
-      get_config('grafana-reporter:ssl-cert')
-    end
-
     # @return [String] destination filename for the report in {MODE_SINGLE_RENDER}.
     def to_file
       return get_config('to_file') || true if mode == MODE_SINGLE_RENDER
@@ -209,6 +204,15 @@ module GrafanaReporter
       @logger.level = Object.const_get("::Logger::Severity::#{debug_level}") if debug_level =~ /DEBUG|INFO|WARN|
                                                                                                 ERROR|FATAL|UNKNOWN/x
       self.report_class = Object.const_get(rep_class) if rep_class
+      ::Grafana::WebRequest.ssl_cert = get_config('grafana-reporter:ssl-cert')
+
+      # register callbacks
+      callbacks = get_config('grafana-reporter:callbacks')
+      return unless callbacks
+
+      callbacks.each do |url, event|
+        AbstractReport.add_event_listener(event.to_sym, ReportWebhook.new(url))
+      end
     end
 
     def get_config(path)
@@ -283,6 +287,7 @@ module GrafanaReporter
            }
          ],
         'default-document-attributes' => [Hash, explicit ? 1 : 0],
+        'to_file' => [String, 0],
         'grafana-reporter' =>
         [
           Hash, 1,
@@ -295,7 +300,8 @@ module GrafanaReporter
             'reports-folder' => [String, explicit ? 1 : 0],
             'report-retention' => [Integer, explicit ? 1 : 0],
             'ssl-cert' => [String, 0],
-            'webservice-port' => [Integer, explicit ? 1 : 0]
+            'webservice-port' => [Integer, explicit ? 1 : 0],
+            'callbacks' => [Hash, 0, { nil => [String, 1] }]
           }
         ]
       }

data/lib/grafana_reporter/console_configuration_wizard.rb

@@ -1,14 +1,58 @@
 # frozen_string_literal: true
 
 module GrafanaReporter
+  # This class provides a console configuration wizard, to reduce the manual efforts that have
+  # to be spent for that action and to reduce mistakes as good as possible.
   class ConsoleConfigurationWizard
     # Provides a command line configuration wizard for setting up the necessary configuration
     # file.
     # TODO: refactor class
     def start_wizard(config_file, console_config)
-      config = Configuration.new
+      action = overwrite_or_use_config_file(config_file)
+      return if action == 'abort'
+
+      config = create_config_wizard(config_file, console_config) if action == 'overwrite'
+      config ||= Configuration.new
+
+      begin
+        config.config = YAML.load_file(config_file)
+      rescue StandardError => e
+        raise ConfigurationError, "Could not read config file '#{config_file}' (Error: #{e.message})\n"\
+              "Source:\n#{File.read(config_file)}"
+      end
+
+      begin
+        config.validate(true)
+        puts 'Configuration file validated successfully.'
+      rescue ConfigurationError => e
+        raise e
+      end
+
+      demo_report = create_demo_report(config)
+
+      demo_report ||= '<<your_report_name>>'
+      config_param = config_file == Application::Application::CONFIG_FILE ? '' : " -c #{config_file}"
+      program_call = "#{Gem.ruby} #{$PROGRAM_NAME}"
+      program_call = ENV['OCRA_EXECUTABLE'].gsub("#{Dir.pwd}/".gsub('/', '\\'), '') if ENV['OCRA_EXECUTABLE']
 
-      return unless overwrite_file(config_file)
+      puts
+      puts 'Now everything is setup properly. Create your reports as required in the templates '\
+           'folder and run the reporter either standalone with e.g. the following command:'
+      puts
+      puts "   #{program_call}#{config_param} -t #{demo_report} -o demo_report_with_help.pdf"
+      puts
+      puts 'or run it as a service using the following command:'
+      puts
+      puts "   #{program_call}#{config_param}"
+      puts
+      puts "Open 'http://localhost:#{config.webserver_port}/render?var-template=#{demo_report}' in a webbrowser to"\
+           ' test your configuration.'
+    end
+
+    private
+
+    def create_config_wizard(config_file, console_config)
+      config = Configuration.new
 
       puts 'This wizard will guide you through an initial configuration for'\
            ' the ruby-grafana-reporter. The configuration file will be created'\
@@ -34,6 +78,20 @@ grafana-reporter:
   reports-folder: #{reports}
   report-retention: #{retention}
   webservice-port: #{port}
+# you may want to configure the following webhook callbacks to get informed on certain events
+#  callbacks:
+#    all:
+#      - <<your_callback_url>>
+#      - ...
+#    on_before_create:
+#      - <<your_callback_url>>
+#      - ...
+#    on_after_cancel:
+#      - <<your_callback_url>>
+#      - ...
+#    on_after_finish:
+#      - <<your_callback_url>>
+#      - ...
 
 default-document-attributes:
   imagesdir: #{images}
@@ -47,65 +105,51 @@ default-document-attributes:
         raise e
       end
 
-      begin
-        config.config = YAML.load_file(config_file)
-      rescue StandardError => e
-        raise ConfigurationError, "Could not read config file '#{config_file}' (Error: #{e.message})\n"\
-              "Source:\n#{File.read(config_file)}"
-      end
-
-      begin
-        config.validate(true)
-        puts 'Configuration file validated successfully.'
-      rescue ConfigurationError => e
-        raise e
-      end
-
-      demo_report = create_demo_report(config)
-
-      demo_report ||= '<<your_report_name>>'
-      config_param = config_file == Application::Application::CONFIG_FILE ? '' : " -c #{config_file}"
-      program_call = "#{Gem.ruby} #{$PROGRAM_NAME}"
-      program_call = ENV['OCRA_EXECUTABLE'].gsub("#{Dir.pwd}/".gsub('/', '\\'), '') if ENV['OCRA_EXECUTABLE']
-
-      puts
-      puts 'Now everything is setup properly. Create your reports as required in the templates '\
-           'folder and run the reporter either standalone with e.g. the following command:'
-      puts
-      puts "   #{program_call}#{config_param} -t #{demo_report} -o demo_report_with_help.pdf"
-      puts
-      puts 'or run it as a service using the following command:'
-      puts
-      puts "   #{program_call}#{config_param}"
-      puts
-      puts "Open 'http://localhost:#{config.webserver_port}/render?var-template=#{demo_report}' in a webbrowser to"\
-           ' test your configuration.'
+      config
     end
 
-    private
-
     def create_demo_report(config)
       unless Dir.exist?(config.templates_folder)
         puts "Skip creation of DEMO template, as folder '#{config.templates_folder}' does not exist."
         return nil
       end
 
+      create = user_input('Shall I create a demo report for your new configuration file? Please note '\
+                          'that this report might contain confidential information, depending on the '\
+                          'confidentiality of the information stored in your dashboard.', 'yN')
+      return nil unless create =~ /^(?:y|Y)$/
+
       demo_report = 'demo_report'
       demo_report_file = "#{config.templates_folder}#{demo_report}.adoc"
 
-      # TODO: add question to overwrite file
+      # ask to overwrite file
       if File.exist?(demo_report_file)
-        puts "Skip creation of DEMO template, as file '#{demo_report_file}' already exists."
-        return demo_report
+        input = user_input("Demo template '#{demo_report_file}' does already exist. Do you want to "\
+                           'overwrite it?', 'yN')
+
+        case input
+        when /^(?:y|Y)$/
+          puts 'Overwriting existing DEMO template.'
+
+        else
+          puts 'Skip creation of DEMO template.'
+          return demo_report
+        end
       end
 
-      demo_report = %(= First Grafana Report Template
+      # TODO: move this to Asciidoctor::Report class
+      classes = [Asciidoctor::AlertsTableIncludeProcessor, Asciidoctor::AnnotationsTableIncludeProcessor,
+                 Asciidoctor::PanelImageBlockMacro, Asciidoctor::PanelImageInlineMacro,
+                 Asciidoctor::PanelPropertyInlineMacro, Asciidoctor::PanelQueryTableIncludeProcessor,
+                 Asciidoctor::PanelQueryValueInlineMacro, Asciidoctor::SqlTableIncludeProcessor,
+                 Asciidoctor::SqlValueInlineMacro, Asciidoctor::ShowHelpIncludeProcessor,
+                 Asciidoctor::ShowEnvironmentIncludeProcessor]
 
-include::grafana_help[]
+      grafana = ::Grafana::Grafana.new(config.grafana_host, config.grafana_api_key)
+      demo_report_content = DemoReportWizard.new(classes).build(grafana)
 
-include::grafana_environment[])
       begin
-        File.write(demo_report_file, demo_report, mode: 'w')
+        File.write(demo_report_file, demo_report_content, mode: 'w')
         puts "DEMO template '#{demo_report_file}' successfully created."
       rescue StandardError => e
         puts e.message
@@ -123,10 +167,9 @@ include::grafana_environment[])
         url ||= user_input('Specify grafana host', 'http://localhost:3000')
         print "Testing connection to '#{url}' #{api_key ? '_with_' : '_without_'} API key..."
         begin
-          # TODO: how to handle if ssl access if not working properly?
           res = Grafana::Grafana.new(url,
                                      api_key,
-                                     logger: config.logger, ssl_cert: config.ssl_cert).test_connection
+                                     logger: config.logger).test_connection
         rescue StandardError => e
           puts
           puts e.message
@@ -135,35 +178,39 @@ include::grafana_environment[])
 
         case res
         when 'Admin'
-          valid = true
+          tmp = user_input('Access to grafana is permitted as Admin, which is a potential security risk.'\
+                ' Do you want to use another [a]pi key, [r]e-enter url key or [i]gnore?', 'aRi')
 
-        when 'NON-Admin'
-          print 'Access to grafana is permitted as NON-Admin. Do you want to use an [a]pi key,'\
-                ' [r]e-enter api key or [i]gnore? [aRi]: '
-
-          case gets
+          case tmp
           when /(?:i|I)$/
             valid = true
 
-          # TODO: what is difference between 'a' and 'r'?
           when /(?:a|A)$/
             print 'Enter API key: '
-            api_key = gets.sub(/\n$/, '')
+            api_key = gets.strip
 
-          when /(?:r|R|adRi)$/
+          else
+            url = nil
             api_key = nil
 
           end
 
-        # TODO: ask to enter API key, if grafana cannot be accessed without that
+        when 'NON-Admin'
+          print 'Access to grafana is permitted as NON-Admin.'
+          valid = true
+
         else
-          print "Grafana could not be accessed at '#{url}'. Do you want do [r]e-enter url, or"\
-               ' [i]gnore and proceed? [Ri]: '
+          tmp = user_input("Grafana could not be accessed at '#{url}'. Do you want to use an [a]pi key,"\
+                ' [r]e-enter url, or [i]gnore and proceed?', 'aRi')
 
-          case gets
+          case tmp
           when /(?:i|I)$/
             valid = true
 
+          when /(?:a|A)$/
+            print 'Enter API key: '
+            api_key = gets.strip
+
           else
             url = nil
             api_key = nil
@@ -174,7 +221,7 @@ include::grafana_environment[])
       end
       %(grafana:
   default:
-    host: #{url}#{api_key ? "\n    api_key: #{api_key}" : ''}}
+    host: #{url}#{api_key ? "\n    api_key: #{api_key}" : ''}
 )
     end
 
@@ -254,16 +301,19 @@ include::grafana_environment[])
       false
     end
 
-    def overwrite_file(config_file)
-      return true unless File.exist?(config_file)
+    def overwrite_or_use_config_file(config_file)
+      return 'overwrite' unless File.exist?(config_file)
 
       input = nil
       until input
-        input = user_input("Configuration file '#{config_file}' already exists. Do you want to overwrite it?", 'yN')
-        return false if input =~ /^(?:n|N|yN)$/
+        input = user_input("Configuration file '#{config_file}' already exists. Do you want to [o]verwrite it, "\
+                           'use it to for [d]emo report creation only, or [a]bort?', 'odA')
       end
 
-      true
+      return 'demo_report' if input =~ /^(?:d|D)$/
+      return 'abort' if input =~ /^(?:A|a|odA)$/
+
+      'overwrite'
     end
   end
 end