publapi/pages/users.go

203 lines
5.2 KiB
Go
Raw Normal View History

package pages
import (
"os"
"os/exec"
"regexp"
"runtime"
"sort"
2023-01-23 20:30:41 +05:30
"strconv"
"strings"
2023-07-11 02:53:29 +05:30
2024-09-28 23:41:58 +05:30
log "log/slog"
2023-07-11 02:53:29 +05:30
"github.com/ProjectSegfault/publapi/utils"
"github.com/gofiber/fiber/v2"
"github.com/spf13/viper"
)
2024-09-29 00:20:57 +05:30
type UserStruct struct {
Status int `json:"status"`
Online int `json:"online"`
Total int `json:"total"`
2024-09-29 00:20:57 +05:30
Users []UserInfo `json:"users"`
}
2024-09-29 00:20:57 +05:30
type UserInfo struct {
2023-01-21 16:55:08 +05:30
Name string `json:"name"`
FullName string `json:"fullName"`
Desc string `json:"desc"`
Online bool `json:"online"`
2023-01-23 19:30:34 +05:30
Op bool `json:"op"`
2023-01-23 20:30:41 +05:30
Created int `json:"created"`
2023-01-21 16:55:08 +05:30
Email string `json:"email"`
Matrix string `json:"matrix"`
Fediverse string `json:"fediverse"`
Website string `json:"website"`
Capsule string `json:"capsule"`
Loc string `json:"loc"`
}
2024-09-29 00:20:57 +05:30
type ByAdminAndName []UserInfo
func (a ByAdminAndName) Len() int { return len(a) }
func (a ByAdminAndName) Less(i, j int) bool {
// If one person is an admin and the other is not, place the admin first
if a[i].Op && !a[j].Op {
return true
} else if !a[i].Op && a[j].Op {
return false
}
// If both persons are admins or both are not, sort by name
return a[i].Name < a[j].Name
}
func (a ByAdminAndName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
2024-09-28 23:41:58 +05:30
func UserError(message string, username string, err error) {
log.Error("error", message, log.Any("err", err), "username", username)
}
2024-09-29 00:20:57 +05:30
func userData(username, usersonline, ops string) UserInfo {
regex := "(^| )" + username + "($| )"
isonline, err := regexp.MatchString(string(regex), string(usersonline))
if err != nil {
2024-09-28 23:41:58 +05:30
UserError("couldn't get online status for user", username, err)
}
2023-01-23 20:23:05 +05:30
isop, operr := regexp.MatchString(string(regex), string(ops))
if operr != nil {
2024-09-28 23:41:58 +05:30
UserError("couldn't get op status for user", username, operr)
2023-01-23 20:23:05 +05:30
}
cmd := "/usr/bin/stat -c %W /home/" + username
crd, crerr := exec.Command("bash", "-c", cmd).Output()
if crerr != nil {
2024-09-28 23:41:58 +05:30
UserError("couldn't stat user", username, crerr)
2023-01-23 20:23:05 +05:30
}
crdstr := string(crd)
2023-01-23 20:30:41 +05:30
crdstr = strings.TrimSuffix(crdstr, "\n")
2023-02-26 20:46:38 +05:30
filename := "/home/" + username + "/meta-info.toml"
2023-01-23 20:23:05 +05:30
_, error := os.Stat(filename)
if error != nil {
if os.IsNotExist(error) {
2023-02-26 20:46:38 +05:30
log.Error(username + " does not have a meta-info.toml")
2024-09-29 00:20:57 +05:30
var user UserInfo
user.Name = username
2023-01-23 20:30:41 +05:30
user.Created, _ = strconv.Atoi(crdstr)
2024-09-28 23:41:58 +05:30
if isonline {
user.Online = true
} else {
user.Online = false
}
2024-09-28 23:41:58 +05:30
if isop {
2023-01-23 19:30:34 +05:30
user.Op = true
} else {
user.Op = false
}
return user
}
}
viper.SetConfigFile(filename)
if err := viper.ReadInConfig(); err != nil {
2024-09-28 23:41:58 +05:30
log.Error("message", "Couldn't read a users meta-info.toml file.", "error", log.Any("err", err), "user", username)
2024-09-29 00:20:57 +05:30
user := UserInfo{
Name: username,
}
user.Created, _ = strconv.Atoi(crdstr)
if isonline {
user.Online = true
} else {
user.Online = false
}
if isop {
user.Op = true
} else {
user.Op = false
}
return user
}
2024-09-29 00:20:57 +05:30
user := UserInfo{
Name: username,
FullName: viper.GetString("fullname"),
Capsule: viper.GetString("gemini"),
Website: viper.GetString("website"),
Desc: viper.GetString("description"),
Email: viper.GetString("email"),
Matrix: viper.GetString("matrix"),
Fediverse: viper.GetString("fediverse"),
Loc: viper.GetString("location"),
Op: false,
Online: false,
}
2023-01-23 20:30:41 +05:30
user.Created, _ = strconv.Atoi(crdstr)
2024-09-28 23:41:58 +05:30
if isop {
2023-01-23 19:30:34 +05:30
user.Op = true
}
2024-09-28 23:41:58 +05:30
if isonline {
user.Online = true
}
return user
}
func UsersPage(c *fiber.Ctx) error {
if runtime.GOOS == "windows" {
return c.JSON(fiber.Map{
"message": "/users is not supported on Windows",
"status": c.Response().StatusCode(),
})
}
// Get the number of users online
2024-09-29 00:20:57 +05:30
usersOnline, err := exec.Command("bash", "-c", "/usr/bin/users").Output()
if err != nil {
2024-09-28 23:41:58 +05:30
log.Error("error", log.Any("error", err))
return c.SendStatus(fiber.StatusInternalServerError)
}
2024-09-29 00:20:57 +05:30
usersOnlineStr := string(usersOnline)
usersOnlineDedup := utils.Dedup(usersOnlineStr)
var output int
2024-09-29 00:20:57 +05:30
if strings.Contains(usersOnlineDedup, " ") {
outputa := int(strings.Count(usersOnlineDedup, " "))
2023-01-21 17:13:29 +05:30
output = outputa + 1
2024-09-29 00:20:57 +05:30
} else if usersOnlineDedup == "" {
2023-01-21 17:13:29 +05:30
output = 0
} else {
output = 1
}
2023-01-23 19:30:34 +05:30
// Get OPs
ops, opserr := exec.Command("bash", "-c", "/usr/bin/members sudo").Output()
if opserr != nil {
2024-09-28 23:50:51 +05:30
log.Error("couldn't get ops", "error", log.Any("err", opserr))
2023-01-23 19:30:34 +05:30
return c.SendStatus(fiber.StatusInternalServerError)
}
opstr := string(ops)
// Get all users
users, err2 := exec.Command("bash", "-c", "/usr/bin/ls /home").Output()
if err2 != nil {
2024-09-28 23:41:58 +05:30
log.Error("couldn't get all users", "error", log.Any("err", err2))
return c.SendStatus(fiber.StatusInternalServerError)
}
userstr := string(users)
userstr2 := strings.TrimSuffix(userstr, "\n")
usersarr := strings.Split(userstr2, "\n")
2023-01-23 19:30:34 +05:30
// Fill user info
2024-09-29 00:20:57 +05:30
var userInfoStruct []UserInfo
for i := 0; i < len(usersarr); i++ {
uname := string(usersarr[i])
2024-09-29 00:20:57 +05:30
userInfoStruct = append(
userInfoStruct,
userData(
2023-07-11 02:53:29 +05:30
uname,
2024-09-29 00:20:57 +05:30
strings.TrimSuffix(usersOnlineDedup, "\n"),
2023-07-11 02:53:29 +05:30
strings.TrimSuffix(opstr, "\n"),
),
)
}
2024-09-29 00:20:57 +05:30
sort.Sort(ByAdminAndName(userInfoStruct))
data := UserStruct{
Status: c.Response().StatusCode(),
Online: output,
2024-09-29 00:20:57 +05:30
Users: userInfoStruct,
Total: int(strings.Count(userstr, "\n")),
}
return c.JSON(data)
}