maily_herald-webui 0.8.0

data/config/routes.rb

@@ -0,0 +1,103 @@
+MailyHerald::Webui::Engine.routes.draw do
+	root to: 'dashboard#index'
+  resources "logs" do
+    member do
+      get "preview"
+    end
+  end
+  resources "lists" do
+    member do
+      post "subscribe/:entity_id", action: :subscribe, as: :subscribe_to
+      post "unsubscribe/:entity_id", action: :unsubscribe, as: :unsubscribe_from
+      get "context_variables(/:context)", action: :context_variables, as: :context_variables
+    end
+  end
+  resources "subscriptions" do
+    member do
+      post "toggle"
+    end
+  end
+  resources "one_time_mailings" do
+    collection do 
+      get "archived"
+      post "update_form"
+    end
+    member do
+      post "toggle"
+      post "deliver/(:entity_id)", action: :deliver, as: :deliver
+      get "preview/:entity_id", action: :preview, as: :preview
+    end
+  end
+  resources "periodical_mailings" do
+    collection do 
+      get "archived"
+      post "update_form"
+    end
+    member do
+      post "toggle"
+      get "preview/:entity_id", action: :preview, as: :preview
+    end
+  end
+  resources "sequences" do
+    resources "sequence_mailings", as: "mailings", path: "mailings", except: [:index] do
+      collection do 
+        get "archived"
+        post "update_form"
+      end
+      member do
+        post "toggle"
+        get "preview/:entity_id", action: :preview, as: :preview
+      end
+    end
+    collection do 
+      get "archived"
+      post "update_form"
+    end
+    member do
+      post "toggle"
+    end
+  end
+
+  post "switch_mode/:mode", to: "sessions#switch_mode", as: "switch_mode"
+
+
+
+
+
+
+  #resources "sequences" do
+    #resources "mailings", :only => [:new, :create], :controller => "mailings", :mailing_type => :sequence
+    #member do
+      #get "subscription/:entity_id", :to => :subscription, :as => :subscription
+      #get "subscription/:entity_id/toggle", :to => :toggle_subscription, :as => :toggle_subscription
+      #get "toggle", :to => :toggle, :as => :toggle
+    #end
+  #end
+  #resources "mailings", :except => [:new, :create] do
+    #member do
+      #get "subscription/:entity_id", :to => :subscription, :as => :subscription
+      #get "subscription/:entity_id/toggle", :to => :toggle_subscription, :as => :toggle_subscription
+      #get "dashboard/:entity_id", :to => :dashboard, :as => :dashboard
+      #get "deliver/(:entity_id)", :to => :deliver, :as => :deliver
+      #get "toggle", :to => :toggle, :as => :toggle
+      #get "preview/:subscription_id", :to => :preview, :as => :preview
+    #end
+    #collection do
+      #get "context_attributes/(:context_name)", :to => :context_attributes, :as => :context_attributes
+    #end
+  #end
+  #resources "sequences_mailings", :only => [:index, :new], :controller => "mailings", :mailing_type => :sequence
+  #resources "one_time_mailings", :only => [:index, :new, :create], :controller => "mailings", :mailing_type => :one_time
+  #resources "periodical_mailings", :only => [:index, :new, :create], :controller => "mailings", :mailing_type => :periodical
+  #resources "subscription_groups" do
+    #member do
+      #get "subscription/:subscription_id/toggle", :to => :toggle_subscription, :as => :toggle_subscription
+    #end
+  #end
+  #resources "dashboard", :only => [:index, :show] do
+    #collection do 
+      #get "time_travel"
+      #get "forget"
+    #end
+  #end
+end

data/config/spring.rb

@@ -0,0 +1 @@
+Spring.application_root = "./spec/dummy"

data/lib/maily_herald/webui.rb

@@ -0,0 +1,15 @@
+require 'maily_herald/webui/version'
+
+require 'smart_listing'
+require 'haml'
+
+if defined?(::Rails::Engine)
+  require "maily_herald/webui/engine"
+end
+
+module MailyHerald
+  module Webui
+    autoload :Breadcrumbs,					'maily_herald/webui/breadcrumbs'
+    autoload :MenuManager,					'maily_herald/webui/menu_manager'
+  end
+end

data/lib/maily_herald/webui/breadcrumbs.rb

@@ -0,0 +1,50 @@
+module MailyHerald
+  module Webui
+    module Breadcrumbs
+      module ControllerExtensions
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, MailyHerald::Webui::Breadcrumbs::ControllerExtensions::InstanceMethods
+        end
+
+        module ClassMethods
+          protected
+
+          def add_breadcrumb name, url = nil, options = {}
+            before_filter options do |controller|
+              controller.send(:add_breadcrumb, name, url, options)
+            end
+          end
+        end
+
+        module InstanceMethods
+          protected
+
+          def self.included(base)
+            base.extend ClassMethods
+          end
+
+          def add_breadcrumb name, url = nil, options = {}
+            return unless name
+
+            @breadcrumbs ||= []
+            url = self.instance_eval(&url) if url.is_a?(Proc)
+            url = eval(url.to_s) if url.to_s =~ /_path|_url|@/
+            url = url.merge(:d => current_domain.id.to_s, :host => current_domain.hostname) if url && options[:localized]
+            @breadcrumbs << {:name => name, :url => url, :intitle => options[:intitle], :intitle_only => options[:intitle_only]}
+          end
+
+          def disable_breadcrumbs 
+            @breadcrumbs_disabled = true
+          end
+        end
+      end
+
+      module HelperExtensions
+        def has_breadcrumbs?
+          !@breadcrumbs_disabled && @breadcrumbs && !@breadcrumbs.empty?
+        end
+      end
+    end
+  end
+end

data/lib/maily_herald/webui/engine.rb

@@ -0,0 +1,18 @@
+module MailyHerald
+  module Webui
+    class Engine < ::Rails::Engine
+      isolate_namespace MailyHerald::Webui
+
+      config.generators do |g|
+        g.test_framework      :rspec,         :fixture => false
+        g.fixture_replacement :factory_girl,  :dir => 'spec/factories'
+      end
+      config.autoload_paths += Dir["#{config.root}/lib/**/"]
+
+      initializer :assets do |config|
+        Rails.application.config.assets.paths << root.join("vendor", "assets", "fonts")
+        Rails.application.config.assets.precompile << /\.(?:svg|eot|woff|ttf)\z/
+      end
+    end
+  end
+end

data/lib/maily_herald/webui/form_builder.rb

@@ -0,0 +1,285 @@
+module MailyHerald
+  module Webui
+    class FormBuilder < ActionView::Helpers::FormBuilder
+      FIELD_HELPERS = %w{text_field text_area}
+
+      attr_reader :layout, :label_col, :control_col, :has_error, :inline_errors, :acts_like_form_tag
+
+      delegate :content_tag, :capture, :concat, :t, :tw, to: :@template
+
+      def initialize(object_name, object, template, options, proc = nil)
+        @layout = options[:layout]
+        @label_col = options[:label_col] || default_label_col
+        @control_col = options[:control_col] || default_control_col
+        @inline_errors = options[:inline_errors] != false
+        @help_scope = options[:help_scope]
+        super
+      end
+
+      def prepend_and_append_input(options, &block)
+        options = options.extract!(:prepend, :append)
+        input = capture(&block)
+        input = content_tag(:span, options[:prepend], class: options[:prepend].include?("button") ? "input-group-btn" : "input-group-addon") + input if options[:prepend]
+        input << content_tag(:span, options[:append], class: options[:append].include?("button") ? "input-group-btn" : "input-group-addon") if options[:append]
+        input = content_tag(:div, input, class: "input-group") unless options.empty?
+        input
+      end
+
+      FIELD_HELPERS.each do |method_name|
+        with_method_name = "#{method_name}_with_maily"
+        without_method_name = "#{method_name}_without_maily"
+        define_method(with_method_name) do |name, options = {}|
+          form_group_builder(name, options) do
+            prepend_and_append_input(options) do
+              send(without_method_name, name, options)
+            end
+          end
+        end
+        alias_method_chain method_name, :maily
+      end
+
+
+      def select_with_maily(method, choices, options = {}, html_options = {})
+        form_group_builder(method, options, html_options) do
+          content_tag(:span, class: ["select-wrap", ("has-error" if has_error?(method))]) do
+            select_without_maily(method, choices, options, html_options)
+          end
+        end
+      end
+      alias_method_chain :select, :maily
+
+      def check_box_with_maily(method, options = {}, checked_value = "1", unchecked_value = "0")
+        form_group_builder(method, options.merge(hide_label: true)) do
+          content_tag(:div, class: "checkbox") do
+            label method do
+              concat(content_tag(:span, check_box_without_maily(method, options, checked_value, unchecked_value), class: "checkbox-wrap"))
+              concat(object.class.human_attribute_name(method))
+            end
+          end
+        end
+      end
+      alias_method_chain :check_box, :maily
+
+      def radio_button_with_maily(method, options = {}, checked_value = "1", unchecked_value = "0")
+        form_group_builder(method, options.merge(hide_label: true)) do
+          content_tag(:div, class: "radio-wrap") do
+            label method do
+              concat(content_tag(:span, check_box_without_maily(method, options, checked_value, unchecked_value), class: "radio-btn"))
+              concat(object.class.human_attribute_name(method))
+            end
+          end
+        end
+      end
+      alias_method_chain :radio_button, :maily
+
+      def maily_context_select(options = {}, html_options = {})
+        choices = MailyHerald.contexts.values.collect do |context|
+          [@template.friendly_name(context), context.name]
+        end
+        select_with_maily :context_name, choices, options, html_options
+      end
+
+      def maily_mailer_select(options = {}, html_options = {})
+        choices = ObjectSpace.each_object(Class).select { |klass| klass < ActionMailer::Base }.collect do |mailer|
+          if mailer.name == "MailyHerald::Mailer"
+            ["Generic Mailer", "generic"]
+          else
+            [mailer.name, mailer.name]
+          end
+        end
+        select_with_maily :mailer_name, choices, options, html_options
+      end
+
+      def maily_list_select(options = {}, html_options = {})
+        choices = MailyHerald::List.all.collect do |list|
+          [@template.friendly_name(list), list.name]
+        end
+        select_with_maily :list, choices, options.merge(prompt: tw("commons.please_select")), {autocomplete: "off"}.merge(html_options)
+      end
+
+      def maily_from_field options = {}, html_options = {}
+        form_group_builder(:from, options.merge(wrapper_class: "mailing-from")) do
+          radio1 = content_tag(:label, content_tag(:span, @template.radio_button_tag(:mailing_from, "default", !object.from.present?), class: "radio-btn") + @template.display_mailing_from(object), class: "radio")
+          radio2 = content_tag(:label, content_tag(:span, @template.radio_button_tag(:mailing_from, "specify", object.from.present?), class: "radio-btn") + tw("mailings.from.specify"), class: "radio")
+
+          field = prepend_and_append_input(options) do
+            text_field_without_maily(:from, {class: "form-control", placeholder: tw("mailings.placeholders.from")})
+          end
+
+          concat(content_tag(:p, radio1 + radio2)).concat(field)
+        end
+      end
+
+      def maily_start_at_field options = {}, html_options = {}
+        form_group_builder(:start_at, options.merge(wrapper_class: "dispatch-start-at")) do
+          radio1 = content_tag(:label, content_tag(:span, @template.radio_button_tag(:mailing_from, "absolute", !object.from.present?), class: "radio-btn") + tw("mailings.start_at.absolute"), class: "radio")
+          radio2 = content_tag(:label, content_tag(:span, @template.radio_button_tag(:mailing_from, "relative", object.from.present?), class: "radio-btn") + tw("mailings.start_at.relative"), class: "radio")
+          calendar_btn = content_tag(:button, @template.icon(:calendar), class: "btn btn-default", type: "button")
+          list_btn = @template.link_to_context_attributes_overview(object.list, class: "btn btn-default")
+
+          field = prepend_and_append_input({append: calendar_btn + list_btn}) do
+            text_field_without_maily(:start_at, {class: "form-control", placeholder: tw("mailings.placeholders.start_at")})
+          end
+
+          #concat(content_tag(:p, radio1 + radio2)).concat(field)
+          field
+        end
+      end
+
+      def maily_period_field options = {}, html_options = {}
+        text_field :period_in_days, help: true, append: tw("mailings.help.period_unit"), placeholder: tw("mailings.placeholders.period")
+      end
+
+      def maily_absolute_delay_field options = {}, html_options = {}
+        text_field :absolute_delay_in_days, help: true, append: tw("mailings.help.absolute_delay_unit"), placeholder: tw("mailings.placeholders.absolute_delay")
+      end
+
+      def form_group(*args, &block)
+        options = args.extract_options!
+        name = args.first
+
+        options[:class] = ["form-group", options[:class]].compact.join(' ')
+        options[:class] << " #{error_class}" if has_error?(name)
+        options[:class] << " #{feedback_class}" if options[:icon]
+
+        content_tag(:div, options.except(:id, :label, :help, :icon, :label_col, :control_col, :layout)) do
+          label   = generate_label(options[:id], name, options[:label], options[:label_col], options[:layout], options[:help]) if options[:label]
+          control = capture(&block).to_s
+          control.concat(generate_help(name, options[:help]).to_s)
+          #control.concat(generate_help(options[:help].is_a?(TrueClass) ? name : options[:help])) if options[:help]
+          control.concat(generate_icon(options[:icon])) if options[:icon]
+
+          if get_group_layout(options[:layout]) == :horizontal
+            control_class = (options[:control_col] || control_col)
+
+            unless options[:label]
+              control_offset = offset_col(/([0-9]+)$/.match(options[:label_col] || default_label_col))
+              control_class.concat(" #{control_offset}")
+            end
+            control = content_tag(:div, control, class: control_class)
+          end
+
+          concat(label).concat(control)
+        end
+      end
+
+      def buttons *bs
+        form_group do
+          bs.each do |button|
+            if button.is_a?(Array)
+              label = button.last
+              button = button.first
+            end
+            if button.is_a?(Symbol)
+              case button
+              when :submit
+                concat(content_tag(:button, label || tw("commons.submit"), :class => "btn btn-webui", :type => "submit"))
+              when :create
+                concat(content_tag(:button, label || tw("commons.create"), :class => "btn btn-webui", :type => "submit", :name => "submit"))
+              when :save
+                concat(content_tag(:button, label || tw("commons.save"), :class => "btn btn-webui", :type => "submit", :name => "submit"))
+              when :save_continue
+                concat(content_tag(:button, label || tw("commons.save_continue"), :class => "btn btn-webui", :type => "submit", :name => "submit_continue"))
+              when :cancel
+                concat(content_tag(:button, label || tw("commons.cancel"), :class => "btn btn-webui-alternative cancel"))
+              end
+            else
+              concat(content_tag(:button, button[:text], :class => button[:class], :type => button[:type]))
+            end
+            concat(" ")
+          end
+        end
+      end
+
+      private
+
+      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(" ")
+
+        label = options.delete(:label)
+        label_class = hide_class if options.delete(:hide_label)
+        wrapper_class = options.delete(:wrapper_class)
+        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(method, id: options[:id], label: { text: label, class: label_class }, help: help, icon: icon, label_col: label_col, control_col: control_col, layout: layout, class: wrapper_class) do
+          yield
+        end
+      end
+
+      def horizontal?
+        layout == :horizontal
+      end
+
+      def get_group_layout(group_layout)
+        group_layout || layout
+      end
+
+      def default_label_col
+        "col-sm-2"
+      end
+      def offset_col(offset)
+        "col-sm-offset-#{offset}"
+      end
+      def default_control_col
+        "col-sm-10"
+      end
+      def hide_class
+        "sr-only" # still accessible for screen readers
+      end
+      def control_class
+        "form-control"
+      end
+      def label_class
+        "control-label"
+      end
+      def error_class
+        "has-error"
+      end
+      def feedback_class
+        "has-feedback"
+      end
+
+      def has_error?(name)
+        object.respond_to?(:errors) && !(name.nil? || object.errors[name].empty? || object.errors[name.to_s.chomp("_id").to_sym].empty?)
+      end
+
+      def generate_label(id, name, options, custom_label_col, group_layout, help)
+        options[:for] = id if acts_like_form_tag
+        classes = [options[:class], label_class]
+        classes << (custom_label_col || label_col) if get_group_layout(group_layout) == :horizontal
+        options[:class] = classes.compact.join(" ")
+
+        text = options[:text] || object.class.human_attribute_name(name)
+        text += " " + generate_help_icon(help.is_a?(TrueClass) ? name : help) if help
+
+        label(name, text.html_safe, options.except(:text))
+      end
+
+      def generate_help_icon(help)
+        @template.display_help_icon help, scope: @help_scope, placement: "top"
+      end
+
+      def generate_help(name, help_text)
+        help_text = object.errors[name].join(", ") if has_error?(name) && inline_errors
+        return if help_text === false
+
+        help_text ||= I18n.t(name, scope: "activerecord.help.#{object.class.to_s.downcase}", default: '')
+        content_tag(:span, help_text, class: 'help-block') if help_text.present? && help_text.is_a?(String)
+      end
+
+      def generate_icon(icon)
+        content_tag(:span, "", class: "glyphicon glyphicon-#{icon} form-control-feedback")
+      end
+    end
+  end
+end