ripple-api/app/v1/friend.go

208 lines
5.5 KiB
Go
Raw Normal View History

2016-04-07 09:20:35 +00:00
package v1
import (
"database/sql"
"strconv"
"time"
2016-04-19 14:07:27 +00:00
"git.zxq.co/ripple/rippleapi/common"
2016-04-07 09:20:35 +00:00
)
type friendData struct {
userData
IsMutual bool `json:"is_mutual"`
}
2016-04-16 16:05:24 +00:00
type friendsGETResponse struct {
common.ResponseBase
Friends []friendData `json:"friends"`
}
2016-04-07 09:20:35 +00:00
// FriendsGET is the API request handler for GET /friends.
// It retrieves an user's friends, and whether the friendship is mutual or not.
2016-04-16 16:05:24 +00:00
func FriendsGET(md common.MethodData) common.CodeMessager {
2016-04-07 09:20:35 +00:00
var myFrienders []int
myFriendersRaw, err := md.DB.Query("SELECT user1 FROM users_relationships WHERE user2 = ?", md.ID())
2016-04-07 09:20:35 +00:00
if err != nil {
md.Err(err)
2016-04-16 16:05:24 +00:00
return Err500
2016-04-07 09:20:35 +00:00
}
defer myFriendersRaw.Close()
for myFriendersRaw.Next() {
var i int
err := myFriendersRaw.Scan(&i)
if err != nil {
md.Err(err)
2016-04-07 09:20:35 +00:00
continue
}
myFrienders = append(myFrienders, i)
}
if err := myFriendersRaw.Err(); err != nil {
md.Err(err)
2016-04-07 09:20:35 +00:00
}
// Yes.
myFriendsQuery := `
SELECT
users.id, users.username, users.register_datetime, users.rank, users.latest_activity,
2016-04-09 21:58:27 +00:00
users_stats.username_aka,
2016-04-07 09:20:35 +00:00
users_stats.country, users_stats.show_country
FROM users_relationships
LEFT JOIN users
ON users_relationships.user2 = users.id
LEFT JOIN users_stats
ON users_relationships.user2=users_stats.id
WHERE users_relationships.user1=?
ORDER BY users_relationships.id`
2016-05-19 15:15:17 +00:00
results, err := md.DB.Query(myFriendsQuery+common.Paginate(md.C.Query("p"), md.C.Query("l"), 50), md.ID())
2016-04-07 09:20:35 +00:00
if err != nil {
md.Err(err)
2016-04-16 16:05:24 +00:00
return Err500
2016-04-07 09:20:35 +00:00
}
var myFriends []friendData
defer results.Close()
for results.Next() {
newFriend := friendPuts(md, results)
for _, uid := range myFrienders {
if uid == newFriend.ID {
newFriend.IsMutual = true
break
}
}
myFriends = append(myFriends, newFriend)
}
if err := results.Err(); err != nil {
md.Err(err)
2016-04-07 09:20:35 +00:00
}
2016-04-16 16:05:24 +00:00
r := friendsGETResponse{}
r.Code = 200
2016-04-16 16:05:24 +00:00
r.Friends = myFriends
return r
2016-04-07 09:20:35 +00:00
}
func friendPuts(md common.MethodData, row *sql.Rows) (user friendData) {
var err error
registeredOn := int64(0)
latestActivity := int64(0)
var showcountry bool
2016-04-09 21:58:27 +00:00
err = row.Scan(&user.ID, &user.Username, &registeredOn, &user.Rank, &latestActivity, &user.UsernameAKA, &user.Country, &showcountry)
2016-04-07 09:20:35 +00:00
if err != nil {
md.Err(err)
2016-04-07 09:20:35 +00:00
return
}
user.RegisteredOn = time.Unix(registeredOn, 0)
user.LatestActivity = time.Unix(latestActivity, 0)
// If the user wants to stay anonymous, don't show their country.
// This can be overriden if we have the ReadConfidential privilege and the user we are accessing is the token owner.
if !(showcountry || (md.User.Privileges.HasPrivilegeReadConfidential() && user.ID == md.ID())) {
2016-04-07 09:20:35 +00:00
user.Country = "XX"
}
return
}
2016-04-07 10:21:54 +00:00
2016-04-16 16:05:24 +00:00
type friendsWithResponse struct {
common.ResponseBase
2016-04-07 10:21:54 +00:00
Friends bool `json:"friend"`
Mutual bool `json:"mutual"`
}
// FriendsWithGET checks the current user is friends with the one passed in the request path.
2016-04-16 16:05:24 +00:00
func FriendsWithGET(md common.MethodData) common.CodeMessager {
r := friendsWithResponse{}
2016-04-07 10:21:54 +00:00
r.Code = 200
uid, err := strconv.Atoi(md.C.Query("id"))
2016-04-07 10:21:54 +00:00
if err != nil {
2016-04-16 16:05:24 +00:00
return common.SimpleResponse(400, "That is not a number!")
2016-04-07 10:21:54 +00:00
}
2016-04-16 16:05:24 +00:00
err = md.DB.QueryRow("SELECT EXISTS(SELECT 1 FROM users_relationships WHERE user1 = ? AND user2 = ? LIMIT 1), EXISTS(SELECT 1 FROM users_relationships WHERE user2 = ? AND user1 = ? LIMIT 1)", md.ID(), uid, md.ID(), uid).Scan(&r.Friends, &r.Mutual)
2016-04-08 16:18:42 +00:00
if err != sql.ErrNoRows && err != nil {
md.Err(err)
2016-04-16 16:05:24 +00:00
return Err500
2016-04-07 10:21:54 +00:00
}
2016-04-16 16:05:24 +00:00
if !r.Friends {
r.Mutual = false
}
return r
2016-04-07 10:21:54 +00:00
}
// FriendsAddGET is the GET version of FriendsAddPOST.
2016-04-16 16:05:24 +00:00
func FriendsAddGET(md common.MethodData) common.CodeMessager {
uidS := md.C.Query("id")
uid, err := strconv.Atoi(uidS)
if err != nil {
2016-04-16 16:05:24 +00:00
return common.SimpleResponse(400, "Nope. That's not a number.")
}
return addFriend(md, uid)
}
2016-04-16 16:05:24 +00:00
func addFriend(md common.MethodData, u int) common.CodeMessager {
if md.ID() == u {
2016-04-16 16:05:24 +00:00
return common.SimpleResponse(406, "Just so you know: you can't add yourself to your friends.")
}
if !userExists(md, u) {
2016-04-16 16:05:24 +00:00
return common.SimpleResponse(404, "I'd also like to be friends with someone who doesn't even exist (???), however that's NOT POSSIBLE.")
}
var (
relExists bool
isMutual bool
)
err := md.DB.QueryRow("SELECT EXISTS(SELECT 1 FROM users_relationships WHERE user1 = ? AND user2 = ?), EXISTS(SELECT 1 FROM users_relationships WHERE user2 = ? AND user1 = ?)", md.ID(), u, md.ID(), u).Scan(&relExists, &isMutual)
if err != nil && err != sql.ErrNoRows {
md.Err(err)
2016-04-16 16:05:24 +00:00
return Err500
}
if !relExists {
_, err := md.DB.Exec("INSERT INTO users_relationships(user1, user2) VALUES (?, ?)", md.User.UserID, u)
if err != nil {
md.Err(err)
2016-04-16 16:05:24 +00:00
return Err500
}
}
2016-04-16 16:05:24 +00:00
var r friendsWithResponse
r.Code = 200
2016-04-16 16:05:24 +00:00
r.Friends = true
r.Mutual = isMutual
return r
}
// userExists makes sure an user exists.
func userExists(md common.MethodData, u int) (r bool) {
2016-04-12 19:41:08 +00:00
err := md.DB.QueryRow("SELECT EXISTS(SELECT 1 FROM users WHERE id = ? AND users.allowed='1')", u).Scan(&r)
if err != nil && err != sql.ErrNoRows {
md.Err(err)
}
return
}
2016-04-08 17:23:52 +00:00
// FriendsDelGET is the GET version of FriendDelPOST.
2016-04-16 16:05:24 +00:00
func FriendsDelGET(md common.MethodData) common.CodeMessager {
uidS := md.C.Query("id")
2016-04-08 17:23:52 +00:00
uid, err := strconv.Atoi(uidS)
if err != nil {
2016-04-16 16:05:24 +00:00
return common.SimpleResponse(400, "Nope. That's not a number.")
2016-04-08 17:23:52 +00:00
}
return delFriend(md, uid)
}
2016-04-16 16:05:24 +00:00
func delFriend(md common.MethodData, u int) common.CodeMessager {
2016-04-08 17:23:52 +00:00
_, err := md.DB.Exec("DELETE FROM users_relationships WHERE user1 = ? AND user2 = ?", md.ID(), u)
if err != nil {
md.Err(err)
return Err500
}
2016-04-16 16:05:24 +00:00
r := friendsWithResponse{
Friends: false,
Mutual: false,
2016-04-08 17:23:52 +00:00
}
2016-04-16 16:05:24 +00:00
r.Code = 200
return r
2016-04-08 17:23:52 +00:00
}