symphonia 2.1.7

data/app/controllers/symphonia/users_controller.rb

@@ -0,0 +1,168 @@
+module Symphonia
+  class UsersController < ApplicationController
+    include Swagger::Blocks
+
+    swagger_path '/admin/users/{id}.json' do
+      operation :get do
+        key :summary, 'Find User by ID'
+        key :description, 'Returns a single user if the user has access'
+        # key :operationId, 'findPetById'
+        # key :tags, [
+        #   'pet'
+        # ]
+        parameter do
+          key :name, :id
+          key :in, :path
+          key :description, 'ID of user to fetch'
+          key :required, true
+          key :type, :integer
+          key :format, :int64
+        end
+        extend Symphonia::Swagger::Responses
+        response 200 do
+          key :description, 'user response'
+          schema do
+            key :'$ref', :User
+          end
+        end
+          # response :default do
+          #   key :description, 'unexpected error'
+          #   schema do
+          #     key :'$ref', :ErrorModel
+          #   end
+          # end
+      end
+    end
+
+    helper Symphonia::RendererHelper
+
+    before_action :find_user, except: %i[index new create show]
+    before_action :authorize, except: [:show]
+    before_action -> { menu_item(:my_account) }, only: %i[current edit_current update_current]
+
+    def index
+      @query = Symphonia::User.query.new
+      @query.from_params params
+      @entities = @query.entities
+      respond_to do |format|
+        format.html do
+          @entities = @entities.page(params[:page])
+          render layout: !request.xhr?
+        end
+        format.json { render json: @entities.all, only: %i[id]+Symphonia::User.registered_attributes.keys }
+      end
+    end
+
+    def show
+      @user = Symphonia::User.find(params[:id]) if params[:id]
+      @user ||= Symphonia::User.current
+      authorize
+      respond_to do |format|
+        format.html
+        format.json { render json: @user, except: %w[crypted_password password_salt persistence_token perishable_token] }
+      end
+    end
+
+    def new
+      @user = Symphonia::User.new
+      @roles = Symphonia::Role.sorted
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    def create
+      @user = Symphonia::User.new(user_params)
+      respond_to do |format|
+        if @user.save
+          format.html { redirect_to @user, notice: t(:text_created) }
+          format.xml { render xml: @user, status: :created, location: @user }
+          format.json { render json: @user, status: :created, location: @user }
+        else
+          format.html do
+            @roles = Symphonia::Role.sorted
+            render action: 'new'
+          end
+          format.xml { render xml: @user.errors, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def edit
+      @roles = Role.all
+    end
+
+    def update
+      @user.attributes = user_params
+      @user.admin = params[:admin] if params[:admin] && Symphonia::User.current.admin?
+      if params[:role_id].present? && Symphonia::User.current.admin?
+        @role = Role.find(params[:role_id])
+        @user.role = @role
+      end
+      respond_to do |format|
+        @user.edited_by = current_user
+        @user.edited_at = DateTime.now
+        if @user.save
+          format.html { redirect_back_or_default user_path(@user), notice: t(:text_updated) }
+          format.any(:json ,:xml) { head :no_content }
+        else
+          format.html do
+            @roles = Symphonia::Role.all
+            render action: 'edit'
+          end
+          format.xml { render xml: @user.errors, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def destroy
+      @user.destroy
+
+      respond_to do |format|
+        format.html { redirect_to params[:back_url] || users_url }
+        format.js { render js: "Symphonia.filters.removeRow('#{view_context.dom_id(@user)}')"}
+        format.json { head :no_content }
+      end
+    end
+
+    def archive
+      @user.archive!
+      respond_to do |format|
+        format.html { redirect_to params[:back_url] || users_url }
+        format.json { head :no_content }
+      end
+    end
+
+    def unarchive
+      Notifier.user_change_to_active(@user).deliver_later
+      @user.unarchive!
+
+      respond_to do |format|
+        format.html { redirect_to params[:back_url] || users_url }
+        format.xml { head :no_content }
+      end
+    end
+
+    private
+
+    def find_user
+      @user = Symphonia::User.find(params[:id])
+    end
+
+    def authorize
+      if User.current.id == @user.try!(:id)
+        true
+      else
+        super
+      end
+    end
+
+    def user_params
+      allowed = [:login, :first_name, :last_name, :password, :password_confirmation, :email, :mail, preference_ids: []]
+      allowed.concat(%i[admin role_id]) if Symphonia::User.current.admin?
+      params.require(:user).permit(allowed)
+    end
+  end
+end

data/app/helpers/symphonia/application_helper.rb

@@ -0,0 +1,422 @@
+# require 'symphonia/bootstrap_link_render'
+module Symphonia
+  module ApplicationHelper
+    include FontAwesome::Rails::IconHelper
+    include FormHelper
+
+    def bootstrap_class_for(flash_type)
+      case flash_type.to_sym
+      when :notice
+        'alert-success'
+      when :error, :alert
+        'alert-danger'
+      when :warning
+        'alert-warning'
+      when :info
+        'alert-info'
+      else
+        flash_type.to_s
+      end
+    end
+
+    # Renders flash messages
+    def render_flash_messages(flash_messages = nil)
+      s = ''
+      Array(flash_messages || flash).each do |type, message|
+        s << content_tag(:div, class: "alert #{bootstrap_class_for(type)}") do
+          content_tag(:button, '', class: 'fa fa-times-circle-o close', data: { dismiss: 'alert' }) + Array.wrap(message).collect { |m| fa_icon(type, text: m) }.join("<br>").html_safe
+        end
+      end
+
+      return s.html_safe
+    end
+
+    def render_menu(menu, options = {})
+      s = ''
+      Symphonia::MenuManager.menu(menu).each do |name, item|
+        s << render_menu_node(name, item).to_s
+      end
+      options[:container_class] ||= 'mr-auto'
+
+      return content_tag(:ul, s.html_safe, itemscope: '', itemtype: 'http://data-vocabulary.org/BreadcrumbList', class: "navbar-nav #{options[:container_class]}", id: menu.to_s)
+    end
+
+    def render_menu_node(menu, item, options = {})
+      condition = item[:if] ? item[:if].call : true
+      selected = @menu_item.to_sym == menu
+      label = case item[:label].class.name
+              when 'NilClass'
+                '&nbsp;'.html_safe
+              when 'String'
+                item[:label]
+              when 'Symbol'
+                t(item[:label])
+              when 'Proc'
+                item[:label].call(controller)
+              else
+                raise "MenuManager error: Label is unknown type: #{item[:label].class}"
+              end
+      if item[:children].blank?
+        return content_tag(:li, render_menu_link(item, label, options), class: "nav-item #{menu} #{'active' if selected} #{options[:class]}", id: item[:id]) if condition
+      else
+        children = ''
+        item[:children].each do |child, subitem|
+          children << render_menu_node(menu, subitem, class: 'dropdown-item').to_s
+        end
+        unless children.blank?
+          return content_tag(:li, class: "nav-item dropdown #{menu}") do
+            concat render_menu_link(item.merge({ class: 'dropdown-toggle', data: { toggle: 'dropdown' } }), label, { is_submenu: true })
+            concat content_tag(:ul, children.html_safe, class: 'dropdown-menu')
+          end
+        end
+      end
+    end
+
+    def render_menu_link(item, label, _options = {})
+      url = case item[:url].class.name
+            when 'Symbol'
+              if item[:url].to_s.include?('.')
+                endpoint, path = item[:url].to_s.split('.')
+                send(endpoint).send(path)
+              else
+                main_app.send item[:url]
+              end
+            when 'Proc'
+              item[:url].call(self)
+            else
+              item[:url]
+            end
+      link_to(
+        (content_tag(:i, '', class: "#{item[:icon]}") + "\n" + content_tag(:span, label, itemprop: 'title')).html_safe,
+        url,
+        class: "nav-link #{item[:class]}",
+        data: item[:data],
+        method: item[:method],
+        itemprop: 'url'
+      )
+    end
+
+    def html_title(*args)
+      if args.empty?
+        title = @html_title || []
+        title << t(:meta_title)
+        title.reject(&:blank?).join(' — ')
+      else
+        @html_title ||= []
+        @html_title += args
+      end
+    end
+
+    def html_description(*args)
+      if args.empty?
+        desc = @html_description
+        desc ||= t(:meta_description)
+        desc.to_s
+      else
+        @html_description ||= []
+        @html_description += args
+      end
+    end
+
+    def title(*args, &block)
+      options = args.extract_options!
+      header = args.shift
+      small = args.shift || ''
+      header_text = if header.is_a?(Symbol)
+                      t(header, default: header.to_s.humanize)
+                    else
+                      header.to_s.dup
+                    end
+      if @symphonia_modal_dialog
+        ActiveSupport::Deprecation.warn "@symphonia_modal_dialog is no used anymore !"
+        @symphonia_modal_dialog.title ||= header_text
+        ''
+      else
+        html_title(header_text.dup)
+        header_text << "\n" + content_tag(:small, small, class: 'text-muted') if small.present?
+        s = ''
+        if options[:back] && !request.xhr?
+          back_url = options[:back] unless options[:back].is_a? TrueClass
+          s << link_to_back(back_url)
+        end
+        s << capture(&block).to_s if block_given?
+        header_tag = content_tag request.xhr? && :h5 || :h1, id: 'page_header', class: s.present? && "col-6" || nil do
+          header_text.html_safe
+        end
+        return header_tag if s.blank?
+
+        content_tag :div, class: "row" do
+          header_tag + content_tag(:div, s.html_safe, class: "col-6 text-right")
+        end
+      end
+    end
+
+    alias_method :page_header, :title
+
+    def render_no_data(message = nil)
+      content_tag(:div, message || t(:text_no_data), class: 'nodata')
+    end
+
+    def content_for(name, content = nil, &block)
+      @has_content ||= {}
+      @has_content[name] = true
+      super(name, content, &block)
+    end
+
+    def has_content?(name)
+      !!(@has_content && @has_content[name])
+    end
+
+    def format_text(text, _options = {})
+      return '' if text.nil?
+
+      markdown = RDiscount.new(text, :smart, :filter_html)
+      markdown.to_html.html_safe
+    end
+
+    def format_html(text)
+      content_tag(:div, (defined?(Ckeditor) ? text.html_safe : format_text(text)), class: 'formatted-text')
+    end
+
+    def format_price(value, options = {})
+      number_to_currency(value, { precision: 1, strip_insignificant_zeros: true }.merge(options))
+    end
+
+    def multiselect_toggler(id = nil)
+      link_to(fa_icon(:plus), 'javascript:void(0);', onclick: "toggleMultiSelect(#{id || 'this'});return false", class: 'btn fa fa-border')
+    end
+
+    def link_to_back(url = nil)
+      link_to(icon(:back, t(:button_back)), (params[:back_url] || url || :back), class: 'btn btn-link back')
+    end
+
+    def link_to_new_entity(options = {})
+      return '' unless User.current.allowed_to?(:"manage_#{controller_name}")
+
+      anchor = options.has_key?(:anchor) ? options.delete(:anchor) : 'page_header'
+      label = options.delete(:label) || t("label_#{controller_name.singularize}_new")
+      url = options.delete(:url) || new_polymorphic_path(controller_name.singularize, anchor: anchor)
+      link = link_to(fa_icon('add', text: label), url, { class: 'btn btn-primary' }.merge(options))
+
+      # content_tag(:div, link, class: 'contextual')
+    end
+
+    # change the default link renderer for will_paginate
+    def will_paginate(collection_or_options = nil, options = {})
+      if collection_or_options.is_a? Hash
+        options, collection_or_options = collection_or_options, nil
+      end
+      unless options[:renderer]
+        options = options.merge renderer: Symphonia::BootstrapLinkRender
+      end
+      options[:query] ||= @query if @query
+      super *[collection_or_options, options].compact
+    end
+
+    def ckeditor_for(field_id, options = {})
+      return '' unless !!defined?(Ckeditor)
+
+      inline = options.delete(:inline)
+      opts = options.inject({}) do |mem, var|
+        key = var[0].to_s.camelcase(:lower)
+        key[0].downcase!
+        mem[key] = var[1]
+
+        mem
+      end
+      opts['toolbar'] ||= 'Basic'
+      # opts['customConfig'] ||= 'Basic'
+      js = if inline
+             "CKEDITOR.inline('#{field_id}', {toolbar: 'Basic'});"
+           else
+             "
+        var ta_editor = CKEDITOR.instances['#{field_id}'];
+        if (ta_editor) {CKEDITOR.remove(ta_editor);}
+        CKEDITOR.replace('#{field_id}', #{opts.to_json.html_safe});
+      "
+           end
+      javascript_tag("$(document).ready(function() {#{js.html_safe}})".html_safe)
+    end
+
+    def icon(fa, text = nil)
+      fa_icon(fa, text && { text: content_tag(:span, text, class: 'd-none d-sm-inline') } || {})
+    end
+
+    def render_symphonia_dialog(*args, &block)
+      ActiveSupport::Deprecation.warn "Use `render_modal` instead"
+      options = args.extract_options!
+      title = options[:title] || args.shift # first arg possible `title`
+      body = args.shift
+      options[:form_disabled] = true
+      size = options.delete(:size)
+      size ||= '90%' if options.delete(:large)
+      if size.to_s.match(%r(^\d+$))
+        size = size.to_s + '%'
+      end
+      @symphonia_modal_dialog = SymphoniaModalDialog.new(self, options)
+      @symphonia_modal_dialog.size = size
+      if block_given?
+        yield @symphonia_modal_dialog
+      else
+        raise ArgumentError if body.nil?
+      end
+      @symphonia_modal_dialog.title ||= title
+      if @symphonia_modal_dialog.body.blank?
+        if body.is_a?(Hash)
+          body.merge!(formats: [:html])
+        else
+          body = { partial: body, formats: [:html] }
+        end
+        @symphonia_modal_dialog.body = render(body)
+      end
+      html = @symphonia_modal_dialog.to_html
+      if options[:render_only]
+        html
+      else
+        js = %Q(
+        $('##{@symphonia_modal_dialog.modal_id}').modal('hide').remove();
+        $('body').append('#{j html}');
+        showModal('##{@symphonia_modal_dialog.modal_id}');
+        $("##{@symphonia_modal_dialog.modal_id} .modal-dialog input:text").first().focus();
+        $("##{@symphonia_modal_dialog.modal_id} .modal-dialog .modal-body div.buttons").remove();
+      )
+        js.concat("$('##{@symphonia_modal_dialog.modal_id} .modal-dialog').css({width: '#{size}'});") if size.present?
+        js.html_safe
+      end
+    end
+
+    # def render_modal_dialog(show = true, options = {}, &block)
+    #   tags = SymphoniaModalDialog.new(self, options)
+    #   yield tags if block_given?
+    #   html = tags.to_html
+    #   if show
+    #     "$('##{tags.modal_id}').remove();$('body').append('#{j html}'); showModal('##{tags.modal_id}');".html_safe
+    #   else
+    #     html
+    #   end
+    # end
+
+    class SymphoniaModalDialog
+
+      attr_writer :title, :body, :footer
+      attr_reader :modal_id, :title
+
+      attr_accessor :size
+
+      def initialize(controller, options = {})
+        @c = controller
+        @title = options.delete(:title)
+        @modal_id = options.delete(:id) || 'modal-dialog'
+        @form_options = options.delete(:form_options) || {}
+        @options = options
+      end
+
+      alias_attribute :id, :modal_id
+
+      def to_html
+        html = "<div id='#{@modal_id}' style='' class='modal fade' role='dialog'><div class='modal-dialog #{'modal-lg' if size.present?}'><div class='modal-content'>"
+        html << @c.content_tag(:div, class: 'modal-header') do
+          @c.content_tag(:button, '', class: 'close fa fa-times', data: { dismiss: 'modal' }, 'aria-hidden' => true) + @c.content_tag(:h4, @title, class: 'modal-title') + @header.to_s
+        end
+        content = @c.content_tag(:div, @c.content_tag(:div, body.html_safe, class: 'modal-content-inner-container container-fluid'), class: 'modal-body')
+        content << @c.content_tag(:div, footer.html_safe, class: 'modal-footer')
+
+        html << content.html_safe
+        html << '</div></div></div>'
+        html.html_safe
+      end
+
+      def header(&block)
+        if block_given?
+          @header = @c.capture(&block)
+        else
+          @header = (@header.is_a?(Proc) ? @header.call.to_s : @header.to_s)
+        end
+      end
+
+      def body(&block)
+        if block_given?
+          @body = @c.capture(&block)
+        else
+          @body = (@body.is_a?(Proc) ? @body.call.to_s : @body.to_s)
+        end
+      end
+
+      def footer(&block)
+        if block_given?
+          @footer = @c.capture(&block)
+        else
+          @footer = (@footer.is_a?(Proc) ? @footer.call.to_s : @footer.to_s)
+        end
+      end
+
+      def submit(name = nil, options = {})
+        name ||= @c.t(:button_save)
+        @footer = footer.to_s + @c.link_to(name, 'javascript:void(0)', { onclick: "$('##{@modal_id}').find('form').submit()", class: 'btn btn-primary' }.merge(options)).html_safe
+      end
+
+    end
+
+    # Example of use
+    # <%=
+    # table_header_tag_for(User) do |t|
+    #  t.th :login
+    #  t.th :email
+    # end
+    # %>
+    # options:
+    # => column : DB full name of column
+    #
+    # def table_header_tag_for(model, &block)
+    #   tags = TableHeaderTag.new(model, self)
+    #   yield tags
+    #   tags.to_html
+    # end
+    #
+    # class TableHeaderTag
+    #
+    #   attr_reader :view, :model
+    #
+    #   def initialize(model, view)
+    #     @model = model
+    #     @tags = Array.new
+    #     @view = view
+    #   end
+    #
+    #   def th(*args)
+    #     options = args.extract_options!
+    #     attribute = args.first
+    #     label = args[1]
+    #     raise ArgumentError if attribute.nil?
+    #
+    #     sort_options = options.delete(:sort_options) || {}
+    #     html_options = options.delete(:html_options) || {}
+    #
+    #     label ||= @model.send(:human_attribute_name, attribute, options[:i18n] || {})
+    #     @tags << @view.content_tag(:th, html_options) do
+    #       if options[:sort] === false
+    #         label
+    #       else
+    #         sort_options[:column] ||= options.delete(:column)
+    #         sort_options[:column] ||= "#{@model.send(:table_name)}.#{attribute}"
+    #         # @view.sortable_column(label, sort_options) # TODO: Rails 5 error
+    #         label
+    #       end
+    #     end
+    #
+    #   end
+    #
+    #   def to_html
+    #     @tags.join("\n").html_safe
+    #   end
+    #
+    # end
+
+    # def render_share_buttons(url, name, options = {})
+    #   options[:icon_css] ||= ''
+    #   render(partial: 'common/share_links', locals: options.merge({ url: url, name: name }))
+    # end
+  end
+end
+
+#ApplicationHelper.send :include, Symphonia::ApplicationHelperExtension

data/app/helpers/symphonia/bootstrap_modal_helper.rb

@@ -0,0 +1,59 @@
+module Symphonia
+  module BootstrapModalHelper
+
+    # Ruby shortcut for generate modals
+    #
+    # <%= render_modal title: t(:title) do %>
+    # <% render(template: 'path_to_template_or_partial', formats: [:html]) %>
+    # <% end %>
+
+    # template_or_partial example:
+
+    # <%= title(@entity, back: !request.xhr?) %>
+    #
+    # <%= symphonia_form_for(@entity, remote: request.xhr?) do |f| %>
+    #
+    #   <%= render(partial: 'form', locals: { f: f }) %>
+    #
+    #   <%= f.primary unless request.xhr? %>
+    # <% end -%>
+
+
+
+    #
+    def render_modal(options = {}, &block)
+      opts = options.slice(:id, :title, :submit, :large)
+      opts[:submit] = t(:button_submit) unless opts.has_key?(:submit)
+
+      id = options.delete(:id) || 'ad_hoc_modal'
+
+
+      script = <<SCRIPT
+        if (typeof(renderModal) == "undefined")
+          var renderModal = {}
+        if (renderModal["#{id}"])
+          renderModal["#{id}"].destroy();
+
+        renderModal["#{id}"] = new SymphoniaDialog("#{id}", #{raw opts.to_json});
+        renderModal["#{id}"].body.innerHTML = "#{j(capture(&block))}";
+        var submitButton = renderModal["#{id}"].body.querySelector("input[type=submit]")
+        if (submitButton)
+          submitButton.remove()
+SCRIPT
+      unless opts[:title]
+        script.concat <<EOF
+        var title = document.getElementById(renderModal["#{id}"].id).querySelector("#page_header");
+        if (title) {
+          title.className = 'modal-title'; title.id = null;
+          $(renderModal["#{id}"].title).replaceWith($(title));
+          renderModal["#{id}"].title = title;
+        }
+EOF
+      end
+      # script << %q{}
+      script << %Q{renderModal["#{id}"].show();} unless opts.has_key?(:render_only)
+      script.html_safe
+    end
+
+  end
+end

data/app/helpers/symphonia/form_helper.rb

@@ -0,0 +1,50 @@
+module Symphonia
+  module FormHelper
+
+    def symphonia_form_for(object, options={}, &block)
+      options.reverse_merge!(builder: Symphonia::FormBuilder)
+
+      options = process_options(options)
+
+      unless options[:remote] && options[:local].nil?
+        options[:local] = true
+      end
+      if (as = options[:as])
+        options[:scope] ||= as
+      end
+
+      with_bootstrap_form_field_error_proc do
+        form_for(object, options, &block)
+      end
+    end
+
+    # def symphonia_form_for(object, options = {}, &block)
+    #   options.reverse_merge!({ builder: Symphonia::FormBuilder })
+    #
+    #   options[:html] ||= {}
+    #   options[:html][:role] ||= 'form'
+    #
+    #   if options[:layout] == :inline
+    #     options[:html][:class] = [options[:html][:class], 'form-inline'].compact.join(' ')
+    #   end
+    #
+    #   unless options[:remote] && options[:local].nil?
+    #     options[:local] = true
+    #   end
+    #   if (as = options[:as])
+    #     options[:scope] ||= as
+    #   end
+    #
+    #   temporarily_disable_field_error_proc do
+    #     form_for(object, options, &block)
+    #   end
+    #
+    # end
+
+    def symphonia_form_tag(options = {}, &block)
+      options[:acts_like_form_tag] = true
+
+      symphonia_form_for("", options, &block)
+    end
+  end
+end