forcast 0.0.110

data/lib/forcast/jobs/jobs_wrapper.rb

@@ -0,0 +1,25 @@
+require 'sidekiq'
+require 'active_job'
+include Sidekiq::Worker
+
+module Forcast
+	module Jobs
+		module JobsWrapper
+		    class Repetitive < ActiveJob::Base
+				sidekiq_options queue: 'sync_repetitive'
+				def perform(callback,array,t,interval,unidad)
+					vas = eval(callback)
+					unidad = 'minutes' unless units.include?(unidad)
+		      		i = interval || 1  
+					t = (t/i).round  || 1
+					t.times do |time|
+						vas.perform_at(((time+1)*interval).send(unidad).from_now,array)
+					end
+				end
+				def units
+					return ['seconds','minutes','hours','days']
+				end
+			end	
+		end
+	end
+end

data/lib/forcast/jobs/rule_engine/jobs_actions.rb

@@ -0,0 +1,73 @@
+require 'sidekiq'
+require 'date'
+
+include Sidekiq::Worker
+
+module JobsActions
+  class Actions < ActiveJob::Base
+    sidekiq_options queue: 'action_queue'
+
+    def perform (object_id,rule_id)		
+      puts "SendAction"
+      rule = Rule.find(rule_id)
+      object = rule.rule_model.classify.constantize.find(object_id)
+      actions = rule.action.where(:active? => true)
+      actions.each do |action|
+        action_type = action.action_type
+        puts "Select Action #{action_type}"
+        begin
+          JobsActions::Actions.send(action_type,object,rule,action.action_params)
+        rescue StandardError => e
+          puts e
+        end
+      end
+    end
+
+    def self.callback(object,rule,action_params)
+      puts "callback"
+      action_params = JSON.parse(action_params)
+      url = action_params["url"]
+      attributes = action_params["attr"]
+      servidor = Forcast::Utils::Server::Server.new do |config|
+        config.dns = url
+        config.connect = 1
+        config.write = 1
+        config.read = 1
+        #config.ssl = true
+        #config.headers.store("accept","application/json")
+        config.before_ping = false
+      end
+      model_id = object.attributes.slice(*attributes) unless attributes.include?("all")
+      json_send = {:data => model_id}
+      servidor.conexion(:post,{},"",json_send)
+    end
+
+    def self.telegram(object,rule,action_params)
+      puts "telegram"
+    end
+
+    def self.slack(object,rule,action_params)
+      puts "slack"
+    end
+
+    def self.email(object, rule, action_params)
+      puts "action_params"
+      puts action_params
+      # attributes = action_params["attributes"]
+      # model_id_attributes = object.attributes.slice(*attributes) unless attributes.include?("all")
+      # model_id_attributes ||= object.attributes
+
+      obj_identifier = action_params['attr_id'] ? object.send(action_params['attr_id']) : object.id
+      Forcast::Utils::Email::Layout.with(
+        to: action_params['owner_email'], cc: action_params['target_email']
+      ).default(
+        object: object, rule: rule, obj_identifier: obj_identifier
+      ).deliver_now
+    end
+
+    def self.notification(action_params); end
+
+    def self.sms(action_params); end
+
+  end
+end

data/lib/forcast/jobs/rule_engine/jobs_pollings.rb

@@ -0,0 +1,77 @@
+require 'sidekiq'
+require 'date'
+
+include Sidekiq::Worker
+
+module JobsPollings
+	class AddModelPolling < ActiveJob::Base
+		sidekiq_options queue: 'polling_queue'
+		
+		def perform(args={})
+			puts "AddModelPolling"
+			JobsPollings::ValidateModelPolling.perform_in(args["review_time"].to_i.send("second"),args)
+		end
+	end
+
+	class ValidateModelPolling < ActiveJob::Base
+		sidekiq_options queue: 'polling_queue'
+		
+		def perform(args={})
+			puts "ValidateModelPolling"
+			object = c_to_m(args["polling_model"]).find(args["polling_model_id"].to_i)
+			#Se podria obtener lista desde el cache
+			pollings = object.currents_pollings
+			puts "Pollings: #{pollings.size}"
+			return if pollings.size == 0
+			pollings.each do |polling|
+				next unless polling.validate_duration_time
+				next unless polling.validate_execute_time
+				begin
+					rule = polling.rule
+					puts "polling Validate Rule #{rule.id}"
+					validate_rule(object,rule,polling)
+				rescue Exception => e
+					puts "Somethings where wrong: "+e.to_s
+				end
+			end
+			review_time = define_review_time(pollings.pluck("review_time"))
+			puts review_time
+			args = {
+					:polling_model => args["polling_model"], 
+					:polling_model_id => args["polling_model_id"],
+					:review_time => review_time,
+					:pollings => pollings.size.to_s,
+					:created_at => args["created_at"],
+					:last_trigger_at => Time.now.strftime("%m/%d/%Y %H:%M"),
+				   }
+			JobsPollings::ValidateModelPolling.perform_in(review_time.to_i.send(:second),args)
+		end
+		
+		def define_review_time(pollings_times)
+			puts "Shorter Review Time"
+			min = pollings_times.min
+			min ||= 10
+			return min
+		end
+
+		def validate_rule(object,rule,polling)
+			#Tipos de regla:= Logicas, Cambio
+			#Validar reglas si estan activas
+			#return unless rule.active?
+			validation = rule.validate_logic(object)
+			if validation
+				puts "Rule Fulfilled"
+				rule_id = rule.id
+				JobsActions::Actions.perform_async(object.id,rule_id) if polling.validate_send_time
+			else
+				puts "Rule Not Met"
+			end
+		end
+
+		def c_to_m(model)
+			return model.classify.constantize
+		end
+
+	end
+
+end

data/lib/forcast/jobs/rule_engine/jobs_webhooks.rb

@@ -0,0 +1,54 @@
+require 'sidekiq'
+require 'date'
+
+include Sidekiq::Worker
+
+module JobsWebhooks
+
+  class ValidateModelWebhook < ActiveJob::Base
+    sidekiq_options queue: 'webhook_queue'
+    def perform(webhook_model:, webhook_model_id:, changed_attrs_json:, created_at:)
+      changed_attrs = JSON.parse(changed_attrs_json)
+      puts 'ValidateModelWebhook'
+      object = c_to_m(webhook_model).find(webhook_model_id.to_i)
+      # Se podria obtener lista desde el cache
+      webhooks = triggered_webhooks(object: object, changed_attrs: changed_attrs.keys)
+      puts "Webhooks: #{webhooks.size}"
+      return if webhooks.empty?
+
+      webhooks.each do |webhook|
+        next unless webhook.validate_duration_time
+
+        begin
+          rule = webhook.rule
+          puts "Webhook Validate Rule #{rule.id}"
+          validate_rule(object, rule, webhook)
+        rescue Exception => e
+          puts 'Somethings where wrong: ' + e.to_s
+        end
+      end
+    end
+
+    private
+
+    def validate_rule(object, rule, webhook)
+      validation = rule.validate_logic(object)
+      if validation
+        puts 'Rule Fulfilled'
+        rule_id = rule.id
+        JobsActions::Actions.perform_async(object.id, rule_id) if webhook.validate_send_time
+      else
+        puts 'Rule Not Met'
+      end
+    end
+
+    def c_to_m(model)
+      model.classify.constantize
+    end
+
+    def triggered_webhooks(object:, changed_attrs:)
+      Webhook.includes(:rule).references(:rule)
+             .merge(Rule.actives.for_attributes(changed_attrs).for_object_and_class(object))
+    end
+  end
+end

data/lib/forcast/migrations/0_migracion_general.rb

@@ -0,0 +1,44 @@
+$files = Dir["#{Rails.root}/db/migrate/tables/*.rb"]
+$files.each do |file|
+  require file 
+end
+
+class MigracionGeneral < ActiveRecord::Migration[5.1]
+
+  def self.tables
+    general_tables
+  end
+
+  def self.general_tables
+    @tables = []
+    $files.each do |file|
+      require file 
+      table = "#{file.split("/").last.gsub('.rb','').titleize.delete(' ')}"
+      next if table == 'Base'
+      @tables.push(eval("Tables::#{table}"))
+    end
+    return @tables
+  end
+
+  def up
+    run_migrations
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration, 'Error'
+  end
+
+  private
+
+  def run_migrations
+    create_tables
+  end
+
+  def create_tables
+    self.class.tables.each do |table|
+      table.create(self)
+    end
+  end
+
+
+end

data/lib/forcast/migrations/paper_trail/versions.rb

@@ -0,0 +1,61 @@
+# This migration creates the `versions` table, the only schema PT requires.
+# All other migrations PT provides are optional.
+class CreateVersions < ActiveRecord::Migration[5.1]
+
+  # The largest text column available in all supported RDBMS is
+  # 1024^3 - 1 bytes, roughly one gibibyte.  We specify a size
+  # so that MySQL will use `longtext` instead of `text`.  Otherwise,
+  # when serializing very large objects, `text` might not be big enough.
+  TEXT_BYTES = 1_073_741_823
+
+  def change
+    create_table :versions do |t|
+      t.string   :item_type, {:null=>false}
+      t.integer  :item_id,   null: false
+      t.string   :event,     null: false
+      t.string   :whodunnit
+      t.text     :object, limit: TEXT_BYTES
+
+      # Known issue in MySQL: fractional second precision
+      # -------------------------------------------------
+      #
+      # MySQL timestamp columns do not support fractional seconds unless
+      # defined with "fractional seconds precision". MySQL users should manually
+      # add fractional seconds precision to this migration, specifically, to
+      # the `created_at` column.
+      # (https://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html)
+      #
+      # MySQL users should also upgrade to at least rails 4.2, which is the first
+      # version of ActiveRecord with support for fractional seconds in MySQL.
+      # (https://github.com/rails/rails/pull/14359)
+      #
+      t.datetime :created_at
+    end
+    add_index :versions, %i(item_type item_id)
+  end
+end
+
+require_relative 'base'
+
+class Tables::Webhooks < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string  :webhook_model
+      t.integer :webhook_model_id
+      t.integer :send_time
+      t.integer :duration_time
+      t.boolean :active?
+      t.boolean :forever_true?
+      t.datetime :last_execution
+      t.datetime :last_review_send
+      t.datetime :last_send
+      t.boolean :execute?
+      t.boolean :send?
+      t.bigint  :rule_id
+      t.index   :rule_id, name: 'index_rule_webhook_id'
+      t.timestamps
+    end
+  end
+end
+

data/lib/forcast/migrations/rule_engine/action_logs.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+class Tables::ActionLogs < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string   :action_type
+      t.text     :action_params
+      t.text     :action_result
+      t.bigint   :action_id
+      t.index    :action_id, name: 'index_action_action_log_id'
+      t.timestamps
+    end
+  end
+end

data/lib/forcast/migrations/rule_engine/actions.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+class Tables::Actions < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string   :action_type
+      t.json     :action_params
+      t.boolean  :active?
+      t.bigint   :rule_id
+      t.index    :rule_id, name: 'index_rule_action_id'
+      t.timestamps
+    end
+  end
+end

data/lib/forcast/migrations/rule_engine/pollings.rb

@@ -0,0 +1,26 @@
+require_relative 'base'
+
+class Tables::Pollings < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string  :polling_model
+      t.integer :polling_model_id
+      t.integer :review_time
+      t.integer :send_time
+      t.integer :duration_time
+      t.boolean :active?
+      t.datetime :last_execution
+      t.datetime :last_review_send
+      t.datetime :last_send
+      t.boolean :execute?
+      t.boolean :send?
+      t.boolean :class_polling?
+      t.bigint  :rule_id
+      t.index   :rule_id, name: 'index_rule_polling_id'
+
+      t.timestamps
+    end
+  end
+end
+

data/lib/forcast/migrations/rule_engine/rule_logs.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+
+class Tables::RuleLogs < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string   :name
+      t.string   :rule_model
+      t.integer  :rule_model_id
+      t.string   :attr_comparable
+      t.string   :rule
+      t.string   :rule_type
+      t.string   :rule_class
+      t.string   :value
+      t.text     :actions
+      t.bigint   :rule_id
+      t.index    :rule_id, name: 'index_rule_rule_log_id'
+      t.timestamps
+    end
+  end
+end
+

data/lib/forcast/migrations/rule_engine/rules.rb

@@ -0,0 +1,27 @@
+require_relative 'base'
+
+class Tables::Rules < Tables::Base
+
+  def self.table(migration)
+    create_table migration do |t|
+      t.string   :name
+      t.string   :rule_model
+      t.integer  :rule_model_id
+      t.string   :value_s
+      t.integer  :value_i
+      t.decimal  :value_d
+      t.boolean  :value_b
+      t.datetime :value_t
+      t.string   :rule
+      t.string   :rule_type
+      t.string   :rule_class
+      t.string   :combine_type
+      t.string   :attr_comparable
+      t.string   :last_value_attr_comparable
+      t.boolean  :class_rule?
+      t.boolean  :active?
+      t.timestamps
+    end
+  end
+end
+