Class: User

80
81
82
83
84
85
86
87

# File 'app/models/user.rb', line 80

def self.find_for_database_authentication(conditions={})
  conditions = conditions.dup
  conditions[:username] = conditions[:username].downcase
  if conditions[:username] =~ /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i # email regex
    conditions[:email] = conditions.delete(:username)
  end
  where(conditions).first
end

308
309
310
311

# File 'app/models/user.rb', line 308

def self.generate_key
  key_size = (Rails.env == 'test' ? 512 : 4096)
  OpenSSL::PKey::RSA::generate key_size
end

106
107
108
109

# File 'app/models/user.rb', line 106

def add_contact_to_aspect(contact, aspect)
  return true if AspectMembership.exists?(:contact_id => contact.id, :aspect_id => aspect.id)
  contact.aspect_memberships.create!(:aspect => aspect)
end

138
139
140
141
142
143

# File 'app/models/user.rb', line 138

def add_to_streams(post, aspects_to_insert)
  post.socket_to_user(self, :aspect_ids => aspects_to_insert.map{|x| x.id}) if post.respond_to? :socket_to_user
  aspects_to_insert.each do |aspect|
    aspect.posts << post
  end
end

317
318
319

# File 'app/models/user.rb', line 317

def admin?
  AppConfig[:admins].present? && AppConfig[:admins].include?(self.username)
end

145
146
147
148
149
150
151

# File 'app/models/user.rb', line 145

def aspects_from_ids(aspect_ids)
  if aspect_ids == "all" || aspect_ids == :all
    self.aspects
  else
    aspects.where(:id => aspect_ids)
  end
end

165
166
167

# File 'app/models/user.rb', line 165

def build_comment(options = {})
  build_relayable(Comment, options)
end

170
171
172

# File 'app/models/user.rb', line 170

def build_like(options = {})
  build_relayable(Like, options)
end

112
113
114
115
116
117
118

# File 'app/models/user.rb', line 112

def build_post(class_name, opts = {})
  opts[:author] = self.person
  opts[:diaspora_handle] = opts[:author].diaspora_handle

  model_class = class_name.to_s.camelize.constantize
  model_class.diaspora_initialize(opts)
end

157
158
159
160
161
162

# File 'app/models/user.rb', line 157

def build_relayable(model, options = {})
  r = model.new(options.merge(:author_id => self.person.id))
  r.set_guid
  r.initialize_signatures
  r
end

89
90
91
92
93

# File 'app/models/user.rb', line 89

def can_add?(person)
  return false if self.person == person
  return false if self.contact_for(person).present?
  true
end

331
332
333
334
335
336
337
338
339
340
341

# File 'app/models/user.rb', line 331

def disconnect_everyone
  self.contacts.each do |contact|
    if contact.person.remote?
      self.disconnect(contact)
    else
      contact.person.owner.disconnected_by(self.person)
      remove_contact(contact, :force => true)
    end
  end
  self.aspects.destroy_all
end

120
121
122
123

# File 'app/models/user.rb', line 120

def dispatch_post(post, opts = {})
  mailman = Postzord::Dispatch.new(self, post)
  mailman.post(opts)
end

313
314
315

# File 'app/models/user.rb', line 313

def encryption_key
  OpenSSL::PKey::RSA.new(serialized_private_key)
end

234
235
236
237
238
239
240
241
242
243
244
245

# File 'app/models/user.rb', line 234

def invite_user(aspect_id, service, identifier, invite_message = "")
  aspect = aspects.find(aspect_id)
  if aspect
    Invitation.invite(:service => service,
                      :identifier => identifier,
                      :from => self,
                      :into => aspect,
                      :message => invite_message)
  else
    false
  end
end

182
183
184
185
186
187
188
189

# File 'app/models/user.rb', line 182

def like_for(post)
  [post.likes, post.dislikes].each do |likes|
    likes.each do |like|
      return like if like.author_id == self.person.id
    end
  end
  return nil
end

174
175
176
177
178
179
180

# File 'app/models/user.rb', line 174

def liked?(post)
  if self.like_for(post)
    return true
  else
    return false
  end
end

192
193
194
195
196
197

# File 'app/models/user.rb', line 192

def mail(job, *args)
  pref = job.to_s.gsub('Job::Mail', '').underscore
  if(self.disable_mail == false && !self.user_preferences.exists?(:email_type => pref))
    Resque.enqueue(job, *args)
  end
end

96
97
98
99
100
101
102
103
104

# File 'app/models/user.rb', line 96

def move_contact(person, to_aspect, from_aspect)
  return true if to_aspect == from_aspect
  contact = contact_for(person)

  add_contact_to_aspect(contact, to_aspect)

  membership = contact ? AspectMembership.where(:contact_id => contact.id, :aspect_id => from_aspect.id).first : nil
  return(membership && membership.destroy)
end

132
133
134
135
136

# File 'app/models/user.rb', line 132

def notify_if_mentioned(post)
  return unless self.contact_for(post.author) && post.respond_to?(:mentions?)

  post.notify_person(self.person) if post.mentions? self.person
end

321
322
323
324
325

# File 'app/models/user.rb', line 321

def remove_all_traces
  disconnect_everyone
  remove_mentions
  remove_person
end

343
344
345
346
347

# File 'app/models/user.rb', line 343

def remove_mentions
  Mention.where( :person_id => self.person.id).each do |mentioned_person|
    mentioned_person.delete
  end
end

327
328
329

# File 'app/models/user.rb', line 327

def remove_person
  self.person.destroy
end

200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

# File 'app/models/user.rb', line 200

def retract(post)
  if post.respond_to?(:relayable?) && post.relayable?
    aspects = post.parent.aspects
    retraction = RelayableRetraction.build(self, post)
  else
    aspects = post.aspects
    retraction = Retraction.for(post)
  end

  mailman = Postzord::Dispatch.new(self, retraction)
  mailman.post

  retraction.perform(self)

  retraction
end

153
154
155

# File 'app/models/user.rb', line 153

def salmon(post)
  Salmon::SalmonSlap.create(self, post.to_diaspora_xml)
end

303
304
305
306

# File 'app/models/user.rb', line 303

def seed_aspects
  self.aspects.create(:name => I18n.t('aspects.seed.family'))
  self.aspects.create(:name => I18n.t('aspects.seed.work'))
end

76
77
78

# File 'app/models/user.rb', line 76

def set_current_language
  self.language = I18n.locale.to_s if self.language.blank?
end

278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301

# File 'app/models/user.rb', line 278

def setup(opts)
  self.username = opts[:username]
  self.email = opts[:email]
  self.valid?
  errors = self.errors
  errors.delete :person
  return if errors.size > 0

  opts[:person] ||= {}
  unless opts[:person][:profile].is_a?(Profile)
    opts[:person][:profile] ||= Profile.new
    opts[:person][:profile] = Profile.new(opts[:person][:profile])
  end

  self.person = Person.new(opts[:person])
  self.person.diaspora_handle = "#{opts[:username]}@#{AppConfig[:pod_uri].host}"
  self.person.url = AppConfig[:pod_url]


  self.serialized_private_key = User.generate_key if self.serialized_private_key.blank?
  self.person.serialized_public_key = OpenSSL::PKey::RSA.new(self.serialized_private_key).public_key

  self
end

69
70
71
72
73
74

# File 'app/models/user.rb', line 69

def strip_and_downcase_username
  if username.present?
    username.strip!
    username.downcase!
  end
end

125
126
127
128
129
130

# File 'app/models/user.rb', line 125

def update_post(post, post_hash = {})
  if self.owns? post
    post.update_attributes(post_hash)
    Postzord::Dispatch.new(self, post).post
  end
end

218
219
220
221
222
223
224
225
226
227
228
229
230
231

# File 'app/models/user.rb', line 218

def update_profile(params)
  if photo = params.delete(:photo)
    photo.update_attributes(:pending => false) if photo.pending
    params[:image_url] = photo.url(:thumb_large)
    params[:image_url_medium] = photo.url(:thumb_medium)
    params[:image_url_small] = photo.url(:thumb_small)
  end
  if self.person.profile.update_attributes(params)
    Postzord::Dispatch.new(self, profile).post
    true
  else
    false
  end
end

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# File 'app/models/user.rb', line 50

def update_user_preferences(pref_hash)
  if self.disable_mail
    UserPreference::VALID_EMAIL_TYPES.each{|x| self.user_preferences.find_or_create_by_email_type(x)}
    self.disable_mail = false
    self.save
  end

  pref_hash.keys.each do |key|
    if pref_hash[key] == 'true'
      self.user_preferences.find_or_create_by_email_type(key)
    else
      block = self.user_preferences.where(:email_type => key).first
      if block
        block.destroy
      end
    end
  end
end