bmc 1.0.0

data/app/libs/bmc/mini_model_serializer/serialize.rb

@@ -0,0 +1,30 @@
+class BMC::MiniModelSerializer::Serialize
+  attr_reader :object, :options
+
+  def initialize(object, options = {})
+    @object  = object
+    @options = options
+  end
+
+  def call
+    if object.is_a?(Hash)
+      object.map { |k, v| [k.to_s, serialize(v)] }.to_h
+    elsif object.is_a?(Enumerable)
+      object.map { |e| serialize(e) }
+    elsif (serializer = "#{object.class}Serializer".safe_constantize)
+      serializer.call(object, options)
+    else
+      object.as_json
+    end
+  end
+
+  def self.call(...)
+    new(...).call
+  end
+
+  private
+
+  def serialize(object)
+    BMC::MiniModelSerializer::Serialize.call(object, options)
+  end
+end

data/app/libs/bmc/mini_model_serializer/serializer.rb

@@ -0,0 +1,23 @@
+class BMC::MiniModelSerializer::Serializer < BMC::MiniModelSerializer::Serialize
+  def attributes
+    raise NotImplementedError
+  end
+
+  def call
+    serialize attributes.map { |k| [k, send(k)] }.to_h
+  end
+
+  private
+
+  def method_missing(m, *args)
+    if respond_to_missing?(m)
+      object.send(m, *args)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(m, *)
+    super || object.respond_to?(m, true)
+  end
+end

data/app/libs/bmc/monkey.rb

@@ -0,0 +1,39 @@
+module BMC::Monkey
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def prepend_instances(&block)
+      m = Module.new(&block)
+      send(:prepend, m)
+    end
+
+    def prepend_class(&block)
+      m = Module.new(&block)
+      singleton_class.send(:prepend, m)
+    end
+
+    def prepend_instance_method(name, &block)
+      check_instance_method_exist!(name)
+
+      m = Module.new
+      m.send(:define_method, name, &block)
+      send(:prepend, m)
+    end
+
+    def prepend_class_method(name, &block)
+      check_class_method_exist!(name)
+
+      m = Module.new
+      m.send(:define_method, name, &block)
+      singleton_class.send(:prepend, m)
+    end
+
+    def check_instance_method_exist!(name)
+      raise "instance method `#{name}` does not exist" unless instance_methods.include?(name)
+    end
+
+    def check_class_method_exist!(name)
+      raise "class method `#{name}` does not exist" unless methods.include?(name)
+    end
+  end
+end

data/app/libs/bmc/sortable_uuid_generator.rb

@@ -0,0 +1,11 @@
+# Microtime based uuids to be sortable
+class BMC::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.call
+    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/libs/bmc/token_generator.rb

@@ -0,0 +1,37 @@
+class BMC::TokenGenerator
+  attr_reader :options
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def size
+    options[:size] || self.class.default_size
+  end
+
+  def alphabet
+    options[:alphabet] || self.class.default_alphabet
+  end
+
+  def call
+    (alphabet * size).sample(size).join
+  end
+
+  class << self
+    def call(*args)
+      new(*args).call
+    end
+
+    attr_writer :default_size
+
+    def default_size
+      @default_size ||= 64
+    end
+
+    attr_writer :default_alphabet
+
+    def default_alphabet
+      @default_alphabet ||= (0..9).to_a + ("a".."z").to_a + ("A".."Z").to_a
+    end
+  end # class << self
+end

data/app/mailers/bmc/application_mailer.rb

@@ -0,0 +1,2 @@
+class BMC::ApplicationMailer < BMC.parent_mailer
+end

data/app/mailers/bmc/generic_mailer.rb

@@ -0,0 +1,9 @@
+class BMC::GenericMailer < BMC::ApplicationMailer
+  def generic_email(data)
+    data.delete(:attachments).to_h.each do |filename, content|
+      attachments[filename] = content
+    end
+
+    mail(data)
+  end
+end

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

@@ -0,0 +1,17 @@
+module BMC::ActiveRecordUUIDConcern
+  extend ActiveSupport::Concern
+
+  private
+
+  def assign_default_uuid
+    unless self.class.columns_hash["id"].type == :uuid
+      raise "invalid id type, please change to uuid"
+    end
+
+    self.id ||= BMC::SortableUUIDGenerator.call
+  end
+
+  included do
+    before_save :assign_default_uuid
+  end
+end

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

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

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

@@ -0,0 +1,56 @@
+module BMC::ModelI18n
+  extend ActiveSupport::Concern
+
+  MissingTranslationError = Class.new(StandardError)
+  class << self
+    attr_accessor :raise_on_missing_translations
+  end
+  self.raise_on_missing_translations = false
+
+  def t(*args)
+    self.class.t(*args)
+  end
+
+  def ts
+    self.class.ts
+  end
+
+  def tv(attribute)
+    value = public_send(attribute)
+    t("#{attribute}.#{value}") if value.present?
+  end
+
+  class_methods do
+    def t(attribute = nil, options = {})
+      should_raise = BMC::ModelI18n.raise_on_missing_translations
+      exception_class = BMC::ModelI18n::MissingTranslationError
+
+      if should_raise
+        options = options.merge(default: "")
+      end
+
+      if should_raise && attribute.nil?
+        human = model_name.human(options)
+        type = options[:count].to_i > 1 ? "plural" : "singular"
+        raise exception_class, "translation missing: #{self} #{type} model name" if human.blank?
+        return human
+      end
+
+      if should_raise && attribute
+        human = human_attribute_name(attribute, options)
+        raise exception_class, "translation missing: #{self}##{attribute}" if human.blank?
+        return human
+      end
+
+      if attribute.nil?
+        return model_name.human(options)
+      end
+
+      human_attribute_name(attribute, options) if attribute
+    end
+
+    def ts
+      t(nil, count: 2)
+    end
+  end # class_methods
+end # BMC::ModelI18n

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

@@ -0,0 +1,9 @@
+module BMC::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/bmc/pluck_distinct.rb

@@ -0,0 +1,13 @@
+module BMC::PluckDistinct
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def pluck_distinct(column)
+      all
+        .reorder(column)
+        .select(column)
+        .distinct
+        .pluck(column)
+    end
+  end # class_methods
+end

data/app/models/concerns/bmc/pluck_to_hash.rb

@@ -0,0 +1,9 @@
+module BMC::PluckToHash
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def pluck_to_hash(*attributes)
+      pluck(*attributes).map { |values| attributes.zip(values).to_h }
+    end
+  end # class_methods
+end

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

@@ -0,0 +1,37 @@
+module BMC::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}-#{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)
+    if guid.blank?
+      self.relation = nil
+      return
+    end
+
+    type, id      = guid.split("-", 2)
+    self.relation = type.constantize.find(id)
+  end
+end

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

@@ -0,0 +1,28 @@
+module BMC::Search
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def default_search_fields
+      columns
+        .select { |column| column.type.in?([:string, :text]) }
+        .map    { |column| "#{table_name}.#{column.name}" }
+    end # def default_search_fields
+
+    def search(q, *fields)
+      words  = q.to_s.parameterize.split("-")
+      fields = default_search_fields if fields.empty?
+
+      return all if words.empty?
+
+      sql_query = words.map.with_index { |_word, index|
+        fields.map { |field|
+          "(UNACCENT(CAST(#{field} AS TEXT)) ILIKE :w#{index})"
+        }.join(" OR ")
+      }.map { |e| "(#{e})" }.join(" AND ")
+
+      sql_params = words.map.with_index { |word, index| ["w#{index}".to_sym, "%#{word}%"] }.to_h
+
+      where(sql_query, sql_params)
+    end # def search
+  end # class_methods
+end # class BMC::Search

data/app/models/concerns/bmc/timestamp_helpers.rb

@@ -0,0 +1,17 @@
+module BMC::TimestampHelpers
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def first_created
+      reorder(:created_at, :id).first
+    end
+
+    def last_created
+      reorder(:created_at, :id).last
+    end
+
+    def last_updated
+      reorder(:updated_at, :id).last
+    end
+  end
+end

data/app/serializers/bmc/serializers/base.rb

@@ -0,0 +1,63 @@
+class BMC::Serializers::Base
+  attr_reader :data, :options
+
+  def initialize(data, options = {})
+    @data    = data
+    @options = options
+  end
+
+  def formatted_data
+    data.map do |line|
+      line.map { |value| self.class.format(value) }
+    end
+  end
+
+  def render_inline
+    raise NotImplementedError
+  end
+
+  def render_file(_file_path)
+    raise NotImplementedError
+  end
+
+  class << self
+    def decimals_precision
+      @decimals_precision ||= 2
+    end
+
+    attr_writer :decimals_precision
+
+    def format_integer(value)
+      value
+    end
+
+    def format_decimal(value)
+      value.to_f.round(decimals_precision) # Fix BigDecimal and 0.1 + 0.2
+    end
+
+    def format_boolean(value)
+      I18n.t(value.to_s)
+    end
+
+    def format_date_or_time(value)
+      value
+    end
+
+    def format_default(value)
+      value.to_s
+    end
+
+    def formatter_for(value)
+      return :integer if value.is_a?(Integer)
+      return :decimal if value.is_a?(Numeric)
+      return :boolean if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      return :date_or_time if value.is_a?(Date) || value.is_a?(Time)
+      return :default
+    end
+
+    def format(value)
+      formatter = "format_" + formatter_for(value).to_s
+      public_send(formatter, value)
+    end
+  end # class << self
+end

data/app/serializers/bmc/serializers/xlsx.rb

@@ -0,0 +1,38 @@
+class BMC::Serializers::XLSX < BMC::Serializers::Base
+  def render_inline
+    headers, *data = formatted_data
+
+    SpreadsheetArchitect.to_xlsx(
+      headers: headers,
+      data: data,
+      freeze_headers: true,
+      range_styles: range_styles(data[0]),
+    )
+  end
+
+  def render_file(file_path)
+    File.open(file_path, "w+b") do |f|
+      f.write(render_inline)
+    end
+  end
+
+  private
+
+  def range_styles(row)
+    return [] if row.nil?
+
+    date_range_styles(row) + time_range_styles(row)
+  end
+
+  def date_range_styles(row)
+    row.each_index.select { row[_1].is_a?(Date) }.map do
+      {range: {rows: :all, columns: _1}, styles: {format_code: "dd/mm/yyyy"}}
+    end
+  end
+
+  def time_range_styles(row)
+    row.each_index.select { row[_1].is_a?(Time) }.map do
+      {range: {rows: :all, columns: _1}, styles: {format_code: "dd/mm/yyyy hh:mm:ss"}}
+    end
+  end
+end

data/app/serializers/bmc/serializers.rb

@@ -0,0 +1,2 @@
+module BMC::Serializers
+end

data/app/sms/bmc/sms/application_sms.rb

@@ -0,0 +1,42 @@
+class BMC::SMS::ApplicationSMS
+  attr_reader :options
+
+  def initialize(options)
+    @options = options
+  end
+
+  private
+
+  def action_name
+    options[:action_name]
+  end
+
+  def t(key, **args)
+    if key.start_with?(".")
+      path = self.class.to_s.underscore.tr("/", ".")
+      key  = "#{path}.#{action_name}#{key}"
+    end
+
+    I18n.t(key, **args)
+  end
+
+  def sms(data)
+    BMC::SMS::Message.new(data)
+  end
+
+  class << self
+    private :new
+
+    def method_missing(m, *args)
+      if respond_to_missing?(m)
+        new(action_name: m).public_send(m, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(m, *)
+      super || public_instance_methods.include?(m)
+    end
+  end # class << self
+end

data/app/sms/bmc/sms/message.rb

@@ -0,0 +1,25 @@
+class BMC::SMS::Message
+  attr_reader :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def strategy=(value)
+    @strategy = BMC::SMS.parse_strategy(value)
+  end
+
+  def strategy(value = :no_argument)
+    self.strategy = value unless value == :no_argument
+    @strategy || BMC::SMS.strategy
+  end
+
+  def deliver_now
+    strategy.call(data)
+  end
+
+  # TODO : Delay
+  def deliver_later
+    deliver_now
+  end
+end

data/app/sms/bmc/sms/strategies/amazon_sns.rb

@@ -0,0 +1,48 @@
+class BMC::SMS::Strategies::AmazonSNS < BMC::SMS::Strategies::Base
+  class << self
+    attr_writer :sns_region
+
+    def sns_region
+      @sns_region ||= (ENV["SNS_REGION"] || ENV["AWS_REGION"])
+    end
+
+    attr_writer :sns_access_key_id
+
+    def sns_access_key_id
+      @sns_access_key_id ||= (ENV["SNS_ACCESS_KEY_ID"] || ENV["AWS_ACCESS_KEY_ID"])
+    end
+
+    attr_writer :sns_secret_access_key
+
+    def sns_secret_access_key
+      @sns_secret_access_key ||= (ENV["SNS_SECRET_ACCESS_KEY"] || ENV["AWS_SECRET_ACCESS_KEY"])
+    end
+  end # class << self
+
+  def client
+    @client ||= Aws::SNS::Client.new(
+      :region            => self.class.sns_region,
+      :access_key_id     => self.class.sns_access_key_id,
+      :secret_access_key => self.class.sns_secret_access_key,
+    )
+  end
+
+  def call
+    from = data[:from] || BMC::SMS.default_from
+
+    client.publish(
+      :phone_number       => data[:to],
+      :message            => data[:body],
+      :message_attributes => {
+        "AWS.SNS.SMS.SenderID" => {
+          :data_type    => "String",
+          :string_value => from,
+        },
+        "AWS.SNS.SMS.SMSType"  => {
+          :data_type    => "String",
+          :string_value => "Transactional",
+        },
+      },
+    )
+  end
+end

data/app/sms/bmc/sms/strategies/base.rb

@@ -0,0 +1,15 @@
+class BMC::SMS::Strategies::Base
+  attr_reader :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def call
+    raise NotImplementedError
+  end
+
+  def self.call(...)
+    new(...).call
+  end
+end

data/app/sms/bmc/sms/strategies/test.rb

@@ -0,0 +1,10 @@
+class BMC::SMS::Strategies::Test < BMC::SMS::Strategies::Base
+  def self.deliveries
+    @deliveries ||= []
+  end
+
+  def call
+    self.class.deliveries << data
+    Rails.logger.info "New SMS sent : #{data.inspect}"
+  end
+end

data/app/sms/bmc/sms.rb

@@ -0,0 +1,35 @@
+module BMC::SMS
+  class << self
+    def strategy=(value)
+      @strategy = parse_strategy(value)
+    end
+
+    def strategy
+      @strategy ||= default_strategy
+    end
+
+    attr_writer :default_from
+
+    def default_from
+      @default_from ||= Rails.application.class.to_s.chomp("::Application")
+    end
+
+    def parse_strategy(value)
+      if value.is_a?(Symbol)
+        "BMC::SMS::Strategies::#{value.to_s.camelcase}".constantize
+      else
+        value
+      end
+    end
+
+    private
+
+    def default_strategy
+      if Rails.env.development? || Rails.env.test?
+        BMC::SMS::Strategies::Test
+      else
+        BMC::SMS::Strategies::AmazonSNS
+      end
+    end
+  end # class << self
+end

data/app/sorters/bmc/sorter.rb

@@ -0,0 +1,26 @@
+class BMC::Sorter
+  include BMC::SortingHelper
+
+  attr_reader :collection, :sort_param, :column, :direction
+
+  def initialize(collection, sort_param = nil)
+    @collection         = collection
+    @sort_param         = sort_param
+    @column, @direction = sortable_column_order(sort_param.to_s)
+  end
+
+  def sort
+    raise NotImplementedError
+  end
+
+  def call
+    # Don't replace by `collection.reorder(sort)`
+    # #sort can change #collection and must be called before #collection
+    order = sort
+    collection.reorder(order)
+  end
+
+  def self.call(...)
+    new(...).call
+  end
+end

data/app/views/bmc/search/_form.html.slim

@@ -0,0 +1 @@
+= render "bmc/search/form_bs#{Bootstrap::VERSION[0]}", action: action