class User

Constants

STAFF

Usuarios que se consideran personal de Lehendakaritza

STATUS

Estados de los usuarios: pendiente: el usuario se ha dado de alta y no ha confirmado su registro (para ciudadanos que se registran desde la web) aprobado: el usuario se ha dado de alta y ha confirmado su registro (para los ciudadadanos)

o los admin han cambiado su estado (para los demás usuarios)

vetado: los admin han vetado el acceso del usuario.

       Si es político, en la web no sale ni su página de político ni él sale en el equipo de área al que está asignado.
       Este usuario no puede logearse en la web
eliminado: un ciudadanno que se ha dado de baja (ha eliminado su perfil). 
           Se ven los contenidos que él ha creado pero no salen sus datos personales

ex-cargo: político que ya no está en el cargo que ocupaba.

Sale su página y su actividad pero no se le pueden hacer preguntas ni se le puede seguir
TYPES

Attributes

password[RW]

Virtual attribute for the unencrypted password

stream_flow_ids[W]

Public Class Methods

authenticate(email, password) click to toggle source

Autentifica al usuario por su email, status y contraseña. Devuelve el usuario o nil.

# File app/models/user.rb, line 132
def self.authenticate(email, password)
  u = find_by_email_and_status(email, 'aprobado') # need to get the salt
  u && u.authenticated?(password) ? u : nil
end
authenticate_from_url(user_id, crypted_password) click to toggle source

Autentifica al usuario por su id y contraseña encriptada. Devuelve el usuario o nil

# File app/models/user.rb, line 138
def self.authenticate_from_url(user_id, crypted_password)
  u = find_by_id_and_status_and_crypted_password(user_id, "aprobado", crypted_password)
end
encrypt(password, salt) click to toggle source

Encripta los datos con el salt.

# File app/models/user.rb, line 171
def self.encrypt(password, salt)
  Digest::SHA1.hexdigest("--#{salt}--#{password}--")
end
irekia_robot() click to toggle source
# File app/models/user.rb, line 122
def self.irekia_robot
  find_by_email("sn@irekia.euskadi.net")
end
official_commenters() click to toggle source
# File app/models/user.rb, line 143
def self.official_commenters
  # This is expensive, so we memoize it. Memo will be flushed if there is a user type change
  # or a permission is changed.
  # Note: class variable localization only works in production by default
  # http://stackoverflow.com/questions/9720520/do-ruby-class-variables-get-cleared-between-rails-requests
  @@official_commenters ||= User.approved.find(:all).select {|u| u.is_official_commenter?}
  # @@official_commenters = [User.find(4067)]
end
random_password(size = 5) click to toggle source

Genera un password aleatorio snippets.dzone.com/posts/show/2137

# File app/models/user.rb, line 544
def self.random_password(size = 5)
  chars = (('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a) - %w(i o 0 1 l 0 I O)
  (1..size).collect{|a| chars[rand(chars.size)] }.join
end
with_department() click to toggle source

Devuelve un array con los tipos de usuarios que pertenecen a algún departamento

# File app/models/user.rb, line 127
def self.with_department
  User::TYPES.select {|k, v| k.constantize.new.has_department?}.collect {|u| u[0].to_s}
end

Public Instance Methods

active_notifications_for(item) click to toggle source
# File app/models/user.rb, line 517
def active_notifications_for(item)
  self.notifications.pending.find(:all, :conditions => "notifiable_id=#{item.id} AND notifiable_type='#{item.class.base_class}'")
end
all_editable_permissions() click to toggle source

Devuelve un array con todos los permisos que tiene un usuario Incluye:

  • Los permisos heredados del tipo de usuario

  • Los permisos dados manualmene a través de la clase #Permission

  • Los permisos dados manualmente a través de la clase #SchedulesPermission. Solo se incluyen los permisos sobre la agenda del departamento al que pertenece el usuario (si es que pertenece a alguno) porque son los únicos que se pueden modificar a través de ese formulario

# File app/models/user.rb, line 384
def all_editable_permissions
  fp = self.permissions.dup

  if self.has_department_schedule?
    schedules_permissions.find(:all).each do |sp|
      if sp.can_edit?
        fp << Permission.new(:user_id => self.id, :module => "schedule_events", :action => "can_edit", :not_editable => false)
      end
      if sp.can_change_schedule?
        fp << Permission.new(:user_id => self.id, :module => "schedule_events", :action => "can_change_schedule", :not_editable => false)
      end
    end
  end

  if self.class.respond_to?("inherited_permissions")
    self.class.inherited_permissions.each do |perm|
      fp << Permission.new(perm.merge(:not_editable => true, :user_id => self.id))
    end
  end
  return fp
end
all_permission_by_module() click to toggle source

Devuelve un hash con todos los permisos de este usuario, tanto los heredados por el role como los obtenidos a traves de Permission. Formato:

<tt>{"comments"=>["edit", "official"], "events"=>["create_private", "create_irekia"], "news"=>["create"]}</tt>
# File app/models/user.rb, line 411
def all_permission_by_module
  all_perms = {}
  all_editable_permissions.each {|p| all_perms.has_key?(p.module) ? all_perms[p.module] << p.action : all_perms[p.module] = [p.action]}
  return all_perms
end
approved?() click to toggle source
# File app/models/user.rb, line 549
def approved?
  self.status.eql?('aprobado')
end
approved_and_published_proposals() click to toggle source
# File app/models/user.rb, line 553
def approved_and_published_proposals
  self.proposals.approved.published
end
approved_arguments() click to toggle source
# File app/models/user.rb, line 561
def approved_arguments
  self.arguments.published
end
approved_comments() click to toggle source
# File app/models/user.rb, line 557
def approved_comments
  self.comments.approved
end
approved_headlines() click to toggle source
# File app/models/user.rb, line 565
def approved_headlines
  []
end
authenticated?(password) click to toggle source

Determina si el usuario está autentificado

# File app/models/user.rb, line 181
def authenticated?(password)
  crypted_password == encrypt(password)
end
can?(perm_type, doc_type) click to toggle source

Indica si el colaborador tiene permiso de tipo perm_type en los contenidos de tipo doc_type. Los tipos de contenidos y los correspondientes permisos se pueden consultar en #Permission

Ejemplos:

  • current_user.can?(“create”, “news”)

  • current_user.can?(“administer”, “permissions”)

# File app/models/user.rb, line 348
def can?(perm_type, doc_type)
  # Admin tiene permiso para todo menos para gestionar usuarios y repartir permisos
  if self.is_a?(Admin) && !%w(users permissions).include?(doc_type)
    true
  elsif (![DepartmentMember, Politician].include?(self.class)) && doc_type.eql?("events") &&  %w(create_irekia create_private).include?(perm_type)
    # Los permisos para publicar noticias en irekia, agencia y privados, solo se ponen para los miembros
    # de departamento y políticos. Para los demas, el permiso es el mismo de crear evento
    self.can_create?(doc_type)
  else
    permission?(perm_type, doc_type)
  end
end
can_access?(doc_type) click to toggle source

Indica si tiene permiso para acceder a la administración de los recursos de tipo doc_type. Por defecto, sólo los usuarios de tipo Admin pueden acceder a todos los módulos. En las subclases se concretan los permisos para cada tipo de usuario

Ejemplos:

  • current_user.can_access?(“news”)

  • current_user.can_access?(“photos”)

# File app/models/user.rb, line 228
def can_access?(doc_type)
  if doc_type.eql?("users")
    can?("administer", "permissions")
  else
    [Admin].include?(self.class) 
  end
end
can_change_schedule?(schedule_id) click to toggle source

Indica si el usuario puede traspasar los eventos de la agenda schedule_id a la agenda compartida.

# File app/models/user.rb, line 335
def can_change_schedule?(schedule_id)
  res = false
  if perm = self.schedules_permissions.find_by_schedule_id(schedule_id)
    res = perm.can_change_schedule?
  end
  res
end
can_create?(doc_type) click to toggle source

Indica si puede crear recursos de tipo doc_type. Por defecto, sólo los usuarios de tipo Admin pueden modificar todos los módulos. En las subclases se concretan los permisos para cada tipo de usuario.

Ejemplos:

  • current_user.can_create?(“news”)

  • current_user.can_create?(“photos”)

# File app/models/user.rb, line 250
def can_create?(doc_type)
  [Admin].include?(self.class) 
end
can_edit?(doc_type) click to toggle source

Indica si puede modificar recursos de tipo doc_type. Por defecto, sólo los usuarios de tipo Admin pueden modificar todos los módulos. En las subclases se concretan los permisos para cada tipo de usuario.

Ejemplos:

  • current_user.can_edit?(“news”)

  • current_user.can_edit?(“photos”)

# File app/models/user.rb, line 241
def can_edit?(doc_type)
  [Admin].include?(self.class) 
end
can_edit_schedule?(schedule_id) click to toggle source

Indica si el usuario puede modificar los eventos de la agenda schedule_id

# File app/models/user.rb, line 326
def can_edit_schedule?(schedule_id)
  res = false
  if perm = self.schedules_permissions.find_by_schedule_id(schedule_id)
    res = perm.can_edit?
  end
  res
end
can_see_l_schedule?() click to toggle source

Indica si puede ver los eventos a los que asiste el lehendakari

# File app/models/user.rb, line 318
def can_see_l_schedule?
  if s = Schedule.lehendakari
    return self.can_see_schedule?(s.id)
  end
  false
end
can_see_schedule?(schedule_id) click to toggle source

Indica si puede ver la agenda especial schedule_id

# File app/models/user.rb, line 313
def can_see_schedule?(schedule_id)
  self.schedule_ids.include?(schedule_id)
end
city4api() click to toggle source
# File app/models/user.rb, line 505
def city4api
  self.city
end
deactivate_account() click to toggle source
# File app/models/user.rb, line 521
def deactivate_account
  self.status = 'eliminado'
  self.email = "deleted_#{self.id}@email.com"
  self.remove_photo!
  self.name = 'deleted'
  self.last_names = 'deleted'
  self.screen_name = nil
  self.fb_id = nil
  self.asecret = nil
  self.atoken = nil
  pass = User.random_password
  self.password = pass
  self.password_confirmation = pass
  if self.is_a?(Journalist)  
    self.media = 'deleted'
    self.last_names = 'deleted'
  end  
  self.comments.map{|c| c.update_attribute(:name, 'deleted')}
  self.save
end
editable_schedules_with_create_option() click to toggle source

Returns the list with schedules for which a separate create event button is shown

# File app/models/user.rb, line 298
def editable_schedules_with_create_option
  self.editable_schedules.find(:all, :conditions => 'department_id IS NULL')
end
editable_schedules_with_radio() click to toggle source
# File app/models/user.rb, line 302
def editable_schedules_with_radio
  self.editable_schedules - self.editable_schedules_with_create_option
end
encrypt(password) click to toggle source

Encripta la contraseña con el salt del usuario

# File app/models/user.rb, line 176
def encrypt(password)
  self.class.encrypt(password, salt)
end
follows?(item) click to toggle source
# File app/models/user.rb, line 509
def follows?(item)
  self.send("following_#{item.class.name.downcase.pluralize}").include?(item) if item.present?
end
forget_me() click to toggle source
# File app/models/user.rb, line 204
def forget_me
  self.remember_token_expires_at = nil
  self.remember_token            = nil
  save(false)
end
has_admin_access?() click to toggle source

Indica si puede acceder a alguna de las secciones de la administracion

# File app/models/user.rb, line 260
def has_admin_access?
  self.is_staff? || ["Colaborator", "StreamingOperator", "DepartmentMember", "RoomManager"].include?(self.class.to_s)
end
has_department?() click to toggle source

Indica si se debe especificar departamento para este usuario

# File app/models/user.rb, line 271
def has_department?
  self.respond_to?("department")
end
has_department_schedule?() click to toggle source

Indica si el usuario existe una agenda privada para el departamento al que pertenece el usuario, si es que pertenece a alguno

# File app/models/user.rb, line 460
def has_department_schedule?
  self.has_department? && self.department_id.present? && Schedule.exists?(:department_id=> self.department_id)
end
has_schedule_permissions?() click to toggle source

Permisos para las agendas especiales

# File app/models/user.rb, line 308
def has_schedule_permissions?
  !self.schedules_permissions.blank?
end
internal_name() click to toggle source

Nombre interno, principalmente para el “staff” que tiene nombres públicos con los que no se les puede identificar fácilmente

# File app/models/user.rb, line 164
def internal_name
  internal_name = public_name
  internal_name << " (#{telephone})" unless telephone.blank?
  return internal_name
end
is_admin?() click to toggle source
# File app/models/user.rb, line 210
def is_admin?
  self.is_a?(Admin)
end
is_citizen?() click to toggle source
# File app/models/user.rb, line 214
def is_citizen?
  self.is_a?(Person) || self.is_a?(Journalist)
end
is_facebook_user?() click to toggle source
# File app/models/user.rb, line 480
def is_facebook_user?
  fb_id.present?
end
is_official_commenter?() click to toggle source

Indica si los comentarios de este usuario se consideran oficiales y, por lo tanto, se aprueban automáticamente y se muestran en color destacado

# File app/models/user.rb, line 266
def is_official_commenter?
  self.is_staff? || self.can?('official', 'comments')
end
is_outside_user?() click to toggle source
# File app/models/user.rb, line 472
def is_outside_user?
  is_twitter_user? || is_facebook_user?
end
is_staff?() click to toggle source

Indica si el usuario es miembro del “staff”

# File app/models/user.rb, line 255
def is_staff?
  User::STAFF.include?(self.class.to_s)
end
is_twitter_user?() click to toggle source
# File app/models/user.rb, line 476
def is_twitter_user?
  screen_name.present?
end
lastname4api() click to toggle source
# File app/models/user.rb, line 493
def lastname4api
  self.last_names
end
name4api() click to toggle source
# File app/models/user.rb, line 489
def name4api
  self.name
end
not_follows?(item) click to toggle source
# File app/models/user.rb, line 513
def not_follows?(item)
  !self.follows?(item)
end
organization_ids() click to toggle source

Devuelve un array de los organismos a los que está suscrito. Sólo relevante para periodistas

# File app/models/user.rb, line 276
def organization_ids
  []
end
permission?(perm_type, doc_type) click to toggle source

Indica si el usuario tiene permiso de tipo perm_type en el modulo doc_type. Para ver los valores posibles de estas dos variables, ver el comentario inicial de la clase Permission

# File app/models/user.rb, line 363
def permission?(perm_type, doc_type)
  conditions = ["module=?", doc_type]
  case
  when perm_type.eql?("edit")
    # El permiso de crear lleva consigo el de modificar
    conditions[0] << " AND action IN ('edit', 'create')"
  when !perm_type.eql?("access")
    # access significa cualquier tipo de permiso sobre el modulo
    conditions[0] << " AND action=?"
    conditions << perm_type
  end
  permissions.exists?(conditions)
end
permissions_for_form_array() click to toggle source

Devuelve los mismos permisos que all_editable_permissions pero en el siguiente formato, adecuado para los campos del formulario [perm[news][create], perm[events][create_private]]

# File app/models/user.rb, line 420
def permissions_for_form_array
  output = self.all_editable_permissions.collect {|p| "perm[#{p.module}][#{p.action}]"}
  # logger.info "permissions_for_form_array #{output.inspect}"
  return output
end
postal_code4api() click to toggle source
# File app/models/user.rb, line 497
def postal_code4api
  self.zip
end
province4api() click to toggle source
# File app/models/user.rb, line 501
def province4api
  self.state
end
public_name() click to toggle source

Nombre tal y como aparecerá en las páginas públicas

# File app/models/user.rb, line 154
def public_name
  if name.eql?('deleted')
    I18n.t('users.eliminado')
  else  
    "#{name} #{last_names}"
  end  
end
published?() click to toggle source
# File app/models/user.rb, line 218
def published?
  self.status.eql?('aprobado')
end
remember_me() click to toggle source

These create and unset the fields required for remembering users between browser closes

# File app/models/user.rb, line 190
def remember_me
  remember_me_for(2.weeks)
end
remember_me_for(time) click to toggle source
# File app/models/user.rb, line 194
def remember_me_for(time)
  remember_me_until time.from_now.utc
end
remember_me_until(time) click to toggle source
# File app/models/user.rb, line 198
def remember_me_until(time)
  self.remember_token_expires_at = time
  self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
  save(false)
end
remember_token?() click to toggle source
# File app/models/user.rb, line 185
def remember_token?
  remember_token_expires_at && Time.now.utc < remember_token_expires_at 
end
role4api() click to toggle source

irekia-auth API related methods

# File app/models/user.rb, line 485
def role4api
  self.type.to_s
end
tag_name_es() click to toggle source

Esto lo necesito para poder aplicar el scope “leading” sobre las noticias del home de un usuario porque en el home de usuario se usa la misma función que en el home de un área o de un político

# File app/models/user.rb, line 571
def tag_name_es
  "los usuarios no tienen tag"
end
update_permissions(new_permissions) click to toggle source

Actualiza los permisos del usuario, tanto los de los eventos especiales como los permisos generales

# File app/models/user.rb, line 427
def update_permissions(new_permissions)
  new_permissions ||= {}
  self.transaction do
    logger.info "Nuevos permisos..... #{new_permissions.inspect}"
    if new_schedules_permissions = new_permissions.delete(:schedule_events)
      logger.info "Schedules permissions......... #{new_schedules_permissions.inspect}"
      # Con esta interfaz simplificada, solo podemos asignar permisos en agendas especiales
      # en el departamento al que pertenece el usuario. El resto hay que hacerlo a mano en SQL
      if has_department_schedule?
        # Mantenemos los permisos que le hemos dado fuera de su departamento
        self.schedules_permissions = self.schedules_permissions.find(:all, :conditions => "schedule_id <>#{self.department.schedule.id}")
        new_schedules_permissions_with_sym_keys = Hash[*new_schedules_permissions.collect {|k, v| [k.to_sym, v]}.flatten]
        self.schedules_permissions.build({:schedule_id => self.department.schedule.id, :can_edit => false, :can_change_schedule => false}.merge(new_schedules_permissions_with_sym_keys))
      end
    else
      if self.has_department_schedule?
        self.schedules_permissions.delete(self.schedules_permissions.find(:all, :conditions => "schedule_id =#{self.department.schedule.id}"))
      end
    end
  
    self.permissions.clear
    logger.info "Resto de permisos......... #{new_permissions.inspect}"
    new_permissions.each do |mod, permissions|
      permissions.each do |perm|
        self.permissions.build(:module => mod, :action => perm[0]) if perm[1].to_i == 1
      end
    end
    self.save
  end
end

Protected Instance Methods

create_new_politician_tag() click to toggle source

Crea el tag del político. Se llama desde after_create de un político o al cambiar el tipo de usuario.

# File app/models/user.rb, line 635
def create_new_politician_tag
  tag = Tag.create(:name_es => self.public_name, :name_eu => self.public_name, :name_en => self.public_name, :kind => 'Político', :kind_info => self.id.to_s, :translated => true)
  tag
end
create_tag_if_changed_to_politician() click to toggle source

Si ha cambiado el tipo del usuario y el nuevo tipo es Politician, creamos el tag

# File app/models/user.rb, line 641
def create_tag_if_changed_to_politician
  if !self.respond_to?('tag') && self.type_changed? && self.type.eql?('Politician')
    tag = create_new_politician_tag()
    tag.taggings.create(:taggable_type => 'User', :taggable_id => self.id)
  end
end
destroy_pending_alerts() click to toggle source
# File app/models/user.rb, line 608
def destroy_pending_alerts
  EventAlert.delete_all("spammable_id=#{self.id} AND sent_at IS NULL")
end
email_blank() click to toggle source

Indica si el email está vacío

# File app/models/user.rb, line 618
def email_blank
  self.email.blank?
end
encrypt_password() click to toggle source

Encripta la contraseña

# File app/models/user.rb, line 582
def encrypt_password
  if self.is_a?(Journalist) && self.new_record?
    generate_random_password_if_empty
  end
  
  return if password.blank?
  self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new_record?
  self.crypted_password = encrypt(password)
  self.plain_password = password
end
generate_random_password_if_empty() click to toggle source

Genera un password aleatorio

# File app/models/user.rb, line 623
def generate_random_password_if_empty
  self.password = Journalist.random_password if self.password.blank?
end
nullify_url_if_necessary() click to toggle source

Si el usuario deja la URL con el valor por defecto, se quita porque no es una URL válida

# File app/models/user.rb, line 629
def nullify_url_if_necessary
  self.url = nil if self.url.eql?("http://")
  return true
end
password_required?() click to toggle source

Determina si el password es obligatorio

# File app/models/user.rb, line 613
def password_required?
  !type.eql?('Journalist') && !is_twitter_user? && !is_facebook_user? && (crypted_password.blank? || !password.blank?)
end
reset_official_commenters() click to toggle source
# File app/models/user.rb, line 648
def reset_official_commenters
  if self.type_changed? || User::STAFF.include?(self.type_was)
    User.official_commenters = nil
  end
end
reset_permissions_if_role_changed() click to toggle source

Resetea los permisos de la tabla permissions si el usuario cambia de role

# File app/models/user.rb, line 599
def reset_permissions_if_role_changed
  self.permissions.clear if self.type_changed?
end
reset_schedules_permissions_if_department_changed() click to toggle source

Resetea los permisos de las agendas de departamento si el usuario cambia de departamento

# File app/models/user.rb, line 604
def reset_schedules_permissions_if_department_changed
  self.schedules_permissions = self.schedules_permissions.select {|sp| sp.schedule.department_id.nil?} if self.department_id_changed?
end
set_default_status() click to toggle source

Por defecto los usuarios están aprobados. Se llama desde before_create.

# File app/models/user.rb, line 594
def set_default_status
  self.status = 'aprobado' unless self.status
end