ruby on rails - gema - Rails 4-Pundit-política de alcance para el índice

resourcify rails

Question

Estoy tratando de aprender a usar Pundit con mi aplicación Rails 4.

Tengo los siguientes modelos:

class User < ActiveRecord::Base
has_one :profile
has_many :eois
end
class Profile < ActiveRecord::Base
belongs_to :user
has_many :projects, dependent: :destroy
end
class Project < ActiveRecord::Base
belongs_to :profile
has_many :eois
end
class Eoi < ActiveRecord::Base
belongs_to :project
belongs_to :user
end

Tengo una EoiPolicy ámbito con:

class EoiPolicy < ApplicationPolicy
class Scope
attr_reader :user, :scope
def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
if user.profile.project.id == @eoi.project_id?
scope.where(project_id: @user.profile.project.id)
elsif user.id == eoi.user_id?
scope.where(user_id: user.id)
else
nil
end
end
end
def index?
user.profile.project.id == @eoi.project_id? or user.id == eoi.user_id?
end
def new?
true
end
def show?
user.profile.project.id == @eoi.project_id? or user.id == eoi.user_id?
end
def edit?
user.id == eoi.user.id?
end
def create?
true
end
def update?
user.id == eoi.user.id?
end
def destroy?
user.id == eoi.user.id?
end
end

En mi EoisController , he tratado de usar el alcance con:

def index
# @eois = @project.eois
@eois = policy_scope(Eoi)
# @eois = Eois.find_by_project_id(params[:project_id])
end

Luego, en mi view/eois/index , he tratado de mostrar el índice con:

<% policy_scope(@user.eois).each do |group| %>

No puedo hacer que esto funcione. El mensaje de error resalta esta línea de mi método de alcance en la política:

if user.profile.project.id == @eoi.project_id?

Para mí, esto parece correcto, aunque aún estoy tratando de resolver esto. ¿Alguien puede ver lo que debe suceder para que esto funcione, de modo que si el usuario es el usuario, quién es el perfil propietario del proyecto relevante, todas las funciones relacionadas con ese proyecto están visibles?

De lo contrario, si el usuario es el usuario que creó el eoi, entonces ¿todas las eois que han creado son visibles?

El mensaje de error dice:

undefined method `project'' for #<Profile:0x007fa03f3faf48>
Did you mean? projects
projects=

Me pregunto si eso se debe a que un índice tendrá muchos registros, ¿necesita mostrar algo diferente en la política para reconocer la pluralidad?

También he intentado reemplazar esa línea con:

if @eoi.project_id == @user.profile.project.id?

aunque eso también es incorrecto y da

undefined method `project_id'' for nil:NilClass
Did you mean? object_id

También intenté hacer el alcance:

 def resolve
# cant figure what is wrong with this
if eoi.project_id == user.profile.project.id?
scope.where(project_id: @user.profile.project.id)
else
nil
end
end

pero eso también es incorrecto y da este error:

 undefined local variable or method `eoi'' for #<EoiPolicy::Scope:0x007ffb505784f8>

También probé:

 def resolve
# cant figure what is wrong with this
if @eoi.project_id == user.profile.project.id? or Eoi.project_id == user.profile.project.id?
scope.where(project_id: @user.profile.project.id)
elsif user.id == eoi.user_id?
scope.where(user_id: user.id)
else
nil
end
end
end
def index?
user.profile.project.id == Eoi.project_id? or user.id == Eoi.user_id?
end

pero ese intento da este mensaje de error:

undefined method `project_id'' for nil:NilClass
Did you mean? object_id

PENSAMIENTO ACTUAL

Creo que necesito pasar más que usuario y alcance al método de alcance. Si también puedo pasar el proyecto, entonces puedo hacer que el alcance sea referible al proyecto al que se relaciona la EoI.

Si pudiera hacer que esto funcionara, entonces tal vez podría hacer que el método de alcance funcione para la vista de índice en el controlador:

class Scope
attr_reader :user, :scope
def initialize(user, scope, project)
@user = user
@scope = scope
@project = project
end
end

luego en el controlador:

 def index
# @eois = @project.eois
@eois = policy_scope(Eoi, @project)
# authorize @eois
# @eois = Eois.find_by_project_id(params[:project_id])
end

Esto no funciona, cuando intento recibo un error que dice que la política

wrong number of arguments (given 2, expected 1)

¡Por favor ayuda!

PRÓXIMO INTENTO

Mi próximo intento es tratar de tomar las sugerencias de [este] problema de Pundit e implementar esa idea de cómo obtener el alcance correcto para un usuario en particular.

En mi política de Eoi, cambié el método de resolución a:

class Scope
attr_reader :user, :scope
def initialize(user, scope) #project
@user = user
@scope = scope
# @project = project
end
def resolve
# if Eoi.project_id == user.profile.project.id? or Eoi.project_id == user.profile.project.id?
if user.id == eoi.projects.profile.user.map(&:id)
scope.joins(eois: :projects).where(project_id: user.profile.projects.map(&:id)).empty?
# if scope.eoi.project_id == user.profile.projects.map(&:id)
# scope.where(project_id: user.profile.projects.map(&:id)).empty?
# scope.where(project_id: user.profile.project.id)
# elsif user.id == eoi.user_id?
# scope.where(user_id: user.id)
else
# nil
end
end
end

Luego, en mi acción de índice de controlador eoi, probé esto:

def index
# @eois = @project.eois
# @eois = policy_scope(Eoi, @project)
policy_scope(Eoi).where(project_id: params[:project_id])
# authorize @eois
# @eois = Eois.find_by_project_id(params[:project_id])
end

Eso tampoco funciona. El mensaje de error para este intento dice:

undefined local variable or method `eoi'' for #<EoiPolicy::Scope:0x007f98677c9cf8>

Estoy sin ideas para probar. ¿Alguien puede ver la forma de darle al alcance las entradas correctas para configurar esto?

OBSERVACIÓN He notado que muchos de los repos en github que usan Pundit con alcances también incluyen un método como este:

def scope
Pundit.policy_scope!(user, record.class)
end

Ese método es adicional a la clase Scope y no se muestra en los documentos de gemas Pundit. Si es necesario incluir, ¿qué hace? 1

VOLVER A ESCRIBIR

Ahora he examinado más de 200 repositorios en github para conocer cómo se supone que debo escribir una política para cumplir mis objetivos. No tengo ideas sobre cómo usar Pundit como estaba previsto.

He cambiado mi configuración por completo para tratar de solucionar los bits que no puedo entender. Ahora tengo:

Controlador Eois

class EoisController < ApplicationController
def index
@eois = Eoi.by_user_id(current_user.id)
end
end

Proyectos :: Controlador Eois

module Projects
class EoisController < ApplicationController
before_action :get_project
before_action :set_eoi, only: [:edit, :update, :destroy]
# after_action :verify_authorized
def index
@eois = Project.by_user_id(current_user.id).find_by(id: params[:project_id]).try(:eois) || []
end
def show
@eoi = Eoi.find(params[:id])
authorize @eoi
end
def set_eoi
@eoi = EoiPolicy::Scope.new(current_user, params[:project_id]).resolve.find(params[:id])
end
def get_project
@project = Project.find(params[:project_id])
end

Política Eoi (para decidir cuándo mostrar todas las eois hechas por un usuario)

class EoiPolicy < ApplicationPolicy
class Scope
attr_reader :user, :scope
def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
if scope.present?
Eoi.by_user_id(user.id)
# end
else
[]
end
end
end
def index?
user.profile.project.id == Eoi.project_id? or user.id == Eoi.user_id?
end
def new?
true
end
def show?
record.user_id == user.id || user.profile.project_id == record.project_id
# user.profile.project.id == @eoi.project_id? or user.id == eoi.user_id?
end
def edit?
user.id == eoi.user.id?
end
def create?
true
end
def update?
user.id == eoi.user.id?
end
def destroy?
user.id == eoi.user.id?
end
end

Rutas

resources :eois
resources :projects do
member do
resources :eois, controller: ''projects/eois
end

Cuando quiero mostrar EoIs que se envían en relación con un proyecto, utilizo la Política de Eoi de Proyectos y cuando quiero mostrar la EO que ha creado un usuario, utilizo la Política de Eoi - sin alcances.

Me encantaría resolver esto para poder usar esta gema de la manera en que está destinada. El consejo sería muy apreciado. Estoy seguro de que este intento no es para lo que se sirve el Pundit, pero no puedo entender cómo usar esta gema como se muestra en los documentos.

No puedo usar policy_scope porque necesito pasar el parámetro project_id en la acción de índice para la acción del índice del controlador eoi del proyecto.

SUGERENCIA PaReeOhNos

Mi intento de tratar de implementar la sugerencia de PareeOhNos se establece a continuación. No estoy seguro de entenderlo correctamente porque eois siempre tendrá una identificación de proyecto y una identificación de usuario, pero tal vez no entiendo qué está haciendo el método load_parent.

En mi controlador Eois, tengo:

class EoisController < ApplicationController
before_action :load_parent
before_action :load_eoi, only: [:show, :edit, :update, :destroy]
def index
authorize @parent
@eois = EoiPolicy::Scope.new(current_user, @parent).resolve
end
def show
end
# GET /eois/new
def new
@project = Project.find(params[:project_id])
@eoi = @project.eois.build
@contribute = params[:contribute] || false
@participate = params[:participate] || false
@partner = params[:partner] || false
@grant = params[:grant] || false
@invest = params[:invest] || false
end
# GET /eois/1/edit
def edit
end
# POST /eois
# POST /eois.json
def create
@eoi = Project.find(params[:project_id]).eois.build(eoi_params)
@eoi.user_id = @current_user.id
respond_to do |format|
if @eoi.save
format.html { redirect_to Project.find(params[:project_id]), notice: ''Eoi was successfully created.'' }
format.json { render :show, status: :created, location: @project }
else
format.html { render :new }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /eois/1
# PATCH/PUT /eois/1.json
def update
respond_to do |format|
if @eoi.update(eoi_params)
format.html { redirect_to @project, notice: ''Eoi was successfully updated.'' }
format.json { render :show, status: :ok, location: @eoi }
else
format.html { render :edit }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# DELETE /eois/1
# DELETE /eois/1.json
def destroy
@eoi.destroy
respond_to do |format|
format.html { redirect_to @project, notice: ''Eoi was successfully destroyed.'' }
format.json { head :no_content }
end
end
private
def load_parent
# @parent = (params[:project_id] ? Project.find(params[:project_id] : current_user)
@parent = params[:project_id] ? Project.find(params[:project_id]) : current_user
end
def load_eoi
@eoi = Eoi.find(params[:id])
authorize @eoi
end

En mi política de Eoi, tengo:

class EoiPolicy < ApplicationPolicy
class Scope
attr_reader :user, :scope
def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
if scope.is_a?(User)
Eoi.where(user_id: scope.id)
elsif scope.is_a?(Project)
Eoi.where(project_id: scope.id)
else
[]
end
end
end
def index?
record.is_a?(User) || user.profile.project.id == record.project_id
end
def new?
true
end
def show?
record.user_id == user.id || user.profile.project_id == record.project_id
end
def edit?
user.id == eoi.user.id?
end
def create?
true
end
def update?
user.id == eoi.user.id?
end
def destroy?
user.id == eoi.user.id?
end
end

En mi routes.rb, tengo:

resources :projects do
member do
resources :eois, shallow: true
resources :eois, only: [:index]

En mi eois / index, tengo:

 <% @eois.sort_by(&:created_at).in_groups_of(2) do |group| %>
<% group.compact.each do |eoi| %>
<h4><%= link_to eoi.user.full_name %></h4>
<%= link_to ''VIEW DETAILS'', eoi_path(eoi), :class=>"portfolio-item-view" %>
<% end %>
<% end %> 

En mi eois / show, tengo:

"test"

Cuando intento todo esto, carga la página eois / index. Cuando trato de mostrar una página específica de eoi, aparece un error que dice:

wrong number of arguments (given 2, expected 0)

el mensaje de error apunta a autorizar la línea @eoi del controlador:

def load_eoi
@eoi = Eoi.find(params[:id])
authorize @eoi
end

El mismo error surge si puse autorize @eoi en la acción show en lugar del método load eoi.

LA POLÍTICA DE APLICACIÓN TIENE

class ApplicationPolicy
attr_reader :user, :scope
class Scope
def initialize(user, scope)
#byebug
@user = user
# record = record
@scope = scope
end
def resolve
scope
end
end
def index?
false
end
def show?
scope.where(:id => record.id).exists?
end
def create?
false
end
def new?
create?
end
def update?
false
end
def edit?
update?
end
def destroy?
false
end
def scope
Pundit.policy_scope!(user, record.class)
end

PRÓXIMO INTENTO

Tomando la sugerencia de PaReeOhNos (copiada arriba), he tratado de adaptarla un poco para que se ajuste mejor a mis casos de uso.

Ahora tengo:

Controlador Eoi

class EoisController < ApplicationController
# before_action :get_project
# before_action :set_eoi, only: [:show, :edit, :update, :destroy]
before_action :load_parent
before_action :load_eoi, only: [:show, :edit, :update, :destroy]
# GET /eois
# GET /eois.json
# def index
# @eois = @project.eois
# # @eois = Eois.find_by_project_id(params[:project_id])
# end
def index
# authorize @parent
@eois = policy_scope(Eoi.where(project_id: params[:project_id]))
# @eois = EoiPolicy::Scope.new(current_user, @parent).resolve
end
# GET /eois/1
# GET /eois/1.json
def show
end
# GET /eois/new
def new
@project = Project.find(params[:project_id])
@eoi = @project.eois.build
@contribute = params[:contribute] || false
@participate = params[:participate] || false
@partner = params[:partner] || false
@grant = params[:grant] || false
@invest = params[:invest] || false
end
# GET /eois/1/edit
def edit
end
# POST /eois
# POST /eois.json
def create
@eoi = Project.find(params[:project_id]).eois.build(eoi_params)
@eoi.user_id = @current_user.id
respond_to do |format|
if @eoi.save
format.html { redirect_to Project.find(params[:project_id]), notice: ''Eoi was successfully created.'' }
format.json { render :show, status: :created, location: @project }
else
format.html { render :new }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /eois/1
# PATCH/PUT /eois/1.json
def update
respond_to do |format|
if @eoi.update(eoi_params)
format.html { redirect_to @project, notice: ''Eoi was successfully updated.'' }
format.json { render :show, status: :ok, location: @eoi }
else
format.html { render :edit }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# DELETE /eois/1
# DELETE /eois/1.json
def destroy
@eoi.destroy
respond_to do |format|
format.html { redirect_to @project, notice: ''Eoi was successfully destroyed.'' }
format.json { head :no_content }
end
end
private
def load_parent
# @parent = (params[:project_id] ? Project.find(params[:project_id] : current_user)
@parent = params[:project_id] ? Project.find(params[:project_id]) : current_user
end
def load_eoi
@eoi = Eoi.find(params[:id])
# authorize @eoi
end

Política de Eoi

class EoiPolicy < ApplicationPolicy
class Scope
attr_reader :user, :scope
def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
# since we send the scoped eois from controller, we can pick
# any eoi and get its project id
# check if the current user is the owner of the project
# if (user.profile.projects.map(&:id).include?(project_id))
# # user is the owner of the project, get all the eois
# scope.all
# end
# #not the owner , then get only the eois created by the user
# scope.where(user_id: user.id)
# end
if scope.is_a?(User)
Eoi.where(user_id: scope.id)
elsif scope.is_a?(Project) && (user.profile.projects.map(&:id).include?(project_id))
project_id = scope.first.project_id
Eoi.where(project_id: scope.id)
else
Eoi.none
end
end
end
def index?
record.is_a?(User) || user.profile.project.id == record.project_id
end
def new?
true
end
def show?
record.user_id == user.id || user.profile.project_id == record.project_id
end
def edit?
user.id == eoi.user.id?
end
def create?
true
end
def update?
user.id == eoi.user.id?
end
def destroy?
user.id == eoi.user.id?
end
end

Rutas

resources :eois#, only: [:index]
concern :eoiable do
resources :eois
end
resources :projects do
concerns :eoiable
end

Índice

 <% @eois.sort_by(&:created_at).in_groups_of(2) do |group| %>
<% group.compact.each do |eoi| %>
<h4><%= link_to eoi.user.full_name %></h4>
<%= link_to ''VIEW DETAILS'', project_eoi_path(eoi.project, eoi), :class=>"portfolio-item-view" %>
<% end %>
<% end %> 

Ver

''test''

Esto no funciona, porque cuando navego a un proyecto y luego trato de representar el índice de eois que tienen un id. De proyecto coincidente, obtengo una página de índice vacía, cuando tengo 4 registros en mi base de datos que deben mostrarse.

LA SUGERENCIA DE LEITO

Tomando la sugerencia de Leito, también he intentado esto:

Controlador Eoi

class EoisController < ApplicationController
before_action :get_project
before_action :set_eoi, only: [:show, :edit, :update, :destroy]
# before_action :load_parent
# before_action :load_eoi, only: [:show, :edit, :update, :destroy]
# GET /eois
# GET /eois.json
# def index
# @eois = @project.eois
# # @eois = Eois.find_by_project_id(params[:project_id])
# end
def index
# authorize @eois
# authorize @parent
# policy_scope(@project.eois)
@eois = policy_scope(Eoi.where(project_id: params[:project_id]))
# @eois = EoiPolicy::Scope.new(current_user, @parent).resolve
end
# GET /eois/1
# GET /eois/1.json
def show
end
# GET /eois/new
def new
@project = Project.find(params[:project_id])
@eoi = @project.eois.build
@contribute = params[:contribute] || false
@participate = params[:participate] || false
@partner = params[:partner] || false
@grant = params[:grant] || false
@invest = params[:invest] || false
end
# GET /eois/1/edit
def edit
end
# POST /eois
# POST /eois.json
def create
@eoi = Project.find(params[:project_id]).eois.build(eoi_params)
@eoi.user_id = @current_user.id
respond_to do |format|
if @eoi.save
format.html { redirect_to Project.find(params[:project_id]), notice: ''Eoi was successfully created.'' }
format.json { render :show, status: :created, location: @project }
else
format.html { render :new }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /eois/1
# PATCH/PUT /eois/1.json
def update
respond_to do |format|
if @eoi.update(eoi_params)
format.html { redirect_to @project, notice: ''Eoi was successfully updated.'' }
format.json { render :show, status: :ok, location: @eoi }
else
format.html { render :edit }
format.json { render json: @eoi.errors, status: :unprocessable_entity }
end
end
end
# DELETE /eois/1
# DELETE /eois/1.json
def destroy
@eoi.destroy
respond_to do |format|
format.html { redirect_to @project, notice: ''Eoi was successfully destroyed.'' }
format.json { head :no_content }
end
end
private
# def load_parent
# # @parent = (params[:project_id] ? Project.find(params[:project_id] : current_user)
# @parent = params[:project_id] ? Project.find(params[:project_id]) : current_user
# end
# def load_eoi
# @eoi = Eoi.find(params[:id])
# # authorize @eoi
# end
# # Use callbacks to share common setup or constraints between actions.
def set_eoi
@eoi = Eoi.find(params[:id])
end
def get_project
@project = Project.find(params[:project_id])
end

Política Eoi

def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
if scope.joins(project: :profile).where profiles: { user_id: user }
Eoi.where(project_id: scope.ids)
elsif scope.joins(eoi: :user).where eois: { user_id: user }
Eoi.where(user_id: scope.ids)
else
Eoi.none
end
# since we send the scoped eois from controller, we can pick
# any eoi and get its project id
# check if the current user is the owner of the project
# if (user.profile.projects.map(&:id).include?(project_id))
# # user is the owner of the project, get all the eois
# scope.all
# end
# #not the owner , then get only the eois created by the user
# scope.where(user_id: user.id)
# end
# if scope.is_a?(User)
# Eoi.where(user_id: scope.id)
# elsif scope.is_a?(Project) && (user.profile.projects.map(&:id).include?(project_id))
# project_id = scope.first.project_id
# Eoi.where(project_id: scope.id)
# else
# Eoi.none
# end
end
end
def index?
true
# record.is_a?(User) || user.profile.project.id == record.project_id
end
def new?
true
end
def show?
true
# record.user_id == user.id || user.profile.project_id == record.project_id
end
def edit?
user.id == eoi.user.id?
end
def create?
true
end
def update?
user.id == eoi.user.id?
end
def destroy?
user.id == eoi.user.id?
end
end

Las rutas y vistas son las mismas que el intento anterior

El problema aquí es con el método get project en mi controlador. Necesito eso para el escenario en el que estoy tratando de mostrar todas las eois en un proyecto específico. No lo necesito cuando estoy tratando de mostrar toda la energía de un usuario.

Cuando guardo todo esto y lo intento, las eois en un proyecto se muestran correctamente. Sin embargo, la eois (no anidada dentro de un proyecto) que se supone que me muestran toda mi (como usuario) eois, muestra un error que dice:

Couldn''t find Project with ''id''=

El mensaje de error resalta el ''método get_project''.

LA SUGERENCIA ACTUALIZADA DE LEITO

Tomando la sugerencia actualizada de Leito, he establecido el intento actual.

Antes de hacerlo, quiero aclarar que todos los Eois tendrán una identificación de usuario y una identificación de proyecto. Utilizo esta tabla para que los usuarios expresen interés en los proyectos. Mi objetivo es que el usuario cuyo perfil es propietario del proyecto vea todas las eois enviadas en ese proyecto. Luego, también quiero que los usuarios vean todas sus propias publicaciones (en todos los proyectos).

Política Eoi

def resolve
if scope.joins(project: :profile).where ''profiles.user_id = ? OR eois.user_id = ?'', user.id, user.id
Eoi.all
else
Eoi.none
end 

Controlador Eoi

def index
@eois = policy_scope(Eoi)
@eois = @eois.where(project_id: params[:project_id]) if params[:project_id]
end

Actualmente, esto funciona bien para encontrar las eois que están anidadas en un proyecto (project / 26 / eois). Sin embargo, cuando intento hacer eois / index (no anidado en el proyecto), que quiero devolver a todos los usuarios, me sale un error que dice:

Couldn''t find Project with ''id''=

Destaca esta línea del controlador eoi:

def get_project
@project = Project.find(params[:project_id])
end

No estoy seguro de entender el método de resolución o la idea de eliminar el controlador ahora. No puedo ver qué pasa con la línea de alcance para ver qué cambiar.

Answer 1

En tu primer ejemplo, hay un par de problemas. En primer lugar, @eoi no existe, y no puede existir. La variable @eoi se establece en el controlador, y este es un objeto diferente. No funciona de la misma manera que sus vistas, donde esto es accesible, por lo que nunca se establecerá.

Igualmente, la variable eoi no se establecerá, ya que su método de initialize solo asigna las variables de user y de resource , por lo que son las únicas dos a las que tiene acceso (a menos que cambie el nombre)

El alcance de la política funciona de forma un poco diferente de cómo piensas que funciona. La política en sí misma generalmente toma al usuario conectado, y una clase, o un registro que usted está autorizando. El alcance sin embargo, normalmente no toma un registro como el segundo argumento. Es un ámbito, por lo tanto, una subclase de registro activo o una relación. Sin embargo, no está restringido a esto y podría solucionarlo suministrando un registro, pero tenga en cuenta que este no es un comportamiento normal para Pundit.

Para lograr lo que busca, solo debe hacer algunos ajustes:

class EoiPolicy < ApplicationPolicy
class Scope
attr_reader :user, :eoi
def initialize(user, eoi)
@user = user
@eoi = eoi
end
def resolve
if user.profile.project.id == eoi.project_id
Eoi.where(project_id: user.profile.project.id)
elsif user.id == eoi.user_id
Eoi.where(user_id: user.id)
else
nil
end
end
end
def index?
user.profile.project.id == record.project_id or user.id == record.user_id
end
def new?
true
end
def show?
user.profile.project.id == record.project_id? or user.id == record.user_id
end
def edit?
user.id == record.user.id
end
def create?
true
end
def update?
user.id == record.user.id
end
def destroy?
user.id == record.user.id
end
end

Los cambios principales aquí son que attr_reader :user, :scope ahora es attr_reader :user, :eoi que le dará acceso a eoi dentro de ese alcance.

El acceso a esto ya no está prefijado con @ ya que está en línea con el funcionamiento del experto.

A lo largo del resto de la política, @eoi nuevamente no puede funcionar, pero esto se ha cambiado para record (suponiendo que esto es lo que es en ApplicationPolicy). Tenga en cuenta el alcance, y el resto de la política son dos clases diferentes.

Con esta configuración, ahora debería poder simplemente llamar a policy_scope(@eoi) desde su controlador. Tenga en cuenta el uso de la variable @eoi aquí y NO la clase Eoi como antes. Esto es crucial, ya que sin esto, no tendrá acceso a cosas como user_id o project_id ya que esos métodos no existen en la clase Eoi, sino solo en un registro.

También he eliminado el ? símbolos desde el final de sus condiciones if. En general, se utilizan para indicar que el método al que se llama devuelve un valor booleano, mientras que los tenía al final de algo que simplemente devuelve un número entero. Me imagino que en realidad obtendrías un error al decir que el método no existe, pero si has cambiado el nombre de las cosas, entonces querrás volver a ponerlas, pero como digo, eso va en contra de los estilos de codificación ruby.

Y en una nota lateral, el uso de or o en las declaraciones en lugar de || o && puede en las ocasiones ocasionales comportarse de manera diferente a como espera. En la mayoría de los escenarios está bien, pero técnicamente no significa lo mismo.

Espero que todo esto ayude, avíseme si tiene más problemas con él.

Answer 2

Soy el comentarista anterior sobre ese tema.

Para su EoiScope, simplemente quiere a qué EoT tiene acceso el usuario (porque pertenecen a proyectos bajo este perfil), independiente del proyecto (este requisito es solo para el controlador, porque está anidado), por lo que su controlador debería verse como esta:

Editar : Basado en su último intento, actualicé el alcance para dar cuenta de Eois que pertenece directamente al usuario (no a través de un proyecto) y simplemente debería extenderlo a un proyecto o no basado en la presencia de params [: project_id] , mira la respuesta actualizada.

@eois = policy_scope(Eoi)
@eois = @eios.where(project_id: params[:project_id]) if params[:project_id]

Y su alcance debería hacer combinaciones hasta que llegue al usuario o simplemente busque la propiedad user_id en Eoi.

 class EoiPolicy < ApplicationPolicy
class Scope < Scope
def resolve
scope.joins(project: : profile).where ''profiles.user_id = ? OR eois.user_id = ?'', user.id, user.id
end
end
# Other methods that differ from ApplicationPolicy''s methods
end

Tenga en cuenta que Scope no llama a eoi , pero el alcance predeterminado * solo conoce el scope y el user . * Por defecto, quiero decir cuando hereda de ApplicationPolicy::Scope

Answer 3

Para otros, no estoy seguro de si esta es una solución que hace uso de Pundit de la manera que se pretendía, sin embargo, genera los flujos que quiero, dentro de los límites de mi capacidad.

Gracias a todos los que ayudaron en esto. Estoy seguro de que todavía tengo mucho que aprender sobre cómo mejorar esto, pero por ahora, esta es una solución que funciona.

En resumen, ahora tengo dos políticas para 1 controlador.

Política Eoi

class EoiPolicy < ApplicationPolicy
class Scope
def initialize(user, scope)
@user = user
@scope = scope
end
def resolve
# selects all the EOI''s for a given user
@scope.where(user_id: @user.id)
end
end
def index?
true
end

Política del Proyecto Eoi

class ProjectEoiPolicy < ApplicationPolicy
class Scope < Scope
def resolve(project_id)
project = Project.find(project_id)
if project.owner?(@user)
# if the user is the owner of the project, then get
# all the eois
project.eois
else
# select all the eois for the project
# created by this user
Eoi.for_user(@user.id).for_project(project_id)
end
end
end
end

Eoi Controller index action

class EoisController < ApplicationController
before_action :get_project, except: [:index, :show]
before_action :set_eoi, only: [:show, :edit, :update, :destroy]
def index
if params[:project_id]
@eois = ProjectEoiPolicy::Scope.new(current_user, Eoi).resolve(params[:project_id])
else
@eois = policy_scope(Eoi)
end
end