forcast 0.0.110

data/lib/forcast/controllers/controller/rule_engine/action_engine.rb

@@ -0,0 +1,92 @@
+require 'active_support'
+require 'json'
+module Forcast
+	module Controller
+		module RuleEngine
+			module ActionEngine
+			extend ActiveSupport::Concern
+
+			included do
+
+			end
+			  def create
+			    raise Forcast::Application::Error::General.new(t("error_action_type_dont_permit")) unless Action.action_type_allowed.include?(@action_type)
+			    raise Forcast::Application::Error::General.new(t("error_action_params_dont_permit")) unless validation_for(@action_type)
+			    params[:active?] = true
+			    super
+			  end
+
+			  def update 
+			    super
+			  end
+
+			  def validation_for(action_type)
+			    case action_type
+			    when "callback"
+			    	return validation_for_callback
+			    when "email"
+			    	required_email_params = ['owner_email','target_email','attributes']
+			    	validation_for_email(required_email_params)
+			    	convert_params_to_hash(required_email_params)
+			    when "telegram"
+			    	return true
+			    else
+			      return false
+			    end
+			  end
+
+			  def validation_for_callback
+			  	begin
+			    	action_params =  JSON.parse(@action_params)
+			    rescue
+			    	puts "Error Parser JSON"
+			    	return false
+			    end
+			    puts action_params
+			    unless action_params && action_params["url"] && action_params["attr"]
+			      return false
+			    else
+			      return false unless action_params["attr"].is_a?(Array)
+			      model = Rule.find(@rule_id).rule_model
+			      validate_attr_model(model,action_params["attr"])
+			      return true
+			    end
+			  end
+
+			  def validation_for_email(required_email_params)
+					raise Forcast::Application::Error::General.new(t("error_params_email_are_missing")) if params_for_are_missing(required_email_params)
+			  	model = Rule.find(@rule_id).rule_model
+			  	validate_attr_model(model,@attributes)
+			  end
+
+			  def params_for_are_missing(required_params)
+			  	validation = false
+			  	required_params.each do |key|
+			  		next if params.include?(key)
+			  		validation = true
+			  	end
+			  	validation
+			  end
+
+			  def convert_params_to_hash(parameters)
+			  	new_params = params.permit(parameters)
+			  	new_params[:attributes] = params[:attributes]
+			  	params[:action_params] = new_params
+			  end
+
+			  def validate_attr_model(model,attributes)
+			    model = model.classify.constantize
+			    attributes.each do |attribute|
+			      next if attribute == "all"
+			      if model.column_names.include?(attribute)
+			        return true 
+			      else
+			        raise Forcast::Application::Error::General.new(t("error_modelo_attr_doesn't_exist"))
+			      end
+			    end
+			  end
+
+			end
+		end
+	end
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/action_logs_controller.rb

@@ -0,0 +1,12 @@
+class Api::ActionLogsController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+
+private
+
+
+
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/actions_controller.rb

@@ -0,0 +1,10 @@
+class Api::ActionsController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+  include Forcast::Controller::RuleEngine::ActionEngine
+private
+
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/pollings_controller.rb

@@ -0,0 +1,13 @@
+class Api::PollingsController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+  include Forcast::Controller::RuleEngine::PollingEngine
+
+private
+
+  
+
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/rule_logs_controller.rb

@@ -0,0 +1,12 @@
+class Api::RuleLogsController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+
+private
+
+
+
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/rules_controller.rb

@@ -0,0 +1,19 @@
+class Api::RulesController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+  include Forcast::Controller::RuleEngine::RuleEngine
+
+private
+
+  def validate_model
+
+    return rule_models = ["Usuario",
+                      	  "Administrador"]
+
+  end
+
+
+end

data/lib/forcast/controllers/controller/rule_engine/controllers/webhooks_controller.rb

@@ -0,0 +1,27 @@
+class Api::WebhooksController < ApplicationController
+
+  include Forcast::Application::Permitirtodo
+  include Forcast::Controller::Relacion
+  include Forcast::Controller::Asociar
+  include Forcast::Controller::Filtro
+  include Forcast::Controller::Busqueda
+  include Forcast::Controller::RuleEngine::WebhookEngine
+
+
+  private
+
+	
+  # def params_permitidos_enviar
+  #   return params_permitidos_enviar = []
+  # end
+
+  # def params_permitidos_update
+  #   return params_permitidos_update = []
+  # end
+
+  # def params_permitidos_buscar
+  #   return params_permitidos_buscar = []
+  # end
+
+
+end

data/lib/forcast/controllers/controller/rule_engine/polling_engine.rb

@@ -0,0 +1,76 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module RuleEngine
+			module PollingEngine
+			extend ActiveSupport::Concern
+
+			included do
+				  before_action :set_model_rule_and_model_id_rule, only: [:create]
+			end
+			def create
+			    params[:polling_model] = @polling_model
+			    params[:polling_model_id] = @polling_model_id
+			    params[:active?] = false
+			    params[:execute?] = true
+			    params[:send?] = true
+			    params[:last_execution] = Time.now
+			    params[:duration_time] ||= 10
+			    params[:review_time] ||= 30
+			    params[:send_time] ||= 10
+			    model_id = super
+			  if @auto_active
+			    	model_id.update_columns(:active? => true)
+			    	activate_polling
+			  end
+			end
+
+			def update
+			    if @variable == 'active?' && @dato == 'true'
+			      response_to_active
+			  	elsif params[:active?]
+			      response_to_active
+			      @datos = @datos.without("active?")
+			  	end
+			    super
+			end
+
+			def response_to_active
+			      rule = @model_id.rule
+			      @polling_model = rule.rule_model
+			      @polling_model_id = rule.rule_model_id 
+			      @model_id.update_columns(:active? => true,
+			                               :execute? => true,
+			                               :send? => true)
+			      activate_polling
+			end
+
+			def set_model_rule_and_model_id_rule
+			    puts "set_modelo_and_modelo_id"
+			    rule = Rule.find(@rule_id)
+			    @polling_model = rule.rule_model
+			    @polling_model_id = rule.rule_model_id
+			    #pollings = rule.polling.where(:activo? => true)
+			    #raise Forcast::Application::Error::General.new(t("polling_exist_and_active")) if pollings.first
+			    raise Forcast::Application::Error::General.new(t("polling_exist")) if Polling.duplicate_object?(object_duplicate_params)
+			    rule.update_columns(:last_value_attr_comparable => nil)
+			end
+
+			def activate_polling
+			  	Polling.validate_if_work_exists_to_polling(:polling_model => @polling_model,
+			                                               :polling_model_id => @polling_model_id,
+			                                               :created_at => Time.now.strftime("%m/%d/%Y %H:%M")) 
+			end
+
+			def object_duplicate_params
+			  	comp = Hash.new
+			  	comp["polling_model"] = @polling_model
+			  	comp["polling_model_id"] = @polling_model_id
+			  	comp["rule_id"] = @rule_id
+			  	return comp
+			end
+
+			end
+		end
+	end
+end

data/lib/forcast/controllers/controller/rule_engine/rule_controller.rb

@@ -0,0 +1,27 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module RuleController
+			extend ActiveSupport::Concern
+			included do
+				before_action :set_model_id_rule, only: [:webhooks, :pollings, :rules]
+			end
+
+			def webhooks
+				json_response(@model_id.webhook,'ok')
+			end
+
+			def pollings
+				json_response(@model_id.polling,'ok')
+			end
+
+			def rules
+				json_response(@model_id.rule,'ok')
+			end
+
+			def set_model_id_rule
+				set_model_id
+			end		
+		end
+	end
+end

data/lib/forcast/controllers/controller/rule_engine/rule_engine.rb

@@ -0,0 +1,88 @@
+require 'active_support'
+module Forcast
+  module Controller
+    module RuleEngine
+      module RuleEngine
+        extend ActiveSupport::Concern
+        included do
+
+        end
+        def create
+          unless @rules
+            raise Forcast::Application::Error::General.new(t("error_rule_model")) unless validate_model.include?(@rule_model)
+            unless params[:class_rule?]
+              raise Forcast::Application::Error::General.new(t("error_rule_model_id_doesn't_exist")) unless Rule.validate_model_id(@rule_model,@rule_model_id) 
+            end
+            raise Forcast::Application::Error::General.new(t("error_rule_model_attr_doesn't_exist")) unless @rule_class = Rule.validate_attr_model(@rule_model,@attr_comparable)
+            raise Forcast::Application::Error::General.new(t("error_unique_rule")) unless Rule.validate_rule_duplicate(nil)
+            raise Forcast::Application::Error::General.new(t("error_rule_model_rule_type_dont_permit")) unless Rule.rules_type_allowed.include?(@rule_type)
+            if @rule_type == 'logic'
+              raise Forcast::Application::Error::General.new(t("error_rule_model_rule_dont_permit")) unless Rule.rules_allowed.include?(@rule)
+              raise Forcast::Application::Error::General.new(t("error_rule_model_rule_class_dont_permit")) unless Rule.rules_class_allowed.include?(@rule_class)
+              raise Forcast::Application::Error::General.new(t("error_rule_model_rule_and_class_dont_permit")) unless Rule.validate_rule_and_class(@rule,@rule_class,params)
+              params[:rule_class] = @rule_class
+            end
+            params[:active?] = true
+            super
+          else
+            json_response(compatibles_rules,"ok")
+          end
+        end
+
+        def update
+          case @variable
+          when "value"
+            attr_comparable = @model_id.attr_comparable
+            rule_model = @model_id.rule_model
+            model = rule_model.classify.constantize
+            rule_class = model.columns_hash["#{attr_comparable}"].type.to_s
+            @variable = Rule.validate_class_update(rule_class)
+            params[:variable] = @variable
+          when "attr_comparable"
+            @attr_comparable = @model_id.attr_comparable
+            rule_model = @model_id.rule_model
+            raise Forcast::Application::Error::General.new(t("error_rule_model_attr_doesn't_exist")) unless Rule.validate_attr_model(rule_model,@dato)
+            @model_id.update_columns(:rule_class => @rule_class)
+          else
+          end
+          super
+        end
+
+        def compatibles_rules
+          rules = Rule.where(:id => @rules)
+          raise Forcast::Application::Error::General.new(t("some_rule_is_missing")) unless @rules.size == rules.size
+          raise Forcast::Application::Error::General.new(t("rules_are_not_compatibles")) if rules.pluck(:rule_model,:rule_model_id).uniq.size > 1
+          raise Forcast::Application::Error::General.new(t("rule_can_not_be_comparable")) if rules.pluck(:rule_type).include?("logic_comparable")
+          rule_type = "logic_comparable"
+          return combine_rules(rules, rule_type)
+        end
+
+        def combine_rules(rules,rule_type)
+          puts "combine_rules"
+          raise Forcast::Application::Error::General.new(t("invalid_combine_type_rule")) unless Rule.valid_combine_type.include?(@combine_type)
+          first_rule = rules.first
+          @attr_comparable = "rules"
+          @rule_model = first_rule.rule_model
+          @rule_model_id = first_rule.rule_model_id
+          @rule = rules.pluck(:id)
+          @rule_class = "array"
+          @rule_type = rule_type
+          hash_new = Hash.new
+          hash_new["active?"] = false
+          hash_new["rule_model"] = @rule_model
+          hash_new["rule_model_id"] = @rule_model_id
+          hash_new["rule_type"] = @rule_type
+          hash_new["rule_class"] = @rule_class
+          hash_new["attr_comparable"] = @attr_comparable
+          hash_new["combine_type"] = @combine_type
+          hash_new["rule"] = @rule.join(',')
+          raise Forcast::Application::Error::General.new(t("error_unique_rule")) unless Rule.validate_rule_duplicate(hash_new)
+          @rule = Rule.create(hash_new)
+          return @rule
+        end
+
+
+      end
+    end
+  end
+end

data/lib/forcast/controllers/controller/rule_engine/webhook_engine.rb

@@ -0,0 +1,38 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module RuleEngine
+			module WebhookEngine
+			extend ActiveSupport::Concern
+
+			included do
+				before_action :set_model_rule_and_model_id_rule, only: [:create]
+			end
+
+		      def create
+		          params[:webhook_model] = @webhook_model
+		          params[:execute?] = true
+		          params[:send?] = true
+		          params[:duration_time] ||= 10
+		          params[:send_time] ||= 10
+		          model_id = super
+		      end
+
+		      def set_model_rule_and_model_id_rule
+		          puts "set_modelo_and_modelo_id"
+		          rule = Rule.find(@rule_id)
+		          raise Forcast::Application::Error::General.new(t("webhook_exist")) if Webhook.duplicate_object?(object_duplicate_params)
+		          rule.update_columns(:last_value_attr_comparable => nil)
+		      end
+
+		      def object_duplicate_params
+		          comp = Hash.new
+		          comp["rule_id"] = @rule_id
+		          return comp
+		      end
+
+
+			end
+		end
+	end
+end

data/lib/forcast/controllers/controller/rule_engine_all.rb

@@ -0,0 +1,5 @@
+require "forcast/controllers/controller/rule_engine/action_engine"
+require "forcast/controllers/controller/rule_engine/rule_engine"
+require "forcast/controllers/controller/rule_engine/polling_engine"
+require "forcast/controllers/controller/rule_engine/webhook_engine"
+require "forcast/controllers/controller/rule_engine/rule_controller"

data/lib/forcast/jobs/all.rb

@@ -0,0 +1,2 @@
+require "forcast/jobs/jobs_assets"
+require "forcast/jobs/jobs_wrapper"

data/lib/forcast/jobs/jobs_assets.rb

@@ -0,0 +1,25 @@
+require 'sidekiq'
+require 'active_job'
+include Sidekiq::Worker
+
+module Forcast
+	module Jobs
+		module JobsAssets
+			class ClearAssests < ActiveJob::Base
+				sidekiq_options queue: 'manage_assets'
+				def perform (folder)
+					system("cd #{folder}")
+					#Borro ultimo archivo
+					system("ls -t -r | head -1 | xargs rm")
+				end
+			end
+
+			class SyncAssests < ActiveJob::Base
+				sidekiq_options queue: 'manage_assets'
+				def perform (array)
+
+				end
+			end
+		end
+	end
+end