vario 0.4.12

data/app/views/vario/settings/_levels.html.slim

@@ -0,0 +1,22 @@
+- context = {} if context.blank?
+
+div data-id="#{setting.id}_levels"
+  .grid.grid-cols-12.gap-4 data-controller='draggable' data-draggable-handle='.draggable'
+    - setting.levels.each do |level|
+      .col-span-12 data-draggable-url="#{vario.move_setting_level_path(setting_id: setting.id, id: level.id)}" class= "#{"hidden" unless level.with_context_values?(context)}"
+        = render partial: 'vario/levels/form', locals: { setting: setting, level: level, context: context }
+
+- function_name = "reload_#{setting.id.gsub('-', '')}"
+javascript:
+  function #{{function_name}}() {
+    document.querySelector("[data-id='#{setting.id}_levels']").addEventListener('draggable.success', function(e) {
+      fetch("#{vario.levels_setting_path(setting)}")
+        .then(response => response.text())
+        .then(function(html) {
+          e.detail.element.outerHTML = html
+          #{{function_name}}()
+        })
+    })
+  }
+
+  #{{function_name}}()

data/app/views/vario/settings/_new_level.html.slim

@@ -0,0 +1,7 @@
+- context = {} if context.blank?
+- level   = setting.new_level
+
+div data-id="#{setting.id}_new_level"
+  .grid.grid-cols-12.gap-4
+    .col-span-12 class="#{"hidden" if level.conditions_not_for(context).size == 0 && setting.levels.find { |level| level.with_context_values?(context)}.present?}"
+      = render partial: 'vario/levels/form', locals: { setting: setting, level: level, label: 'New level', context: context, draggable: false }

data/app/views/vario/settings/_settings.html.slim

@@ -0,0 +1,30 @@
+- ui_card_title = 'Settings' if ui_card_title.blank?
+- context       = {} if context.blank?
+
+= sts.card title: ui_card_title, icon: 'fad fa-slider' do |card|
+  - settings_with_contexts.sort_by { |setting| setting[:setting].name}.each do |setting|
+    - card.tab setting[:setting].name, title: setting[:setting].title, padding: true
+      .grid.grid-cols-12.gap-4
+        .col-span-12.prose
+          p= setting[:setting].description
+        .col-span-12
+          = render partial: 'vario/settings/levels', locals: setting
+        .col-span-12
+          = render partial: 'vario/settings/new_level', locals: setting
+
+javascript:
+  $(document).on('ajax:error', function(event) {
+    window.alert('An error has occurred, your changes are likely not saved. Please try again.')
+  })
+
+css:
+  .row.level {
+    min-height: 32px;
+    padding: 4px 0;
+  }
+  .row.level:nth-of-type(even) {
+    background-color: #f9f9f9;
+  }
+  .row.level:nth-of-type(odd) {
+    background-color: #f0f0f0;
+  }

data/app/views/vario/settings/index.html.slim

@@ -0,0 +1,28 @@
+= sts.card title: @title, icon: 'fad fa-sliders' do |card|
+  .grid.grid-cols-12.gap-4
+    .col-span-4
+
+      - @groups.each do |group|
+        - card.tab group[:name], padding: true
+          table.table
+            thead
+              th Name
+              th Levels
+            tbody
+              - @settings.for_group(group[:name]).each do |setting|
+                tr
+                  td= link_to(setting.setting_name.humanize, setting_path(setting))
+                  td= setting.levels.count
+
+      - if @settings.without_group.present?
+        - card.tab :ungrouped, padding: true
+          table.table
+            thead
+              th Name
+              th Levels
+            tbody
+              - @settings.without_group.each do |setting|
+                tr
+                  td= link_to(setting.setting_name.humanize, setting_path(setting))
+                  td= setting.levels.count
+

data/app/views/vario/settings/levels.html.slim

@@ -0,0 +1 @@
+= render partial: 'vario/settings/levels', locals: { setting: @setting }

data/app/views/vario/settings/show.html.slim

@@ -0,0 +1,13 @@
+= sts.card title: @setting.title, icon: 'fad fa-sliders' do |card|
+
+  - card.action
+    = link_to("Back", settings_path(settable: @setting.settable.to_sgid(for: 'Vario').to_s), class: 'button')
+
+  .grid.grid-cols-12.gap-4
+    .col-span-12.prose
+      - if @setting.default.present?
+        p= "#{@setting.description} (default: #{[*@setting.default].join(', ')})"
+      - else
+        p= @setting.description
+    .col-span-12= render partial: 'vario/settings/levels', locals: { setting: @setting }
+    .col-span-12= render partial: 'vario/settings/new_level', locals: { setting: @setting }

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  vario:
+    levels:
+      form:
+        save: Save
+        delete: Delete

data/config/locales/nl.yml

@@ -0,0 +1,6 @@
+nl:
+  vario:
+    levels:
+      form:
+        save: Opslaan
+        delete: Verwijder

data/config/routes.rb

@@ -0,0 +1,10 @@
+Vario::Engine.routes.draw do
+  resources :settings do
+    get :levels, on: :member
+    resources :levels do
+      member do
+        patch :move
+      end
+    end
+  end
+end

data/db/migrate/20180628103728_create_vario_settings.rb

@@ -0,0 +1,20 @@
+class CreateVarioSettings < ActiveRecord::Migration[5.2]
+  def change
+    enable_extension 'plpgsql'
+    enable_extension 'uuid-ossp'
+    enable_extension 'pgcrypto'
+
+    create_table :vario_settings, id: :uuid do |t|
+      t.references :settable, polymorphic: true, index: true, type: :uuid
+
+      t.string :name
+      t.string :category
+      t.string :description
+      t.string :keys, default: [], array: true
+
+      t.json :levels
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20180706130136_remove_fields_from_settings.rb

@@ -0,0 +1,7 @@
+class RemoveFieldsFromSettings < ActiveRecord::Migration[5.2]
+  def change
+    remove_column :vario_settings, :category
+    remove_column :vario_settings, :description
+    remove_column :vario_settings, :keys
+  end
+end

data/db/migrate/20180706155055_add_keys_to_setting.rb

@@ -0,0 +1,5 @@
+class AddKeysToSetting < ActiveRecord::Migration[5.2]
+  def change
+    add_column :vario_settings, :keys, :string, array: true
+  end
+end

data/db/migrate/20211027040546_unique_levels.rb

@@ -0,0 +1,8 @@
+class UniqueLevels < ActiveRecord::Migration[6.1]
+  def up
+    Vario::Setting.all.each(&:uniq_levels!)
+  end
+
+  def down
+  end
+end

data/lib/vario/action_view_helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Vario
+  module ActionViewHelpers
+    def render_vario_settings(*args)
+      settings_with_contexts = []
+
+      args = [args] unless args.first.is_a?(Array)
+      args.each do |argument_set|
+        settable = argument_set.first
+
+        if argument_set.last.is_a?(Hash)
+          setting_names = argument_set[1..-2]
+          context       = argument_set.last
+        else
+          setting_names = argument_set[1..-1]
+          context       = {}
+        end
+
+        Vario.config.pre_create_settings(settable)
+        settable.settings.where(name: setting_names).each do |setting|
+          settings_with_contexts << { setting: setting, context: context }
+        end
+      end
+
+      render partial: 'vario/settings/settings', locals: {
+        settings_with_contexts: settings_with_contexts
+      }
+    end
+  end
+end

data/lib/vario/active_record_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Vario
+  module ActiveRecordHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      # provides settings_reader method to all models
+      include Vario::SettingsReader
+    end
+
+    class_methods do
+      def settable(options = {})
+        include Vario::Settable
+
+        configuration = { name: :settings }
+        configuration.update(options) if options.is_a?(Hash)
+
+        has_many configuration[:name], as: :settable, class_name: 'Vario::Setting'
+      end
+    end
+  end
+end

data/lib/vario/api.rb

@@ -0,0 +1,148 @@
+# frozen_literal_string: true
+
+require 'grape-swagger'
+
+module Vario
+  class API < Grape::API
+    default_format :json
+    format :json
+
+    helpers do
+      def declared_params
+        declared(params, include_missing: false)
+      end
+
+      def settable
+        configuration[:settable]
+      end
+
+      def find_settable(id)
+        record = settable.find(id)
+        error!("#{settable.name} not found", 404) unless record.present?
+        record
+      end
+
+      def settable_settings
+        Vario.config.settable_settings[settable.name]
+      end
+
+      def settable_setting(setting)
+        settable_settings[setting]
+      end
+
+      def settable_setting_context(setting, context)
+        vario_setting = settable_setting(setting)
+        context.symbolize_keys!
+        vario_setting[:keys].each do |key|
+          context[key] ||= nil
+        end
+        context
+      end
+    end
+
+    given configuration[:settable] do
+      [*configuration[:include]].each do |m|
+        include m
+      end
+
+      Vario.config.settable_settings[configuration[:settable].name].each do |setting_name, setting_data|
+        before do
+          [*configuration[:before]].each do |method|
+            send(method) if method.is_a?(Symbol)
+          end
+        end if configuration[:before].present?
+
+        group_name, short_setting_name = setting_name.split('.', 2)
+
+        next unless Vario.config.show_group?(group_name)
+
+        route_param :id, type: String do
+          namespace configuration[:prefix] do
+            namespace group_name do
+              desc "Get setting value" do
+                detail "Get the setting value for #{setting_name}. Setting description: #{setting_data[:description]}"
+              end
+              params do
+                setting_data[:keys].each do |context_key|
+                  optional context_key, type: String
+                end
+              end
+              scopes = [configuration[:oauth2].to_sym, "#{configuration[:oath2]}:read".to_sym] if configuration[:oauth2]
+              scopes ||= nil
+              get "/#{short_setting_name}", scopes: scopes do
+                record  = find_settable(declared_params[:id])
+                context = settable_setting_context(setting_name, declared_params.reject { |key, value| key == 'id' }.to_h )
+
+                { setting: setting_name, value: record.setting(setting_name, context) }
+              end
+
+              setting_type =
+                case setting_data[:type]
+                when :array
+                  Array[String]
+                when :boolean
+                  Boolean
+                when :integer
+                  Integer
+                else
+                  String
+                end
+
+              desc "Add or change setting value" do
+                detail "Add or change setting value for #{setting_name}. Setting description: #{setting_data[:description]}"
+              end
+              params do
+                setting_data[:keys].each do |context_key|
+                  optional context_key, type: String, documentation: { in: 'body' }
+                end
+                requires :value, type: setting_type, values: setting_data[:collection].present? ? setting_data[:collection].map { |item| item.last.to_s } : nil, documentation: { in: 'body' }
+              end
+              scopes = [configuration[:oauth2].to_sym, "#{configuration[:oath2]}:write".to_sym] if configuration[:oauth2]
+              scopes ||= nil
+              route [:post, :put], "/#{short_setting_name}", scopes: scopes do
+                record          = find_settable(declared_params[:id])
+                context         = settable_setting_context(setting_name, declared_params.reject { |key, value| %w[id value].include?(key) }.to_h )
+                vario_setting   = record.settings.find_or_initialize_by(name: setting_name)
+                conditions_hash = context.values.compact.blank? ? {} : context
+                level           = vario_setting.levels.find { |level| conditions_hash == level.conditions_hash }
+
+                if level.nil?
+                  level = Level.new(vario_setting, { conditions: context })
+                  vario_setting.levels.unshift level
+                end
+
+                level.value = declared_params[:value]
+                vario_setting.save!
+
+                { setting: setting_name, value: record.setting(setting_name, context) }
+              end
+
+              desc "Remove setting value" do
+                detail "Remove setting value for #{setting_name}. Setting description: #{setting_data[:description]}"
+              end
+              params do
+                setting_data[:keys].each do |context_key|
+                  optional context_key, type: String
+                end
+              end
+              scopes = [configuration[:oauth2].to_sym, "#{configuration[:oath2]}:write".to_sym] if configuration[:oauth2]
+              scopes ||= nil
+              delete "/#{short_setting_name}", scopes: scopes do
+                record           = find_settable(declared_params[:id])
+                context          = settable_setting_context(setting_name, declared_params.reject { |key, value| key == 'id' }.to_h )
+                conditions_hash  = context.values.compact.blank? ? {} : context
+
+                vario_setting = record.settings.find_or_initialize_by(name: setting_name)
+                vario_setting.levels.reject! { |level| conditions_hash == level.conditions_hash }
+                vario_setting.save!
+
+                { setting: setting_name, value: record.setting(setting_name, context) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vario/config.rb

@@ -0,0 +1,112 @@
+module Vario
+  class Config
+    attr_writer :logger, :current_settable
+    attr_reader :keys, :settable_types, :settable_settings
+    attr_accessor :base_controller, :admin_layout
+
+    def initialize
+      @logger               = Logger.new(STDOUT)
+      @logger.level         = Logger::INFO
+      @keys = {}
+      @base_controller = '::ApplicationController'
+      @settable_types = {}
+      @settable_settings = {}
+      @settable_type = nil
+      @current_settable = nil
+      @admin_layout = 'application'
+      @show_group_if = {}
+    end
+
+    # Config setters
+
+    def key(name, options)
+      options.symbolize_keys!
+      raise ArgumentError, 'name is required' unless options.keys.include?(:name)
+      raise ArgumentError, 'type is required' unless options.keys.include?(:type)
+      keys[name.to_s] = options
+    end
+
+    def show_group_if(name, block)
+      @show_group_if[name] = block
+    end
+
+    def show_group?(name)
+      if @show_group_if[name].is_a?(Proc)
+        @show_group_if[name].call
+      else
+        true
+      end
+    end
+
+    def setting(name, options = {})
+      settable_type = options.delete(:settable_type) || @settable_type
+      options[:type] ||= :string
+      options[:keys] ||= []
+      options[:default] ||= nil
+      options[:description] ||= "Configuration for #{name}, possible on: #{(options[:keys] + ['default']).map(&:to_s).join(', ')}"
+      settable_settings[settable_type] ||= {}
+      settable_settings[settable_type][name.to_s] = options
+    end
+
+    # If true, raise Vario::UnknownSetting if a unknown setting is retrieved, if false unknown settings return nil
+    def raise_on_undefined(value, options = {})
+      settable_type = options.delete(:settable_type) || @settable_type
+      settable_types[settable_type] ||= {}
+      settable_types[settable_type][:raise_on_undefined] = value
+    end
+
+    # If true, a new setting will be saved for settings that do not exist.
+    def create_on_request(value, options = {})
+      settable_type = options.delete(:settable_type) || @settable_type
+      settable_types[settable_type] ||= {}
+      settable_types[settable_type][:create_on_request] = value
+      settable_types[settable_type][:default_keys] = options[:with_keys]
+    end
+
+    def for_settable_type(settable_type)
+      @settable_type = settable_type
+      yield self
+      @settable_type = nil
+    end
+
+    # Config retrieval
+
+    # Config: logger [Object].
+    def logger
+      @logger.is_a?(Proc) ? instance_exec(&@logger) : @logger
+    end
+
+    def current_settable
+      @current_settable.is_a?(Proc) ? instance_exec(&@current_settable) : @current_settable
+    end
+
+    def settable_setting(settable_type, name)
+      settable_settings.dig(settable_type, name)
+    end
+
+    def key_data_for(key)
+      keys[key.to_s] || { name: key, type: :string, description: 'Not configured in initializer' }
+    end
+
+    def create_on_request?(settable_type)
+      settable_types.dig(settable_type, :create_on_request)
+    end
+
+    def raise_on_undefined?(settable_type)
+      settable_types.dig(settable_type, :raise_on_undefined)
+    end
+
+    def default_keys?(settable_type)
+      settable_types.dig(settable_type, :default_keys) || []
+    end
+
+    def pre_create_settings(settable)
+      return unless settable_settings[settable.class.name]
+
+      settable_settings[settable.class.name].keys.each do |key|
+        s = settable.settings.find_or_initialize_by(name: key)
+        s.save unless s.persisted?
+      end
+    end
+  end
+end

data/lib/vario/engine.rb

@@ -0,0 +1,15 @@
+module Vario
+  class Engine < ::Rails::Engine
+    config.autoload_paths << File.expand_path("../../lib", __dir__)
+
+    isolate_namespace Vario
+
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths['db/migrate'].expanded.each do |expanded_path|
+          app.config.paths['db/migrate'] << expanded_path
+        end
+      end
+    end
+  end
+end

data/lib/vario/settable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Vario
+  module Settable
+    extend ActiveSupport::Concern
+
+    included do
+      def setting(name, context = {})
+        name = name.to_s
+        context.symbolize_keys!
+        @vario_setting_cache ||= {}
+        @vario_setting_cache[name] ||= settings.find_or_initialize_by(name: name)
+        @vario_setting_cache[name]&.value_for(context)
+      end
+
+      def settings_hash(name, context = {})
+        name = name.to_s
+        context.symbolize_keys!
+        raise ArgumentError, 'Cannot request hash with a default' if context.key?(:default)
+
+        settings.where('name ILIKE ?', "#{name}.%").map do |vario_setting|
+          [vario_setting.name.gsub("#{name}.", ''), vario_setting.value_for(context)]
+        end.to_h.with_indifferent_access
+      end
+
+      def settings_save_unsaved
+        return unless @vario_setting_cache
+
+        @vario_setting_cache.each do |_key, vario_setting|
+          vario_setting.save unless vario_setting.persisted?
+        end
+      end
+
+      def settings_prepopulate_cache
+        return if @vario_setting_cache
+
+        @vario_setting_cache ||= {}
+        settings.map do |vario_setting|
+          @vario_setting_cache[vario_setting.name] ||= vario_setting
+        end
+      end
+    end
+  end
+end

data/lib/vario/settings_reader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Vario
+  # Make vario settings accessible as readers on the object
+  module SettingsReader
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def settings_reader(klass, settings)
+        settings.each do |setting|
+          vario_setting = Vario.config.settable_settings[klass.name.to_s][setting]
+
+          method_name = setting.split('.').last
+          method_name += '?' if vario_setting[:type] == :boolean
+
+          define_method(method_name.to_sym) do
+            result = nil
+
+            if respond_to?(:settings) && self.settings.respond_to?(:dig)
+              result = self.settings.dig(*setting.split('.'))
+            end
+
+            if result.nil?
+              context = vario_setting[:keys].map { |key| [key, send(key)] }
+              result = self.setting(setting, context.to_h) if respond_to?(:settings) && self.class.name == klass.name
+              result = send(klass.name.underscore.to_sym)&.setting(setting, context.to_h) if result.nil? && self.respond_to?(klass.name.underscore.to_sym)
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vario/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vario
+  VERSION = "0.4.12"
+end

data/lib/vario.rb

@@ -0,0 +1,30 @@
+require_relative 'vario/engine'
+require_relative 'vario/config'
+require_relative 'vario/settable'
+require_relative 'vario/settings_reader'
+require_relative 'vario/action_view_helpers'
+require_relative 'vario/active_record_helpers'
+require_relative 'vario/api'
+
+module Vario
+  class Error < StandardError; end
+  class UnknownSetting < Error; end
+
+  class << self
+    attr_reader :config
+
+    def setup
+      @config = Vario::Config.new
+      yield config
+    end
+  end
+
+  # Include helpers
+  ActiveSupport.on_load(:active_record) do
+    include ActiveRecordHelpers
+  end
+
+  ActiveSupport.on_load(:action_view) do
+    include ActionViewHelpers
+  end
+end