symphonia 2.1.7

data/lib/symphonia/controller_extensions.rb

@@ -0,0 +1,200 @@
+module Symphonia
+  module ControllerExtensions
+
+    extend ActiveSupport::Concern
+
+
+    included do
+      class Unauthorized < Exception; end
+
+      before_action :current_user, :menu_item
+      before_action :set_default_locale
+
+      # force_ssl if: -> {Rails.env.production? && User.current.ssl?}
+
+      add_flash_types :warning
+      add_flash_types :error
+
+      rescue_from ::ActiveRecord::RecordNotFound do
+        render_404
+      end
+
+      rescue_from Unauthorized do
+        render_403
+      end
+
+      helper_method :current_user
+
+    end
+
+    def back_url
+      url = params[:back_url]
+      if url.nil? && (referer = request.env['HTTP_REFERER'])
+        url = CGI.unescape(referer.to_s)
+      end
+      url
+    end
+
+    # def redirect_back_or_default(default, options={})
+    #   back_url = params[:back_url].to_s
+    #   if back_url.present?
+    #     begin
+    #       uri = URI.parse(back_url)
+    #       # do not redirect user to another host or to the login or register page
+    #       if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
+    #         redirect_to(back_url)
+    #         return
+    #       end
+    #     rescue URI::InvalidURIError
+    #       logger.warn("Could not redirect to invalid URL #{back_url}")
+    #       # redirect to default
+    #     end
+    #   elsif options[:referer]
+    #     redirect_to_referer_or default
+    #     return
+    #   end
+    #   redirect_to default, options
+    #   false
+    # end
+
+    # Redirects to the request referer if present, redirects to args or call block otherwise.
+    def redirect_to_referer_or(*args, &block)
+      redirect_to :back
+    rescue ::ActionController::RedirectBackError
+      if args.any?
+        redirect_to *args
+      elsif block_given?
+        block.call
+      else
+        raise "#redirect_to_referer_or takes arguments or a block"
+      end
+    end
+
+    # private
+
+    def set_locale
+      client_lang = params.fetch(:locale, nil).presence || session[:locale].presence || request.env['HTTP_ACCEPT_LANGUAGE'].to_s.split(',').collect { |l| l.scan(/^[a-z]{2}/) }.flatten
+      @client_lang = Array(client_lang).detect { |l| I18n.available_locales.include?(l.to_sym) }
+
+      I18n.locale = (@client_lang || I18n.default_locale)
+      session[:locale] = I18n.locale
+
+      logger.debug "* Locale set to '#{I18n.locale}'"
+    end
+
+    def set_default_locale
+      if (enforce_default = Symphonia.config.default_locale)
+        I18n.locale = enforce_default
+      end
+    end
+
+    # protected
+
+    def login_require(format = nil)
+      if current_user.nil? || !current_user.logged_in?
+        respond_to do |format|
+          format.html do
+            store_location
+            redirect_to symphonia.login_path, flash: { error: t(:text_login_require) }
+          end
+          format.json do
+            render json: { errors: 'You must be logged in to access this endpoint' }, status: 403
+          end
+        end
+        return false
+      end
+      true
+    end
+
+    alias_method :require_login, :login_require
+    alias_method :require_user, :login_require
+
+    def admin_require
+      return unless login_require
+      unless current_user.admin?
+        render_403
+        return false
+      end
+    end
+
+    alias_method :require_admin, :admin_require
+
+    def render_403
+      respond_to do |format|
+        format.html { render template: 'common/403', message: :notice_not_authorized, status: 403 }
+        format.js { render plain: "alert('#{t :text_access_deny}')", message: :notice_not_authorized, status: 403 }
+        format.json { head 403, message: :notice_not_authorized }
+      end
+    end
+
+    def render_404
+      respond_to do |format|
+        format.html { render template: 'common/404', message: :notice_page_not_found, status: 404 }
+        format.json { head 404, message: :not_found }
+      end
+    end
+
+    # Renders a 200 response for successful updates or deletions via the API
+    def render_api_ok
+      head :ok
+    end
+
+    # Renders a head API response
+    def render_api_head(status)
+      head status
+    end
+
+    def menu_item(item = nil)
+      @menu_item = (item || controller_name)
+    end
+
+    def current_user_session
+      return @current_user_session if defined?(@current_user_session)
+      @current_user_session = UserSession.find
+    end
+
+    def current_user
+      return (Symphonia::User.current ||= @current_user) if defined?(@current_user)
+      @current_user = current_user_session && current_user_session.user
+      Symphonia::User.current = @current_user || Symphonia::User::Anonymous.new
+    end
+
+    def authorize
+      if Symphonia::User.current.authorize?(controller_name, action_name)
+        return true
+      else
+        if Symphonia::User.current.logged_in?
+          raise Unauthorized
+        else
+          respond_to do |format|
+            format.html do
+              return redirect_to(symphonia.login_path(back_url: request.path), error: t(:text_error_login_required))
+            end
+            format.any { return head 401 }
+          end
+        end
+      end
+      raise Unauthorized
+    end
+
+    def handle_unverified_request
+      # raise an exception
+      fail ActionController::InvalidAuthenticityToken
+      # or destroy session, redirect
+      if current_user_session
+        current_user_session.destroy
+      end
+      redirect_to main_app.root_url
+    end
+
+    def store_location
+      session[:return_to] = request.url
+    end
+
+    def redirect_back_or_default(default, options = {})
+      options ||= {}
+      redirect_to(params[:back_url] || default, options)
+    end
+
+  end
+end

data/lib/symphonia/engine.rb

@@ -0,0 +1,137 @@
+require 'symphonia/object'
+require 'symphonia/menu_manager'
+require 'symphonia/permissions'
+require 'symphonia/user_management'
+
+require 'rails-i18n'
+require 'turbolinks'
+require 'authlogic'
+require 'bootstrap'
+
+require 'will_paginate'
+require 'api-pagination'
+require 'font-awesome-rails'
+require 'jquery-rails'
+require 'jquery-ui-rails'
+require 'rdiscount'
+require 'sortable-table'
+require 'paperclip'
+require 'awesome_nested_set'
+require 'acts_as_list'
+require 'bootstrap_form'
+require 'the_sortable_tree'
+require 'bootstrap-datepicker-rails'
+require 'wicked_pdf'
+require 'swagger/blocks'
+
+module Symphonia
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Symphonia
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      # g.fixture_replacement :factory_girl, dir: 'spec/factories'
+    end
+
+    # Rails 5
+    # ActionController::Base.class_eval do
+    #   include Symphonia::ApplicationController
+    # end
+
+
+    initializer :symphonia_extensions do
+    end
+
+    # ActiveSupport::Reloader.to_prepare do
+    #   ::ApplicationController.send :helper, Symphonia::ApplicationHelper
+    #   ::ApplicationMailer.send :helper, Symphonia::ApplicationHelper
+    #   BootstrapForm::FormBuilder.prepend(Symphonia::FormBuilder)
+    # end
+
+    initializer :symphonia_setup do |_app|
+      Mime::Type.register 'application/pdf', :pdf
+      config.i18n.available_locales ||= %i[cs en]
+      config.i18n.default_locale = :cs
+
+      WillPaginate.per_page = 20
+
+      Symphonia.configure do |config|
+        config.after_login_path = ->(h) { h.symphonia.user_current_path }
+        config.allow_registrations = true
+        config.default_locale = :cs
+      end
+
+    end
+
+    initializer :append_migrations do |app|
+      if app.root.to_s != root.to_s && app.root != root.join("spec/dummy")
+        config.paths['db/migrate'].expanded.each do |expanded_path|
+          app.config.paths['db/migrate'] << expanded_path
+        end
+      end
+    end
+
+    # include helpers
+    initializer :load_helper, before: :load_config_initializers do |app|
+      # config.active_record.raise_in_transactional_callbacks = false
+      if Rails.env.development?
+        config.action_mailer.default_url_options ||= { host: 'symphonia.app' }
+        config.action_mailer.preview_path = "{#{app.root.join('spec/mailers/previews')},#{root.join('spec/mailers/previews')}}"
+      end
+    end
+
+    initializer :assets do |_app|
+      if defined?(::Ckeditor)
+        config.assets.precompile << 'ckeditor/**/*'
+        config.assets.precompile << 'symphonia/symphonia_ckeditor.js'
+      end
+    end
+
+    initializer :symphonia_general_permissions do |_app|
+      Symphonia::Permissions.map do |m|
+        m.register(:view_users).add(:users, %i[index show])
+        m.register(:manager_users).add(:users, %i[create update destroy new edit])
+      end
+
+    end
+
+    initializer :wicked_pdf do |_app|
+      WickedPdf.config = {
+        layout: 'application.pdf',
+        print_media_type: true,
+        viewport_size: '1280x800', zoom: 0.7, dpi: 300
+      }
+    end
+
+    initializer :api_paginate do
+      ApiPagination.configure do |config|
+        # If you have both gems included, you can choose a paginator.
+        config.paginator = :will_paginate
+
+        # By default, this is set to 'Total'
+        config.total_header = 'X-Total'
+
+        # By default, this is set to 'Per-Page'
+        config.per_page_header = 'X-Per-Page'
+
+        # Optional: set this to add a header with the current page number.
+        config.page_header = 'X-Page'
+
+        # Optional: what parameter should be used to set the page option
+        # config.page_param = :page
+        # # or
+        # config.page_param do |params|
+        #   params[:page][:number]
+        # end
+        #
+        # # Optional: what parameter should be used to set the per page option
+        # config.per_page_param = :per_page
+        # # or
+        # config.per_page_param do |params|
+        #   params[:page][:size]
+        # end
+      end
+    end
+  end
+end

data/lib/symphonia/form_builder.rb

@@ -0,0 +1,137 @@
+module Symphonia
+  class FormBuilder < ::BootstrapForm::FormBuilder
+
+    def error_messages
+      if object.respond_to?(:errors) && object.errors.any?
+        list = content_tag(:p, I18n.t('activerecord.errors.template.body')).html_safe
+        list += content_tag(:ul) do
+          object.errors.full_messages.collect do |error|
+            content_tag(:li, error)
+          end.join.html_safe
+        end
+        content_tag(:div, list, class: 'error_explanation')
+      end
+    end
+
+    def calendar_field(name, options = {})
+      options[:data] ||= {} #{'date-clear-btn': true, 'date-format': 'yyyy-mm-dd'}
+      options[:data][:'date-clear-btn'] ||= true
+      # options[:data][:'date-format'] ||= 'yyyy-mm-dd'
+      text_field(name, options.merge({
+                                         class: 'form-control datepicker',
+                                         append: @template.fa_icon('calendar')
+                                     }))
+    end
+
+    # def form_group_builder(method, options, html_options = nil)
+    #   options.symbolize_keys!
+    #   html_options.symbolize_keys! if html_options
+    #
+    #   # Add control_class; allow it to be overridden by :control_class option
+    #   css_options = html_options || options
+    #   control_classes = css_options.delete(:control_class) { control_class }
+    #   css_options[:class] = [control_classes, css_options[:class]].compact.join(" ")
+    #   css_options[:class] << " is-invalid" if has_error?(method)
+    #
+    #   options = convert_form_tag_options(method, options) if acts_like_form_tag
+    #
+    #   wrapper_class = css_options.delete(:wrapper_class)
+    #   wrapper_options = css_options.delete(:wrapper)
+    #   help = options.delete(:help)
+    #   icon = options.delete(:icon)
+    #   label_col = options.delete(:label_col)
+    #   control_col = options.delete(:control_col)
+    #   layout = get_group_layout(options.delete(:layout))
+    #   form_group_options = {
+    #     id: options[:id],
+    #     help: help,
+    #     icon: icon,
+    #     label_col: label_col,
+    #     control_col: control_col,
+    #     layout: layout,
+    #     class: wrapper_class
+    #   }
+    #
+    #   if wrapper_options.is_a?(Hash)
+    #     form_group_options.merge!(wrapper_options)
+    #   end
+    #
+    #   unless options.delete(:skip_label)
+    #     if options[:label].is_a?(Hash)
+    #       label_text  = options[:label].delete(:text)
+    #       label_class = options[:label].delete(:class)
+    #       options.delete(:label)
+    #     end
+    #     label_class ||= options.delete(:label_class)
+    #     label_class = hide_class if options.delete(:hide_label)
+    #
+    #     if options[:label].is_a?(String)
+    #       label_text ||= options.delete(:label)
+    #     end
+    #
+    #     form_group_options.merge!(label: {
+    #       text: label_text,
+    #       class: label_class,
+    #       skip_required: options.delete(:skip_required),
+    #       required: options.delete(:required)
+    #     })
+    #   end
+    #
+    #   form_group(method, form_group_options) do
+    #     yield
+    #   end
+    # end
+
+    def label_text(name, options)
+      name = name.to_s.remove(/_id$/)
+
+      if label_errors && error?(name)
+        (options[:text] || object.class.human_attribute_name(name)).to_s.concat(" #{get_error_messages(name)}")
+      else
+        options[:text]
+      end
+    end
+    # def generate_label(id, name, options, custom_label_col, group_layout)
+    #   return if options.blank?
+    #   # id is the caller's options[:id] at the only place this method is called.
+    #   # The options argument is a small subset of the options that might have
+    #   # been passed to generate_label's caller, and definitely doesn't include
+    #   # :id.
+    #   options[:for] = id if acts_like_form_tag
+    #   classes = [options[:class]]
+    #
+    #   if layout_horizontal?(group_layout)
+    #     classes << "col-form-label"
+    #     classes << (custom_label_col || label_col)
+    #   elsif layout_inline?(group_layout)
+    #     classes << "mr-sm-2"
+    #   end
+    #
+    #   xname = name.to_s.remove(/_id$/)
+    #
+    #   case options.delete(:required)
+    #   when true
+    #     classes << "required"
+    #   when nil, :default
+    #     classes << "required" if required_attribute?(object, name)
+    #   end
+    #
+    #   options[:class] = classes.compact.join(" ").strip
+    #   options.delete(:class) if options[:class].empty?
+    #
+    #   if label_errors && has_error?(name)
+    #     error_messages = get_error_messages(name)
+    #     label_text = (options[:text] || object.class.human_attribute_name(xname)).to_s.concat(" #{error_messages}")
+    #     options[:class] = [options[:class], "text-danger"].compact.join(" ")
+    #     label(name, label_text, options.except(:text))
+    #   else
+    #     label(name, options[:text], options.except(:text))
+    #   end
+    # end
+
+    def error_class
+      'is-invalid'
+    end
+
+  end
+end

data/lib/symphonia/menu_manager.rb

@@ -0,0 +1,23 @@
+module Symphonia
+  module MenuManager
+    @@mapper = {}
+    mattr_accessor :mapper
+
+    def self.menu(name)
+      return mapper[name.to_sym] || {}
+    end
+
+    class << self
+      def map(menu_name)
+        mapper[menu_name] ||= {}
+        if block_given?
+          yield mapper[menu_name]
+        end
+      end
+
+      def clear(menu_name)
+        !mapper.delete(menu_name.to_sym).nil?
+      end
+    end
+  end
+end

data/lib/symphonia/model_attributes/attribute.rb

@@ -0,0 +1,137 @@
+module Symphonia
+  module ModelAttributes
+    class Attribute
+
+      attr_reader :name, :options
+      attr_reader :format_options, :sort_column
+      attr_accessor :filter
+
+      def initialize(name, klass, options, formatter)
+        @name = name
+        @klass = klass
+        @formatter = formatter
+        @options = options
+        @format_options = {}
+      end
+
+      def title
+        @klass.human_attribute_name(@name.to_s.remove(/_id$/), @options[:i18n] || {})
+      end
+
+      def value(entity)
+        entity.send(name)
+      end
+
+      def format(view, entity, options={})
+        @format_options = options
+        if @formatter.is_a?(Proc)
+          @formatter.call(view, self, entity).to_s
+        else
+          format_value(view, value(entity), entity)
+        end
+      end
+
+      def sort=(sort_options)
+        t = @klass.arel_table
+        @sort = true
+        case sort_options
+        when false
+          @sort = false
+        when Symbol, Array
+          sort = Array(sort_options).collect { |i| t[i] }
+          asc_desc = { asc: sort.map { |i| i.asc.to_sql }.join(','), desc: sort.map { |i| i.desc.to_sql }.join(',') }
+          @sort_column = SortableTable::SortColumnCustomDefinition.new(@name, asc_desc)
+        when String
+          asc_desc = { asc: sort_options + ' ASC', desc: sort_options + ' DESC' }
+          @sort_column = SortableTable::SortColumnCustomDefinition.new(@name, asc_desc)
+        else
+          raise "Undefined `sort_options` type: #{sort_options.class.name}"
+        end
+      end
+
+      def sort?
+        @sort
+      end
+
+      def filter?
+        !!filter
+      end
+
+      def default?
+        !!@options[:default]
+      end
+
+      private
+
+      def format_value(_view, value, _entity)
+        value.to_s
+      end
+    end
+
+
+    class DecimalAttribute < Attribute
+      def format_value(view, value, entity)
+        view.format_price(value)
+      end
+    end
+
+    class EnumAttribute < Attribute
+      # TODO: @klass.name || @klass.base_class.name || entity.class.name
+      def format_value(view, value, entity)
+        view.t("#{@klass.name.underscore}.#{name.to_s.pluralize}.#{value}", format_options)
+      end
+    end
+
+    class LinkAttribute < Attribute
+      def format_value(view, value, entity)
+        view.link_to value.to_s, entity, format_options
+      end
+    end
+
+    class MailAttribute < Attribute
+      def format_value(view, value, entity)
+        view.mail_to value.to_s, value.to_s, format_options
+      end
+    end
+
+    class ReferenceAttribute < Attribute
+
+      def initialize(name, klass, options, formatter)
+        super
+      end
+
+      def title
+        @klass.human_attribute_name(@klass.reflect_on_association(name).foreign_key, @options[:i18n] || {})
+      end
+
+      def format_value(view, value, entity)
+        view.link_to value.to_s, value, format_options
+      end
+    end
+
+    class BooleanAttribute < Attribute
+      def format_value(view, value, entity)
+        if value.to_boolean
+          view.icon('true', view.t(:true))
+        else
+          view.icon('false', view.t(:false))
+        end
+      end
+    end
+
+    class DateAttribute < Attribute
+      def format_value(view, value, entity)
+        value && view.l(value.to_date, format_options)
+      end
+    end
+
+    class DateTimeAttribute < Attribute
+      def format_value(view, value, entity)
+        value && view.l(value, format_options)
+      end
+    end
+    class DatetimeAttribute < DateTimeAttribute
+      # alias
+    end
+  end
+end