/**
* This function is called in the benchmarking phase which is executed with the -t argument.
*
* <p>gets the list of friends for a member.
*
* @param requesterID The unique identifier of the user who wants to view profile owners friends.
* @param profileOwnerID The id of the profile for which the friends are listed.
* @param fields Contains the attribute names required for each friend. This can be set to null to
* retrieve all the friend information.
* @param result A Vector of HashMaps, where each HashMap is a set field/value pairs for one
* friend.
* @param insertImage If set to true the thumbnail images for the friends will be retrieved from
* the data store.
* @param testMode If set to true the thumbnail images of friends will be written to the file
* system.
* @return Zero on success, a non-zero error code on error. See this class's description for a
* discussion of error codes.
* <p>The code written for this function should retrieve the list of friends for the
* profileOwnerID. The information retrieved per friend depends on the fields specified in the
* fields set. if fields is set to null all profile information for the friends is retrieved
* and the result hashmap is populated. The friend's unique id should be inserted with the
* "userid" key into the result hashmap. The lack of this attribute or the lack of the
* attribute key in lower case causes BG to raise exceptions. In addition if the insertImage
* flag is set to true, the thumbnails for each friend's profile should be retrieved and
* inserted into the result hashmap using the "pic" key.
*/
@Override
public int listFriends(
int requesterID,
int profileOwnerID,
Set<String> fields,
Vector<HashMap<String, ByteIterator>> result,
boolean insertImage,
boolean testMode) {
try {
JsonObject ownerObject = transactionHelper.readUser(String.valueOf(profileOwnerID));
if (ownerObject.has(CONFIRMED_FRIENDS)) {
JsonArray jsonArray = ownerObject.getAsJsonArray(CONFIRMED_FRIENDS);
for (JsonElement element : jsonArray) {
String friendId = element.getAsJsonPrimitive().getAsString();
/** Read all the friends. */
JsonObject friendObject = transactionHelper.readUser(friendId);
HashMap<String, ByteIterator> hashMap = new HashMap<>();
if (fields == null) {
for (Map.Entry<String, JsonElement> entry : friendObject.entrySet()) {
StringByteIterator stringValue =
new StringByteIterator(entry.getValue().getAsJsonPrimitive().getAsString());
hashMap.put(entry.getKey(), stringValue);
}
} else {
for (String field : fields) {
StringByteIterator stringValue =
new StringByteIterator(friendObject.get(field).getAsString());
hashMap.put(field, stringValue);
}
}
result.add(hashMap);
}
}
} catch (ConnectionException | NotFoundException e) {
e.printStackTrace();
return -1;
}
return 0;
}
/**
* This function is called in the benchmarking phase which is executed with the -t argument. Get
* the profile object for a user.
*
* @param requesterID Unique identifier for the requester.
* @param profileOwnerID unique profile owner's identifier.
* @param result A HashMap with all data returned. These data are different user information
* within the profile such as friend count, friend request count, etc.
* @param insertImage Identifies if the users have images in the database. If set to true the
* images for the users will be retrieved.
* @param testMode If set to true images will be retrieved and stored on the file system. While
* running benchmarks this field should be set to false.
* @return 0 on success a non-zero error code on error. See this class's description for a
* discussion of error codes.
* <p>The code written for this function retrieves the user's profile details, friendcount
* (number of friends for that user) and resourcecount (number of resources inserted on that
* user's wall). In addition if the requesterID is equal to the profileOwnerID, the
* pendingcount (number of pending friend requests) needs to be returned as well.
* <p>If the insertImage is set to true, the image for the profileOwnerID will be rertrieved.
* The insertImage should be set to true only if the user entity has an image in the database.
* <p>The friendcount, resourcecount, pendingcount should be put into the results HashMap with
* the following keys: "friendcount", "resourcecount" and "pendingcount", respectively. Lack
* of these attributes or not returning the attribute keys in lower case causes BG to raise
* exceptions. In addition, all other attributes of the profile need to be added to the result
* hashmap with the attribute names being the keys and the attribute values being the values
* in the hashmap.
* <p>If images exist for users, they should be converted to bytearrays and added to the
* result hashmap.
*/
@Override
public int viewProfile(
int requesterID,
int profileOwnerID,
HashMap<String, ByteIterator> result,
boolean insertImage,
boolean testMode) {
JsonObject jsonObject;
try {
jsonObject = transactionHelper.readUser(String.valueOf(profileOwnerID));
} catch (ConnectionException | NotFoundException e) {
e.printStackTrace();
return -1;
}
/** Dump data to result. */
jsonObject
.entrySet()
.forEach(
entry -> {
if (!entry.getKey().equals(PENDING_FRIENDS)
&& !entry.getKey().equals(CONFIRMED_FRIENDS)
&& !entry.getKey().equals(RESOURCES)) {
result.put(entry.getKey(), new StringByteIterator(entry.getValue().getAsString()));
}
});
/** Count friends. */
int friendCount = 0;
if (jsonObject.has(CONFIRMED_FRIENDS)) {
JsonArray jsonArray = jsonObject.getAsJsonArray(CONFIRMED_FRIENDS);
friendCount = jsonArray.size();
}
result.put(FRIEND_COUNT, new ObjectByteIterator(String.valueOf(friendCount).getBytes()));
/** Count resources. */
int resourceCount = 0;
if (jsonObject.has(RESOURCES)) {
JsonArray jsonArray = jsonObject.getAsJsonArray(RESOURCES);
resourceCount = jsonArray.size();
}
result.put(RESOURCE_COUNT, new ObjectByteIterator(String.valueOf(resourceCount).getBytes()));
/** Pending friendships. */
if (requesterID == profileOwnerID) {
int pendingCount = 0;
JsonElement jsonElement = jsonObject.get(PENDING_FRIENDS);
if (jsonElement != null) {
pendingCount = jsonElement.getAsJsonArray().size();
}
result.put(PENDING_COUNT, new ObjectByteIterator(String.valueOf(pendingCount).getBytes()));
}
return 0;
}
/**
* This function is called in the load phase which is executed using the -load or -loadindex
* argument. It is used for inserting users and resources. Any field/value pairs in the values
* HashMap for an entity will be written into the specified entity set with the specified entity
* key.
*
* @param entitySet The name of the entity set with the following two possible values: users and
* resources. BG passes these values in lower case. The implementation may manipulate the case
* to tailor it for the purposes of a data store.
* @param entityPK The primary key of the entity to insert.
* @param values A HashMap of field/value pairs to insert for the entity, these pairs are the
* other attributes for an entity and their values. The profile image is identified with the
* "pic" key attribute and the thumbnail image is identified with the "tpic" key attribute.
* @param insertImage Identifies if images should be inserted for users. if set to true the code
* should populate each entity with an image; the size of the image is specified using the
* imagesize parameter.
* @return Zero on success, a non-zero error code on error. See this class's description for a
* discussion of error codes. The code written for this function call should insert the entity
* and its attributes. The code is responsible for inserting the PK and the other attributes
* in the appropriate order.
*/
@Override
public int insertEntity(
String entitySet,
String entityPK,
HashMap<String, ByteIterator> values,
boolean insertImage) {
/** Insert Users and Resources data using JSON-like data model. */
JsonObject jsonObject = new JsonObject();
for (Map.Entry<String, ByteIterator> entry : values.entrySet()) {
if (!entry.getKey().equals("pic") && !entry.getKey().equals("tpic")) {
jsonObject.add(entry.getKey(), new JsonPrimitive(entry.getValue().toString()));
}
}
try {
transactionHelper.writeUser(entityPK, jsonObject);
} catch (ConnectionException | AbortException e) {
e.printStackTrace();
return -1;
}
/** Update Users data after inserting Resources. */
if (entitySet.equals(RESOURCES)) {
try {
ByteIterator wallUserID = values.get(WALL_USER_ID);
jsonObject = transactionHelper.readUser(wallUserID.toString());
JsonArray jsonArray;
if (jsonObject.has(RESOURCES)) {
jsonArray = jsonObject.getAsJsonArray(RESOURCES);
} else {
jsonArray = new JsonArray();
}
jsonArray.add(new JsonPrimitive(entityPK));
jsonObject.add(RESOURCES, jsonArray);
transactionHelper.writeUser(wallUserID.toString(), jsonObject);
} catch (ConnectionException | NotFoundException | AbortException e) {
e.printStackTrace();
return -1;
}
}
return 0;
}