khedomain.js

Parse.Cloud.define("sendMessage", function(request, response) {
    var senderProfileId = request.user.get("profile").id;
    var Message = Parse.Object.extend("Message");
    var messageObject = new Message();
    var recipientProfileId = request.params.receiverId;
    var messageText = request.params.message;
    messageObject.set("senderId", senderProfileId);
    messageObject.set("receiverId", recipientProfileId);
    messageObject.set("message", messageText);
    messageObject.set("isSeen", false);
    messageObject.save(null, {
        success: function(messageObject) {
            sendPushMessage(recipientProfileId);
        },
        error: function(messageObject, error) {
            response.error("Failed to save message with error: " + error.message);
        }
    });

    function sendPushMessage(recipientProfileId) {
        var messageJson = {
                        type : "message"
                        };
        // Send the push.
        // Find devices associated with the recipient user
        var Profile = Parse.Object.extend("Profile");
        var receiverProfile = new Profile();
        receiverProfile.id = recipientProfileId;

        var userQuery = new Parse.Query(Parse.User);
        userQuery.equalTo('profile', receiverProfile);

        var query = new Parse.Query(Parse.Installation);
        query.matchesQuery('user', userQuery);

        // Send the push notification to results of the query
        Parse.Push.send(
        {
            where: query,
            data:
            {
                alert: messageJson
            }
        }).then(function()
                {
                    response.success(true)
                }, function(error) {
                    response.error("Push failed to send with error: " + error.message);
                }
        );
     }
});

Parse.Cloud.define("getProfile", function(request, response) {
    var profileId = request.params.profileId;
    getProfile(profileId, response.success, response.error);
});

function getProfile(profileId, success, error) {
    var profileQuery = new Parse.Query("Profile");
    profileQuery.get(profileId, {
        success: function(object) {
            success(object);
        },
        error: function(object, error1) {
            error(error1);
        }
    });
}

Parse.Cloud.define("getMessages", function(request, response) {
    var senderProfileId = request.user.get("profile").id;
    var receiverId = request.params.receiverId;
    var limit = request.params.limit;
    var skip = request.params.skip;

    var conversationQuery1 = new Parse.Query("Message");
    conversationQuery1.equalTo("senderId", senderProfileId);
    conversationQuery1.equalTo("receiverId", receiverId);

    var conversationQuery2 = new Parse.Query("Message");
    conversationQuery2.equalTo("senderId", receiverId);
    conversationQuery2.equalTo("receiverId", senderProfileId);

    var mainQuery = new Parse.Query.or(conversationQuery1, conversationQuery2);
    mainQuery.descending("createdAt");

    if (skip !== undefined) {
        mainQuery.skip(skip);
    }

    if (limit !== undefined) {
        mainQuery.limit(limit);
    }

    var resultobj = [];
    mainQuery.find({
        success: function(results) {
            for (var i = 0; i < results.length; i++) {
                var result = {
                    type : "message",
                    message : results[i].get("message"),
                    isSeen : results[i].get("isSeen"),
                    receiverId : results[i].get("receiverId"),
                    senderId : results[i].get("senderId"),
                    createdAt : results[i].createdAt};
                resultobj.push(result);
            }
            response.success(resultobj);
        },
        error: function() {
            response.error("Failed to find messages");
        }
    });
});

Parse.Cloud.define("dislike", function(request, response) {
        var senderId = request.user.id;
        var senderProfileId = request.user.get("profile").id;
        var receiverId = request.params.receiverId;
      //  console.log("receiverId = " + receiverId);

        var Profile = Parse.Object.extend("Profile");
        var profileQuery = new Parse.Query(Profile);
        profileQuery.get(receiverId, {
            success: function(profile) {
                profile.addUnique("dislikedBy", senderProfileId);
                profile.save(response, {
                    success: function(savedProfile) {
              //          console.log("dislike saved");
                        response.success();
                    },
                    error: function (object, error) {
                //        console.log("dislike not saved");
                        response.error(error);
                    }
                });
            },
            error: function(object, error) {
                response.error(error);
            }
        });
});

Parse.Cloud.define("unmatch", function(request, response) {
  //Currnty not working!!!
  //FIX or DELETE
        var unmatchedUserProfileId = request.params.unmatchedUserProfileId;
        var senderUserId = request.user.get("profile").id;

        var Profile = Parse.Object.extend("Profile");
        var profileQuery = new Parse.Query(Profile);

        profileQuery.get(unmatchedUserProfileId, {
            success: function(profile) {
                profileQuery.remove("likedBy", senderProfileId);
                profileQuery.save(response, {
                     success: function(savedProfile) {
                    //    console.log("unmatched user successfuly");
                        response.success();
                },
                error: function (object, error) {
                    //    console.log("unmatched user failed");
                        response.error(error);
                    }
                });
            },
            error: function(object, error) {
                response.error(error);
            }
        });
});

function matchPushFunc(myProfileId, receiverProfileId) {
        var matchObject = {
                        type : "match",
                        receiverId: receiverProfileId,
                        senderId: myProfileId
                        };
        // Send the push.
        // Find devices associated with the recipient user
        var Profile = Parse.Object.extend("Profile");
        var receiverProfile = new Profile();
        receiverProfile.id = receiverProfileId;

        var userQuery = new Parse.Query(Parse.User);
        userQuery.equalTo('profile', receiverProfile);

        var androidQuery = new Parse.Query(Parse.Installation);
        androidQuery.matchesQuery('user', userQuery);
        androidQuery.equalTo('deviceType', "android");

        var iosQuery = new  Parse.Query(Parse.Installation);
        iosQuery.matchesQuery('user', userQuery);
        iosQuery.equalTo('deviceType', "ios");

        console.log("sending push: profileId = " + receiverProfile);
        //Custom push for android devices
        Parse.Push.send({
            where: androidQuery,
            data: {
                alert: matchObject
            }
        });
        //Custom push for iOS devices
        Parse.Push.send({
        where: iosQuery,
        data: {
            alert: "Congrats! You've Got a Match",
            badge: "Increment",
            sound: "default",
            push_container: matchObject
        }
    });
}

Parse.Cloud.define("matchPush", function(request, response) {
        var matchObject = {
                        type : "match",
                        receiverId: request.params.receiverId,
                        senderId: request.user.get("profile").id
                        };
        // Send the push.
        // Find devices associated with the recipient user
        var Profile = Parse.Object.extend("Profile");
        var receiverProfile = new Profile();
        receiverProfile.id = request.params.receiverId;

        var userQuery = new Parse.Query(Parse.User);
        userQuery.equalTo('profile', receiverProfile);

        var query = new Parse.Query(Parse.Installation);
        query.matchesQuery('user', userQuery);

        // Send the push notification to results of the query
        Parse.Push.send(
        {
            where: query,
            data:
            {
                alert: matchObject
            }
        }).then(function()
                {
                    response.success(true)
                }, function(error) {
                    response.error("Push failed to send with error: " + error.message);
                }
        );
});

Parse.Cloud.define("report", function(request, response) {
        Parse.Cloud.useMasterKey();

        var profileId = request.params.profileId;
        var Profile = Parse.Object.extend("Profile");
        var targetProfile = new Profile();
        targetProfile.id = profileId;

        var userQuery = new Parse.Query(Parse.User);
        userQuery.equalTo('profile', targetProfile);
        userQuery.first({
                success: function(targetUser) {
                        targetUser.addUnique("reportedBy", Parse.User.current());
                        targetUser.save().then(function(obj) {
                                response.success(obj);
                        },
                        function(error) {
                                reponse.error(error);
                        });
                },
                error: function(error) {
                        response.error(error);
                }
        });
});


// response object
// {profileId, name, avatar, lastMessage, lastMessageDate}
Parse.Cloud.define("getMatches", function(request, response) {
        var currentUser = Parse.User.current();
        currentUser.get("profile").fetch({
                success: function(currentProfile) {
                        var conversationQuery = new Parse.Query("Profile");
                        conversationQuery.equalTo("likedBy", currentProfile.id);
                        conversationQuery.containedIn("objectId", currentProfile.get("likedBy"));
                        conversationQuery.find({
                                success: function(profiles) {
                                        var results = [];
                                        if (profiles == undefined) {
                                                response.success(results);
                                        }
                                        if (profiles.length == 0) {
                                                response.success(results);
                                        }
                                        for (var i = 0; i < profiles.length; i++) {
                                                getLastMessage(currentProfile.id, profiles[i], {
                                                        success: function (result) {
                                                                results.push(result);
                                                                if (results.length == profiles.length) {
                                                                        results.sort(function(a, b) {
                                                                            if (a.lastMessageDate == undefined) {
                                                                                    return 1;
                                                                            }
                                                                            if (b.lastMessageDate == undefined) {
                                                                                    return -1;
                                                                            }
                                                                            return new Date(b.lastMessageDate) - new Date(a.lastMessageDate);
                                                                        });
                                                                        response.success(results);
                                                                }
                                                        },
                                                        error: function(error) {
                                                                response.error(error);
                                                        }
                                                });
                                         }
                                },
                                error: function(error) {
                                        response.error(error);
                                }
                        });
                },
                error : function(error) {
                        response.error(error);
                }
        });
});

function getLastMessage(currentProfileId, profile, response) {
    var avatar = "";
    var avatars = profile.get("avatars");
   if (avatars !== undefined && avatars.length > 0) {
        if (avatars[0] !== undefined) {
                avatar = avatars[0].url();
         }
   }
    var result = {
            profileId : profile.id,
            name : getFirstname(profile.get("name")),
            avatar : avatar
    };

    var messagesQuery1 = new Parse.Query("Message");
    messagesQuery1.equalTo("senderId", profile.id);
   messagesQuery1.equalTo("receiverId", currentProfileId);

   var messagesQuery2 = new Parse.Query("Message");
   messagesQuery2.equalTo("senderId", currentProfileId);
   messagesQuery2.equalTo("receiverId", profile.id);

   var mainQuery = new Parse.Query.or(messagesQuery1, messagesQuery2);
   mainQuery.descending("createdAt");

   mainQuery.find({
        success : function(messages) {
                if (messages !== undefined) {
                    var message = messages[0];
                     if (message !== undefined) {
                            result.lastMessageDate = message.createdAt.getTime();
                           result.lastMessage = message.get("message");
                     }

                     var unread = 0;
                     for (var j = 0; j < messages.length; j++) {
                        if (!messages[j].get("isSeen") && messages[j].get("receiverId") == currentProfileId) {
                            unread++;
                        }
                     }
                     result.unread = unread;
               }
               response.success(result);
            },
            error: function(error) {
                    response.error(error);
            }
    });
}

function getFirstname(fullname) {
        if (fullname == undefined) {
                return "";
        }
        var splitted = fullname.split(" ");
        return splitted[0];
}

Parse.Cloud.define("deleteAccount", function(request, response) {
        var currentUser = Parse.User.current();
        var currentProfile = currentUser.get("profile");
        if (currentProfile !== undefined) {
            currentProfile.fetch({
                success: function(profileObject) {
                    var profileId = profileObject.id;
                    currentUser.destroy({
                        success: function() {
                            profileObject.destroy({
                                success: function () {
                                    var query1 = new Parse.Query("Profile");
                                    query1.equalTo("likedBy", profileId);

                                    var query2 = new Parse.Query("Profile");
                                    query2.equalTo("dislikedBy", profileId);

                                    var mainQuery = new Parse.Query.or(query1, query2);
                                    mainQuery.find({
                                        success: function (profiles) {
                                            for (var i = 0; i < profiles.length; i++) {
                                                profiles[i].remove("likedBy", profileId);
                                                profiles[i].remove("dislikedBy", profileId);
                                                profiles[i].save();
                                            }

                                            response.success(true);
                                        },
                                        error: function(error) {
                                            response.error(error);
                                        }
                                    });
                                },
                                error: function(error) {
                                    response.error("Failed to destroy current profile " + profileId + " with error: " + error);
                                }
                            });
                        },
                        error: function(error) {
                            response.error("Failed to destroy current user " + currentUser.id + " with error: " + error);
                        }
                    });
                },
                error: function(error) {
                    response.error(error);
                    }
            });
        } else {
                    currentUser.destroy({
                        success: function() {
                            response.success(true);
                        },
                        error: function(error) {
                            response.error("Failed to destroy current user " + currentUser.id + " with error: " + error);
                        }
                    });
        }
});

Parse.Cloud.define("deleteInstallations", function(request, response) {
    Parse.Cloud.useMasterKey();
    var installationId = request.params.installationId;

    var installationsQuery = new Parse.Query("_Installation");
    installationsQuery.equalTo("installationId", installationId);

    console.log("installationId = " + installationId);

    installationsQuery.find({
        success: function(installations) {
            if (installations !== undefined && installations.length != 0) {
                console.log("installations.length == " + installations.length);
                var installationsCount = 0;
                for (var i = 0; i < installations.length; i++) {
                    installations[i].unset("user");
                    installations[i].set("badge", 0);
                    installations[i].save(null, {
                        success: function(install) {
                            installationsCount++;
                            if (installationsCount == installations.length) {
                                response.success(true);
                            }
                        },
                        error: function(install, error) {
                            response.error(error);
                        }
                    });
                }
            } else {
                response.success(false);
            }
        },
        error: function(installations, error) {
            response.error(error);
        }
    });
});

// limit 10
Parse.Cloud.define("getFeed", function(request, response) {
    var currentUser = Parse.User.current();
    currentUser.get("profile").fetch({
        success: function(profile) {
            var searchQuery = new Parse.Query("Profile");
            searchQuery.notEqualTo("objectId", profile.id);

            var isInterestedInMen = profile.get("isInterestedInMen") == false ? false : true;
            var isInterestedInWomen = profile.get("isInterestedInWomen") == false ? false : true;

            if (!isInterestedInMen && !isInterestedInWomen) {
                response.success([]);
            } else if (!isInterestedInMen) {
                searchQuery.notEqualTo("gender", "male");
            } else if (!isInterestedInWomen) {
                searchQuery.notEqualTo("gender", "female");
            }
            var myLocation = profile.get("location");
            var maxDistance = profile.get("searchDistance");
            if (myLocation !== undefined) {
                if (maxDistance == undefined) {
                    maxDistance = 50;
                }
                searchQuery.withinMiles("location", myLocation, maxDistance);
            }

            searchQuery.notEqualTo("likedBy", profile.id);
            searchQuery.notEqualTo("dislikedBy", profile.id);

            var searchNationality = profile.get("searchNationality");
            if (searchNationality !== undefined) {
                if (searchNationality == "Other Non Africans") {
                    searchQuery.equalTo("nationality", "Other Nationality");
                } else if (searchNationality == "All Nationalities") {
                } else {
                    searchQuery.equalTo("nationality", searchNationality);
                }
            }

            var minAge = profile.get("searchAgeMin");
            if (minAge == undefined) {
                minAge = 23;
            }
            var maxAge = profile.get("searchAgeMax");
            if (maxAge == undefined) {
                maxAge = 35;
            }

            if (minAge != 18) {
          //      console.log("minAge != 18");
                var greaterDate = getDateByAge(minAge, true);
                searchQuery.lessThan("dayOfBirth", greaterDate);
            }

            if (maxAge != 65) {
            //    console.log("minAge != 65");
                var smallerDate = getDateByAge(maxAge, false);
                searchQuery.greaterThan("dayOfBirth", smallerDate);
            }

            searchQuery.find({
                success: function(profiles) {
                    var result = [];
                    if (profiles !== undefined) {
                    //    console.log("profiles.length = " + profiles.length);
                        for (var i = 0; i < profiles.length; i++) {
                            var gender = profiles[i].get("gender");
                            if (gender !== undefined) {
                                if (result.length < 10) {
                                    result.push(profiles[i]);
                                }
                            }
                        }
                    }
                    response.success(result);
                },
                error: function(error) {
                    response.error(error);
                }
            });
        },
        error: function(error) {
            response.error(error);
        }
    });
});

function calculateAge(birthday) {
    if (birthday == undefined) {
        return undefined;
    }
   var today = new Date();
   var age = today.getFullYear() - birthday.getFullYear();
   var m = today.getMonth() - birthday.getMonth();
   if (m < 0 || (m === 0 && today.getDate() < birthday.getDate())) {
       age--;
   }
   return age;
}

function getDateByAge(age, isMinAge) {
    var today = new Date();
    var tmpAge = age + 1;
    var tmpDays = -1;
    if (isMinAge) {
        tmpAge = age;
        tmpDays = 0;
    }
    var returnDate = new Date(
        today.getFullYear() - tmpAge,
        today.getMonth(),
        today.getDate() + tmpDays,
        0,
        0,
        0);
    return returnDate;
}

Parse.Cloud.define("setMessagesSeen", function(request, response) {
    var receiverId = request.user.get("profile").id;
    var senderProfileId = request.params.senderId;

    var mainQuery = new Parse.Query("Message");
    mainQuery.equalTo("senderId", senderProfileId);
    mainQuery.equalTo("receiverId", receiverId);

    mainQuery.find({
        success: function(results) {
            for (var i = 0; i < results.length; i++) {
                if (!results[i].get("isSeen")) {
                    results[i].set("isSeen", true);
                    results[i].save(null, {
                        success: function(messageObject) {
                        },
                        error: function(messageObject, error) {
                            response.error("Failed to save message with error: " + error.message);
                        }
                    });
                }
            }
            response.success(true);
        },
        error: function() {
            response.error("Failed to find messages");
        }
    });

});

Parse.Cloud.job("normaliseUsername", function(request, status) {
    Parse.Cloud.useMasterKey();
    var count_user = 0;
    var query = new Parse.Query(Parse.User);
    query.exists('email');
    query.limit(1000);
    return query.find().then(function(users) {
        return Parse.Promise.when(users.map(function(user) {
            count_user += 1;
            if (user.get("email") !== undefined) {
                user.set("username", user.get("email").toLowerCase());
                user.set("email", user.get("email").toLowerCase());
            }
            return user.save();
        }));
    }).then(function() {
        status.success("normaliseUsername with " + count_user + " user(s) updated.");
    }, function(error) {
        status.error("Uh oh, something went wrong.");
    });
});

Parse.Cloud.define("like", function(request, response) {
        var senderProfileId = request.user.get("profile").id;
        var receiverId = request.params.receiverId;

        var Profile = Parse.Object.extend("Profile");
        var profileQuery = new Parse.Query(Profile);
        profileQuery.get(receiverId, {
            success: function(profile) {
                profile.addUnique("likedBy", senderProfileId);
                var profileQuery1 = new Parse.Query("Profile");
                profileQuery1.get(senderProfileId, {
                    success: function(object) {
                        var result = false;
                        var likes = object.get("likedBy");
                        if (likes !== undefined) {
                            for (var i = 0; i < likes.length; i++) {
                                if (likes[i] == receiverId) {
                                    profile.addUnique("matches", senderProfileId);
                                    object.addUnique("matches", receiverId);
                                    result = true;
                                    break;
                                }
                            }
                        }
                        profile.save().then(function(obj) {
                            object.save().then(function(obj) {
                                if (result) {
                                    matchPushFunc(senderProfileId, receiverId);
                                }
                                response.success(result);
                            },
                            function(error) {
                                reponse.error(error);
                            });
                        },
                        function(error) {
                            reponse.error(error);
                        });
                    },
                    error: function(object, error1) {
                        response.error(error1);
                    }
                });
            },
            error: function(object, error) {
                response.error(error);
            }
        });
});

Parse.Cloud.define("deleteAnotherAccount", function(request, response) {
        Parse.Cloud.useMasterKey();

        var profileId = request.params.profileId;
        var Profile = Parse.Object.extend("Profile");
        var currentProfile = new Profile();
        currentProfile.id = profileId;

        if (currentProfile !== undefined) {
            currentProfile.fetch({
                success: function(profileObject) {
                    var curUser = currentProfile.get("user");
                    if (curUser !== undefined) {
                        curUser.fetch({
                            success: function(currentUser) {
                                var profileId = profileObject.id;
                              //  console.log("Removing current user " + currentUser.id);
                                currentUser.destroy({
                                    success: function() {
                                  //      console.log("Removing current profile " + profileObject.id);
                                        profileObject.destroy({
                                            success: function () {
                                                var query1 = new Parse.Query("Profile");
                                                query1.equalTo("likedBy", profileId);

                                                var query2 = new Parse.Query("Profile");
                                                query2.equalTo("dislikedBy", profileId);

                                                var mainQuery = new Parse.Query.or(query1, query2);
                                                mainQuery.find({
                                                    success: function (profiles) {
                                                        for (var i = 0; i < profiles.length; i++) {
                                                  //          console.log("Removing likes and dislikes from profile " + profiles[i].id);
                                                            profiles[i].remove("likedBy", profileId);
                                                            profiles[i].remove("dislikedBy", profileId);
                                                            profiles[i].save();
                                                        }
                                                        response.success(true);
                                                    },
                                                    error: function(error) {
                                                        response.error(error);
                                                    }
                                                });
                                            },
                                            error: function(error) {
                                                response.error("Failed to destroy current profile " + profileId + " with error: " + error);
                                            }
                                        });
                                    },
                                    error: function(error) {
                                        response.error("Failed to destroy current user " + currentUser.id + " with error: " + error);
                                    }
                                });
                            },
                            error: function(currentUser, error) {
                                response.error(error);
                            }
                        });
                    } else {
                        response.success(true);
                    }
                },
                error: function(error) {
                    response.error(error);
                    }
            });
        } else {
          //  console.log("profile not found");
          //  console.log("Removing current user " + currentUser.id);
                    currentUser.destroy({
                        success: function() {
                            response.success(true);
                        },
                        error: function(error) {
                            response.error("Failed to destroy current user " + currentUser.id + " with error: " + error);
                        }
                    });
        }
});

Parse.Cloud.define("sendMessageV2", function(request, response) {
    var senderProfile = request.user.get("profile");
    var senderProfileId = senderProfile.id;
    var Message = Parse.Object.extend("Message");
    var messageObject = new Message();
    var recipientProfileId = request.params.receiverId;
    var messageText = request.params.message;
    messageObject.set("senderId", senderProfileId);
    messageObject.set("receiverId", recipientProfileId);
    messageObject.set("message", messageText);
    messageObject.set("isSeen", false);
    messageObject.save(null, {
        success: function(messageObject) {
            senderProfile.fetch({
                success: function(myProfile) {
                    if (myProfile !== undefined) {
                        var firstname = getFirstname(myProfile.get("name"));
                        var messageObject = {
                            type : "message",
                            senderId: senderProfileId,
                            receiverId: recipientProfileId,
                            senderName: firstname
                        };
                        messagePush(messageObject);
                        response.success(true);
                    } else {
                        response.error("Unable to fetch senders profile");
                    }
                },
                error: function(myProfile, error) {
                    response.error(error);
                }
            });
        },
        error: function(messageObject, error) {
            response.error("Failed to save message with error: " + error.message);
        }
    });
});

function messagePush(messageObject) {
    // Send the push.
    // Find devices associated with the recipient user
    var Profile = Parse.Object.extend("Profile");
    var receiverProfile = new Profile();
    receiverProfile.id = messageObject.receiverId;

    var userQuery = new Parse.Query(Parse.User);
    userQuery.equalTo('profile', receiverProfile);

    var androidQuery = new Parse.Query(Parse.Installation);
    androidQuery.matchesQuery('user', userQuery);
    androidQuery.equalTo('deviceType', "android");

    var iosQuery = new  Parse.Query(Parse.Installation);
    iosQuery.matchesQuery('user', userQuery);
    iosQuery.equalTo('deviceType', "ios");

 var senderName = messageObject.senderName;
    //Custom push for android devices
    Parse.Push.send({
        where: androidQuery,
        data: {
            alert: messageObject
        }
    });
    //Custom push for iOS devices
    Parse.Push.send({
        where: iosQuery,
        data: {
            alert: senderName + " sent you a message",
            badge: "Increment",
            sound: "default",
            pushType: "messagePush",
            push_container: messageObject
        }
    });
}

Parse.Cloud.define("likeV2", function(request, response) {
        var senderProfileId = request.user.get("profile").id;
        var receiverId = request.params.receiverId;

        var Profile = Parse.Object.extend("Profile");
        var profileQuery = new Parse.Query(Profile);
        profileQuery.get(receiverId, {
            success: function(profile) {
                profile.addUnique("likedBy", senderProfileId);
                var profileQuery1 = new Parse.Query("Profile");
                profileQuery1.get(senderProfileId, {
                    success: function(myProfile) {
                        var result = false;
                        var likes = myProfile.get("likedBy");
                        if (likes !== undefined) {
                            for (var i = 0; i < likes.length; i++) {
                                if (likes[i] == receiverId) {
                                    profile.addUnique("matches", senderProfileId);
                                    myProfile.addUnique("matches", receiverId);
                                    result = true;
                                    break;
                                }
                            }
                        }
                        profile.save().then(function(obj) {
                            myProfile.save().then(function(obj) {
                                console.log("objects saved. result = " + result);
                                if (result) {
                                    matchPushFunc(senderProfileId, receiverId);
                                // } else {
                                //     var firstname = getFirstname(myProfile.get("name"));
                                //     var likeObject = {
                                //         type : "like",
                                //         senderId: senderProfileId,
                                //         receiverId: receiverId,
                                //         senderName: firstname
                                //     };
                                //     likePush(likeObject);
                                }
                                response.success(result);
                            },
                            function(error) {
                                reponse.error(error);
                            });
                        },
                        function(error) {
                            reponse.error(error);
                        });
                    },
                    error: function(myProfile, error1) {
                        response.error(error1);
                    }
                });
            },
            error: function(profile, error) {
                response.error(error);
            }
        });
});

function likePush(likeObject) {
    // Send the push.
    // Find devices associated with the recipient user
    var Profile = Parse.Object.extend("Profile");
    var receiverProfile = new Profile();
    receiverProfile.id = likeObject.receiverId;

    var userQuery = new Parse.Query(Parse.User);
    userQuery.equalTo('profile', receiverProfile);

    var androidQuery = new Parse.Query(Parse.Installation);
    androidQuery.matchesQuery('user', userQuery);
    androidQuery.equalTo('deviceType', "android");

    var senderName = likeObject.senderName;
    if (senderName == undefined) {
        senderName = "Someone";
    }
    //Custom push for android devices
    Parse.Push.send({
        where: androidQuery,
        data: {
            alert: likeObject
        }
    });
}

// limit 20
Parse.Cloud.define("getFeedV3", function(request, response) {
    var filter = request.params.filter;
    var currentUser = Parse.User.current();
    currentUser.get("profile").fetch({
        success: function(profile) {
            var searchQuery = new Parse.Query("Profile");
            searchQuery.notEqualTo("objectId", profile.id);

            var isInterestedInMen = profile.get("isInterestedInMen") == false ? false : true;
            var isInterestedInWomen = profile.get("isInterestedInWomen") == false ? false : true;

            if (!isInterestedInMen && !isInterestedInWomen) {
                response.success([]);
            } else if (!isInterestedInMen) {
                searchQuery.notEqualTo("gender", "male");
            } else if (!isInterestedInWomen) {
                searchQuery.notEqualTo("gender", "female");
            }
            var myLocation = profile.get("location");
            var maxDistance = profile.get("searchDistance");
            if (myLocation !== undefined) {
                if (maxDistance == undefined) {
                    maxDistance = 50;
                }
                searchQuery.withinMiles("location", myLocation, maxDistance);
            }

            searchQuery.notEqualTo("likedBy", profile.id);
            searchQuery.notEqualTo("dislikedBy", profile.id);

            var searchNationality = profile.get("searchNationality");
            if (searchNationality !== undefined) {
                if (searchNationality == "Other Non Africans") {
                    searchQuery.equalTo("nationality", "Other Nationality");
                } else if (searchNationality == "All Nationalities") {
                } else {
                    searchQuery.equalTo("nationality", searchNationality);
                }
            }

            var minAge = profile.get("searchAgeMin");
            if (minAge == undefined) {
                minAge = 23;
            }
            var maxAge = profile.get("searchAgeMax");
            if (maxAge == undefined) {
                maxAge = 35;
            }

            if (minAge != 18) {
          //      console.log("minAge != 18");
                var greaterDate = getDateByAge(minAge, true);
                searchQuery.lessThan("dayOfBirth", greaterDate);
            }

            if (maxAge != 65) {
            //    console.log("minAge != 65");
                var smallerDate = getDateByAge(maxAge, false);
                searchQuery.greaterThan("dayOfBirth", smallerDate);
            }

            if (filter !== undefined) {
                for (var f = 0; f < filter.length; f++) {
                    searchQuery.notEqualTo("objectId", filter[f]);
                }
            }

            searchQuery.find({
                success: function(profiles) {
                    var result = [];
                    if (profiles !== undefined) {
                        for (var i = 0; i < profiles.length; i++) {
                            var gender = profiles[i].get("gender");
                            if (gender !== undefined) {
                                if (result.length < 20) {
                                    result.push(profiles[i]);
                                }
                            }
                        }
                    }
                    response.success(result);
                },
                error: function(error) {
                    response.error(error);
                }
            });
        },
        error: function(error) {
            response.error(error);
        }
    });
});