agilibox 1.0.0

data/app/helpers/agilibox/bootstrap_helper.rb

@@ -0,0 +1,6 @@
+module Agilibox::BootstrapHelper
+  def icon(id)
+    id = id.to_s.gsub("_", "-")
+    content_tag(:span, class: "icon fa fa-#{id}"){}
+  end
+end

data/app/helpers/agilibox/button_helper.rb

@@ -0,0 +1,160 @@
+module Agilibox::ButtonHelper
+  def bs_button(url, options = {})
+    action = options.delete(:action)
+    icon   = options.delete(:icon)
+    text   = options.delete(:text) || t("actions.#{action}")
+    title  = options.delete(:title) || text
+
+    text   = "#{icon icon} <span>#{text}</span>".html_safe
+
+    options = {
+      :class => "btn btn-xs link_#{action}",
+      :title => title,
+    }.deep_merge(options)
+
+    if confirm = options.delete(:confirm)
+      confirm = t("actions.confirm") if confirm == true
+
+      options.deep_merge!(
+        :data => {
+          :confirm => confirm,
+        }
+      )
+    end
+
+    link_to(text, url, options)
+  end
+
+  def print_button(options = {})
+    options = {
+      :icon    => :print,
+      :action  => :print,
+      :class   => "btn btn-xs btn-default",
+      :onclick => "print(); return false;",
+    }.merge(options)
+
+    bs_button("#", options)
+  end
+
+  def create_button(url, options = {})
+    options = {
+      :icon   => :plus,
+      :action => :create,
+      :class  =>"btn btn-xs btn-success link_create"
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def read_button(url, options = {})
+    options = {
+      :icon   => "info-circle",
+      :action => :read,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def download_button(url, options = {})
+    options = {
+      :icon     => "cloud-download",
+      :action   => :download,
+      :download => url,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def export_button(url, options = {})
+    ext = url.split(".").last
+
+    if ext.length <= 4
+      action = :"export_#{ext}"
+    else
+      action = :export
+    end
+
+    options = {
+      :icon     => "cloud-download",
+      :action   => action,
+      :download => url,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def update_button(url, options = {})
+    options = {
+      :icon   => :pencil,
+      :action => :update,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def delete_button(url, options = {})
+    options = {
+      :icon    => :trash,
+      :action  => :delete,
+      :class   => "btn btn-xs btn-danger link_delete",
+      :confirm => true,
+      :method  => :delete,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def copy_button(url, options = {})
+    options = {
+      :icon    => :copy,
+      :action  => :copy,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def complete_button(url, options = {})
+    options = {
+      :icon    => :check,
+      :action  => :complete,
+      :class   => "btn btn-xs btn-success link_complete",
+      :confirm => true,
+      :method  => :patch,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def snooze_button(url, options = {})
+    options = {
+      :icon    => :"clock-o",
+      :action  => :snooze,
+      :confirm => true,
+      :method  => :patch,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def lock_button(url, options = {})
+    options = {
+      :icon    => :lock,
+      :action  => :lock,
+      :confirm => true,
+      :method  => :patch,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+
+  def unlock_button(url, options = {})
+    options = {
+      :icon    => :unlock,
+      :action  => :unlock,
+      :confirm => true,
+      :method  => :patch,
+    }.merge(options)
+
+    bs_button(url, options)
+  end
+end

data/app/helpers/agilibox/filters_helper.rb

@@ -0,0 +1,68 @@
+module Agilibox::FiltersHelper
+  def filter_submit_button(options = {})
+    options[:class] ||= "btn btn-default submit filter-submit"
+    options[:type]  ||= "submit"
+    options[:value] ||= "submit"
+
+    text = options.delete(:text) || t("actions.filter")
+    icon = options.delete(:icon) || "filter"
+
+    content_tag(:button, options) do
+      icon(icon) + " " + text
+    end
+  end
+
+  def filter_reset_button(options = {})
+    options[:class] ||= "btn btn-default reset filter-reset"
+    options[:type]  ||= "submit"
+    options[:value] ||= "reset"
+
+    text = options.delete(:text) || t("actions.reset")
+    icon = options.delete(:icon) || "rotate-left"
+
+    content_tag(:button, options) do
+      icon(icon) + " " + text
+    end
+  end
+
+  def filter_buttons
+    filter_reset_button + filter_submit_button
+  end
+
+  def filters_form(options = {}, &block)
+    if options.key?(:buttons)
+      buttons = optins.delete(:buttons)
+    else
+      buttons = true
+    end
+
+    options = {
+      :url     => agilibox.small_data_filters_path,
+      :wrapper => :inline_form,
+    }.merge(options)
+
+    html = simple_form_for(:filters, options, &block)
+
+    if buttons
+      html = html.gsub("</form>", "#{filter_buttons}</form>").html_safe
+    end
+
+    html
+  end
+
+  def agilibox_time_periods_for_select
+    {
+      t("time_periods.all_time")    => "",
+      t("time_periods.today")       => "today",
+      t("time_periods.yesterday")   => "yesterday" ,
+      t("time_periods.this_week")   => "this_week",
+      t("time_periods.last_week")   => "last_week",
+      t("time_periods.this_month")  => "this_month",
+      t("time_periods.last_month")  => "last_month",
+      t("time_periods.this_year")   => "this_year",
+      t("time_periods.last_year")   => "last_year",
+      t("time_periods.custom_date") => "custom_date",
+    }
+  end
+
+end

data/app/helpers/agilibox/form_helper.rb

@@ -0,0 +1,49 @@
+module Agilibox::FormHelper
+  def form_buttons(opts = {})
+   back_url = opts[:back_url]
+   back_url = url_for(:back).html_safe if back_url.blank?
+   back_url = URI(back_url).path       if back_url.include?("://")
+
+    if opts[:obj].present?
+      if opts[:obj].new_record?
+        submit_action = :create
+      else
+        submit_action = :update
+      end
+    else
+      submit_action = :save
+    end
+
+    content_tag("div", class: "actions") do
+      submit = content_tag(:button, type: :submit, class: "btn btn-sm btn-success") do
+        content_tag(:span, class: "fa fa-save") {} + " " + t("actions.#{submit_action}")
+      end
+
+      cancel = content_tag("a", href: back_url, class: "btn btn-primary btn-sm") do
+        content_tag(:span, class: "fa fa-times"){} + " " + t("actions.cancel")
+      end
+
+      cancel = "" if back_url == false
+
+      submit + cancel
+    end
+  end
+
+  def horizontal_form_for(obj, opts={}, &block)
+    opts = {
+      :wrapper => "horizontal_form",
+      :html => {
+        :class => "form-horizontal"
+      }
+    }.deep_merge(opts)
+
+    simple_form_for(obj, opts, &block)
+  end
+
+  def search_form(opts = {})
+    action = opts.delete(:action) || request.fullpath
+
+    render "agilibox/search/form", action: action
+  end
+
+end

data/app/helpers/agilibox/link_helper.rb

@@ -0,0 +1,52 @@
+module Agilibox::LinkHelper
+  def link_to_object(obj, options = {})
+    return if obj.nil?
+
+    if policy(obj).read?
+      link_to(obj.to_s, engine_polymorphic_path(obj), options)
+    else
+      obj.to_s
+    end
+  end
+
+  def icon_link_to(icon, name, options = nil, html_options = nil, &block)
+    name = "#{icon(icon)} #{name}".html_safe
+    link_to(name, options, html_options, &block)
+  end
+
+  def web_link(text, opts = {})
+    return if text.to_s.blank?
+
+    href = text
+    href = "http://#{text}" unless text.include?("://")
+
+    link_to(text, href, opts)
+  end
+
+  def email_link(text, opts = {})
+    return if text.to_s.blank?
+
+    href = "mailto:#{text}"
+
+    link_to(text, href, opts)
+  end
+
+  def tel_link(text, opts = {})
+    return if text.to_s.blank?
+
+    value = text.gsub(" ", "")
+    href  = "tel:#{value}"
+
+    link_to(text, href, opts)
+  end
+
+  def twitter_link(text, opts = {})
+    return if text.to_s.blank?
+
+    href = text
+    href = "https://twitter.com/#{text}" unless text.include?("twitter.com")
+    href = "https://#{text}" unless href.include?("://")
+
+    link_to(text, href, opts)
+  end
+end

data/app/helpers/agilibox/pagination_helper.rb

@@ -0,0 +1,6 @@
+module Agilibox::PaginationHelper
+  def paginate(objects, options = {})
+    options = {theme: "twitter-bootstrap-3"}.merge(options)
+    super(objects, options).gsub(/>(\s+)</, '><').html_safe
+  end
+end

data/app/helpers/agilibox/routes_helper.rb

@@ -0,0 +1,20 @@
+module Agilibox::RoutesHelper
+  def engine_polymorphic_path(obj, opts = {})
+    engine = obj.class.parents[-2]
+
+    if engine.nil?
+      routes = main_app
+    else
+      routes = engine::Engine.routes
+    end
+
+    opts = {
+      :controller => "/#{obj.class.to_s.tableize}",
+      :action     => :show,
+      :id         => obj.to_param,
+      :only_path  => true
+    }.merge(opts)
+
+    routes.url_for(opts)
+  end
+end

data/app/helpers/agilibox/sorting_helper.rb

@@ -0,0 +1,50 @@
+module Agilibox::SortingHelper
+  def sortable_column(name, column)
+    unless column.is_a?(Symbol)
+      raise ArgumentError, "invalid column, please use symbol"
+    end
+
+    current_column, current_direction = sortable_column_order
+
+    if current_column == column
+      if current_direction == :asc
+        name           = "#{name} ↓"
+        new_sort_param = "-#{column}"
+      end
+
+      if current_direction == :desc
+        name           = "#{name} ↑"
+        new_sort_param = column
+      end
+
+      klass = "sort #{current_direction}"
+    else
+      new_sort_param = column
+      klass          = "sort"
+    end
+
+    url_params = params.to_h.symbolize_keys.merge(sort: new_sort_param)
+
+    link_to(name, url_params, class: klass)
+  end
+
+  def sortable_column_order(sort_param = params[:sort])
+    sort_param = sort_param.to_s
+
+    if sort_param.present?
+      if sort_param.start_with?("-")
+        column     = sort_param[1..-1].to_sym
+        direction  = :desc
+      else
+        column     = sort_param.to_sym
+        direction  = :asc
+      end
+    end
+
+    if block_given?
+      yield(column, direction)
+    else
+      [column, direction]
+    end
+  end
+end

data/app/helpers/agilibox/text_helper.rb

@@ -0,0 +1,122 @@
+module Agilibox::TextHelper
+  include ::ActionView::Helpers::NumberHelper
+  include ::ActionView::Helpers::SanitizeHelper
+  include ::ActionView::Helpers::TextHelper
+
+  def euros(n)
+    currency(n, "€")
+  end
+
+  def currency(n, u)
+    return if n.nil?
+
+    I18n.t("number.currency.format.format")
+      .gsub("%n", number(n))
+      .gsub("%u", u)
+      .gsub(" ", "\u00A0")
+  end
+
+  def percentage(n)
+    return if n.nil?
+
+    (number(n) + " %").gsub(" ", "\u00A0")
+  end
+
+  def number(n)
+    return if n.nil?
+
+    opts = {}
+
+    if n.class.to_s.match(/Float|Decimal/i)
+      opts[:precision] = 2
+    else
+      opts[:precision] = 0
+    end
+
+    opts[:delimiter] = I18n.t("number.format.delimiter")
+    opts[:separator] = I18n.t("number.format.separator")
+
+    number_with_precision(n, opts).gsub(" ", "\u00A0")
+  end
+
+  def date(d)
+    return if d.nil?
+    I18n.l(d)
+  end
+
+  def hours(n)
+    return if n.nil?
+
+    number = number_with_precision(n, precision: 2)
+    text   = I18n.t("datetime.prompts.hour").downcase
+    text   = text.pluralize if n > 1
+    "#{number} #{text}"
+  end
+
+  def text2html(str)
+    return if str.to_s.blank?
+
+    str = str.gsub("\r", "").strip
+    strip_tags(str).gsub("\n", "<br />").html_safe
+  end
+
+  def lf2br(str)
+    return if str.to_s.blank?
+
+    str.gsub("\r", "").gsub("\n", "<br />").html_safe
+  end
+
+  def info(object, attribute, value_or_options = nil, options = {})
+    if value_or_options.nil?
+      value = object.public_send(attribute)
+    elsif value_or_options.is_a?(Hash)
+      value = object.public_send(attribute)
+      options = value_or_options
+    else
+      value = value_or_options
+    end
+
+    if value.blank?
+      value = options[:default]
+      return if value == :hide
+    end
+
+    label       = options[:label]     || object.t(attribute)
+    tag         = options[:tag]       || :div
+    separator   = options[:separator] || " : "
+    helper      = options[:helper]
+    i18n_key    = "#{object.class.to_s.tableize.singularize}/#{attribute}"
+    nested      = I18n.t("activerecord.attributes.#{i18n_key}").is_a?(Hash)
+    klass       = object.is_a?(Module) ? object : object.class
+    object_type = klass.to_s.split("::").last.underscore
+
+    value = t("yes")                          if value === true
+    value = t("no")                           if value === false
+    value = object.t("#{attribute}.#{value}") if nested
+    value = send(helper, value)               if helper
+    value = number(value)                     if value.is_a?(Numeric)
+    value = l(value)                          if value.is_a?(Time)
+    value = l(value)                          if value.is_a?(Date)
+    value = value.to_s
+
+    html_label     = content_tag(:strong, class: "info-label") { label }
+    span_css_class = "info-value #{object_type}-#{attribute}"
+    html_value     = content_tag(:span, class: span_css_class) { value }
+    separator_html = content_tag(:span, class: "info-separator") { separator }
+
+    content_tag(tag, class: "info") do
+      [html_label, separator_html, html_value].join.html_safe
+    end
+  end # def info
+
+  def tags(object)
+    return "" if object.tag_list.empty?
+
+    object.tag_list.map { |tag|
+      content_tag(:span, class: "tag label label-primary"){
+        "#{icon :tag} #{tag}".html_safe
+      }
+    }.join(" ").html_safe
+  end
+
+end

data/app/libs/agilibox/sortable_uuid_generator.rb

@@ -0,0 +1,11 @@
+# Microtime based uuids to be sortable
+class Agilibox::SortableUUIDGenerator
+  REGEX_WITH_DASHES    = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/
+  REGEX_WITHOUT_DASHES = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/
+
+  def self.generate
+    prefix = Time.zone.now.strftime("%s%9N").to_i.to_s(16)
+    suffix = SecureRandom.hex(8)
+    (prefix + suffix).gsub(REGEX_WITHOUT_DASHES, '\1-\2-\3-\4-\5')
+  end
+end

data/app/models/concerns/agilibox/active_record_uuid_concern.rb

@@ -0,0 +1,15 @@
+module Agilibox::ActiveRecordUUIDConcern
+  extend ActiveSupport::Concern
+
+  private
+
+  def assign_default_uuid
+    if id.nil? && self.class.columns_hash["id"].type == :uuid
+      self.id = ::Agilibox::SortableUUIDGenerator.generate
+    end
+  end
+
+  included do
+    before_save :assign_default_uuid
+  end
+end

data/app/models/concerns/agilibox/default_values_concern.rb

@@ -0,0 +1,13 @@
+module Agilibox::DefaultValuesConcern
+  extend ActiveSupport::Concern
+
+  def assign_default_values; end
+
+  def assign_default(attribute, value)
+    self.send("#{attribute}=", value) if self.send(attribute).nil?
+  end
+
+  included do
+    after_initialize :assign_default_values
+  end
+end

data/app/models/concerns/agilibox/model_i18n.rb

@@ -0,0 +1,25 @@
+module Agilibox::ModelI18n
+  extend ActiveSupport::Concern
+
+  def t(*args)
+    self.class.t(*args)
+  end
+
+  def ts
+    self.class.ts
+  end
+
+  class_methods do
+    def t(*args)
+      if args.any?
+        human_attribute_name(*args)
+      else
+        model_name.human
+      end
+    end
+
+    def ts
+      model_name.human(count: 2)
+    end
+  end # class_methods
+end # Agilibox::ModelI18n

data/app/models/concerns/agilibox/model_to_s.rb

@@ -0,0 +1,9 @@
+module Agilibox::ModelToS
+  def to_s
+    %w(name title label).map do |m|
+      return send(m) if respond_to?(m)
+    end
+
+    super
+  end
+end

data/app/models/concerns/agilibox/polymorphic_id.rb

@@ -0,0 +1,34 @@
+module Agilibox::PolymorphicId
+  extend ActiveSupport::Concern
+
+  included do
+    def self.polymorphic_id_for(relation_name)
+      module_src = File.read(__FILE__).split("__END__").last
+      module_src = module_src.gsub("relation", relation_name.to_s)
+      send :include, eval(module_src)
+    end
+
+    def guid
+      return nil if new_record?
+
+      "#{self.class.base_class}-#{self.id}"
+    end
+  end # included
+end # module
+
+# __END__
+
+Module.new do
+  def relation_guid
+    return nil if relation_type.blank? || relation_id.blank?
+
+    "#{relation_type}-#{relation_id}"
+  end
+
+  def relation_guid=(guid)
+    return self.relation = nil if guid.blank?
+
+    type, id      = guid.split("-", 2)
+    self.relation = type.constantize.find(id)
+  end
+end

data/app/models/concerns/agilibox/search.rb

@@ -0,0 +1,30 @@
+module Agilibox::Search
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def default_search_fields
+      fields = columns.map do |column|
+        "#{table_name}.#{column.name}"
+      end
+    end # def default_search_fields
+
+    def search(q, *fields)
+      words  = q.to_s.parameterize.split("-")
+      fields = default_search_fields if fields.empty?
+
+      sql_query = words.map.with_index do |word, index|
+        fields.map do |field|
+          "(LOWER(CAST(#{field} AS TEXT)) LIKE :w#{index})"
+        end.join(" OR ")
+      end.map{ |e| "(#{e})" }.join(" AND ")
+
+      sql_params_a = words.map.with_index do |word, index|
+        ["w#{index}".to_sym, "%#{word}%"]
+      end
+
+      sql_params_h = Hash[sql_params_a]
+
+      self.where(sql_query, sql_params_h)
+    end # def search
+  end # class_methods
+end # class Agilibox::Search