forcast 0.0.110

data/lib/forcast/models/rule_engine/models/action.rb

@@ -0,0 +1,41 @@
+class Action < ApplicationRecord
+	belongs_to :rule
+	has_many   :action_log
+	include Forcast::Model::Modelo
+    include Forcast::Model::Permitirtodo	
+    include Forcast::Model::RuleEngine::ActionEngine
+	def init(params)
+	  #self.password=(params['password_hash'])
+	end
+	 
+	def self.parametros_necesario_create
+	  array = []
+	  return array
+	end
+
+	def self.parametros_a_validar_modelo_create
+	  #return parametros_a_validar_modelo_create = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+	  return parametros_a_validar_modelo_create = []
+	end
+
+	def self.parametros_a_validar_modelo_update
+	  #return parametros_a_validar_modelo_update = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+	  return parametros_a_validar_modelo_update = []
+	end
+
+	def self.parametros_permitido_asociar
+	  return parametros_permitido_asociar = []
+	end
+
+	def self.parametros_a_comprobar_si_existen_create
+	  return parametros_a_comprobar_si_existen_create = []
+	end
+
+	def self.parametros_a_comprobar_si_existen_update
+	  return parametros_a_comprobar_si_existen_update = []
+	end
+	# def self.validaciones_tipo_valor(valor)
+	#  return true unless ['string','integer','decimal'].include?(valor)
+	# end
+end
+    

data/lib/forcast/models/rule_engine/models/action_log.rb

@@ -0,0 +1,40 @@
+class ActionLog < ApplicationRecord
+  belongs_to :action
+  include Forcast::Model::Modelo
+  include Forcast::Model::Permitirtodo 
+  def init(params)
+    #self.password=(params['password_hash'])
+  end
+  
+  def self.parametros_necesario_create
+    array = []
+    return array
+  end
+
+  def self.parametros_a_validar_modelo_create
+    #return parametros_a_validar_modelo_create = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_create = []
+  end
+
+  def self.parametros_a_validar_modelo_update
+    #return parametros_a_validar_modelo_update = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_update = []
+  end
+
+  def self.parametros_permitido_asociar
+      return parametros_permitido_asociar = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_create
+      return parametros_a_comprobar_si_existen_create = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_update
+      return parametros_a_comprobar_si_existen_update = []
+  end
+  # def self.validaciones_tipo_valor(valor)
+  #   return true unless ['string','integer','decimal'].include?(valor)
+  # end
+
+end
+    

data/lib/forcast/models/rule_engine/models/polling.rb

@@ -0,0 +1,43 @@
+class Polling < ApplicationRecord
+	
+  belongs_to :rule
+  include Forcast::Model::Modelo
+  include Forcast::Model::Permitirtodo	
+  include Forcast::Model::RuleEngine::PollingEngine
+
+  def init(params)
+    #self.password=(params['password_hash'])
+  end
+ 
+  def self.parametros_necesario_create
+    array = []
+    return array
+  end
+
+  def self.parametros_a_validar_modelo_create
+    #return parametros_a_validar_modelo_create = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_create = []
+  end
+
+  def self.parametros_a_validar_modelo_update
+    #return parametros_a_validar_modelo_update = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_update = []
+  end
+
+  def self.parametros_permitido_asociar
+     return parametros_permitido_asociar = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_create
+     return parametros_a_comprobar_si_existen_create = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_update
+     return parametros_a_comprobar_si_existen_update = []
+  end
+  # def self.validaciones_tipo_valor(valor)
+  #   return true unless ['string','integer','decimal'].include?(valor)
+  # end
+
+end
+    

data/lib/forcast/models/rule_engine/models/rule.rb

@@ -0,0 +1,44 @@
+class Rule < ApplicationRecord
+  has_many :webhook
+  has_many :polling
+  has_many :action
+  has_many :rule_log
+  include Forcast::Model::Modelo
+  include Forcast::Model::Permitirtodo
+  include Forcast::Model::RuleEngine::RuleScope
+  include Forcast::Model::RuleEngine::RuleEngine
+
+  def init(params)
+    # self.password=(params['password_hash'])
+  end
+
+  def self.parametros_necesario_create
+    []
+  end
+
+  def self.parametros_a_validar_modelo_create
+    # [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    []
+  end
+
+  def self.parametros_a_validar_modelo_update
+    # [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    []
+  end
+
+  def self.parametros_permitido_asociar
+    []
+  end
+
+  def self.parametros_a_comprobar_si_existen_create
+    []
+  end
+
+  def self.parametros_a_comprobar_si_existen_update
+    []
+  end
+
+  # def self.validaciones_tipo_valor(valor)
+  #   return true unless ['string','integer','decimal'].include?(valor)
+  # end
+end

data/lib/forcast/models/rule_engine/models/rule_log.rb

@@ -0,0 +1,39 @@
+class RuleLog < ApplicationRecord
+  belongs_to :rule
+  include Forcast::Model::Modelo
+  include Forcast::Model::Permitirtodo
+  def init(params)
+    #self.password=(params['password_hash'])
+  end
+ 
+  def self.parametros_necesario_create
+    array = []
+    return array
+  end
+
+  def self.parametros_a_validar_modelo_create
+    #return parametros_a_validar_modelo_create = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_create = []
+  end
+
+  def self.parametros_a_validar_modelo_update
+    #return parametros_a_validar_modelo_update = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_update = []
+  end
+
+  def self.parametros_permitido_asociar
+     return parametros_permitido_asociar = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_create
+     return parametros_a_comprobar_si_existen_create = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_update
+     return parametros_a_comprobar_si_existen_update = []
+  end
+  # def self.validaciones_tipo_valor(valor)
+  #   return true unless ['string','integer','decimal'].include?(valor)
+  # end
+end
+    

data/lib/forcast/models/rule_engine/models/webhook.rb

@@ -0,0 +1,43 @@
+class Webhook < ApplicationRecord
+	
+  belongs_to :rule
+  include Forcast::Model::Modelo
+  include Forcast::Model::Permitirtodo
+  include Forcast::Model::RuleEngine::WebhookEngine	
+
+  def init(params)
+    #self.password=(params['password_hash'])
+  end
+
+  def self.parametros_necesario_create
+    array = []
+    return array
+  end
+
+  def self.parametros_a_validar_modelo_create
+    #return parametros_a_validar_modelo_create = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_create = []
+  end
+
+  def self.parametros_a_validar_modelo_update
+    #return parametros_a_validar_modelo_update = [{:param => 'tipo_valor', :validacion => 'validaciones_tipo_valor', :error => :bad_param_not_allow_type}]
+    return parametros_a_validar_modelo_update = []
+  end
+
+  def self.parametros_permitido_asociar
+     return parametros_permitido_asociar = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_create
+     return parametros_a_comprobar_si_existen_create = []
+  end
+
+  def self.parametros_a_comprobar_si_existen_update
+     return parametros_a_comprobar_si_existen_update = []
+  end
+  # def self.validaciones_tipo_valor(valor)
+  #   return true unless ['string','integer','decimal'].include?(valor)
+  # end
+
+end
+    

data/lib/forcast/models/rule_engine/polling_engine.rb

@@ -0,0 +1,113 @@
+require 'active_support'
+module Forcast
+  module Model
+      module RuleEngine
+        module PollingEngine
+        extend ActiveSupport::Concern
+        included do
+          def self.duplicate_object?(object)
+            return self.exists?(object)
+          end
+
+          def self.validate_if_work_exists_to_polling(args={})
+            found_work = logic_work_polling(args[:polling_model],args[:polling_model_id])
+            if found_work
+              puts "Work already exists"
+            else
+              puts "Push Work"
+              add_worker_to_polling(args)
+            end
+          end
+
+          def self.add_worker_to_polling(args={})
+            JobsPollings::AddModelPolling.perform_async(args)
+          end
+
+          def self.logic_work_polling(polling_model,polling_model_id)
+            work = 'JobsPollings::ValidateModelPolling'
+            scheduled = Sidekiq::ScheduledSet.new
+            scheduled_jobs = scheduled.select {|job| job.klass == work}
+            queue = Sidekiq::Queue.new("polling_queue")
+            queue_jobs = queue.select {|job| job.klass == work}
+            jobs = scheduled_jobs + queue_jobs
+            regulate_works_logic_from_pollings_actives(jobs,polling_model,polling_model_id)
+          end
+
+          def self.regulate_works_logic_from_pollings_actives(jobs,polling_model,polling_model_id)
+            found_works = jobs.select {|job| job.args[0]["polling_model"]==polling_model&&job.args[0]["polling_model_id"]==polling_model_id}
+            if found_works.length > 0
+              puts "[polling] Work found "+found_works[0].args.to_s
+              return true
+            elsif found_works.length > 1
+              puts "[polling] Deleting another work found "+found_works[1].args.to_s
+              found_works[1].delete
+              return true
+            else
+              puts "[polling] Work not found "+polling_model.to_s+" "+polling_model_id.to_s
+            return false
+            end   
+          end
+        end
+
+        def validate_execute_time
+            puts "validate_execute_time"
+          execution_time = self.review_time
+          execution_time ||= 30
+          last_execution = self.last_execution
+          testing_time = last_execution + execution_time.second
+          if testing_time.to_i > Time.now.to_i
+            puts "It should not be executed"
+            self.update_columns(:execute? => false)
+            return false      
+          else
+            puts "Must be executed"
+            self.update_columns(:last_execution => Time.now,
+                         :execute? => true)
+            return true
+          end
+
+        end
+
+        def validate_duration_time
+          puts "validate_duration_time"
+          polling_duration_time = self.duration_time
+          polling_duration_time ||= 1
+          testing_time = self.created_at + polling_duration_time.minutes
+          if testing_time.to_i < Time.now.to_i
+            self.update_columns(:active? => false)
+            puts "Duration period expire"
+            return false      
+          else
+            puts "Duration period still active"
+            return true
+          end
+        end
+
+      def validate_send_time
+          puts "validate_send_time"
+          send_time = self.send_time
+          send_time ||= 30
+          last_review_send = self.last_review_send
+          last_review_send ||= Time.now
+          testing_time = last_review_send + send_time.second
+          remain = testing_time.to_i - Time.now.to_i
+        if testing_time.to_i > Time.now.to_i
+            puts "Dont send yet, remains #{remain} seconds"
+            self.update_columns( :last_review_send => Time.now,
+                        :send? => false)
+          return false      
+        else
+            puts "Send now"
+            self.update_columns(:last_send => Time.now,
+                         :send? => true)
+          return true
+        end
+
+      end
+
+      end
+    end
+  end
+end
+
+    

data/lib/forcast/models/rule_engine/rule.rb

@@ -0,0 +1,62 @@
+module Forcast
+  module Model
+    module RuleEngine
+      extend ActiveSupport::Concern
+
+      included do
+        after_create :send_webhook_create
+        after_update :send_webhook_update
+        after_destroy :send_webhook_destroy
+      end
+
+      def class_polling
+        Polling.where(polling_model: self.class.name, class_polling?: true)
+      end
+
+      def class_rule
+        Rule.for_class(self.class.name)
+      end
+
+      def webhook
+        Webhook.joins(:rule).merge(rule)
+      end
+
+      def object_webhook
+        Webhook.joins(:rule).merge(Rule.for_object(self))
+      end
+
+      def polling
+        Polling.where(polling_model: self.class.name, polling_model_id: id)
+      end
+
+      def rule
+        Rule.for_object_and_class(self)
+      end
+
+      def send_webhook_create
+        puts 'send_webhook_create'
+      end
+
+      def send_webhook_destroy
+        puts 'send_webhook_destroy'
+      end
+
+      def send_webhook_update
+        puts 'send_webhook_update'
+        JobsWebhooks::ValidateModelWebhook.perform_later(
+          webhook_model: self.class.name,
+          webhook_model_id: id,
+          changed_attrs_json: saved_changes.to_json,
+          created_at: Time.now.to_s
+        )
+      end
+
+      def currents_pollings
+        arr1 = polling.where(created_at: 4.week.ago.beginning_of_day..Time.now)
+                      .where(active?: true)
+        arr2 = class_polling.where(active?: true)
+        arr2 + arr1
+      end
+    end
+  end
+end

data/lib/forcast/models/rule_engine/rule_engine.rb

@@ -0,0 +1,137 @@
+require 'active_support'
+module Forcast
+  module Model
+    module RuleEngine
+      module RuleEngine
+        extend ActiveSupport::Concern
+
+        RULE_VALUES_MAP = {
+          string: :value_s,
+          integer: :value_i,
+          decimal: :value_d,
+          boolean: :value_b,
+          datetime: :value_t
+        }.freeze
+
+        VALID_RULE_COMPARATORS_MAP = {
+          string: %w[eql? ==],
+          integer: %w[eql? > >= < <= ==],
+          decimal: %w[eql? > >= < <= ==],
+          boolean: %w[eql? ==],
+          datetime: %w[eql? > >= < <= ==]
+        }.freeze
+
+        class_methods do
+          def validate_logic_rule(rule, value1, value2)
+            return false unless value1
+
+            value1.send(rule.to_s, value2)
+          end
+
+          def logical_calculation(arr, op)
+            case op
+            when 'and' then arr.reduce(:&)
+            when 'or' then arr.reduce(:|)
+            else
+              false
+            end
+          end
+
+          def rule_value(rule_class)
+            RULE_VALUES_MAP[rule_class.to_sym]&.to_s || 'value_s'
+          end
+
+          def validate_rule_and_class(rule, rule_class, params)
+            return false unless RULE_VALUES_MAP[rule_class.to_sym].present?
+
+            value_name = RULE_VALUES_MAP[rule_class.to_sym]
+            params[value_name] =
+              case rule_class
+              when 'string' then params[:value].to_s
+              when 'integer' then params[:value].to_i
+              when 'decimal' then params[:value].to_f
+              when 'boolean' then params[:value]
+              when 'datetime' then params[:value].to_date
+              end
+
+            VALID_RULE_COMPARATORS_MAP[rule_class.to_sym].include?(rule)
+          end
+
+          def validate_class_update(rule_class)
+            RULE_VALUES_MAP[rule_class.to_sym]&.to_s || false
+          end
+
+          def rules_allowed
+            VALID_RULE_COMPARATORS_MAP.values.flatten.uniq
+          end
+
+          def rules_type_allowed
+            %w[logic change]
+          end
+
+          def rules_class_allowed
+            RULE_VALUES_MAP.keys.map(&:to_s)
+          end
+
+          def valid_combine_type
+            %w[and or]
+          end
+
+          def validate_rule_duplicate(hash_new)
+            if hash_new
+              !Rule.exists?(hash_new)
+            else
+              !Rule.exists?(attr_comparable: @attr_comparable,
+                            rule_model: @rule_model,
+                            rule_model_id: @rule_model_id,
+                            rule: @rule,
+                            rule_class: @rule_class,
+                            rule_type: @rule_type,
+                            combine_type: @combine_type)
+            end
+          end
+
+          def validate_model_id(rule_model, rule_model_id)
+            rule_model.classify.constantize.find(rule_model_id)
+          end
+
+          def validate_attr_model(rule_model,attribute)
+            rule_model = rule_model.classify.constantize
+            return false unless rule_model.column_names.include?(attribute)
+
+            @rule_class = rule_model.columns_hash[attribute.to_s].type.to_s
+          end
+        end
+
+        def validate_logic(object)
+          attr_comparable = self.attr_comparable
+          case rule_type
+          when 'logic'
+            value_attr_comparable = object.send(attr_comparable.to_s)
+            value_type = Rule.rule_value(rule_class)
+            value_comparable = send(value_type)
+            puts "Attr Value: #{value_attr_comparable}"
+            puts "Rule Value: #{value_comparable}"
+            validation = Rule.validate_logic_rule(rule, value_attr_comparable, value_comparable)
+          when 'change'
+            value_attr_comparable = object.send(attr_comparable.to_s)
+            last_value_attr_comparable = self.last_value_attr_comparable
+            validation = !Rule.validate_logic_rule('eql?', value_attr_comparable, last_value_attr_comparable)
+            update_columns(last_value_attr_comparable: value_attr_comparable)
+          when 'logic_comparable'
+            rules_to = Rule.where(id: rule.split(',').map(&:to_i))
+            boolean_array = []
+            rules_to.each do |rule_to|
+              boolean_array.push(validate_logic(object,rule_to))
+            end
+            validation = Rule.logical_calculation(boolean_array, combine_type)
+          else
+            validation = false
+          end
+          validation
+        end
+
+      end
+    end
+  end
+end