pronounsfu/backend/routes/v1/user/get_user.go

236 lines
6.8 KiB
Go
Raw Normal View History

package user
import (
"net/http"
"time"
2023-08-17 09:49:32 -07:00
"codeberg.org/pronounscc/pronouns.cc/backend/common"
2023-06-03 07:18:47 -07:00
"codeberg.org/pronounscc/pronouns.cc/backend/db"
"codeberg.org/pronounscc/pronouns.cc/backend/log"
"codeberg.org/pronounscc/pronouns.cc/backend/server"
2023-09-19 17:39:14 -07:00
"emperror.dev/errors"
"github.com/go-chi/chi/v5"
"github.com/go-chi/render"
"github.com/rs/xid"
)
type GetUserResponse struct {
ID xid.ID `json:"id"`
2023-08-17 09:49:32 -07:00
SnowflakeID common.UserID `json:"id_new"`
2023-06-02 18:06:26 -07:00
SID string `json:"sid"`
Username string `json:"name"`
DisplayName *string `json:"display_name"`
Bio *string `json:"bio"`
MemberTitle *string `json:"member_title"`
Avatar *string `json:"avatar"`
Links []string `json:"links"`
Names []db.FieldEntry `json:"names"`
Pronouns []db.PronounEntry `json:"pronouns"`
Members []PartialMember `json:"members"`
Fields []db.Field `json:"fields"`
CustomPreferences db.CustomPreferences `json:"custom_preferences"`
2023-05-25 04:40:15 -07:00
Flags []db.UserFlag `json:"flags"`
2023-06-05 07:29:18 -07:00
Badges db.Badge `json:"badges"`
2023-07-30 14:13:35 -07:00
UTCOffset *int `json:"utc_offset"`
}
2022-05-05 07:33:44 -07:00
type GetMeResponse struct {
2022-05-10 07:33:29 -07:00
GetUserResponse
2022-05-05 07:33:44 -07:00
CreatedAt time.Time `json:"created_at"`
2023-07-30 14:13:35 -07:00
Timezone *string `json:"timezone"`
2023-06-02 18:06:26 -07:00
MaxInvites int `json:"max_invites"`
IsAdmin bool `json:"is_admin"`
ListPrivate bool `json:"list_private"`
LastSIDReroll time.Time `json:"last_sid_reroll"`
2022-05-05 07:33:44 -07:00
Discord *string `json:"discord"`
DiscordUsername *string `json:"discord_username"`
2023-04-17 18:49:37 -07:00
Tumblr *string `json:"tumblr"`
TumblrUsername *string `json:"tumblr_username"`
2023-04-18 13:52:58 -07:00
Google *string `json:"google"`
GoogleUsername *string `json:"google_username"`
Fediverse *string `json:"fediverse"`
FediverseUsername *string `json:"fediverse_username"`
FediverseInstance *string `json:"fediverse_instance"`
2022-05-05 07:33:44 -07:00
}
type PartialMember struct {
ID xid.ID `json:"id"`
2023-08-17 09:49:32 -07:00
SnowflakeID common.MemberID `json:"id_new"`
2023-06-02 18:06:26 -07:00
SID string `json:"sid"`
Name string `json:"name"`
DisplayName *string `json:"display_name"`
Bio *string `json:"bio"`
Avatar *string `json:"avatar"`
Links []string `json:"links"`
Names []db.FieldEntry `json:"names"`
Pronouns []db.PronounEntry `json:"pronouns"`
}
2023-05-25 04:40:15 -07:00
func dbUserToResponse(u db.User, fields []db.Field, members []db.Member, flags []db.UserFlag) GetUserResponse {
resp := GetUserResponse{
ID: u.ID,
2023-08-17 09:49:32 -07:00
SnowflakeID: u.SnowflakeID,
2023-06-02 18:06:26 -07:00
SID: u.SID,
Username: u.Username,
DisplayName: u.DisplayName,
Bio: u.Bio,
MemberTitle: u.MemberTitle,
Avatar: u.Avatar,
Links: db.NotNull(u.Links),
Names: db.NotNull(u.Names),
Pronouns: db.NotNull(u.Pronouns),
Fields: db.NotNull(fields),
CustomPreferences: u.CustomPreferences,
2023-05-25 04:40:15 -07:00
Flags: flags,
}
2023-06-05 07:29:18 -07:00
if u.IsAdmin {
resp.Badges |= db.BadgeAdmin
}
2023-07-30 14:13:35 -07:00
if offset, ok := u.UTCOffset(); ok {
resp.UTCOffset = &offset
}
resp.Members = make([]PartialMember, len(members))
for i := range members {
resp.Members[i] = PartialMember{
ID: members[i].ID,
2023-08-17 09:49:32 -07:00
SnowflakeID: members[i].SnowflakeID,
2023-06-02 18:06:26 -07:00
SID: members[i].SID,
Name: members[i].Name,
DisplayName: members[i].DisplayName,
Bio: members[i].Bio,
Avatar: members[i].Avatar,
Links: db.NotNull(members[i].Links),
Names: db.NotNull(members[i].Names),
Pronouns: db.NotNull(members[i].Pronouns),
}
}
return resp
}
2023-05-25 04:40:15 -07:00
func (s *Server) getUser(w http.ResponseWriter, r *http.Request) (err error) {
ctx := r.Context()
userRef := chi.URLParamFromCtx(ctx, "userRef")
2023-05-25 04:40:15 -07:00
var u db.User
if id, err := xid.FromString(userRef); err == nil {
2023-05-25 04:40:15 -07:00
u, err = s.DB.User(ctx, id)
if err != nil {
log.Errorf("getting user by ID: %v", err)
}
}
if u.ID.IsNil() {
if id, err := common.ParseSnowflake(userRef); err == nil {
u, err = s.DB.UserBySnowflake(ctx, common.UserID(id))
if err != nil {
log.Errorf("getting user by snowflake: %v", err)
}
}
}
2023-05-25 04:40:15 -07:00
if u.ID.IsNil() {
u, err = s.DB.Username(ctx, userRef)
if err == db.ErrUserNotFound {
return server.APIError{
Code: server.ErrUserNotFound,
}
} else if err != nil {
log.Errorf("Error getting user by username: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting user")
}
}
if u.DeletedAt != nil {
return server.APIError{Code: server.ErrUserNotFound}
}
isSelf := false
if claims, ok := server.ClaimsFromContext(ctx); ok && claims.UserID == u.ID {
isSelf = true
}
2022-05-10 07:33:29 -07:00
fields, err := s.DB.UserFields(ctx, u.ID)
if err != nil {
log.Errorf("Error getting user fields: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting fields")
2022-05-10 07:33:29 -07:00
}
2023-05-25 04:40:15 -07:00
flags, err := s.DB.UserFlags(ctx, u.ID)
if err != nil {
log.Errorf("getting user flags: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting flags")
2023-05-25 04:40:15 -07:00
}
var members []db.Member
if !u.ListPrivate || isSelf {
members, err = s.DB.UserMembers(ctx, u.ID, isSelf)
if err != nil {
log.Errorf("Error getting user members: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting user members")
}
}
2023-05-25 04:40:15 -07:00
render.JSON(w, r, dbUserToResponse(u, fields, members, flags))
return nil
}
func (s *Server) getMeUser(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
claims, _ := server.ClaimsFromContext(ctx)
u, err := s.DB.User(ctx, claims.UserID)
if err != nil {
log.Errorf("Error getting user: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting users")
}
fields, err := s.DB.UserFields(ctx, u.ID)
if err != nil {
log.Errorf("Error getting user fields: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting fields")
}
members, err := s.DB.UserMembers(ctx, u.ID, true)
if err != nil {
log.Errorf("Error getting user members: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting members")
}
2023-05-25 04:40:15 -07:00
flags, err := s.DB.UserFlags(ctx, u.ID)
if err != nil {
log.Errorf("getting user flags: %v", err)
2023-09-19 17:39:14 -07:00
return errors.Wrap(err, "getting flags")
2023-05-25 04:40:15 -07:00
}
render.JSON(w, r, GetMeResponse{
2023-05-25 04:40:15 -07:00
GetUserResponse: dbUserToResponse(u, fields, members, flags),
CreatedAt: u.ID.Time(),
2023-07-30 14:13:35 -07:00
Timezone: u.Timezone,
MaxInvites: u.MaxInvites,
IsAdmin: u.IsAdmin,
ListPrivate: u.ListPrivate,
2023-06-02 18:06:26 -07:00
LastSIDReroll: u.LastSIDReroll,
Discord: u.Discord,
DiscordUsername: u.DiscordUsername,
2023-04-17 18:49:37 -07:00
Tumblr: u.Tumblr,
TumblrUsername: u.TumblrUsername,
2023-04-18 13:52:58 -07:00
Google: u.Google,
GoogleUsername: u.GoogleUsername,
Fediverse: u.Fediverse,
FediverseUsername: u.FediverseUsername,
FediverseInstance: u.FediverseInstance,
})
return nil
}