agilibox 1.0.0 → 1.11.0

data/app/libs/agilibox/fcm/request.rb

@@ -0,0 +1,48 @@
+class Agilibox::FCM::Request < Agilibox::Service
+  URL = "https://fcm.googleapis.com/fcm/send"
+
+  class << self
+    attr_writer :api_key
+
+    def api_key
+      @api_key ||= ENV["FCM_API_KEY"]
+    end
+  end
+
+  initialize_with :request_body
+
+  attr_reader :response_json
+
+  def call
+    response_body = HTTParty.post(URL,
+      :body    => request_body.to_json,
+      :headers => {
+        "Content-Type"  => "application/json",
+        "Authorization" => "key=#{self.class.api_key}",
+      },
+    ).body
+
+    @response_json = JSON.parse(response_body).deep_symbolize_keys
+
+    self
+  rescue JSON::ParserError
+    @response_json = {success: 0, failure: 1, results: [{:error => "InvalidJsonResponse"}]}
+    self
+  end
+
+  def ok?
+    response_json[:success].positive? && response_json[:failure].zero?
+  end
+
+  def error?
+    !ok?
+  end
+
+  def errors
+    response_json[:results].pluck(:error).compact
+  end
+
+  def invalid_token?
+    errors.include?("NotRegistered") || errors.include?("InvalidRegistration")
+  end
+end

data/app/libs/agilibox/initialize_with.rb

@@ -0,0 +1,20 @@
+module Agilibox::InitializeWith
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def initialize_with(*attrs)
+      attr_reader(*attrs)
+
+      define_method(:initialize) do |*args|
+        if attrs.length != args.length
+          message = "wrong number of arguments (given #{args.length}, expected #{attrs.length})"
+          raise ArgumentError, message
+        end
+
+        attrs.length.times do |i|
+          instance_variable_set("@#{attrs[i]}", args[i])
+        end
+      end
+    end
+  end # class_methods
+end

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

@@ -0,0 +1,30 @@
+class Agilibox::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(*args)
+    new(*args).call
+  end
+
+  private
+
+  def serialize(object)
+    Agilibox::MiniModelSerializer::Serialize.call(object, options)
+  end
+end

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

@@ -0,0 +1,23 @@
+class Agilibox::MiniModelSerializer::Serializer < Agilibox::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/agilibox/monkey.rb

@@ -0,0 +1,39 @@
+module Agilibox::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/agilibox/phone_number_sanitizer.rb

@@ -0,0 +1,15 @@
+class Agilibox::PhoneNumberSanitizer
+  attr_reader :phone_number
+
+  def initialize(phone_number)
+    @phone_number = phone_number
+  end
+
+  def call
+    phone_number.to_s.gsub(/[^0-9+]+/, "").presence
+  end
+
+  def self.call(*args)
+    new(*args).call
+  end
+end

data/app/libs/agilibox/sortable_uuid_generator.rb

@@ -3,7 +3,7 @@ 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
+  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')

data/app/libs/agilibox/token_generator.rb

@@ -0,0 +1,37 @@
+class Agilibox::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/agilibox/application_mailer.rb

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

data/app/mailers/agilibox/generic_mailer.rb

@@ -0,0 +1,9 @@
+class Agilibox::GenericMailer < Agilibox::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/agilibox/active_record_uuid_concern.rb

@@ -4,9 +4,11 @@ module Agilibox::ActiveRecordUUIDConcern
   private
 
   def assign_default_uuid
-    if id.nil? && self.class.columns_hash["id"].type == :uuid
-      self.id = ::Agilibox::SortableUUIDGenerator.generate
+    unless self.class.columns_hash["id"].type == :uuid
+      raise "invalid id type, please change to uuid"
     end
+
+    self.id ||= ::Agilibox::SortableUUIDGenerator.call
   end
 
   included do

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

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

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

@@ -1,6 +1,12 @@
 module Agilibox::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
@@ -9,17 +15,42 @@ module Agilibox::ModelI18n
     self.class.ts
   end
 
+  def tv(attribute)
+    value = public_send(attribute)
+    t("#{attribute}.#{value}") if value.present?
+  end
+
   class_methods do
-    def t(*args)
-      if args.any?
-        human_attribute_name(*args)
-      else
-        model_name.human
+    def t(attribute = nil, options = {})
+      should_raise = Agilibox::ModelI18n.raise_on_missing_translations
+      exception_class = Agilibox::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
-      model_name.human(count: 2)
+      t(nil, count: 2)
     end
   end # class_methods
 end # Agilibox::ModelI18n

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

@@ -0,0 +1,13 @@
+module Agilibox::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/agilibox/pluck_to_hash.rb

@@ -0,0 +1,9 @@
+module Agilibox::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/agilibox/polymorphic_id.rb

@@ -11,7 +11,7 @@ module Agilibox::PolymorphicId
     def guid
       return nil if new_record?
 
-      "#{self.class.base_class}-#{self.id}"
+      "#{self.class.base_class}-#{id}"
     end
   end # included
 end # module
@@ -26,7 +26,10 @@ Module.new do
   end
 
   def relation_guid=(guid)
-    return self.relation = nil if guid.blank?
+    if guid.blank?
+      self.relation = nil
+      return
+    end
 
     type, id      = guid.split("-", 2)
     self.relation = type.constantize.find(id)

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

@@ -3,28 +3,26 @@ module Agilibox::Search
 
   class_methods do
     def default_search_fields
-      fields = columns.map do |column|
-        "#{table_name}.#{column.name}"
-      end
+      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?
 
-      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 ")
+      return all if words.empty?
 
-      sql_params_a = words.map.with_index do |word, index|
-        ["w#{index}".to_sym, "%#{word}%"]
-      end
+      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_h = Hash[sql_params_a]
+      sql_params = words.map.with_index { |word, index| ["w#{index}".to_sym, "%#{word}%"] }.to_h
 
-      self.where(sql_query, sql_params_h)
+      where(sql_query, sql_params)
     end # def search
   end # class_methods
 end # class Agilibox::Search

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

@@ -0,0 +1,17 @@
+module Agilibox::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/agilibox/serializers/base.rb

@@ -6,12 +6,58 @@ class Agilibox::Serializers::Base
     @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)
+  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/agilibox/serializers/xlsx.rb

@@ -1,36 +1,38 @@
-require "axlsx"
-
 class Agilibox::Serializers::XLSX < Agilibox::Serializers::Base
   def render_inline
-    xlsx.to_stream.read.force_encoding("BINARY")
+    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)
-    xlsx.serialize(file_path)
+    File.open(file_path, "w+b") do |f|
+      f.write(render_inline)
+    end
   end
 
-  def xlsx
-    @xlsx ||= Axlsx::Package.new do |p|
-      p.workbook.add_worksheet do |sheet|
-        data.each do |line|
-          values = line.map do |value|
-            if value.is_a?(Integer)
-              value
-            elsif value.is_a?(Numeric)
-              value.to_f # Fix BigDecimal
-            elsif value == true || value == false
-              I18n.t(value.to_s)
-            else
-              value.to_s
-            end
-          end
+  private
 
-          sheet.add_row(values)
-        end
-      end
+  def range_styles(row)
+    return [] if row.nil?
 
-      p.use_shared_strings = true
+    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/services/agilibox/service.rb

@@ -0,0 +1,17 @@
+class Agilibox::Service
+  include Agilibox::InitializeWith
+
+  if RUBY_VERSION >= "2.7.0"
+    def self.call(*args, **kwargs)
+      new(*args, **kwargs).call
+    end
+  else
+    def self.call(*args)
+      new(*args).call
+    end
+  end
+
+  def call(*)
+    raise NotImplementedError
+  end
+end

data/app/sms/agilibox/sms/application_sms.rb

@@ -0,0 +1,42 @@
+class Agilibox::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)
+    Agilibox::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/agilibox/sms/message.rb

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