Creating a Facebook Clone - Part XXII - Transcript.pdf

Creating a Facebook Clone - Part XXII
UserService is a big class and it makes sense to cover in two parts

setProps(user, u);
if (u.getPassword() != null) {
u.setPassword(encoder.encode(user.getPassword()));
}
users.save(u);
}
public byte[] getAvatar(String userId) {
User u = users.findById(userId).get();
if (u.getAvatar() != null) {
return u.getAvatar().getData();
}
return null;
}
public void setAvatar(String authToken, String mediaId) {
Media m = medias.findById(mediaId).get();
User u = users.findByAuthtoken(authToken).get(0);
u.setAvatar(m);
users.save(u);
}
public void sendFriendRequest(String auth, String userId) {
User me = users.findByAuthtoken(auth).get(0);
User him = users.findById(userId).get();
UserService
Next on the agenda is getAvatar, it returns the avatar picture of the user as a byte array

setProps(user, u);
}
users.save(u);
}
}
return null;
}
u.setAvatar(m);
users.save(u);
}
UserService
Notice we need an id and not a token to get the avatar as anyone who is familiar with the user ID should be able to see the avatar

setProps(user, u);
}
users.save(u);
}
}
return null;
}
u.setAvatar(m);
users.save(u);
}
UserService
If the avatar reference is null we return null instantly

setProps(user, u);
}
users.save(u);
}
}
return null;
}
u.setAvatar(m);
users.save(u);
}
UserService
The setAvatar method works in a similar way

setProps(user, u);
}
users.save(u);
}
}
return null;
}
u.setAvatar(m);
users.save(u);
}
UserService
Notice that unlike getAvatar with setAvatar we need a token as this is a set operation. This prevents other users from changing our avatar.

When we map this to the webservice we need to first create a media entry and only then set the avatar value.

u.setAvatar(m);
users.save(u);
}
him.getFriendRequests().add(me);
users.save(him);
notifications.sendNotification(him,
new NotificationDAO(null, me.getDAO(),
"wants to be friends",
"uE7FC", 0x587EBE,
0, true, null, null));
}
public void acceptFriendRequest(String auth, String userId) {
if (me.getFriendRequests().contains(him)) {
me.getFriendRequests().remove(him);
me.getFriends().add(him);
him.getFriendRequests().remove(me);
him.getFriends().add(me);
users.saveAll(Arrays.asList(me, him));
UserService
The friend request includes a few moving parts. First we need to send a request.

u.setAvatar(m);
users.save(u);
}
users.save(him);
"uE7FC", 0x587EBE,
}
UserService
We need an auth token as this is a secure operation

u.setAvatar(m);
users.save(u);
}
users.save(him);
"uE7FC", 0x587EBE,
}
UserService
We obviously don't have the auth token of the person we are "friending"

u.setAvatar(m);
users.save(u);
}
users.save(him);
"uE7FC", 0x587EBE,
}
UserService
This is a special case where we modify his entity without an auth-token, that's a bit risky...

u.setAvatar(m);
users.save(u);
}
users.save(him);
"uE7FC", 0x587EBE,
}
UserService
The notification service should notify the user that he got a new friend request. We'll dig into the notification service soon…

users.save(him);
"uE7FC", 0x587EBE,
}
}
}
public void uploadContacts(String auth, List<ShadowUserDAO> contacts) {
Long c = shadows.countByUser(auth);
UserService
But first lets check out the other side of the equation. The acceptFriendRequest method.

users.save(him);
"uE7FC", 0x587EBE,
}
}
}
UserService
This time me & him are flipped

users.save(him);
"uE7FC", 0x587EBE,
}
}
}
UserService
This checks against a potential weakness where a hacker could potentially call accept friend request for a person that didn't request it

users.save(him);
"uE7FC", 0x587EBE,
}
}
}
UserService
When a request is accepted we need to update the friend list on both sides. I didn't add a removeFriendRequest method which I probably should have added. I think it's
trivial to add so I'm leaving it as an exercise.

}
}
User u = users.findByAuthtoken(auth).get(0);
if (c == null || c == 0) {
List<ShadowUser> shadowList = new ArrayList<>();
for (ShadowUserDAO d : contacts) {
shadowList.add(new ShadowUser(d, u));
updatePeopleYouMayKnow(d, u);
}
shadows.saveAll(shadowList);
} else {
List<ShadowUser> results = shadows.findByFullName(auth, d.
getFullName());
if (!results.isEmpty()) {
shadows.save(new ShadowUser(d, u));
} else {
ShadowUser current = results.get(0);
current.setEmail(d.getEmail());
current.setPhone(d.getPhone());
current.setSecondaryPhone(d.getSecondaryPhone());
shadows.save(current);
UserService
The last method for UserService is the `uploadContacts` method...

It's invoked when the user uploads the contacts from his phone.

}
}
if (c == null || c == 0) {
}
} else {
getFullName());
} else {
UserService
If we uploaded contacts in the past its a good idea to try and merge with what we have. We can check that by running a count query

}
}
if (c == null || c == 0) {
}
} else {
getFullName());
} else {
UserService
For every contact we find we check to see if there is a user in the system and if so we add that user to the people you may know list

}
}
if (c == null || c == 0) {
}
} else {
getFullName());
} else {
UserService
When adding a lot of elements using saveAll is much faster than save

if (c == null || c == 0) {
}
} else {
getFullName());
} else {
}
}
}
}
private void updatePeopleYouMayKnow(ShadowUserDAO d, User u) {
UserService
For simplicity I chose to merge based on full name. In retrospect it might have been wiser to use the device unique ID for every contact but that might breed duplicates
too.

I oversimplified a very complex process of handling shadow users. If you take the time to build something like this then make sure to analyze the data more thoroughly
and create a more robust social graph.

}
}
}
}
User friend = findHim(d);
if (friend != null) {
if (!u.getFriends().contains(friend)
&& !u.getPeopleYouMayKnow().contains(friend)) {
u.getPeopleYouMayKnow().add(friend);
users.save(u);
}
}
}
private User findHim(ShadowUserDAO d) {
if (d.getEmail() != null) {
List<User> l = users.findByEmailIgnoreCase(d.getEmail());
if (l != null && !l.isEmpty()) {
return l.get(0);
UserService
Notice that we still need to declare the updatePeopleYouMayKnow method we mentioned before

}
}
}
}
users.save(u);
}
}
}
return l.get(0);
UserService
We search for the shadow user in the table of users using the findHim method which we'll cover soon

}
}
}
}
users.save(u);
}
}
}
return l.get(0);
UserService
If a friend was found & isn't already a friend or in the "People You May Know" list...

}
}
}
}
users.save(u);
}
}
}
return l.get(0);
UserService
Then we can add that user to the people you may know

}
}
}
return l.get(0);
}
}
if (d.getPhone() != null) {
List<User> l = users.findByPhone(d.getPhone());
return l.get(0);
}
}
if (d.getSecondaryPhone() != null) {
List<User> l = users.findByPhone(d.getSecondaryPhone());
return l.get(0);
}
}
return null;
}
}
UserService
The findHim method is simple boilerplate that searches based on all the meta data in the shadow user. We use findByEmail/phone etc. to find the shadow user in our
regular user database.

With that we finished the UserService class which is the largest service class!

Creating a Facebook Clone - Part XXII - Transcript.pdf

More Related Content

Similar to Creating a Facebook Clone - Part XXII - Transcript.pdf (8)

More from ShaiAlmog1 (20)

Recently uploaded (20)

Creating a Facebook Clone - Part XXII - Transcript.pdf