forcast 0.0.110

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

@@ -0,0 +1,40 @@
+module Forcast
+  module Controller
+    module DefinitorPage
+      include Definitor
+
+      def definitor
+        raise Application::Error::General.new(t("operation_notValid")) unless permitted_definition.include?(@operation)
+        @response = send("#{@operation}_view_definitor")
+        json_response(@response, 'ok')
+      end
+
+      def permitted_definition
+        %w[wizard]
+      end
+
+      def wizard_create_resources_definitor(*args)
+        wizard = Hash.new
+        wizard[:type] = 'stepper'
+        wizard[:name] = 'stepper'
+        wizard[:label] = 'test stepper'
+        wizard[:inputType] = 'string'
+        wizard[:wizard] = *args.map {|e| constructor_wizard_create(e) }
+        wizard[:wizard].push({labelStepper: 'Done',fields: []})
+        wizard
+      end
+
+      def constructor_wizard_create(e)
+        key = e.keys.first
+        selected = e[key]
+        result = Hash.new
+        result[:labelStepper] = "Create #{key.to_s.pluralize.capitalize}"
+        result[:resource] = key.to_s.pluralize
+        result[:fields] = serializer_mongo(all_definitions(key.to_s).slice(*selected))
+        result
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+require "forcast/controllers/controller/definitor/definitor"
+require "forcast/controllers/controller/definitor/definitor_page"

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

@@ -0,0 +1,48 @@
+module Forcast
+	module Controller
+		module Filtro
+		  
+		    def index
+		      filtrar_por if params_present?('filtrar_modelo') && params_present?('filtrar_por') && params_present?('filtro') && !params_present?('relacion') 
+		      deep_filtrar_por if params_present?('relacion') && params_present?('filtrar_modelo') && params_present?('filtrar_por') && params_present?('filtro')
+		      super()
+		    end
+
+		private
+
+			def filtrar_por
+
+				comprobar_filtrar_por
+				@response ||= @model.all
+				@response = @model.where(id: @response.pluck(:id))
+				@response = @response.includes(params[:filtrar_modelo])
+							.where( params[:filtrar_modelo]+'s' => { params[:filtrar_por] => params[:filtro] })
+							.last(@limit).pluck_to_hash(*params_permitidos_enviar)
+				
+			end
+
+			#Si el metodo tiene la relacion activada
+			#Se trabaja con el array que proviene de buscar incluyendo relacion
+			#Se verifican las id que cumplan el criterio y luego se limpia el array de buscar / relacion
+			def deep_filtrar_por
+
+				comprobar_filtrar_por
+				paso = @model.where( :id => @response.map { |e| e[@model.to_s]['id']  })
+				paso2 = paso.includes(params[:filtrar_modelo])
+							.where( params[:filtrar_modelo]+'s' => { params[:filtrar_por] => params[:filtro] })
+							.last(@limit).pluck(:id)
+
+				@response = @response.map{ |e| e if paso2.include?(e[@model.to_s]['id']) }
+				@response = @response.compact 
+			end
+
+			def comprobar_filtrar_por
+				raise Application::Error::General.new(t("error_relation_param", param: params[:filtrar_modelo])) unless comprobar_relacion(:has_many, params[:filtrar_modelo])
+				params_permitidos_filtrar = abstract_controller(params[:filtrar_modelo]).new.send (:params_permitidos_buscar)
+				raise Application::Error::General.new(t("error_filter_model_param", param: [params[:filtrar_modelo],params[:filtrar_por]])) unless params_permitidos_filtrar.include?(params[:filtrar_por])
+			end
+
+		end
+	end
+end
+

data/lib/forcast/controllers/controller/login/controllers/base_controller.rb

@@ -0,0 +1,135 @@
+module Api
+  class BaseController < ActionController::Base
+
+    before_action :check_authorization_presence, only: [:check_token_format,:authenticate]
+    before_action :authenticate, except: [:sign_in,:sign_out]
+    before_action :check_token_presence, except: [:sign_in,:sign_out]
+    before_action :check_token_revoke_format, only: [:sign_out]
+    #before_action :init_user
+
+    attr_reader :current_user
+
+    protected
+
+    # Check Methods
+    def check_content_type_presence
+      if request.method == "POST" || request.method == "PATCH"
+        unless request.env['CONTENT_TYPE'].present?
+          render json:{errors:[{title:'Content Type',
+                                detail:"The content type is not present",
+                                source:"Header content type" }]}, status: :bad_request
+        end
+      end
+    end
+
+    def check_token_presence
+      #Check presence and format token
+      if !(request.env['HTTP_AUTHORIZATION'].present?) && !(request.env['HTTP_AUTHORIZATION'].is_a?(String)) && ((request.env['HTTP_AUTHORIZATION'] =~ /Bearer [.]*/) != 0)
+        render json:{errors:[{title:'Http Authorization',
+                              detail:"The http authorization is not present or the format is not  valid, please check your header or the expected format",
+                              source:"Header AUTHORIZATION" }]}, status: :bad_request
+      end
+    end
+
+    def check_token_format
+      #Authorization: Bearer e9629c2a-6763-45f4-9d3a-1b2c7822febe
+      authorization = request.env['HTTP_AUTHORIZATION']
+
+      #TODO: Manage the error when the split can't be executed
+      options = authorization.split(' ')
+
+      bearer_param = options.first
+      token_param = options.second
+
+      if bearer_param.blank? && token_param.blank? && (bearer_param != "Bearer" || token_param.blank?)
+        render json:{errors:[{title:'Authorization Format Token',
+                              detail:"The format token is not valid, please check it",
+                              source:"data/attributes/authorization" }]}, status: :bad_request
+
+      end
+    end
+
+    def check_authorization_presence
+      unless request.env['HTTP_AUTHORIZATION'].present?
+        render json:{errors:[{title:'Authorization Header',
+                              detail:"The Authorization header is not present",
+                              source:"data/headers" }]}, status: :bad_request
+      end
+
+    end
+
+    def check_token_revoke_format
+      token = token_in_params
+
+      if !(token.present?) && !(token.is_a?(String)) && ((token =~ /Bearer [.]*/) != 0)
+        render json:{errors:[{title:'Token presence or format',
+                              detail:"The token is not present or the format is not  valid, please check your params or the expected format",
+                              source:"Token Params" }]}, status: :bad_request
+      end
+    end
+
+    #Action Methods
+    def authenticate
+      authorization = request.env['HTTP_AUTHORIZATION']
+
+      options = authorization.split(' ')
+
+      bearer_param = options.first
+      token_param = options.last
+
+      decoded_token = JsonWebToken.decode(token_param)
+
+      if decoded_token.blank?
+        render_access_denied
+      else
+        user_id = decoded_token[:user_id]
+        created_at_format = decoded_token[:birthday_date]
+        expiration_time = Time.at(decoded_token[:exp])
+
+        #Trick to located the token, it should be created_at
+        created_at = Time.parse(created_at_format)
+        auth = Authorization.find_by(user_id:user_id,active_time_stamp:created_at.to_i)
+
+        #TODO: Check how to use the operative attribute in Authorization model
+
+        if auth.blank? || !auth.try(:operative)
+          render json:{errors: [{message:"No estás autorizado a entrar", code:401}]}, status: :unauthorized
+        else
+          @current_user = User.find(decoded_token[:user_id])
+        end
+      end
+
+    end
+
+    #Methods for authorizations
+    def get_plants
+      if @current_user.rol_5s == User::USER_ROLES[:auditor] || @current_user.rol_5s == User::USER_ROLES[:supervisor]
+        [PlantService.get_plant(@current_user)["object"]]
+      elsif @current_user.rol_5s == User::USER_ROLES[:corporative]
+        PlantService.get_plants["object"]
+      end
+    end
+
+    #Methods for authorizations
+    def current_plant_id
+      puts "#NOMBRE => #{@current_user.userccu}, ROL => #{@current_user.rol_5s}"
+      if @current_user.rol_5s == User::USER_ROLES[:auditor] || @current_user.rol_5s == User::USER_ROLES[:supervisor]
+        @current_user.plant_id
+      elsif @current_user.rol_5s == User::USER_ROLES[:corporative]
+        puts "SOY CORPORATIVO"
+        params[:id]
+      end
+    end
+
+    #Acordarse de borrar
+    def init_user
+      puts controller_name
+      if params[:user_id]
+        @current_user = User.find_by(:instance_id => params[:user_id])       
+      elsif params[:id] && controller_name == 'users'
+        @current_user = User.find_by(:instance_id => params[:id]) if params[:id] 
+      end  
+    end
+
+  end
+end

data/lib/forcast/controllers/controller/login/controllers/login_controller.rb

@@ -0,0 +1,38 @@
+class Api::LoginController < ApplicationController
+
+include Forcast::Controller::Login
+
+private
+
+
+def validaciones_login (user)
+
+#raise Application::Error::General.new(t("error_bad_custom")) if  user.class.name == "Administrador"
+
+
+end
+
+
+
+def modelo_a_validar
+
+
+return modelo_a_validar =  []
+
+
+
+end
+
+def modelo_login
+
+
+return modelo_login =  []
+
+
+
+end
+
+
+
+
+end

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

@@ -0,0 +1,71 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module Login
+		
+		extend ActiveSupport::Concern
+
+		  included do
+
+		  	before_action :set_user, only: [:create_login, :destroy_login]
+
+		  end
+		  
+		  def create_login
+		    raise Application::Error::General.new(t("error_bad_password")) unless @user.is_password?(params[:password])
+			validaciones_login(@user)
+			h = Hash.new
+			h["auth_token"] = @user.generate_auth_token
+			h["token_telefono"] = @token_telefono
+			json_response(h,t("login_ok"))
+		  end
+
+
+		  def destroy_login
+		    raise Application::Error::General.new(t("error_bad_password")) unless @user.is_password?(params[:password])
+		    validaciones_login(@user)
+		    @user.invalidate_auth_token
+		   	json_response('',t("logout_ok")) 
+		  end
+
+
+		 private
+
+		    def set_user
+		    	    
+		    	@variable = params[:variable]
+			    @dato = params[:dato]
+			    #raise Application::Error::General.new(t("error_present_mail")) unless params[:mail].present?
+			    raise Application::Error::General.new(t("error_present_password")) unless params[:password].present?
+			    set_user_using_model if params[:model].present?
+			    mm = ''
+			    modelo_a_validar.each do |x|
+			    	mm = c_to_m(x)
+			    	next unless mm.exists?("#{@variable}" => @dato)
+			    	user = mm.find_by("#{@variable}" => @dato)
+			    	@user ||= user
+			    end
+			    raise Application::Error::General.new(t("error_not_user")) if @user === nil
+
+		    end
+
+		    def set_user_using_model
+			    
+			    raise Application::Error::General.new(t("error_present_modelo", params: params[:model])) unless modelo_a_validar.include?(params[:model])
+			    mm = ''
+			    modelo_a_validar.each do |x|
+					next if params[:model] != x
+			    	mm = c_to_m(x)
+			    end
+			   	raise Application::Error::General.new(t("error_not_user", params: @dato)) unless mm.exists?("#{@variable}" => @dato)
+			   	@user ||= mm.find_by("#{@variable}" => @dato)
+
+		    end
+
+			def c_to_m(str)
+				str.classify.constantize
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1 @@
+require "forcast/controllers/controller/login/login"

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

@@ -0,0 +1,21 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module PaperTrail
+			extend ActiveSupport::Concern
+
+			included do
+				before_action :set_model_id_version, only: [:versions]
+			end
+
+			def versions
+			  json_response(@model_id.versions,'ok')
+			end
+
+			def set_model_id_version
+			  set_model_id
+			end
+		
+		end
+	end
+end

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

@@ -0,0 +1 @@
+require "forcast/controllers/controller/paper_trail/paper_trail"

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

@@ -0,0 +1,157 @@
+require 'active_support'
+module Forcast
+	module Controller
+		module Relacion
+
+		## Este módulo hace que cuando se pregunta por los has_many de un modelo los entregue
+		## EJ: GET api/camaras/1/alarmas => entregaria las alarmas de camaras_id = 1
+		## EJ: GET api/camaras/1/alarmas/1 => entregaria la alarma_id = 1 de camaras_id = 1
+
+		extend ActiveSupport::Concern
+
+		included do
+			before_action :set_relation
+			before_action :set_relation_id, only: [:show, :update, :destroy]
+			
+			def set_relation
+				##Compruebo que exista el parametro de relacion
+				##Porque el metodo relation arroja un Array en caso de no encontrar nada
+				relation.is_a?(Array) ? deep_relation : @model = relacion_directa_indirecta
+			end
+
+			def set_relation_id
+				relation.is_a?(Array) ? @model_id : @model_id = relation.find(params[:id]) 
+				relacion_padre if params[:padre]
+			end
+
+		end
+
+			def c_to_m(str)
+				return str.classify.constantize
+			end
+
+			def relation
+				controller = controller_name.chomp('s')
+				model.reflect_on_all_associations(:belongs_to).each do |x|
+					 n = x.name.to_s
+					 nid = n +"_id"
+					 if params.include?(nid)
+						return c_to_m(n).find(params[nid]).send(controller)
+					 	break
+					 end
+				end
+			end
+			
+			def comprobar_relacion(re,var)
+
+				model.reflect_on_all_associations(re).each do |x|
+					 n = x.name.to_s
+					 if n == var
+					 	return true
+					 	break
+					 else
+					 	next
+					 end
+				end
+				return false
+			end
+
+			def relacion_padre
+			
+				raise Application::Error::General.new(t("error_relation_param", param: params[:padre])) unless comprobar_relacion(:belongs_to, params[:padre])
+				params_permitidos_enviar = abstract_controller(params[:padre]).new.send (:params_permitidos_enviar)
+				@response  = c_to_m(params[:padre]).find(@model_id.send(params[:padre]+'_id'))
+				@response = @response.attributes.slice(*params_permitidos_enviar)
+			end
+
+			def relacion_directa_indirecta
+				##Fijarse en estos parametros ya que nos interesan solo los de la url original, quizas sea mejor parsear la url.split("/")
+				return @model unless request.request_method_symbol == :get 
+				rel = []
+				params.keys.map { |val|  rel.push(val.chomp('_id')) if val.include?('_id') && val != 'model_id' && val != 'modelo_id' && val != 'modelo'}
+				if rel.length > 1
+					return deep_relacion_directa_indirecta(rel)
+				end
+				relation
+			end
+			#Comprueba que el recurso anidado corresponda al orden del request
+			#EX: localhost:4000/api/usuarios/20/recintos/2/ubicacions
+			#El metodo comprueba que la ubicacion pertenezca al recinto 2 asociado al usuario 20
+			def deep_relacion_directa_indirecta(rel)
+				init = c_to_m(rel[0]).find(params[rel[0]+'_id'])
+				rel.each_with_index do |ar,index|
+				 	next if index + 1 == rel.length
+				 	#Lanza un error si no encuentra el recurso en alguno de los padres
+				 	begin 
+				 		init = init.send(rel[index+1]).find(params[rel[index+1]+'_id'])
+				 	rescue => e
+				 		raise Application::Error::General.new(t("error_deep_relation_doesnt_exist", param: e))
+				 	end
+				end
+				relation
+			end
+
+			def deep_relation
+
+				return @model unless request.request_method_symbol == :get 
+				rel = []
+				params.keys.map { |val|  rel.push(val.chomp('_id')) if val.include?('_id') && val != 'model_id' && val != 'modelo_id' && val != 'modelo'}
+				rel = rel.last
+				#Entender bien cuando se produce el Trigger, si la url es 
+				#/usuarios el last es action, si es /usuario/:id es id
+				#ademas si  /usuario limit=1 envio parametos el last key es igual a usuario
+				#entonces compruebo el largo de los params
+				return @model if rel == nil || rel == 'action' || rel == 'id' || params.keys.length > 7
+				return @model if comprobar_relacion(:belongs_to, rel)
+				init = c_to_m(rel)
+				i = 0
+				arr = []
+				arr.push(rel)
+				comp = model.name.to_s.downcase!
+				catch :exit do
+					deep_deep_relation(init,comp,i,arr)
+				end
+				return fetch_from_relations_model(arr,rel)
+			end
+			def deep_deep_relation (init,comp,i,arr)
+				#Encuentra la cadena de relaciones entre un modelo padre y otro hijo
+				#EX: [usuario,recinto,ubicacion,camara,grabacions]
+				#Toma usuario y grabacions y encuentra la cadena
+				init.reflect_on_all_associations(:has_many).each do |x|
+					x = x.name.to_s
+					#p x
+					#p i
+					arr.push(x)
+					if x == comp
+						throw :exit
+					else
+						i = i + 1
+						deep_deep_relation(c_to_m(x),comp,i,arr)
+					end
+					i = i - 1
+					arr.delete(x)
+				end
+			end
+			def fetch_from_relations_model(arr,rel)
+				#Recibe un array con las relaciones ordenadas de mayor a menos
+				#[usuario,recinto,ubicacion,camara]
+				#Recibe rel que es igual al primer valor del parametro mayor
+				#params[:usuario_id]
+				rel = params[rel+'_id']
+
+				init = c_to_m(arr[0]).find(rel)
+				arr.each_with_index do |ar,index|
+					next if index + 1 == arr.length
+					init = c_to_m(arr[index+1]).send(:where, { ar + '_id' => init})
+				end
+				@model = init
+				# @model = Grabacion.where(camara_id: 
+				#   		Camara.where(hub_id: 
+				#   		Hub.where(recinto_id: 
+				#   		Recinto.where(usuario_id: 
+				#   		Usuario.find(rel)))))
+			end
+
+		end
+	end
+end