Module: Amistad::Mongoid::FriendModel::InstanceMethods

Defined in:
lib/amistad/mongoid/friend_model.rb

Instance Method Summary collapse

Instance Method Details

#approve(user) ⇒ Object

approve a friendship invitation. If the operation succeeds, the method returns true, else false



37
38
39
40
41
42
43
44
 
# File 'lib/amistad/mongoid/friend_model.rb', line 37

def approve(user)
  return false unless pending_inverse_friend_ids.include?(user.id) && user.pending_friend_ids.include?(self.id)
  pending_inverse_friend_ids.delete(user.id)
  user.pending_friend_ids.delete(self.id)
  inverse_friend_ids << user.id
  user.friend_ids << self.id
  self.save && user.save
end

#block(user) ⇒ Object

blocks a friendship



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/amistad/mongoid/friend_model.rb', line 116

def block(user)          
  if inverse_friend_ids.include?(user.id)
    inverse_friend_ids.delete(user.id)
    user.friend_ids.delete(self.id)
    blocked_inverse_friend_ids << user.id
  elsif pending_inverse_friend_ids.include?(user.id)
    pending_inverse_friend_ids.delete(user.id)
    user.pending_friend_ids.delete(self.id)
    blocked_pending_inverse_friend_ids << user.id
  elsif friend_ids.include?(user.id)
    friend_ids.delete(user.id)
    user.inverse_friend_ids.delete(user.id)
    blocked_friend_ids << user.id
  else
    return false
  end

  self.save
end

#blocked ⇒ Object

returns the list of blocked friends



160
161
162
163
 
# File 'lib/amistad/mongoid/friend_model.rb', line 160

def blocked
  blocked_ids = blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids
  self.class.find(blocked_ids)
end

#blocked?(user) ⇒ Boolean

checks if a user is blocked

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/amistad/mongoid/friend_model.rb', line 171

def blocked?(user)
  (blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids).include?(user.id) or user.blocked_pending_inverse_friend_ids.include?(self.id)
end

#common_friends_with(user) ⇒ Object

return the list of the ones among its friends which are also friend with the given use



77
78
79
 
# File 'lib/amistad/mongoid/friend_model.rb', line 77

def common_friends_with(user)
  self.friends & user.friends
end

#connected_with?(user) ⇒ Boolean

checks if a current user is connected to given user

Returns:

  • (Boolean) 


88
89
90
 
# File 'lib/amistad/mongoid/friend_model.rb', line 88

def connected_with?(user)
  friendshiped_with?(user)
end

#delete_all_friendships ⇒ Object

deletes all the friendships



181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/amistad/mongoid/friend_model.rb', line 181

def delete_all_friendships
  friend_ids.clear
  inverse_friend_ids.clear
  pending_friend_ids.clear
  pending_inverse_friend_ids.clear
  blocked_friend_ids.clear
  blocked_inverse_friend_ids.clear
  blocked_pending_friend_ids.clear
  blocked_pending_inverse_friend_ids.clear
  self.save
end

#friend_with?(user) ⇒ Boolean

checks if a user is a friend

Returns:

  • (Boolean) 


82
83
84
85
 
# File 'lib/amistad/mongoid/friend_model.rb', line 82

def friend_with?(user)
  return false if user == self
  (friend_ids + inverse_friend_ids).include?(user.id)
end

#friends ⇒ Object

returns the list of approved friends



47
48
49
 
# File 'lib/amistad/mongoid/friend_model.rb', line 47

def friends
  self.invited + self.invited_by
end

#friendshiped_with?(user) ⇒ Boolean

check if any friendship exists with another user

Returns:

  • (Boolean) 


176
177
178
 
# File 'lib/amistad/mongoid/friend_model.rb', line 176

def friendshiped_with?(user)
  (friend_ids + inverse_friend_ids + pending_friend_ids + pending_inverse_friend_ids + blocked_friend_ids).include?(user.id)
end

#invite(user) ⇒ Object

suggest a user to become a friend. If the operation succeeds, the method returns true, else false



29
30
31
32
33
34
 
# File 'lib/amistad/mongoid/friend_model.rb', line 29

def invite(user)
  return false if friendshiped_with?(user) or user == self or blocked?(user)
  pending_friend_ids << user.id
  user.pending_inverse_friend_ids << self.id
  self.save && user.save
end

#invited ⇒ Object

return the list of invited friends



57
58
59
 
# File 'lib/amistad/mongoid/friend_model.rb', line 57

def invited
  self.class.find(friend_ids)
end

#invited?(user) ⇒ Boolean

checks if a current user invited given user

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/amistad/mongoid/friend_model.rb', line 98

def invited?(user)
  self.friend_ids.include?(user.id) or self.pending_friend_ids.include?(user.id)
end

#invited_by ⇒ Object

return the list of friends who invited



62
63
64
 
# File 'lib/amistad/mongoid/friend_model.rb', line 62

def invited_by
  self.class.find(inverse_friend_ids)
end

#invited_by?(user) ⇒ Boolean

checks if a current user received invitation from given user

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/amistad/mongoid/friend_model.rb', line 93

def invited_by?(user)
  user.friend_ids.include?(self.id) or user.pending_friend_ids.include?(self.id)
end

#pending_invited ⇒ Object

return the list of pending invited friends



67
68
69
 
# File 'lib/amistad/mongoid/friend_model.rb', line 67

def pending_invited
  self.class.find(pending_friend_ids)
end

#pending_invited_by ⇒ Object

return the list of pending friends who invited



72
73
74
 
# File 'lib/amistad/mongoid/friend_model.rb', line 72

def pending_invited_by
  self.class.find(pending_inverse_friend_ids)
end

#remove_friendship(user) ⇒ Object

deletes a friendship



103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/amistad/mongoid/friend_model.rb', line 103

def remove_friendship(user)
  friend_ids.delete(user.id)
  user.inverse_friend_ids.delete(self.id)
  inverse_friend_ids.delete(user.id)
  user.friend_ids.delete(self.id)
  pending_friend_ids.delete(user.id)
  user.pending_inverse_friend_ids.delete(self.id)
  pending_inverse_friend_ids.delete(user.id)
  user.pending_friend_ids.delete(self.id)
  self.save && user.save
end

#total_blocked ⇒ Object

total # of blockades and blockedes_by without association loading



166
167
168
 
# File 'lib/amistad/mongoid/friend_model.rb', line 166

def total_blocked
  (blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids).count
end

#total_friends ⇒ Object

total # of invited and invited_by without association loading



52
53
54
 
# File 'lib/amistad/mongoid/friend_model.rb', line 52

def total_friends
  (friend_ids + inverse_friend_ids).count
end

#unblock(user) ⇒ Object

unblocks a friendship



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/amistad/mongoid/friend_model.rb', line 137

def unblock(user)
  if blocked_inverse_friend_ids.include?(user.id)
    blocked_inverse_friend_ids.delete(user.id)
    user.blocked_friend_ids.delete(self.id)
    inverse_friend_ids << user.id
    user.friend_ids << self.id
  elsif blocked_pending_inverse_friend_ids.include?(user.id)
    blocked_pending_inverse_friend_ids.delete(user.id)
    pending_inverse_friend_ids << user.id
    user.pending_friend_ids << self.id
  elsif blocked_friend_ids.include?(user.id)
    blocked_friend_ids.delete(user.id)
    user.blocked_inverse_friend_ids.delete(self.id)
    friend_ids << user.id
    user.inverse_friend_ids << self.id
  else
    return false
  end

  self.save && user.save
end