forcast 0.0.110

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

@@ -0,0 +1,25 @@
+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.boolean :class_webhook?
+      t.bigint  :rule_id
+      t.index   :rule_id, name: 'index_rule_webhook_id'
+      t.timestamps
+    end
+  end
+end
+

data/lib/forcast/models/all.rb

@@ -0,0 +1,8 @@
+require "forcast/models/meta"
+require "forcast/models/asociar"
+require "forcast/models/busqueda"
+require "forcast/models/modelo"
+require "forcast/models/permitirtodo"
+require "forcast/models/rule_engine_all"
+require "forcast/models/paper_trail_all"
+require "forcast/models/login_all"

data/lib/forcast/models/asociar.rb

@@ -0,0 +1,74 @@
+require 'active_support'
+module Forcast
+  module Model
+      module Asociar
+
+      extend ActiveSupport::Concern
+
+
+
+      included do
+
+        def self.no_asociados_a(modelo)
+
+                self.where(modelo => [1,nil])
+        end
+
+      end
+
+        def ver_asociado(modelo)
+
+           return c_to_m(modelo).where(:id => self.id)
+         
+        end
+
+        def asociar_a(modelo, id)
+
+           self.update(modelo => id)
+         
+        end
+
+        def agregar_asociado(modelo,id)
+        	nombre = (self.class.name + '_id').downcase 
+        	c_to_m(modelo).find(id).update( nombre => self.id)
+        end
+
+        def desasociar_de(modelo)
+
+          self.update(modelo => 1)
+         
+        end
+
+        def quitar_asociado(modelo,id)
+          nombre = (self.class.name + '_id').downcase 
+          c_to_m(modelo).find(id).update( nombre => 1)
+        end
+
+       
+        def asociado_a?(modelo, id)
+
+          self.read_attribute(modelo) === id.to_i ? false : true
+
+        end
+
+        def agregar_asociado_a?(modelo, id)
+
+          nombre = (self.class.name + '_id').downcase 
+          c_to_m(modelo).find(id).read_attribute(nombre) === self.id.to_i ? false : true
+
+        end
+
+        def asociado_existe?(modelo, id)
+
+         c_to_m(modelo).exists?(id) ? true : false
+
+        end
+
+        def c_to_m(str)
+          return str.classify.constantize
+        end
+
+
+      end
+  end
+end

data/lib/forcast/models/busqueda.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+module Forcast
+	module Model
+		module Busqueda
+			extend ActiveSupport::Concern
+
+			included do
+				scope :buscar_nombre_scope, -> (nombre) { where nombre: nombre }
+				scope :buscar_parametro_exacto_scope, -> (parametro,dato) { where parametro => dato }
+				scope :buscar_parametro_contiene_scope, -> (parametro,contiene) { where "#{parametro} like ?", "%#{contiene}%"}
+			end
+
+
+		end
+	end
+end
+

data/lib/forcast/models/login/authorization.rb

@@ -0,0 +1,37 @@
+class Authorization < ApplicationRecord
+  belongs_to :user, optional: true
+
+def get_token
+  jwt_token = if user.present?
+                JsonWebToken.encode({user_id:self.user.id, birthday_date:self.created_at})
+              elsif admin_user.present?
+                JsonWebToken.encode({admin_user_id:self.admin_user.id, birthday_date:self.created_at})
+              end
+
+  jwt_token
+end
+
+def self.invalidate_token(given_token)
+  temporal_auth = Authorization.new()
+
+  decoded_token = JsonWebToken.decode(given_token)
+
+  if decoded_token.blank?
+    temporal_auth.errors.add(:base, I18n.t("activerecord.errors.token.not_exits"))
+  else
+    user_id = decoded_token[:user_id]
+    created_at_format = decoded_token[:birthday_date]
+    created_at = Time.parse(created_at_format)
+
+    auth = Authorization.find_by(user_id:user_id,active_time_stamp:created_at.to_i)
+    if auth.present? && auth.operative
+      auth.operative = false
+      auth.save
+    else
+      temporal_auth.errors.add(:base, I18n.t("activerecord.errors.token.already_invalid"))
+    end
+  end
+
+  temporal_auth
+end
+end

data/lib/forcast/models/login/json_web_token.rb

@@ -0,0 +1,15 @@
+class JsonWebToken
+  class << self
+    def encode(payload,exp = 15.year.from_now)
+      payload[:exp] = exp.to_i
+      JWT.encode(payload, Rails.application.secrets.secret_key_base)
+    end
+
+    def decode(token)
+      return HashWithIndifferentAccess.new(JWT.decode(token, Rails.application.secrets.secret_key_base)[0])
+    rescue
+      nil
+    end
+
+  end
+end

data/lib/forcast/models/login/login.rb

@@ -0,0 +1,26 @@
+require 'bcrypt'
+module Forcast
+	module Model
+		module Login
+		  include BCrypt
+
+		  def generate_auth_token
+			  token = SecureRandom.hex
+			  self.update_columns(auth_token: token, token_created_at: Time.zone.now)
+			  return token
+		  end
+
+		  def invalidate_auth_token
+		    self.update_columns(auth_token: nil, token_created_at: nil)
+		  end
+
+		  def password=(password)
+		    self.password_hash = BCrypt::Password.create(password)
+		  end
+
+		  def is_password?(password)
+		    BCrypt::Password.new(self.password_hash) == password
+		  end
+		end
+	end
+end

data/lib/forcast/models/login_all.rb

@@ -0,0 +1,2 @@
+require "forcast/models/login/login"
+

data/lib/forcast/models/meta.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+module Forcast
+	module Model
+		module Meta
+			extend ActiveSupport::Concern
+
+			included do
+
+			end
+
+			def initialize()
+			   @name = attributes[:name]
+			   @email = attributes[:email]
+			end
+
+		end
+	end
+end
+

data/lib/forcast/models/modelo.rb

@@ -0,0 +1,125 @@
+require 'active_support'
+module Forcast
+	module Model
+		module Modelo
+
+		extend ActiveSupport::Concern
+
+		    def create(params)
+		    	self.attributes.each do |att|
+		    		next if att[0] == 'id'
+		    		self.write_attribute(att[0], params[att[0]])
+		     	end
+		        begin
+		        	init(params)
+		        rescue
+				
+				ensure
+					return true if self.save	        
+		        end
+		        
+		    end
+
+			def errores
+		        self.errors.full_messages
+		    end
+
+		included do
+
+			def self.model
+				return model_name.name.classify.constantize
+			end
+
+			def self.nombre_existe?(nombre)
+		    	model.exists?(nombre: nombre) 
+		  	end
+
+			def self.parametro_existe?(param,dato)
+				return model.exists?(param => dato) 
+			end
+
+			def self.duplate_object?(comp)
+				object_unique = model.exists?(comp)
+				return object_unique
+			end
+
+			def self.parametros_existen_create?(param)
+				a,b = false
+				parametros_a_comprobar_si_existen_create.each do |comprobar|
+					next unless model.exists?(comprobar => param[comprobar])
+					a = true
+					b = comprobar
+					break
+				end
+				return [a,b]
+			end
+
+			def self.parametros_a_validar_create (datos)
+				a,b = false
+				c = []
+				datos.each do |data|
+					c = model.validaciones_create(data[0],data[1])
+					next unless c[1]
+					a = true
+					b = c[0]
+					break
+				end
+				return [a,b]
+			end
+
+			def self.parametros_estan_create?(params) 
+				if (parametros_necesario_create - params).empty?
+					return false 
+				else
+					return true 
+				end           
+			end
+
+			def self.validaciones_create(param, dato)
+			    vald = parametros_a_validar_modelo_create.select{ |item| item[:param] == param }
+			    return ['',false] if vald.empty?
+			    abstract_validation do
+			    	conf = Hash.new
+			    	conf[:param_param] = param
+			    	conf[:param] = vald[0][:param]
+			    	conf[:valor] = vald[0][:valor]
+			    	conf[:validacion] = vald[0][:validacion]
+			    	conf[:error] = vald[0][:error]
+			    	conf[:comp] = dato
+			    	conf
+			    end
+			end
+
+			def self.validaciones_update(param, dato)
+			    vald = parametros_a_validar_modelo_update.select{ |item| item[:param] == param }
+			    return ['',false] if vald.empty?
+			    abstract_validation do
+			    	conf = Hash.new
+			    	conf[:param_param] = param
+			    	conf[:param] = vald[0][:param]
+			    	conf[:valor] = vald[0][:valor]
+			    	conf[:validacion] = vald[0][:validacion]
+			    	conf[:error] = vald[0][:error]
+			    	conf[:comp] = dato
+			    	conf
+			    end
+			end
+
+			def self.abstract_validation
+				conf = yield
+				if conf[:param_param] == conf[:param]
+					if self.send(conf[:validacion],conf[:comp])
+						return [conf[:error],true] 
+					else
+						return ['',false]
+					end
+				else
+				  return ['',false]
+				end	
+			end
+
+		end
+
+		end
+	end
+end

data/lib/forcast/models/models/meta.rb

@@ -0,0 +1,6 @@
+class Meta < ApplicationRecord
+  include Forcast::Model::Meta
+
+
+
+end

data/lib/forcast/models/paper_trail/paper_trail.rb

@@ -0,0 +1,13 @@
+require 'active_support'
+module Forcast
+  module Model
+    module PaperTrail
+	    extend ActiveSupport::Concern
+
+	    included do
+			has_paper_trail ignore: []
+			#before_action :set_paper_trail_whodunnit     
+	    end
+    end
+  end
+end

data/lib/forcast/models/paper_trail_all.rb

@@ -0,0 +1 @@
+require "forcast/models/paper_trail/paper_trail"

data/lib/forcast/models/permitirtodo.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+module Forcast
+	module Model
+		module Permitirtodo
+		  
+		  extend ActiveSupport::Concern
+
+		  def init
+		  
+
+		  end
+
+		  included do
+
+			  def self.parametros_necesario_create
+				  array = []
+				  return array
+			  end
+
+
+			  def self.params_permitidos_asociar
+				 n = []
+				 self.reflect_on_all_associations(:belongs_to).each do |x|
+					n = n.push(x.name.to_s+'_id')		
+				 end
+			     return params_permitidos_asociar = n
+			  end
+
+			  def self.params_permitidos_agregar
+				 n = []
+				 self.reflect_on_all_associations(:has_many).each do |x|
+					n = n.push(x.name.to_s+'_id')		
+				 end
+			     return params_permitidos_agregar = n
+			  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_create(param, dato)
+			 	return ['',false]
+			  end
+
+			  def self.validaciones_update (param,dato)
+			  	return ['',false]
+			  end
+		  end
+		end
+	end
+end
+

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

@@ -0,0 +1,19 @@
+require 'active_support'
+module Forcast
+  module Model
+  	module RuleEngine
+       module ActionEngine
+	      extend ActiveSupport::Concern
+
+	      included do
+
+	        def self.action_type_allowed
+	          return action_type_allowed = ["callback", "telegram","email"]
+	        end
+	        
+	      end
+
+    	end
+	end
+  end
+end