forcast 0.0.110

data/lib/forcast/controllers/application/utils.rb

@@ -0,0 +1,28 @@
+module Forcast
+	module Application
+		module Utils
+
+		private
+
+			def limit_query
+
+				@limit = nil		
+				@limit = params[:limit] if params[:limit].present?
+				@limit_nested = nil
+				@limit_nested = params[:limit_nested] if params[:limit_nested].present?
+			end
+
+			def params_present? (param)
+				true if params[param].present? 
+			end
+
+			def abstract_controller (model)
+
+	        	controller_path.tableize.gsub!(controller_name, model+ "s_controller").classify.constantize 
+
+			end
+
+
+		end
+	end
+end

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

@@ -0,0 +1,8 @@
+require "forcast/controllers/controller/asociar"
+require "forcast/controllers/controller/busqueda"
+require "forcast/controllers/controller/filtro"
+require "forcast/controllers/controller/relacion"
+require "forcast/controllers/controller/definitor_all"
+require "forcast/controllers/controller/rule_engine_all"
+require "forcast/controllers/controller/paper_trail_all"
+require "forcast/controllers/controller/login_all"

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

@@ -0,0 +1,121 @@
+require 'active_support'
+
+module Forcast
+	module Controller
+		module Asociar
+
+		extend ActiveSupport::Concern
+
+		included do
+
+			before_action :raise_error_asociar, only: [:ver_no_asociados_a, :ver_asociado_a, :asociar_a, :desasociar_de]
+			before_action :raise_error_agregar, only: [:agregar_asociado, :quitar_asociado]
+			## Sobre escribre todos los metodos anteriores.... hay que buscar una forma de arreglarlo
+			## Solucion por ahora es cambiar el nombre a los metodos
+			before_action :set_model_id_asociar, only: [:ver_asociado_a, :asociar_a, :agregar_asociado, :desasociar_de, :quitar_asociado]
+		end
+		#Collection
+		def ver_no_asociados_a
+
+			@response = model.no_asociados_a(@modelo + "_id")
+			json_response(@response.select(*params_permitidos_enviar),t("ok")) 
+
+		end
+		#Member
+		def ver_asociado_a
+			
+			 @response = @model_id.ver_asociado(@modelo)
+	         params_permitidos_enviar = abstract_controller(@modelo).new.send (:params_permitidos_enviar)
+			 json_response(@response.select(*params_permitidos_enviar),t("ok")) 
+
+		end
+
+		def asociar_a
+
+			raise Application::Error::General.new(t("error_relation_already_taken", param: params[:modelo])) unless @model_id.asociado_a?(@modelo+'_id', @modelo_id)
+			raise Application::Error::General.new(t("error_relation_model_id_doesnt_exist", param: params[:modelo])) unless @model_id.asociado_existe?(@modelo, @modelo_id)
+			@model_id.asociar_a(@modelo+'_id', @modelo_id)
+			json_response(@model_id.attributes.slice(*params_permitidos_enviar),t("ok")) 
+				
+		end
+
+		def desasociar_de
+
+			@model_id.desasociar_de(@modelo+'_id')
+			json_response(@model_id.attributes.slice(*params_permitidos_enviar),t("ok")) 
+
+		end
+
+		def agregar_asociado
+			
+			@response = []
+			@modelo_id.is_a?(Array) ? @modelo_id : @modelo_id = [@modelo_id]
+			@modelo_id.each do |modelo_id|
+			    #raise Application::Error::General.new(t("error_relation_already_taken", param: [params[:modelo],modelo_id])) unless @model_id.agregar_asociado_a?(@modelo, modelo_id)
+				raise Application::Error::General.new(t("error_relation_model_id_doesnt_exist", param: [params[:modelo],modelo_id])) unless @model_id.asociado_existe?(@modelo,modelo_id)
+				@model_id.agregar_asociado(@modelo, modelo_id)	
+				paso = c_to_m(@modelo).find(modelo_id)
+				params_permitidos_enviar = abstract_controller(@modelo).new.send (:params_permitidos_enviar)
+				@response.push(paso.attributes.slice(*params_permitidos_enviar))
+			end
+			json_response(@response,t("ok")) 
+		
+		end
+
+		def quitar_asociado
+
+			@response = []
+			@modelo_id.is_a?(Array) ? @modelo_id : @modelo_id = [@modelo_id]
+			@modelo_id.each do |modelo_id|
+			    #raise Application::Error::General.new(t("error_relation_already_taken", param: [params[:modelo],modelo_id])) unless @model_id.agregar_asociado_a?(@modelo, modelo_id)
+				raise Application::Error::General.new(t("error_relation_model_id_doesnt_exist", param: [params[:modelo],modelo_id])) unless @model_id.asociado_existe?(@modelo,modelo_id)
+				@model_id.quitar_asociado(@modelo, modelo_id)	
+				paso = c_to_m(@modelo).find(modelo_id)
+				params_permitidos_enviar = abstract_controller(@modelo).new.send (:params_permitidos_enviar)
+				@response.push(paso.attributes.slice(*params_permitidos_enviar))
+			end
+			json_response(@response,t("ok")) 
+		
+		end
+
+
+		def modelo_db
+
+			n = []
+			nn = []
+			model.reflect_on_all_associations(:has_many).each do |x|
+				n = n.push(x.name.to_s.classify)		
+			end
+			model.reflect_on_all_associations(:belongs_to).each do |x|
+				nn = nn.push(x.name.to_s.classify)	
+			end
+			rep = {model:model.name,belongs_to: nn, has_many: n}
+			json_response(rep,t("ok")) 
+				
+		end
+
+
+		def raise_error_asociar
+
+			raise Application::Error::General.new(t("error_relation", param: params[:modelo])) unless comprobar_relacion(:belongs_to, @modelo)
+			raise Application::Error::General.new(t("error_relation_not_permitted", param: params[:modelo])) unless model.params_permitidos_asociar.include?(@modelo+'_id')
+
+		end
+
+		def raise_error_agregar
+
+			raise Application::Error::General.new(t("error_relation", param: params[:modelo])) unless comprobar_relacion(:has_many, @modelo)
+			raise Application::Error::General.new(t("error_relation_not_permitted", param: params[:modelo])) unless model.params_permitidos_agregar.include?(@modelo+'_id')
+
+		end
+
+		def set_model_id_asociar
+				
+		 		@model_id ||= model.find(params[:id])
+		end
+
+
+		end
+
+	end
+end

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

@@ -0,0 +1,151 @@
+module Forcast
+	module Controller
+		module Busqueda
+		  
+		    def index
+		      params[:dato] = true  if params[:dato] == 'true'
+	          params[:dato] = false if params[:dato] == 'false'
+		      params[:contiene] = true  if params[:dato] == 'true'
+	          params[:contiene] = false if params[:dato] == 'false'
+	                    
+		      buscar_relaciones if params_present?('relacion') && !params_present?('buscar_por') && !params_present?('dato')
+		      es_array_buscar_por_parametro_exacto if params_present?('buscar_por') && params_present?('dato')
+		      es_array_buscar_por_parametro_contiene if params_present?('buscar_por') && params_present?('contiene')
+
+		      super()
+		    end
+
+		    def show
+		      buscar_relaciones if params_present?('relacion') && !params_present?('buscar_por') && !params_present?('dato')
+		      super()
+		    end
+
+		private
+
+			def es_array_buscar_por_parametro_exacto
+
+				buscar_por = params[:buscar_por]
+				dato 	   = params[:dato]
+				buscar_por.is_a?(Array) ? array_buscar_por_parametro_exacto(buscar_por,dato) : buscar_por_parametro_exacto(buscar_por,dato)
+
+			end
+
+			def es_array_buscar_por_parametro_contiene
+
+				buscar_por = params[:buscar_por]
+				contiene 	   = params[:contiene]
+				buscar_por.is_a?(Array) ? array_buscar_por_parametro_contiene(buscar_por,contiene) : buscar_por_parametro_contiene(buscar_por,contiene)
+
+			end
+
+			def array_buscar_por_parametro_exacto (buscar_por, dato)
+				raise Application::Error::General.new(t("error_same_length_array")) unless buscar_por.length == dato.length
+				response = []
+				buscar_por.each_with_index do |b,index|
+					response[index] = buscar_por_parametro_exacto(b,dato[index])
+				end
+				paso = []
+				response = response.inject(:&) if params[:join].to_s == 'false'  
+				response = [response] unless response.is_a?(Array)
+				response.each_with_index do |rr,index|
+					rr = [rr] unless rr.is_a?(Array)
+					rr.each do |r|
+						paso.push(r)
+					end
+				end
+				@response = paso.uniq
+			end
+
+			def array_buscar_por_parametro_contiene (buscar_por, contiene)
+				raise Application::Error::General.new(t("error_same_length_array")) unless buscar_por.length == contiene.length
+				response = []
+				buscar_por.each_with_index do |b,index|
+					response[index] = buscar_por_parametro_contiene(b,contiene[index])
+				end
+				paso = []
+				response = response.inject(:&) if params[:join].to_s == 'false'  
+				response = [response] unless response.is_a?(Array)
+				response.each do |rr|
+					rr = [rr] unless rr.is_a?(Array)
+					rr.each do |r|
+						paso.push(r)
+					end
+				end
+				@response = paso.uniq
+			end
+
+			def buscar_por_parametro_exacto (buscar_por, dato)
+			  	raise Application::Error::General.new(t("error_search_param", param: buscar_por)) unless params_permitidos_buscar.include?(buscar_por)
+			  	raise Application::Error::General.new(t("error_find_param", param: buscar_por)) unless @model.parametro_existe?(buscar_por,dato)
+				resp = @model.buscar_parametro_exacto_scope(buscar_por,dato).limit(@limit).order('id desc').select(*params_permitidos_enviar)
+				params_present?('relacion') ? @response = buscar_relacion(resp,params[:relacion]) : @response = resp
+			end
+			
+			def buscar_por_parametro_contiene (buscar_por, contiene)
+				raise Application::Error::General.new(t("error_search_param", param: buscar_por)) unless params_permitidos_buscar.include?(buscar_por)
+				resp = @model.buscar_parametro_contiene_scope(buscar_por,contiene).limit(@limit).order('id desc').select(*params_permitidos_enviar)
+				params_present?('relacion') ? @response = buscar_relacion(resp,params[:relacion]) : @response = resp
+			end
+
+			def buscar_relaciones			
+				resp = @model.all if @model
+				resp = [@model_id] if @model_id
+				@response = buscar_relacion(resp,params[:relacion])
+			end
+			
+			#Ver si es posible mejorar este metodo, se podria realizar una unica consulta
+			#a la DB para tener todos los registro de toda la tabla
+			def buscar_relacion(resp,rel)
+				return buscar_relacion_array(resp,rel) if rel.is_a?(Array)
+				#p Api::CamarasController.name.tableize.gsub!('camaras', 'hubs').classify
+				comprobar_relacion_buscar(rel)
+				array = []
+				
+				resp.each do |x|
+					array.push(
+					{
+					controller_name.classify => [x.attributes.slice(*params_permitidos_enviar)],
+					rel.classify => x.send(rel).limit(@limit_nested).select(*@params_permitidos_enviar)
+					}					
+					)
+				end
+				return array
+			end
+			
+			def buscar_relacion_array(resp,rels)
+
+				 array = [Hash.new]
+				 rels.each do |rel|
+					i = 0
+					comprobar_relacion_buscar(rel)
+					resp.each_with_index do |x,index|
+						array[index] = {} if array[index].nil?
+						array[index].merge!({controller_name.classify => [x.attributes.slice(*params_permitidos_enviar)]}) if i == 0
+						array[index].merge!({
+										rel.classify => x.send(rel)
+										 				 .limit(@limit_nested)
+										                 .select(*@params_permitidos_enviar)
+							})
+									
+					end
+					i += 1
+
+				 end
+
+				 return array
+
+			end
+
+			def comprobar_relacion_buscar (rel)
+				begin
+					@params_permitidos_enviar = abstract_controller(rel).new.send (:params_permitidos_enviar)
+				rescue NameError => e
+					raise Application::Error::General.new(t("error_relation_param", param: rel))
+				end
+				raise Application::Error::General.new(t("error_relation_param", param: rel)) unless comprobar_relacion(:has_many, rel)
+
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,322 @@
+module Forcast
+  module Controller
+    module Definitor
+      def definitor
+        raise Application::Error::General.new(t("operation_notValid")) unless permitted_definition.include?(@operation)
+        if @operation == 'put' || @operation == 'patch' || @operation == 'edit'
+          @operation = 'put_or_patch'
+        end
+        @response = send("#{@operation}_view_definitor")
+        json_response(@response, 'ok')
+      end
+
+      def permitted_definition
+        %w[create show put patch edit delete wizard info info_table card association webhook]
+      end
+
+      def selected_definitions(*selected)
+        all_definitions.slice(*selected)
+      end
+
+      def excluded_definitions(*selected)
+        all_definitions.except(*selected)
+      end
+
+      def selected_serializer_definitions(*selected)
+        serializer(all_definitions.slice(*selected))
+      end
+
+      def selected_serializer_definitions_mongo(*selected)
+        serializer_mongo(all_definitions.slice(*selected))
+      end
+
+
+      def excluded_serializer_definitions(*selected)
+        serializer(all_definitions.except(*selected))
+      end
+
+      def all_serializer_definitions
+        serializer(all_definitions)
+      end
+
+      def all_definitions(name_controller = nil)
+        name_controller = controller_name if name_controller.nil?
+        model = name_controller.classify.constantize
+        attrs = model.attribute_names.map { |n| [n.to_sym, model.type_for_attribute(n).type] }.to_h
+        model.reflect_on_all_associations(:belongs_to).each do |relation|
+          relation = relation.name.to_s + '_id'
+          attrs[relation.to_sym] = 'relation'
+        end
+        attrs
+      end
+
+      def selected_info_serializer_definitions(*selected)
+        serializer_info(all_definitions.slice(*selected))
+      end
+
+      def serializer_info(object)
+          definitor = []
+          keys = object.keys
+          keys.each do |key|
+            type = object[key]
+            result = send("definitor_#{type}", key.to_s, type)
+            sender = {key: key, type: result[:typeAttribute], label: result[:label]}
+            definitor.push(sender)
+          end
+          definitor
+      end
+
+      def selected_association_serializer_definitions(*selected)
+          serializer_association(all_definitions.slice(*selected))
+      end
+
+      def serializer_association(object)
+          definitor = []
+          keys = object.keys.map {|e| e.to_s.gsub('_id', 's')}
+          sender = {type: "select", label: "Resource", 
+                    name: "resource", required: false, disabled: false, 
+                    options: keys
+                  }
+          definitor.push(sender)
+          keys.each do |key|
+            model = key[0...-1].classify.constantize
+            args =[:id]
+            if model.attribute_names.include?('name')
+              args.push(:name) 
+            elsif model.attribute_names.include?('serie')
+              args.push(:serie) 
+            elsif model.attribute_names.include?('model')
+              args.push(:model)
+            end
+            options = model.all.pluck(*args).map { |e| e.size == 2 ? {id: e[0], label: e[1]} : {id: e} }
+            sender = {type: "dataselect", label: "ID", 
+                      name: key[0...-1]+'_id', required: false, disabled: true, 
+                      options: options
+                      }
+            definitor.push(sender)
+          end
+          definitor
+      end
+
+      def selected_association_serializer_definitions_mongo(*selected)
+          serializer_association_mongo(all_definitions.slice(*selected))
+      end
+
+      def serializer_association_mongo(object)
+          definitor = []
+          keys = object.keys.map {|e| e.to_s.gsub('_id', 's')}
+          sender = {type: "select", label: "Resource", 
+                    name: "resource", required: false, disabled: false,  
+                    options: keys
+                  }
+          definitor.push(sender)
+          keys.each do |key|
+            model = (key[0...-1]+'_mongo').classify.constantize
+            args =[:_id]
+            if model.attribute_names.include?('name')
+              args.push(:name) 
+            elsif model.attribute_names.include?('serie')
+              args.push(:serie) 
+            elsif model.attribute_names.include?('model')
+              args.push(:model)
+            end
+            options = model.all.pluck(*args).map { |e| e.is_a?(Array) ? {id: e[0].to_s, label: e[0].to_s.last(5)+' - '+e[1].to_s} : {id: e.to_s, label: e.to_s.last(5)+' - '+model.to_s } }
+            sender = {type: "dataselect", label: "ID", 
+                      name: key[0...-1]+'_id', required: false, disabled: true, 
+                      options: options
+                      }
+            definitor.push(sender)
+          end
+          definitor
+      end
+
+      def serializer(object)
+        definitor = []
+        object.delete(:id) if params[:operation] == 'create'
+        keys = object.keys
+        keys.each do |key|
+          type = object[key]
+          result = send("definitor_#{type}", key.to_s, type)
+          definitor.push(result)
+        end
+        definitor
+      end
+
+      def serializer_mongo(object)
+        definitor = []
+        object.delete(:id) if params[:operation] == 'create'
+        keys = object.keys
+        keys.each do |key|
+          type = object[key]
+          result = send("definitor_#{type}", key.to_s, type)
+          result = send("definitor_#{type}_mongo", key.to_s, type) if type == 'relation'
+          definitor.push(result)
+        end
+        definitor
+      end
+
+      def constructor(key, type)
+        result = Hash.new
+        result[:label] = key.titleize
+        result[:typeAttribute] = type
+        result[:name] = key
+        result[:required] = model.parametros_necesario_create.include?(key)
+        yield(result)
+        result
+      end
+
+      def definitor_datetime(key, type)
+        constructor(key, type) do |result|
+          result[:type] = 'date'
+        end
+      end
+
+      def definitor_decimal(key, type)
+        constructor(key, type) do |result|
+          result[:type] = 'input'
+          result[:inputType] = 'number'
+        end
+      end
+
+      def definitor_relation(key, type)
+        constructor(key, type) do |result|
+          controller_name = key.gsub('_id', '')
+          model = controller_name.singularize.classify.constantize
+          args =[:id]
+          if model.attribute_names.include?('name')
+            args.push(:name) 
+          elsif model.attribute_names.include?('serie')
+            args.push(:serie) 
+          elsif model.attribute_names.include?('model')
+              args.push(:model)
+          end
+          options = model.all.pluck(*args).map { |e| e.size == 2 ? {id: e[0], label: e[1]} : {id: e, label: controller_name.singularize.classify } }
+          result[:type] = "dataselect"
+          result[:label] = controller_name.singularize.classify
+          result[:disabled] = true
+          result[:options] = options
+          result[:typeAttribute] = "string"
+        end
+      end
+
+      def definitor_relation_mongo(key, type)
+        constructor(key, type) do |result|
+          controller_name = key.gsub('_id', '') + '_mongo'
+          model = (controller_name).singularize.classify.constantize
+          args =[:id]
+          if model.attribute_names.include?('name')
+            args.push(:name) 
+          elsif model.attribute_names.include?('serie')
+            args.push(:serie) 
+          elsif model.attribute_names.include?('model')
+              args.push(:model)
+          end
+          options = model.all.pluck(*args).map { |e| e.is_a?(Array) ? {id: e[0].to_s, label: e[0].to_s.last(5)+' - '+e[1].to_s} : {id: e.to_s, label: e.to_s.last(5)+' - '+model.to_s } }
+          result[:type] = "dataselect"
+          result[:label] = key.singularize.classify
+          result[:disabled] = true
+          result[:options] = options
+        end
+      end
+
+      def definitor_integer(key, type)
+        constructor(key, type) do |result|
+          result[:type] = 'input'
+          result[:inputType] = 'number'
+        end
+      end
+
+      def definitor_password(key, type)
+        constructor(key, type) do |result|
+          result[:type] = 'input'
+          result[:inputType] = 'password'
+        end
+      end
+
+      def definitor_random_string(key, type)
+        constructor(key, type) do |result|
+          random_string_type(result)
+        end
+      end
+
+      def definitor_string(key, type)
+        constructor(key, type) do |result|
+          input_type(result)
+        end
+      end
+
+      def definitor_text(key, type)
+        constructor(key, type) do |result|
+          input_type(result)
+        end
+      end
+
+      def definitor_boolean(key, type)
+        constructor(key, type) do |result|
+          result[:type] = 'checkbutton'
+        end
+      end
+
+      def definitor_json(key, type)
+        constructor(key, type) do |result|
+          result[:key] = key
+          result[:type] = 'json'
+          result[:inputType] = 'text'
+          result[:label] = key.classify
+          result[:typeAttribute] = 'string'
+          result[:name] = key.to_s
+          result[:meta] = {
+                          selectItem: {
+                            type: 'select',
+                            label: key.classify,
+                            name: key.to_s+'Key',
+                            required: false,
+                            options: []
+                          },
+                          areaItem: {
+                            type: 'input',
+                            inputType: 'text',
+                            label: key.classify,
+                            typeAttribute: 'string',
+                            name: key.to_s+'Value',
+                            required: false,
+                          }
+                          }      
+        end
+      end
+
+      def definitor_with_options(type, object, array, value)
+        object = all_definitions.slice(object)
+        key = object.keys.first.to_s
+        definition_result = constructor(key, object[key]) do |result|
+          send("#{type}_type", result, array, value)
+        end
+        [definition_result]
+      end
+
+      def random_string_type(result)
+        list = ['radiobutton','input','select']
+        number = rand(0...3)
+        type = list[number]
+        send("#{type}_type", result, ['Opt1', 'Opt2'], 'Opt1')
+      end
+
+      def select_type(result, array, value)
+        result[:type] = 'select'
+        result[:options] = array
+        result[:value] = value
+      end
+
+      def input_type(result, array='', value='')
+        result[:type] = 'input'
+        result[:inputType] = 'text'
+      end
+
+      def radiobutton_type(result, array, value)
+        result[:type] = 'radiobutton'
+        result[:options] = array
+        result[:value] = value
+      end
+    end
+  end
+end