ditty 0.7.1 → 0.10.1

data/lib/ditty/helpers/component.rb

@@ -13,8 +13,10 @@ module Ditty
       # param :count, Integer, min: 1, default: 10 # Can't do this, since count can be `all`
       def check_count
         return 10 if params[:count].nil?
+
         count = params[:count].to_i
         return count if count >= 1
+
         excp = Sinatra::Param::InvalidParameterError.new 'Parameter cannot be less than 1'
         excp.param = :count
         raise excp
@@ -31,22 +33,25 @@ module Ditty
         param :q, String
         param :page, Integer, min: 1, default: 1
         param :sort, String
-        param :order, String, in: %w[asc desc], transform: :downcase, default: 'asc'
+        param :order, String, in: %w[asc desc], transform: :downcase
         # TODO: Can we dynamically validate the search / filter fields?
 
         ds = dataset
         ds = ds.dataset if ds.respond_to?(:dataset)
+        params[:order] ||= 'asc' if params[:sort]
         return ds if params[:count] == 'all'
+
         params[:count] = check_count
 
         # Account for difference between sequel paginate and will paginate
         return ds.paginate(page: params[:page], per_page: params[:count]) if ds.is_a?(Array)
+
         ds.paginate(params[:page], params[:count])
       end
 
       def heading(action = nil)
         @headings ||= begin
-          heading = settings.model_class.to_s.demodulize.titleize
+          heading = settings.heading || settings.model_class.to_s.demodulize.singularize.titleize
           h = Hash.new(heading)
           h[:new] = "New #{heading}"
           h[:list] = pluralize heading
@@ -78,6 +83,7 @@ module Ditty
       def filters
         filter_fields.map do |filter|
           next if params[filter[:name]].blank?
+
           filter[:field] ||= filter[:name]
           filter[:modifier] ||= :to_s # TODO: Do this with Sinatra Param?
           filter
@@ -86,6 +92,7 @@ module Ditty
 
       def ordering
         return if params[:sort].blank?
+
         Sequel.send(params[:order].to_sym, params[:sort].to_sym)
       end
 
@@ -112,11 +119,13 @@ module Ditty
         assoc = filter[:field].to_s.split('.').first.to_sym
         assoc = settings.model_class.association_reflection(assoc)
         raise "Unknown association #{assoc}" if assoc.nil?
+
         assoc
       end
 
       def search_filters
         return [] if params[:q].blank?
+
         searchable_fields.map { |f| Sequel.ilike(f.to_sym, "%#{params[:q]}%") }
       end
     end

data/lib/ditty/helpers/pundit.rb

@@ -12,23 +12,39 @@ module Ditty
         super
       end
 
-      def permitted_attributes(record, action)
-        param_key = PolicyFinder.new(record).param_key
+      def permitted_attributes(record, action = nil)
         policy = policy(record)
+        action ||= record.new? ? :create : :update
         method_name = if policy.respond_to?("permitted_attributes_for_#{action}")
-                        "permitted_attributes_for_#{action}"
-                      else
-                        'permitted_attributes'
-                      end
+          "permitted_attributes_for_#{action}"
+        else
+          'permitted_attributes'
+        end
+        policy.public_send(method_name)
+      end
 
-        policy_fields = policy.public_send(method_name)
+      def permitted_parameters(record, action = nil)
+        param_key = PolicyFinder.new(record).param_key
+        policy_fields = permitted_attributes(record, action)
         request.params.fetch(param_key, {}).select do |key, _value|
           policy_fields.include? key.to_sym
         end
       end
 
+      def permitted_response_attributes(record, method = :values)
+        policy = policy(record)
+        response = record.send(method)
+
+        return response unless policy.respond_to? :response_attributes
+
+        policy_fields = policy.response_attributes
+        response.select do |key, _value|
+          policy_fields.include? key.to_sym
+        end
+      end
+
       def pundit_user
-        current_user
+        current_user unless current_user&.anonymous?
       end
     end
   end

data/lib/ditty/helpers/response.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
+require 'csv'
+
 module Ditty
   module Helpers
     module Response
-      def list_response(result)
+      def list_response(result, view: 'index')
         respond_to do |format|
           format.html do
             actions = {}
             actions["#{base_path}/new"] = "New #{heading}" if policy(settings.model_class).create?
-            haml :"#{view_location}/index",
+            haml :"#{view_location}/#{view}",
                  locals: { list: result, title: heading(:list), actions: actions },
                  layout: layout
           end
@@ -16,12 +18,21 @@ module Ditty
             # TODO: Add links defined by actions (New #{heading})
             total = result.respond_to?(:pagination_record_count) ? result.pagination_record_count : result.count
             json(
-              'items' => result.all.map(&:for_json),
+              'items' => result.all.map { |e| permitted_response_attributes(e, :for_json) },
               'page' => (params['page'] || 1).to_i,
               'count' => result.count,
               'total' => total
             )
           end
+          format.csv do
+            attachment "#{base_path}.csv"
+            CSV.generate do |csv|
+              csv << result.first.for_csv.keys
+              result.all.each do |r|
+                csv << r.for_csv.values
+              end
+            end
+          end
         end
       end
 
@@ -29,29 +40,42 @@ module Ditty
         respond_to do |format|
           format.html do
             flash[:success] = "#{heading} Created"
-            redirect with_layout("#{base_path}/#{entity.id}")
+            redirect with_layout(params[:redirect_to] || flash[:redirect_to] || "#{base_path}/#{entity.display_id}")
           end
           format.json do
             content_type :json
-            redirect "#{base_path}/#{entity.id}", 201
+            redirect "#{base_path}/#{entity.display_id}", 201
           end
         end
       end
 
+      def actions(entity = nil)
+        actions = {}
+        actions["#{base_path}/#{entity.display_id}/edit"] = "Edit #{heading}" if entity && policy(entity).update?
+        actions["#{base_path}/new"] = "New #{heading}" if policy(settings.model_class).create?
+        actions
+      end
+
       def read_response(entity)
+        actions = actions(entity)
         respond_to do |format|
           format.html do
-            actions = {}
-            actions["#{base_path}/#{entity.id}/edit"] = "Edit #{heading}" if policy(entity).update?
-            actions["#{base_path}/new"] = "New #{heading}" if policy(entity).create?
             title = heading(:read) + (entity.respond_to?(:name) ? ": #{entity.name}" : '')
+            last_modified entity.updated_at if entity.respond_to?(:updated_at)
+            etag entity.etag if entity.respond_to?(:etag)
             haml :"#{view_location}/display",
                  locals: { entity: entity, title: title, actions: actions },
                  layout: layout
           end
           format.json do
             # TODO: Add links defined by actions (Edit #{heading})
-            json entity.for_json
+            json permitted_response_attributes(entity, :for_json)
+          end
+          format.csv do
+            CSV.generate do |csv|
+              csv << entity.for_csv.keys
+              csv << entity.for_csv.values
+            end
           end
         end
       end
@@ -61,11 +85,11 @@ module Ditty
           format.html do
             # TODO: Ability to customize the return path and message?
             flash[:success] = "#{heading} Updated"
-            redirect with_layout("#{base_path}/#{entity.id}")
+            redirect with_layout(params[:redirect_to] || flash[:redirect_to] || "#{base_path}/#{entity.display_id}")
           end
           format.json do
-            headers 'Location' => "#{base_path}/#{entity.id}"
-            json body entity.for_json
+            content_type :json
+            redirect "#{base_path}/#{entity.display_id}", 200, json(entity.for_json)
           end
         end
       end
@@ -74,12 +98,11 @@ module Ditty
         respond_to do |format|
           format.html do
             flash[:success] = "#{heading} Deleted"
-            redirect with_layout(base_path.to_s)
+            redirect with_layout(params[:redirect_to] || flash[:redirect_to] || back || base_path)
           end
           format.json do
             content_type :json
-            headers 'Location' => base_path.to_s
-            status 204
+            redirect base_path.to_s, 204
           end
         end
       end

data/lib/ditty/helpers/views.rb

@@ -7,6 +7,7 @@ module Ditty
     module Views
       def layout
         return :embedded if request.params['layout'] == 'embedded'
+
         :layout
       end
 
@@ -14,6 +15,7 @@ module Ditty
         uri = URI.parse(url)
         # Don't set the layout if there's none. Don't set the layout for external URIs
         return url if params['layout'].nil? || uri.host
+
         qs = { 'layout' => params['layout'] }.merge(uri.query ? CGI.parse(uri.query) : {})
         uri.query = Rack::Utils.build_query qs
         uri.to_s
@@ -22,9 +24,11 @@ module Ditty
       def form_control(name, model, opts = {})
         label = opts.delete(:label) || name.to_s.titlecase
         klass = opts.delete(:class) || 'form-control' unless opts[:type] == 'file'
+        klass = "#{klass} is-invalid" if model.errors[name]
         group = opts.delete(:group) || model.class.to_s.demodulize.underscore
         field = opts.delete(:field) || name
         default = opts.delete(:default) || nil
+        help_text = opts.delete(:help_text) || nil
 
         attributes = { type: 'text', id: name, name: "#{group}[#{name}]", class: klass }.merge(opts)
         haml :'partials/form_control', locals: {
@@ -34,33 +38,37 @@ module Ditty
           name: name,
           group: group,
           field: field,
-          default: default
+          default: default,
+          help_text: help_text
         }
       end
 
       def filter_control(filter, opts = {})
         meth = "#{filter[:name]}_options".to_sym
         return unless respond_to? meth
+
         haml :'partials/filter_control', locals: {
           name: filter[:name],
           label: opts[:label] || filter[:name].to_s.titlecase,
-          options: send(meth)
+          options: send(meth),
+          total_filters: opts[:filters]
         }
       end
 
       def flash_messages(key = :flash)
         return '' if flash(key).empty?
+
         id = (key == :flash ? 'flash' : "flash_#{key}")
         messages = flash(key).collect do |message|
           "  <div class='alert alert-#{message[0]} alert-dismissable' role='alert'>#{message[1]}</div>\n"
         end
-        "<div id='#{id}'>\n" + messages.join + '</div>'
+        "<div id='#{id}'>\n#{messages.join}</div>"
       end
 
       def query_string(add = {})
         qs = params.clone.merge(add)
         qs.delete('captures')
-        Rack::Utils.build_query qs
+        Rack::Utils.build_query(qs.delete_if { |_k, v| v == '' })
       end
 
       def delete_form(entity, label = 'Delete')
@@ -86,14 +94,15 @@ module Ditty
       def form_tag(url, options = {}, &block)
         options[:form_verb] ||= :post
         options[:attributes] ||= {}
-        options[:attributes] = { 'class': 'form-horizontal' }.merge options[:attributes]
+        options[:attributes] = { class: 'form-horizontal' }.merge options[:attributes]
         options[:url] = options[:form_verb].to_sym == :get ? url : with_layout(url)
         haml :'partials/form_tag', locals: options.merge(block: block)
       end
 
       def pagination(list, base_path, qp = {})
         return unless list.respond_to?(:pagination_record_count) || list.respond_to?(:total_entries)
-        list = Ditty::Services::PaginationWrapper.new(list)
+
+        list = ::Ditty::Services::PaginationWrapper.new(list)
         locals = {
           first_link: "#{base_path}?" + query_string(qp.merge(page: 1)),
           next_link: list.last_page? ? '#' : "#{base_path}?" + query_string(qp.merge(page: list.next_page)),
@@ -114,6 +123,39 @@ module Ditty
           value
         end
       end
+
+      def url_for(options = nil)
+        return options if options.is_a? String
+        return request.env['HTTP_REFERER'] if options == :back && request.env['HTTP_REFERER']
+
+        raise 'Unimplemented'
+      end
+
+      def link_to(name = nil, options = nil, html_options = {})
+        html_options[:href] ||= url_for(options)
+
+        capture_haml do
+          haml_tag :a, name, html_options
+        end
+      end
+
+      def sort_ui(field)
+        haml :'partials/sort_ui', locals: { field: field }
+      end
+
+      def sort_query(field)
+        query_string(
+          order: params[:sort] == field.to_s && params[:order] == 'asc' ? 'desc' : 'asc',
+          sort: field,
+        )
+      end
+
+      def sort_icon(field)
+        return 'fa-sort' unless params[:sort] == field.to_s
+        return 'fa-sort-up' if params[:order] == 'asc'
+
+        'fa-sort-down'
+      end
     end
   end
 end

data/lib/ditty/listener.rb

@@ -17,43 +17,73 @@ module Ditty
     end
 
     def method_missing(method, *args)
-      return unless args[0].is_a?(Hash) && args[0][:target].is_a?(Sinatra::Base) && args[0][:target].settings.track_actions
+      unless args[0].is_a?(Hash) && args[0][:target].is_a?(Sinatra::Base) && args[0][:target].settings.track_actions
+        return
+      end
 
-      log_action({
-        user: args[0][:target].current_user,
-        action: action_from(args[0][:target], method),
-        details: args[0][:details]
-      }.merge(args[0][:values] || {}))
+      log_action(
+        user_traits(args[0][:target]).merge(
+          action: action_from(args[0][:target], method),
+          details: args[0][:details]
+        ).merge(args[0][:values] || {})
+      )
     end
 
     def respond_to_missing?(method, _include_private = false)
       EVENTS.include? method
     end
 
+    def user_login(event)
+      log_action(
+        user_traits(event[:target]).merge(
+          action: action_from(event[:target], :user_login),
+          details: event[:details]
+        ).merge(event[:values] || {})
+      )
+
+      @mutex.synchronize do
+        UserLoginTrait.update_or_create(user_traits(event[:target]), updated_at: Time.now)
+      end
+    end
+
     def user_register(event)
       user = event[:values][:user]
-      log_action({
-        user: user,
-        action: action_from(event[:target], :user_register),
-        details: event[:details]
-      }.merge(event[:values] || {}))
+      log_action(
+        user_traits(event[:target]).merge(
+          user_id: user.id,
+          action: action_from(event[:target], :user_register),
+          details: event[:details]
+        ).merge(event[:values] || {})
+      )
 
       # Create the SA user if none is present
       sa = Role.find_or_create(name: 'super_admin')
       return if User.where(roles: sa).count.positive?
+
       user.add_role sa
     end
 
     def action_from(target, method)
       return method unless method.to_s.start_with? 'component_'
-      target.class.to_s.demodulize.underscore + '_' + method.to_s.gsub(/^component_/, '')
+
+      "#{target.class.to_s.demodulize.underscore}_#{method.to_s.gsub(/^component_/, '')}"
     end
 
     def log_action(values)
       values[:user] ||= values[:target].current_user if values[:target]
-      @mutex.synchronize { Ditty::AuditLog.create values }
+      @mutex.synchronize { ::Ditty::AuditLog.create values }
+    end
+
+    def user_traits(target)
+      {
+        user_id: target.current_user&.id,
+        platform: target.browser.platform.name,
+        device: target.browser.device.name,
+        browser: target.browser.name,
+        ip_address: target.request.ip
+      }
     end
   end
 end
 
-Wisper.subscribe(Ditty::Listener.new) unless ENV['RACK_ENV'] == 'test'
+Wisper.subscribe(::Ditty::Listener.new) unless ENV['RACK_ENV'] == 'test'