# File app/models/user.rb, line 70
70:   def self.authenticate(email, password)
71:     u = find_by_email_and_status(email, 'aprobado') # need to get the salt
72:     u && u.authenticated?(password) ? u : nil
73:   end

    # File app/models/user.rb, line 76
76:   def self.authenticate_from_url(user_id, crypted_password)
77:     u = find_by_id_and_status_and_crypted_password(user_id, "aprobado", crypted_password)
78:   end

    # File app/models/user.rb, line 94
94:   def self.encrypt(password, salt)
95:     Digest::SHA1.hexdigest("--#{salt}--#{password}--")
96:   end

    # File app/models/user.rb, line 60
60:   def self.irekia_robot
61:     find_by_email("sn@open.irekia.net")
62:   end

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

     # File app/models/user.rb, line 287
287:   def all_editable_permissions
288:     fp = self.permissions.dup
289: 
290:     if self.has_department_schedule?
291:       schedules_permissions.find(:all).each do |sp|
292:         if sp.can_edit?
293:           fp << Permission.new(:user_id => self.id, :module => "schedule_events", :action => "can_edit", :not_editable => false)
294:         end
295:         if sp.can_change_schedule?
296:           fp << Permission.new(:user_id => self.id, :module => "schedule_events", :action => "can_change_schedule", :not_editable => false)
297:         end
298:       end
299:     end
300: 
301:     if self.class.respond_to?("inherited_permissions")
302:       self.class.inherited_permissions.each do |perm|
303:         fp << Permission.new(perm.merge(:not_editable => true, :user_id => self.id))
304:       end
305:     end
306:     return fp
307:   end

     # File app/models/user.rb, line 314
314:   def all_permission_by_module
315:     all_perms = {}
316:     all_editable_permissions.each {|p| all_perms.has_key?(p.module) ? all_perms[p.module] << p.action : all_perms[p.module] = [p.action]}
317:     return all_perms
318:   end

     # File app/models/user.rb, line 104
104:   def authenticated?(password)
105:     crypted_password == encrypt(password)
106:   end

     # File app/models/user.rb, line 251
251:   def can?(perm_type, doc_type)
252:     # Admin tiene permiso para todo menos para gestionar usuarios y repartir permisos
253:     if self.is_a?(Admin) && !%w(users permissions).include?(doc_type)
254:       true
255:     elsif !self.is_a?(DepartmentMember) && doc_type.eql?("events") &&  %w(create_irekia create_agencia create_private).include?(perm_type)
256:       # Los permisos para publicar noticias en irekia, agencia y privados, solo se ponen para los miembros
257:       # de departamento. Para los demas, el permiso es el mismo de crear evento
258:       self.can_create?(doc_type)
259:     else
260:       permission?(perm_type, doc_type)
261:     end
262:   end

     # File app/models/user.rb, line 143
143:   def can_access?(doc_type)
144:     if doc_type.eql?("users")
145:       can?("administer", "permissions")
146:     else
147:       [Admin].include?(self.class) 
148:     end
149:   end

     # File app/models/user.rb, line 238
238:   def can_change_schedule?(schedule_id)
239:     res = false
240:     if perm = self.schedules_permissions.find_by_schedule_id(schedule_id)
241:       res = perm.can_change_schedule?
242:     end
243:     res
244:   end

     # File app/models/user.rb, line 165
165:   def can_create?(doc_type)
166:     [Admin].include?(self.class) 
167:   end

     # File app/models/user.rb, line 156
156:   def can_edit?(doc_type)
157:     [Admin].include?(self.class) 
158:   end

     # File app/models/user.rb, line 229
229:   def can_edit_schedule?(schedule_id)
230:     res = false
231:     if perm = self.schedules_permissions.find_by_schedule_id(schedule_id)
232:       res = perm.can_edit?
233:     end
234:     res
235:   end

     # File app/models/user.rb, line 221
221:   def can_see_l_schedule?
222:     if s = Schedule.ldk
223:       return self.can_see_schedule?(s.id)
224:     end
225:     false
226:   end

     # File app/models/user.rb, line 216
216:   def can_see_schedule?(schedule_id)
217:     self.schedule_ids.include?(schedule_id)
218:   end

     # File app/models/user.rb, line 201
201:   def editable_schedules_with_create_option
202:     self.editable_schedules.find(:all, :conditions => 'department_id IS NULL')
203:   end

     # File app/models/user.rb, line 205
205:   def editable_schedules_with_radio
206:     self.editable_schedules - self.editable_schedules_with_create_option
207:   end

     # File app/models/user.rb, line 99
 99:   def encrypt(password)
100:     self.class.encrypt(password, salt)
101:   end

     # File app/models/user.rb, line 127
127:   def forget_me
128:     self.remember_token_expires_at = nil
129:     self.remember_token            = nil
130:     save(false)
131:   end

     # File app/models/user.rb, line 180
180:   def has_admin_access?
181:     self.is_staff? || ["Colaborator", "StreamingOperator", "RoomManager", "DepartmentMember"].include?(self.class.to_s)
182:   end

     # File app/models/user.rb, line 191
191:   def has_department?
192:     self.respond_to?("department")
193:   end

     # File app/models/user.rb, line 361
361:   def has_department_schedule?
362:     self.has_department? && Schedule.exists?(:department_id=> self.department_id)
363:   end

     # File app/models/user.rb, line 175
175:   def has_ma_access?
176:     self.has_admin_access? || ["Journalist"].include?(self.class.to_s)
177:   end

     # File app/models/user.rb, line 211
211:   def has_schedule_permissions?
212:     !self.schedules_permissions.blank?
213:   end

    # File app/models/user.rb, line 87
87:   def internal_name
88:     internal_name = public_name
89:     internal_name << " (#{telephone})" unless telephone.blank?
90:     return internal_name
91:   end

     # File app/models/user.rb, line 133
133:   def is_admin?
134:     self.is_a?(Admin)
135:   end

     # File app/models/user.rb, line 186
186:   def is_official_commenter?
187:     self.is_staff? || self.can?('official', 'comments')
188:   end

     # File app/models/user.rb, line 170
170:   def is_staff?
171:     User::STAFF.include?(self.class.to_s)
172:   end

     # File app/models/user.rb, line 374
374:   def is_twitter_user?
375:     screen_name.present?
376:   end

     # File app/models/user.rb, line 196
196:   def organization_ids
197:     []
198:   end

     # File app/models/user.rb, line 266
266:   def permission?(perm_type, doc_type)
267:     conditions = ["module=?", doc_type]
268:     case
269:     when perm_type.eql?("edit")
270:       # El permiso de crear lleva consigo el de modificar
271:       conditions[0] << " AND action IN ('edit', 'create')"
272:     when !perm_type.eql?("access")
273:       # access significa cualquier tipo de permiso sobre el modulo
274:       conditions[0] << " AND action=?"
275:       conditions << perm_type
276:     end
277:     permissions.exists?(conditions)
278:   end

     # File app/models/user.rb, line 323
323:   def permissions_for_form_array
324:     output = self.all_editable_permissions.collect {|p| "perm[#{p.module}][#{p.action}]"}
325:     # logger.info "permissions_for_form_array #{output.inspect}"
326:     return output
327:   end

    # File app/models/user.rb, line 81
81:   def public_name
82:     "#{name} #{last_names}"
83:   end

     # File app/models/user.rb, line 113
113:   def remember_me
114:     remember_me_for 2.weeks
115:   end

     # File app/models/user.rb, line 117
117:   def remember_me_for(time)
118:     remember_me_until time.from_now.utc
119:   end

     # File app/models/user.rb, line 121
121:   def remember_me_until(time)
122:     self.remember_token_expires_at = time
123:     self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
124:     save(false)
125:   end

     # File app/models/user.rb, line 108
108:   def remember_token?
109:     remember_token_expires_at && Time.now.utc < remember_token_expires_at 
110:   end

     # File app/models/user.rb, line 369
369:   def stream_flow_ids=(val)
370:     RoomManagement.delete_all("room_manager_id = #{self.id}") unless (self.new_record? || self.is_a?(RoomManager))
371:   end

     # File app/models/user.rb, line 330
330:   def update_permissions(new_permissions)
331:     new_permissions ||= {}
332:     self.transaction do
333:       logger.info "Nuevos permisos..... #{new_permissions.inspect}"
334:       if new_schedules_permissions = new_permissions.delete(:schedule_events)
335:         logger.info "Schedules permissions......... #{new_schedules_permissions.inspect}"
336:         # Con esta interfaz simplificada, solo podemos asignar permisos en agendas especiales
337:         # en el departamento al que pertenece el usuario. El resto hay que hacerlo a mano en SQL
338:         if has_department_schedule?
339:           # Mantenemos los permisos que le hemos dado fuera de su departamento
340:           self.schedules_permissions = self.schedules_permissions.find(:all, :conditions => "schedule_id <>#{self.department.schedule.id}")
341:           new_schedules_permissions_with_sym_keys = Hash[*new_schedules_permissions.collect {|k, v| [k.to_sym, v]}.flatten]
342:           self.schedules_permissions.build({:schedule_id => self.department.schedule.id, :can_edit => false, :can_change_schedule => false}.merge(new_schedules_permissions_with_sym_keys))
343:         end
344:       else
345:         self.schedules_permissions.delete(self.schedules_permissions.find(:all, :conditions => "schedule_id =#{self.department.schedule.id}"))
346:       end
347:     
348:       self.permissions.clear
349:       logger.info "Resto de permisos......... #{new_permissions.inspect}"
350:       new_permissions.each do |mod, permissions|
351:         permissions.each do |perm|
352:           self.permissions.build(:module => mod, :action => perm[0]) if perm[1].to_i == 1
353:         end
354:       end
355:       self.save
356:     end
357:   end

     # File app/models/user.rb, line 413
413:     def email_blank
414:       self.email.blank?
415:     end

     # File app/models/user.rb, line 380
380:     def encrypt_password
381:       if self.is_a?(Journalist) && self.new_record?
382:         generate_random_password_if_empty
383:       end
384:       
385:       return if password.blank?
386:       self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new_record?
387:       self.crypted_password = encrypt(password)
388:       self.plain_password = password
389:     end

     # File app/models/user.rb, line 418
418:     def generate_random_password_if_empty
419:       self.password = Journalist.random_password if self.password.blank?
420:     end

     # File app/models/user.rb, line 424
424:     def nullify_url_if_necessary
425:       self.url = nil if self.url.eql?("http://")
426:       return true
427:     end

     # File app/models/user.rb, line 407
407:     def password_required?
408:       !type.eql?('Journalist') && !is_twitter_user? && (crypted_password.blank? || !password.blank?)
409:     end

     # File app/models/user.rb, line 397
397:     def reset_permissions_if_role_changed
398:       self.permissions.clear if self.type_changed?
399:     end

     # File app/models/user.rb, line 402
402:     def reset_schedules_permissions_if_department_changed
403:       self.schedules_permissions = self.schedules_permissions.select {|sp| sp.schedule.department_id.nil?} if self.department_id_changed?
404:     end

     # File app/models/user.rb, line 392
392:     def set_default_status
393:       self.status = 'aprobado' unless self.status
394:     end