forcast 0.0.110

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

@@ -0,0 +1,91 @@
+require 'active_support'
+module Forcast
+  module Application
+      module Crud
+
+      extend ActiveSupport::Concern
+
+      included do
+        #before_action :require_login!
+        #before_action :require_admin!, only: [:create, :update, :destroy]
+        before_action :model, :limit_query
+        before_action :jsonparser,:params_to_global, except:[:index, :show]
+        before_action :set_model_id, only: [:show, :update, :destroy]
+        
+      end
+        #model = Metodo que devuelve el objecto ActiveRecord por Nombre del controlador
+        #@model_id = Objecto instanciado por el param ID
+
+        def index
+          # buscar_por_nombre if params_present?('nombre')
+          # buscar_por_parametro_exacto if params_present?('buscar_por') && params_present?('dato')
+          # buscar_por_parametro_contiene if params_present?('buscar_por') && params_present?('contiene')
+
+          #Arreglar HARDCODEO
+          #@response = @model.last(@limit) if controller_name == 'alarmas'
+          meta = Meta::MetaRelation.new(@model)
+          @model = meta.egear_load(@model)
+          @response ||= @model.all.limit(@limit).order('id desc').select(*params_permitidos_enviar).map {|e| e.as_json.merge("meta" => meta.has_relation(e)) }
+          json_response(@response,t("ok"),200)
+        end
+
+        def show
+          meta = Meta::MetaRelation.new(@model)
+          @model = meta.egear_load(@model)
+          @response ||= @model_id.attributes.slice(*params_permitidos_enviar)
+          @response[:meta] = meta.has_relation(@model_id)
+          json_response(@response,t("ok"))
+        end
+
+        def create
+          @create_model = @model.new
+          raise Error::General.new(t("bad_params")) if @model.parametros_estan_create?(@params)
+          #raise Error::General.new(t("bad_name")) if @model.nombre_existe?(@nombre)
+          #raise Error::General.new(t("#{c}.#{a}.bad_custom", param: 'nombre')) if @model.parametro_existe?('nombre',@nombre)
+          ## Metodo General para comprobar parametros de creación
+          comprobar = @model.parametros_existen_create?(params)
+          raise Error::General.new(t("bad_custom", param: comprobar[1])) if comprobar[0]
+          comprobar = @model.parametros_a_validar_create(@datos)
+          raise Error::General.new(t("bad_params_not_allow_custom", param: t(comprobar[1].to_s))) if comprobar[0]
+          @response ||= @create_model
+          @create_model.create(params) ? json_response(@response,t("ok")) : (raise Error::General.new(@create_model.errores))
+          return @create_model
+        end
+
+        def update
+            unless @variable == "all"
+              raise Error::General.new(t("bad_param")) unless params_permitidos_update.include?(@variable)
+              raise Error::General.new(t("bad_param_exists_custom", param: @variable)) if @model.parametro_existe?(@variable,@dato) && @model.parametros_a_comprobar_si_existen_update.include?(@variable)
+              comprobar = @model.validaciones_update(@variable,@dato)
+              raise Error::General.new(t("bad_param_not_allow_custom", param: t(comprobar[0].to_s))) if comprobar[1]
+              @dato = true  if @dato == 'true'
+              @dato = false if @dato == 'false'
+              @model_id.update(Hash[@variable, @dato])
+              #@model_id.update_columns(Hash[@variable, @dato]) 
+            else
+              @datos_mod = @datos.without("variable") 
+              @datos_mod.keys.each do |key|
+                @variable = key
+                @dato = @datos_mod[key]
+                raise Error::General.new(t("bad_param")) unless params_permitidos_update.include?(@variable)
+                raise Error::General.new(t("bad_param_exists_custom", param: @variable)) if @model.parametro_existe?(@variable,@dato) && @model.parametros_a_comprobar_si_existen_update.include?(@variable)
+                comprobar = @model.validaciones_update(@variable,@dato)
+                raise Error::General.new(t("bad_param_not_allow_custom", param: t(comprobar[0].to_s))) if comprobar[1]
+                @dato = true  if @dato == 'true'
+                @dato = false if @dato == 'false'
+              end
+              @model_id.update(@datos_mod)
+              #@model_id.update_columns(@datos_mod)               
+            end
+            @response ||= @model_id.attributes.slice(*params_permitidos_enviar)
+            json_response(@response,t("ok"))
+        end
+
+
+        def destroy
+          @model_id.destroy ? json_response(t("ok"))  : (raise Error::General.new(@model_id.errores))
+        end
+
+      end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Forcast
+	module Application
+		module Database
+			def insert_multiples_object_db_sqlite3(model,array)
+				params = array[0].keys.collect { |x| "'"+x.to_s+"'" }.join(', ').to_s+",'created_at','updated_at'"
+				values = []
+				array.each do |arr|  
+					next if arr.nil?
+				    str = contructor_insert_multiples_object_db_sqlite3(arr.values)
+				    values.push(str)   
+				end
+				values = values.join(",")
+				begin
+					ActiveRecord::Base.connection.execute("INSERT INTO #{model} (#{params}) VALUES #{values}")
+				rescue
+
+				end
+				ActiveRecord::Base.connection.close
+			end
+
+			def contructor_insert_multiples_object_db_sqlite3(array)
+				str = '('
+				array.each do |arr|
+					str += "'"+arr.to_s+"'"+',' 
+				end
+				str += "'"+Time.now.to_s+"'"+','
+				str += "'"+Time.now.to_s+"'"+','
+				str = str[0...-1]
+				str += ')'
+				return str
+			end
+		end
+	end
+end

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

@@ -0,0 +1,18 @@
+module Forcast
+	module Application
+			module Error
+			  class General < StandardError
+
+			    attr_reader :status, :error, :message
+
+			    def initialize(_message=nil)
+			      @message = _message || 'Error General'
+			    end
+
+			    def fetch_json
+			      Helpers::Render.json(error, message, status)
+			    end
+			  end
+			end
+	end
+end

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

@@ -0,0 +1,25 @@
+# app/controllers/concerns/exception_handler.rb
+require 'active_support'
+module Forcast
+  module Application
+      module ExceptionHandler
+        # provides the more graceful `included` method
+        extend ActiveSupport::Concern
+
+        included do
+          rescue_from ActiveRecord::RecordNotFound do |e|
+            json_response({ message: e.message }, :not_found, 404)
+          end
+
+          rescue_from ActiveRecord::RecordInvalid do |e|
+            json_response({ message: e.message }, :unprocessable_entity)
+          end
+
+          rescue_from Error::General do |e|
+            jsonerror_response(e.message)
+          end  
+
+        end
+      end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Forcast
+  module Application
+    module Json
+
+      def json_response(object = '', message = '', status = 200, meta = {})
+      
+           object.is_a?(Hash) ? object = [object]  : object 
+           
+           render json: {
+              object: object,
+              message: message,
+              status: status,
+              meta: meta
+              }, status: status
+      end
+
+      def jsonerror_response(message = '')
+
+        render json: {
+              message: message,
+              status: 400
+              }, status: 400
+
+      end
+
+
+    def json_requestall(object)
+
+      @datos = []
+      @datos = JSON.parse(object) if valid_json?(object)
+      @params = []
+      @params_data = []
+      @datos.each do |datos|
+
+        unless datos[0].nil?  || datos [1].nil?
+          symbol = datos[0]
+  		####     
+          @params.push(symbol)
+          @params_data.push(datos [1])
+          next if symbol.include?('?')
+          instance_variable_set("@#{symbol}", datos[1])
+        end
+
+      end 
+     
+    end
+
+
+    #convierto los parametros en variable globales @
+    def params_to_global
+  	@params = []
+  	@params_data = []
+    	params.each do |key, value|
+    		@params.push(key)
+    		@params_data.push(value)
+        next if key.include?('?')
+        instance_variable_set("@#{key}", value)
+    	end
+
+    end
+    
+
+    def jsonparser
+
+    data = request.body.read
+    json_requestall(data)
+
+    end
+
+
+    def valid_json?(json)
+        JSON.parse(json)
+        return true
+      rescue JSON::ParserError => e
+        return false
+    end
+
+
+
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'active_support'
+module Forcast
+	module Application
+		module Locale
+
+			extend ActiveSupport::Concern
+
+			included do
+				before_action :set_locale
+			end
+			def set_locale
+			   I18n.locale = I18n.default_locale
+			end
+
+			def t (s,custom='')
+				str = c + '.' + a + '.'+s
+				return I18n.t(str,custom)
+			end
+			
+			def c
+				return controller_name
+			end
+
+			def a
+				return action_name
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,22 @@
+require 'active_support'
+module Forcast
+	module Application  
+	  module Log
+
+		  extend ActiveSupport::Concern
+		  included do
+		    around_action :global_request_logging
+		  end
+	  
+		  def global_request_logging 
+		    #logger.info "USERAGENT: #{request.headers['HTTP_USER_AGENT']}"
+		    begin 
+		      yield 
+		    ensure 
+		      #logger.info "response_status: #{response.status}"
+		    end 
+		  end 
+
+	  end
+	end
+end

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

@@ -0,0 +1,41 @@
+module Forcast
+  module Application
+    module Login
+      
+    	def require_login!
+        authenticate_token
+    	end
+
+      def require_admin!
+        raise Application::Error::General.new(t("required_admin")) unless current_user.class.name == ENV('login_admin')
+      end
+
+    	def current_user
+      	@current_user
+    	end
+
+    		private
+        
+      def authenticate_token
+        headers_require
+        authenticate_with_http_token do |token, options|
+          models = ENV('login_models').split(":")
+          models.each do |model|
+            next if @current_user
+            @current_user = model.classify.constantize.where(auth_token: token).first
+          end
+          raise Application::Error::General.new(t("error_with_auth")) unless @current_user
+          raise Application::Error::General.new(t("token_expire")) if @current_user[:token_created_at] < ENV('login_expire_session').to_i.send(ENV('login_time_expire_session')).ago
+          @current_user.update_columns(Hash["last_connection", DateTime.now]) if @current_user
+          return @current_user
+        end     
+      end 
+
+      def headers_require
+        auth = request.headers["Authorization"]
+        raise Application::Error::General.new(t("error_with_headers")) if auth.nil?
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'active_support'
+module Forcast
+  module Application
+      module Meta
+
+        extend ActiveSupport::Concern
+
+        included do
+             
+        
+        end
+
+        class MetaRelation    
+          attr_accessor :class_name
+          attr_accessor :belongs_to
+          attr_accessor :has_many
+
+          def initialize(e)
+            self.class_name = e.to_s
+            self.belongs_to = e.reflect_on_all_associations(:belongs_to).map { |e| e.name.to_s }
+            self.has_many = e.reflect_on_all_associations(:has_many).map { |e| e.name.to_s }
+            #e.includes(self.belongs_to + self.has_many)
+          end
+
+          def has_relation(model)
+            rel = Hash.new
+            rel[:has_relation] = {}
+            rel[:has_relation][:belongs_to] = []
+            rel[:has_relation][:has_many] = []
+            self.belongs_to.each do |relation|
+              object = model.send(relation)
+              unless object.blank?
+                sender = [object].map {|e| e}
+                #object.is_a?(Array) ? sender = object.map {|e| e.as_json["id"]} : sender = [object].map {|e| e.as_json["id"]}
+                rel[:has_relation][:belongs_to].push({related_to: relation.to_s.pluralize, label: relation.to_s.pluralize.capitalize, ids: sender})
+              end
+            end
+            self.has_many.each do |relation|
+              object = model.send(relation)
+              ##Return 'Array' Coleection Proxy
+              unless object.blank?
+                sender = object.map {|e| e}
+                #object.is_a?(Array) ? sender = object.map {|e| e.as_json["id"]} : sender = [object].map {|e| e.as_json["id"]}
+                rel[:has_relation][:has_many].push({related_to: relation.to_s.pluralize, label: relation.to_s.pluralize.capitalize, ids: sender})
+              end
+            end
+            return rel
+          end
+
+          def egear_load(model)
+            model.includes(self.belongs_to + self.has_many)
+          end   
+
+          # def meta_child(model)
+          #   {hasChild:  [{ relatedTo: "plants", childResource: "edificio"}]}
+          # end   
+
+        end
+      end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Forcast
+	module Application
+		module Model
+
+			def model
+				@model ||= controller_name.classify.constantize 
+			end
+
+			def set_model_id
+				#instance_variable_set("@#{c.chomp('s')}", model.find(params[:id]))
+		 		return if params[:id_mongo] #This is for mongo db or another database
+		 		@model_id ||= model.find(params[:id])
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,27 @@
+module Forcast
+  module Application
+  	module Permitirtodo
+  	
+  	  def params_permitidos_enviar
+        return params_permitidos_enviar = controller_name.classify.constantize.column_names + assoc
+      end
+
+      def params_permitidos_update
+         return params_permitidos_update = controller_name.classify.constantize.column_names + assoc
+      end
+
+      def params_permitidos_buscar 
+         return params_permitidos_buscar = controller_name.classify.constantize.column_names + assoc
+      end
+
+      def assoc
+        nn = []
+        controller_name.classify.constantize.reflect_on_all_associations(:belongs_to).each do |x|
+          nn = nn.push(x.name.to_s + '_id')  
+        end
+        return nn
+      end
+
+  	end
+  end
+end