ruby on rails - ¿Cómo usar el envío privado para ocultarlo del perfil?

ruby-on-rails model-view-controller

Question

Cuando un usuario realiza una presentación private ¿cómo podemos ocultar la información enviada del feed y que otros usuarios puedan verla en su perfil público?

<%= button_tag(type: ''submit'', class: "btn") do %>
...
<%= button_tag(type: ''submit'', class: "btn", id: "2", name: ''private'') do %>
...

Ponemos lo siguiente en el controlador, pero dado que el botón privado estará en muchas formas diferentes, ¿tengo que ponerlo en cada controlador o podemos ponerlo en el controlador de la aplicación?

if params[:private]
# the private action / What do we need to put here?
else
# normal submit / and here?

Seguí este episodio ferroviario casi a la T para construir el feed de actividad: http://railscasts.com/episodes/406-public-activity .

Aquí está el código para el perfil público:

users_controller.rb

def show
@user = User.find(params[:id])
@habits = @user.habits
@valuations = @user.valuations
@accomplished_goals = @user.goals.accomplished
@unaccomplished_goals = @user.goals.unaccomplished
@averaged_quantifieds = @user.quantifieds.averaged
@instance_quantifieds = @user.quantifieds.instance
end

show.html.erb

<% if @user.habits.any? %>
<h2>Habits</h2>
<h4>Challenges</h4>
<%= render partial: ''habits'', locals: {habits: @habits} %>
<% end %>
<% if @user.valuations.any? %>
<h2>Values</h2>
<%= render @valuations %>
<% end %>
<% if @user.goals.any? %>
<h2>Goals</h2>
<h4> Current</h4>
<%= render @unaccomplished_goals %>
<% end %>
<% if @user.goals.any? %>
<h4>Accomplished</h4>
<%= render @accomplished_goals %>
<% end %>
<% if @user.quantifieds.any? %>
<h2>Stats</h2>
<h4>Averaged</h4>
<%= render partial: ''averaged'', locals: {habits: @averaged_quantifieds} %>
<% end %>
<% if @user.quantifieds.any? %>
<h4>Instance</h4>
<%= render partial: ''instance'', locals: {habits: @instance_quantifieds} %>
<% end %>

Según lo solicitado :)

Modelo de usuario

class User < ActiveRecord::Base
has_many :authentications
has_many :habits, dependent: :destroy
has_many :levels
has_many :valuations, dependent: :destroy
has_many :comments, as: :commentable
has_many :goals, dependent: :destroy
has_many :quantifieds, dependent: :destroy
has_many :results, through: :quantifieds
accepts_nested_attributes_for :quantifieds, :reject_if => :all_blank, :allow_destroy => true
accepts_nested_attributes_for :results, :reject_if => :all_blank, :allow_destroy => true
has_many :active_relationships, class_name: "Relationship",
foreign_key: "follower_id",
dependent: :destroy
has_many :passive_relationships, class_name: "Relationship",
foreign_key: "followed_id",
dependent: :destroy
has_many :following, through: :active_relationships, source: :followed
has_many :followers, through: :passive_relationships, source: :follower
attr_accessor :remember_token, :activation_token, :reset_token
before_save :downcase_email
before_create :create_activation_digest
validates :name, presence: true, length: { maximum: 50 }
VALID_EMAIL_REGEX = //A[/w+/-.]+@[a-z/d/-.]+/.[a-z]+/z/i
validates :email, presence: true, length: { maximum: 255 },
format: { with: VALID_EMAIL_REGEX },
uniqueness: { case_sensitive: false }, unless: -> { from_omniauth? }
has_secure_password
validates :password, length: { minimum: 6 }
def self.from_omniauth(auth)
where(provider: auth.provider, uid: auth.uid).first_or_initialize.tap do |user|
user.provider = auth.provider
user.uid = auth.uid
user.name = auth.info.name
user.oauth_token = auth.credentials.token
user.oauth_expires_at = Time.at(auth.credentials.expires_at)
user.password = (0...8).map { (65 + rand(26)).chr }.join
user.email = (0...8).map { (65 + rand(26)).chr }.join+"@mailinator.com"
user.save!
end
end
# Returns the hash digest of the given string.
def User.digest(string)
cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST :
BCrypt::Engine.cost
BCrypt::Password.create(string, cost: cost)
end
# Returns a random token.
def User.new_token
SecureRandom.urlsafe_base64
end
# Remembers a user in the database for use in persistent sessions.
def remember
self.remember_token = User.new_token
update_attribute(:remember_digest, User.digest(remember_token))
end
# Forgets a user. NOT SURE IF I REMOVE
def forget
update_attribute(:remember_digest, nil)
end
# Returns true if the given token matches the digest.
def authenticated?(attribute, token)
digest = send("#{attribute}_digest")
return false if digest.nil?
BCrypt::Password.new(digest).is_password?(token)
end
# Activates an account.
def activate
update_attribute(:activated, true)
update_attribute(:activated_at, Time.zone.now)
end
# Sends activation email.
def send_activation_email
UserMailer.account_activation(self).deliver_now
end
def create_reset_digest
self.reset_token = User.new_token
update_attribute(:reset_digest, User.digest(reset_token))
update_attribute(:reset_sent_at, Time.zone.now)
end
# Sends password reset email.
def send_password_reset_email
UserMailer.password_reset(self).deliver_now
end
# Returns true if a password reset has expired.
def password_reset_expired?
reset_sent_at < 2.hours.ago
end
def good_results_count
results.good_count
end
# Returns status feed.
def feed
following_ids = "SELECT followed_id FROM relationships
WHERE follower_id = :user_id"
Habit.where("user_id IN (#{following_ids})
OR user_id = :user_id", user_id: id)
Valuation.where("user_id IN (#{following_ids})
OR user_id = :user_id", user_id: id)
Goal.where("user_id IN (#{following_ids})
OR user_id = :user_id", user_id: id)
Quantified.where("user_id IN (#{following_ids})
OR user_id = :user_id", user_id: id)
end
# Follows a user.
def follow(other_user)
active_relationships.create(followed_id: other_user.id)
end
# Unfollows a user.
def unfollow(other_user)
active_relationships.find_by(followed_id: other_user.id).destroy
end
# Returns true if the current user is following the other user.
def following?(other_user)
following.include?(other_user)
end
private
def from_omniauth?
provider && uid
end
# Converts email to all lower-case.
def downcase_email
self.email = email.downcase unless from_omniauth?
end
# Creates and assigns the activation token and digest.
def create_activation_digest
self.activation_token = User.new_token
self.activation_digest = User.digest(activation_token)
end
end

Controlador de usuario

class UsersController < ApplicationController
before_action :logged_in_user, only: [:index, :edit, :update, :destroy,
:following, :followers]
before_action :correct_user, only: [:edit, :update]
before_action :admin_user, only: :destroy
def index
@users = User.paginate(page: params[:page])
end
def show
@user = User.find(params[:id])
@habits = @user.habits
@valuations = @user.valuations
@accomplished_goals = @user.goals.accomplished
@unaccomplished_goals = @user.goals.unaccomplished
@averaged_quantifieds = @user.quantifieds.averaged
@instance_quantifieds = @user.quantifieds.instance
end
def new
@user = User.new
end
def create
@user = User.new(user_params)
if @user.save
@user.send_activation_email
flash[:info] = "Please check your email to activate your account."
redirect_to root_url
else
@feed_items = []
render ''pages/home''
end
end
def edit
@user = User.find(params[:id])
end
def update
@user = User.find(params[:id])
if @user.update_attributes(user_params)
flash[:success] = "Profile updated"
redirect_to @user
else
render ''edit''
end
end
def destroy
User.find(params[:id]).destroy
flash[:success] = "User deleted"
redirect_to users_url
end
def following
@title = "Following"
@user = User.find(params[:id])
@users = @user.following.paginate(page: params[:page])
render ''show_follow''
end
def followers
@title = "Followers"
@user = User.find(params[:id])
@users = @user.followers.paginate(page: params[:page])
render ''show_follow''
end
private
def user_params
params.require(:user).permit(:name, :email, :password,
:password_confirmation)
end
# Before filters
# Confirms a logged-in user.
def logged_in_user
unless logged_in?
store_location
flash[:danger] = "Please log in."
redirect_to login_url
end
end
# Confirms the correct user.
def correct_user
@user = User.find(params[:id])
redirect_to(root_url) unless current_user?(@user)
end
# Confirms an admin user.
def admin_user
redirect_to(root_url) unless current_user.admin?
end
end

ACTUALIZAR

Con la respuesta de K a continuación, aparece este mensaje de error al dirigirse a usuarios o usuarios / 1, usuarios / 2, etc.

Started GET "/users/1" for 127.0.0.1 at 2015-04-01 16:32:13 -0400
SyntaxError (/Users/galli01anthony/Desktop/Pecoce/app/controllers/users_controller.rb:79: syntax error, unexpected '':'', expecting keyword_end
users_attributes: [:name, :email, :password, :...
^
/Users/galli01anthony/Desktop/Pecoce/app/controllers/users_controller.rb:79: syntax error, unexpected '','', expecting keyword_end
...ivate, :password_confirmation], valuations_attributes: [:nam...
... ^
/Users/galli01anthony/Desktop/Pecoce/app/controllers/users_controller.rb:79: syntax error, unexpected ''='', expecting keyword_end
... [:name, :tag_list, :private] = true
... ^
/Users/galli01anthony/Desktop/Pecoce/app/controllers/users_controller.rb:81: syntax error, unexpected '':'', expecting keyword_end
users_attributes: [:name, :email, :password, :...
^
/Users/galli01anthony/Desktop/Pecoce/app/controllers/users_controller.rb:81: syntax error, unexpected '','', expecting keyword_end
...sword, :password_confirmation], valuations_attributes: [:nam...
... ^):
app/controllers/users_controller.rb:79: syntax error, unexpected '':'', expecting keyword_end
app/controllers/users_controller.rb:79: syntax error, unexpected '','', expecting keyword_end
app/controllers/users_controller.rb:79: syntax error, unexpected ''='', expecting keyword_end
app/controllers/users_controller.rb:81: syntax error, unexpected '':'', expecting keyword_end
app/controllers/users_controller.rb:81: syntax error, unexpected '','', expecting keyword_end

Esta es una pregunta de dos partes. Encuentre la segunda parte aquí: ¿Cómo usar el envío privado para ocultar del feed?

Answer 1

Agregue un campo ''privado'' al modelo de Usuario con su valor predeterminado ''falso''. Toda la información de usuario normal se marcará como ''pública'' (porque el campo privado tiene el valor falso) Solo si params [: private], el valor del campo privado se establecerá en ''true''.

A continuación, puede agregar un método al modelo de usuario que solo captará los datos del usuario con el indicador privado = falso (para vistas públicas).

EDITAR:

Viendo público o privado:

Agregue un campo ''privado'' a cada uno de sus modelos relacionados que posiblemente se puedan marcar como privados. No olvide agregar esto en sus migraciones. Establezca el valor predeterminado del privado en falso .

Incluir en la valoración y migración del usuario / esquema

t.boolean :private, default: false

valuation.rb

def public?
private == true ? false : true
end

usuario.rb

# gets public valutations or nil, if there''s no public valutation
def public_valuations
valuations.find(&:public?)
end

Haga esto de la misma manera para cada una de sus relaciones deseadas. Le permite obtener información pública a través de

@valuations = @user.public_valuations

Su acción show actual muestra ahora todas las informaciones adicionales del usuario, públicas y privadas, que solo deben mostrarse si current_user = @user.

Por último, debes insertar una condición en tu acción de mostrar:

def show
@user = User.find(params[:id])
if current_user == @user
@habits = @user.habits
@valuations = @user.valuations
@accomplished_goals = @user.goals.accomplished
@unaccomplished_goals = @user.goals.unaccomplished
@averaged_quantifieds = @user.quantifieds.averaged
@instance_quantifieds = @user.quantifieds.instance
else
@valuations = @user.public_valuations
end
end

Esa solución depende de current_user, es decir, debe tener un método que devuelva el objeto del usuario actualmente logged_in (tal vez en una sesión). Michael Hartl escribió un fantástico tutorial sobre autenticación de usuarios. * RubyonRailsBeginner utilizó Hartl Tutorial para esto :)

Crear registros públicos o privados

Como ha configurado el valor predeterminado del privado en falso , puede usar su código existente para crear entradas públicas.

Para entradas privadas, debe establecer el atributo correspondiente en su user_params en verdadero .

EDIT con params.require:

Establecí el [: private] en la cláusula else explícita en falso, para que un usuario pueda establecer sus atributos privados en público, si lo desea.

def user_params
if params[:private] = true
params.require(:user).permit(:name, :email, :password, :private, :password_confirmation, valuations_attributes: [:name, :tag_list, :private])
else
params[:user][:valuations][:private] = false
params.require(:user).permit(:name, :email, :password, :password_confirmation, valuations_attributes: [:name, :tag_list])
end
end

Rails Api te da algunos consejos sobre parámetros potentes con atributos anidados.

¡Espero que ayude!