mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2026-10-25 07:15:01 +03:00
DIMFLIX
15fee2a035
The bot answered every action with a new message, so a chat filled with stale menus whose buttons still acted, and long client or inbound lists were paged through dozens of buttons. Each chat now has one live screen that is edited in place: the menu is grouped into Server, Clients, Traffic and Maintenance, lists open through inline search, the add-client flow starts from a draft card, QR codes arrive as one labelled sheet, and repeated notices collapse into one with a counter. A client's /start and /usage show only that client's own links and usage, groups are refused, and the settings page warns when the bot's inline mode is off. Admin topics, the indexed Telegram lookup and every locale, Slovak included, carry over.
466 lines
15 KiB
Go
466 lines
15 KiB
Go
package tgbot
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"html"
|
|
"net/url"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/mhsanaei/3x-ui/v3/internal/database/model"
|
|
"github.com/mhsanaei/3x-ui/v3/internal/logger"
|
|
"github.com/mhsanaei/3x-ui/v3/internal/util/common"
|
|
"github.com/mhsanaei/3x-ui/v3/internal/web/service"
|
|
"github.com/mhsanaei/3x-ui/v3/internal/xray"
|
|
|
|
"github.com/mymmrac/telego"
|
|
tu "github.com/mymmrac/telego/telegoutil"
|
|
)
|
|
|
|
// BuildClientDraftMessage builds a protocol-neutral summary of the in-progress
|
|
// client (email, attached inbounds, traffic limit, expiry, ip limit, comment)
|
|
// shown in the multi-inbound add flow. Per-protocol secrets (UUID, password,
|
|
// flow, method) are generated by fillProtocolDefaults on submit, so the bot
|
|
// never has to track them per inbound itself.
|
|
func (t *Tgbot) BuildClientDraftMessage(draft *clientDraft) string {
|
|
now := time.Now().UnixMilli()
|
|
|
|
expiry := ""
|
|
switch {
|
|
case draft.expiryTime == 0:
|
|
expiry = t.I18nBot("tgbot.unlimited")
|
|
case draft.expiryTime < 0:
|
|
expiry = fmt.Sprintf("%d %s", draft.expiryTime/-86400000, t.I18nBot("tgbot.days"))
|
|
default:
|
|
diff := draft.expiryTime - now
|
|
if diff > 172800000 {
|
|
expiry = time.UnixMilli(draft.expiryTime).Format("2006-01-02 15:04:05")
|
|
} else {
|
|
expiry = fmt.Sprintf("%d %s", diff/3600000, t.I18nBot("tgbot.hours"))
|
|
}
|
|
}
|
|
|
|
traffic := "♾️ Unlimited(Reset)"
|
|
if draft.totalGB > 0 {
|
|
traffic = common.FormatTraffic(draft.totalGB)
|
|
}
|
|
|
|
ipLimit := "♾️ Unlimited(Reset)"
|
|
if draft.limitIP > 0 {
|
|
ipLimit = fmt.Sprint(draft.limitIP)
|
|
}
|
|
|
|
attached := t.describeAttachedInbounds(draft.receiverInboundIDs)
|
|
if attached == "" {
|
|
attached = "—"
|
|
}
|
|
|
|
comment := draft.comment
|
|
if comment == "" {
|
|
comment = "—"
|
|
}
|
|
|
|
tgID := draft.tgID
|
|
if tgID == "" {
|
|
tgID = "—"
|
|
}
|
|
|
|
var b strings.Builder
|
|
b.WriteString("📝 <b>New client draft</b>\r\n")
|
|
fmt.Fprintf(&b, "📧 Email: <code>%s</code>\r\n", html.EscapeString(draft.email))
|
|
fmt.Fprintf(&b, "🔗 Attached: %s\r\n", html.EscapeString(attached))
|
|
fmt.Fprintf(&b, "📊 Traffic: %s\r\n", traffic)
|
|
fmt.Fprintf(&b, "📅 Expire: %s\r\n", expiry)
|
|
fmt.Fprintf(&b, "🔢 IP limit: %s\r\n", ipLimit)
|
|
fmt.Fprintf(&b, "👤 TG user: %s\r\n", html.EscapeString(tgID))
|
|
fmt.Fprintf(&b, "💬 Comment: %s\r\n", html.EscapeString(comment))
|
|
return b.String()
|
|
}
|
|
|
|
// describeAttachedInbounds returns a short "remark1, remark2" list for the given
|
|
// inbound ids, falling back to "#id" when an inbound can't be loaded.
|
|
func (t *Tgbot) describeAttachedInbounds(ids []int) string {
|
|
if len(ids) == 0 {
|
|
return ""
|
|
}
|
|
parts := make([]string, 0, len(ids))
|
|
for _, id := range ids {
|
|
ib, err := t.inboundService.GetInbound(id)
|
|
if err != nil || ib == nil {
|
|
parts = append(parts, fmt.Sprintf("#%d", id))
|
|
continue
|
|
}
|
|
label := ib.Remark
|
|
if label == "" {
|
|
label = fmt.Sprintf("#%d", id)
|
|
}
|
|
parts = append(parts, label)
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
}
|
|
|
|
// SubmitAddClient sends the in-progress client to ClientService.Create with
|
|
// the full set of attached inbound ids. Per-inbound fillProtocolDefaults on
|
|
// the panel generates UUID/password/auth per protocol, so the bot only
|
|
// supplies the universal fields it actually collected.
|
|
func (t *Tgbot) SubmitAddClient(draft *clientDraft) (bool, error) {
|
|
inboundIDs := draft.receiverInboundIDs
|
|
if len(inboundIDs) == 0 && draft.receiverInboundID > 0 {
|
|
inboundIDs = []int{draft.receiverInboundID}
|
|
}
|
|
if len(inboundIDs) == 0 {
|
|
return false, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
|
|
}
|
|
|
|
tgIDInt, _ := strconv.ParseInt(draft.tgID, 10, 64)
|
|
client := model.Client{
|
|
Email: draft.email,
|
|
Enable: draft.enable,
|
|
LimitIP: draft.limitIP,
|
|
TotalGB: draft.totalGB,
|
|
ExpiryTime: draft.expiryTime,
|
|
SubID: draft.subID,
|
|
Comment: draft.comment,
|
|
Reset: draft.reset,
|
|
TgID: tgIDInt,
|
|
}
|
|
|
|
return t.clientService.Create(&t.inboundService, &service.ClientCreatePayload{
|
|
Client: client,
|
|
InboundIds: inboundIDs,
|
|
})
|
|
}
|
|
|
|
// buildSubscriptionURLs builds the HTML sub page URL and JSON subscription URL for a client email
|
|
func (t *Tgbot) buildSubscriptionURLs(email string) (string, string, error) {
|
|
// Resolve subId from client email
|
|
traffic, client, err := t.inboundService.GetClientByEmail(email)
|
|
_ = traffic
|
|
if err != nil || client == nil {
|
|
return "", "", errors.New("client not found")
|
|
}
|
|
|
|
// Gather settings to construct absolute URLs
|
|
subURI, _ := t.settingService.GetSubURI()
|
|
subJsonURI, _ := t.settingService.GetSubJsonURI()
|
|
subDomain, _ := t.settingService.GetSubDomain()
|
|
subPort, _ := t.settingService.GetSubPort()
|
|
subPath, _ := t.settingService.GetSubPath()
|
|
subJsonPath, _ := t.settingService.GetSubJsonPath()
|
|
subJsonEnable, _ := t.settingService.GetSubJsonEnable()
|
|
subKeyFile, _ := t.settingService.GetSubKeyFile()
|
|
subCertFile, _ := t.settingService.GetSubCertFile()
|
|
|
|
tls := (subKeyFile != "" && subCertFile != "")
|
|
scheme := "http"
|
|
if tls {
|
|
scheme = "https"
|
|
}
|
|
|
|
// Fallbacks
|
|
if subDomain == "" {
|
|
// try panel domain, otherwise OS hostname
|
|
if d, err := t.settingService.GetWebDomain(); err == nil && d != "" {
|
|
subDomain = d
|
|
} else if hostname != "" {
|
|
subDomain = hostname
|
|
} else {
|
|
subDomain = "localhost"
|
|
}
|
|
}
|
|
|
|
host := subDomain
|
|
if (subPort == 443 && tls) || (subPort == 80 && !tls) {
|
|
// standard ports: no port in host
|
|
} else {
|
|
host = fmt.Sprintf("%s:%d", subDomain, subPort)
|
|
}
|
|
|
|
// Ensure paths
|
|
if !strings.HasPrefix(subPath, "/") {
|
|
subPath = "/" + subPath
|
|
}
|
|
if !strings.HasSuffix(subPath, "/") {
|
|
subPath = subPath + "/"
|
|
}
|
|
if !strings.HasPrefix(subJsonPath, "/") {
|
|
subJsonPath = "/" + subJsonPath
|
|
}
|
|
if !strings.HasSuffix(subJsonPath, "/") {
|
|
subJsonPath = subJsonPath + "/"
|
|
}
|
|
|
|
var subURL string
|
|
var subJsonURL string
|
|
|
|
// If pre-configured URIs are available, use them directly
|
|
if subURI != "" {
|
|
if !strings.HasSuffix(subURI, "/") {
|
|
subURI = subURI + "/"
|
|
}
|
|
subURL = fmt.Sprintf("%s%s", subURI, client.SubID)
|
|
} else {
|
|
subURL = fmt.Sprintf("%s://%s%s%s", scheme, host, subPath, client.SubID)
|
|
}
|
|
|
|
if subJsonURI != "" {
|
|
if !strings.HasSuffix(subJsonURI, "/") {
|
|
subJsonURI = subJsonURI + "/"
|
|
}
|
|
subJsonURL = fmt.Sprintf("%s%s", subJsonURI, client.SubID)
|
|
} else {
|
|
subJsonURL = fmt.Sprintf("%s://%s%s%s", scheme, host, subJsonPath, client.SubID)
|
|
}
|
|
|
|
if !subJsonEnable {
|
|
subJsonURL = ""
|
|
}
|
|
return subURL, subJsonURL, nil
|
|
}
|
|
|
|
// clientSubLinks builds the subscription's links in-process for the host subURL
|
|
// names; fetching subURL instead fails whenever that host does not resolve here.
|
|
func (t *Tgbot) clientSubLinks(email, subURL string) ([]string, error) {
|
|
u, err := url.Parse(subURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, client, err := t.inboundService.GetClientByEmail(email)
|
|
if err != nil || client == nil {
|
|
return nil, errors.New("client not found")
|
|
}
|
|
return t.inboundService.GetSubLinks(u.Hostname(), client.SubID)
|
|
}
|
|
|
|
// clientInfoMsg formats client information message based on traffic and flags.
|
|
func (t *Tgbot) clientInfoMsg(
|
|
traffic *xray.ClientTraffic,
|
|
printEnabled bool,
|
|
printOnline bool,
|
|
printActive bool,
|
|
printDate bool,
|
|
printTraffic bool,
|
|
printRefreshed bool,
|
|
) string {
|
|
now := time.Now().Unix()
|
|
expiryTime := ""
|
|
flag := false
|
|
diff := traffic.ExpiryTime/1000 - now
|
|
if traffic.ExpiryTime == 0 {
|
|
expiryTime = t.I18nBot("tgbot.unlimited")
|
|
} else if traffic.ExpiryTime < 0 {
|
|
// A negative expiry counts days from first use, not a date; the disabled
|
|
// branch below would otherwise render it as a 1969 timestamp.
|
|
expiryTime = fmt.Sprintf("%d %s", traffic.ExpiryTime/-86400000, t.I18nBot("tgbot.days"))
|
|
flag = true
|
|
} else if diff > 172800 || !traffic.Enable {
|
|
expiryTime = time.Unix((traffic.ExpiryTime / 1000), 0).Format("2006-01-02 15:04:05")
|
|
if diff > 0 {
|
|
days := diff / 86400
|
|
hours := (diff % 86400) / 3600
|
|
minutes := (diff % 3600) / 60
|
|
remainingTime := ""
|
|
if days > 0 {
|
|
remainingTime += fmt.Sprintf("%d %s ", days, t.I18nBot("tgbot.days"))
|
|
}
|
|
if hours > 0 {
|
|
remainingTime += fmt.Sprintf("%d %s ", hours, t.I18nBot("tgbot.hours"))
|
|
}
|
|
if minutes > 0 {
|
|
remainingTime += fmt.Sprintf("%d %s", minutes, t.I18nBot("tgbot.minutes"))
|
|
}
|
|
expiryTime += fmt.Sprintf(" (%s)", remainingTime)
|
|
}
|
|
} else {
|
|
expiryTime = fmt.Sprintf("%d %s", diff/3600, t.I18nBot("tgbot.hours"))
|
|
flag = true
|
|
}
|
|
|
|
total := ""
|
|
if traffic.Total == 0 {
|
|
total = t.I18nBot("tgbot.unlimited")
|
|
} else {
|
|
total = common.FormatTraffic(traffic.Total)
|
|
}
|
|
|
|
enabled := ""
|
|
isEnabled, err := t.clientService.CheckIsEnabledByEmail(&t.inboundService, traffic.Email)
|
|
if err != nil {
|
|
logger.Warning(err)
|
|
enabled = t.I18nBot("tgbot.wentWrong")
|
|
} else if isEnabled {
|
|
enabled = t.I18nBot("tgbot.messages.yes")
|
|
} else {
|
|
enabled = t.I18nBot("tgbot.messages.no")
|
|
}
|
|
|
|
active := ""
|
|
if traffic.Enable {
|
|
active = t.I18nBot("tgbot.messages.yes")
|
|
} else {
|
|
active = t.I18nBot("tgbot.messages.no")
|
|
}
|
|
|
|
status := t.I18nBot("tgbot.offline")
|
|
isOnline := false
|
|
if process := service.XrayProcess(); process != nil && process.IsRunning() {
|
|
if slices.Contains(process.GetOnlineClients(), traffic.Email) {
|
|
status = t.I18nBot("tgbot.online")
|
|
isOnline = true
|
|
}
|
|
}
|
|
|
|
output := ""
|
|
output += t.I18nBot("tgbot.messages.email", "Email=="+traffic.Email)
|
|
if attachIds, err := t.clientService.GetInboundIdsForEmail(nil, traffic.Email); err == nil && len(attachIds) > 0 {
|
|
output += fmt.Sprintf("🔗 Inbounds: %s\r\n", t.describeAttachedInbounds(attachIds))
|
|
}
|
|
if printEnabled {
|
|
output += t.I18nBot("tgbot.messages.enabled", "Enable=="+enabled)
|
|
}
|
|
if printOnline {
|
|
output += t.I18nBot("tgbot.messages.online", "Status=="+status)
|
|
if !isOnline && traffic.LastOnline > 0 {
|
|
output += t.I18nBot("tgbot.messages.lastOnline", "Time=="+time.UnixMilli(traffic.LastOnline).Format("2006-01-02 15:04:05"))
|
|
}
|
|
}
|
|
if printActive {
|
|
output += t.I18nBot("tgbot.messages.active", "Enable=="+active)
|
|
}
|
|
if printDate {
|
|
if flag {
|
|
output += t.I18nBot("tgbot.messages.expireIn", "Time=="+expiryTime)
|
|
} else {
|
|
output += t.I18nBot("tgbot.messages.expire", "Time=="+expiryTime)
|
|
}
|
|
}
|
|
if printTraffic {
|
|
output += t.I18nBot("tgbot.messages.upload", "Upload=="+common.FormatTraffic(traffic.Up))
|
|
output += t.I18nBot("tgbot.messages.download", "Download=="+common.FormatTraffic(traffic.Down))
|
|
output += t.I18nBot("tgbot.messages.total", "UpDown=="+common.FormatTraffic((traffic.Up+traffic.Down)), "Total=="+total)
|
|
}
|
|
if printRefreshed {
|
|
output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
|
|
}
|
|
|
|
return output
|
|
}
|
|
|
|
// clientOwnedByTgUser reports whether email belongs to a client bound to this
|
|
// Telegram account, the same list the self-service usage command reads.
|
|
func (t *Tgbot) clientOwnedByTgUser(tgUserID int64, email string) bool {
|
|
traffics, err := t.inboundService.GetClientTrafficTgBot(tgUserID)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
for _, traffic := range traffics {
|
|
if traffic.Email == email {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// getClientUsage retrieves and sends client usage information to the chat.
|
|
func (t *Tgbot) getClientUsage(chatId int64, tgUserID int64, email ...string) {
|
|
traffics, err := t.inboundService.GetClientTrafficTgBot(tgUserID)
|
|
if err != nil {
|
|
logger.Warning(err)
|
|
msg := t.I18nBot("tgbot.wentWrong")
|
|
t.SendMsgToTgbot(chatId, msg)
|
|
return
|
|
}
|
|
|
|
if len(traffics) == 0 {
|
|
t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.askToAddUserId", "TgUserID=="+strconv.FormatInt(tgUserID, 10)))
|
|
return
|
|
}
|
|
|
|
// A client sees only its own card, and never the admin keyboard: every button
|
|
// on it (reset traffic, limits, IP limit, enable/disable) acts on an account.
|
|
if t.levelOf(tgUserID) != levelAdmin {
|
|
t.screenClientHome(chatId, tgUserID)
|
|
return
|
|
}
|
|
|
|
output := ""
|
|
|
|
if len(traffics) > 0 {
|
|
if len(email) > 0 {
|
|
for _, traffic := range traffics {
|
|
if traffic.Email == email[0] {
|
|
output := t.clientInfoMsg(traffic, true, true, true, true, true, false)
|
|
t.SendMsgToTgbot(chatId, output)
|
|
return
|
|
}
|
|
}
|
|
msg := t.I18nBot("tgbot.noResult")
|
|
t.SendMsgToTgbot(chatId, msg)
|
|
return
|
|
} else {
|
|
for _, traffic := range traffics {
|
|
output += t.clientInfoMsg(traffic, true, true, true, true, true, false)
|
|
output += "\r\n"
|
|
}
|
|
}
|
|
}
|
|
|
|
output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
|
|
rows := [][]telego.InlineKeyboardButton{}
|
|
if len(email) > 0 {
|
|
rows = t.clientRows(email[0])
|
|
} else if len(traffics) > 0 {
|
|
rows = t.clientRows(traffics[0].Email)
|
|
}
|
|
t.renderScreen(chatId, t.newScreen("client", output, rows...))
|
|
}
|
|
|
|
// getCommonClientButtons returns the shared inline keyboard rows for the
|
|
// client-first multi-inbound add flow. Per-protocol secrets (UUID, password,
|
|
// flow, method) are generated by fillProtocolDefaults on submit, so the bot
|
|
// only exposes the universal client fields here.
|
|
func (t *Tgbot) getCommonClientButtons(draft *clientDraft) [][]telego.InlineKeyboardButton {
|
|
attachLabel := t.I18nBot("tgbot.buttons.attachInbound",
|
|
"Count=="+strconv.Itoa(len(draft.receiverInboundIDs)))
|
|
return [][]telego.InlineKeyboardButton{
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.change_email")).WithCallbackData("add_client_ch_default_email"),
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.change_comment")).WithCallbackData("add_client_ch_default_comment"),
|
|
),
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.limitTraffic")).WithCallbackData("add_client_ch_default_traffic"),
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.resetExpire")).WithCallbackData("add_client_ch_default_exp"),
|
|
),
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.ipLimit")).WithCallbackData("add_client_ch_default_ip_limit"),
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.setTGUser")).WithCallbackData("add_client_ch_default_tg_id"),
|
|
),
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(attachLabel).WithCallbackData("add_client_attach_more"),
|
|
),
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.submitDisable")).WithCallbackData("add_client_submit_disable"),
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.submitEnable")).WithCallbackData("add_client_submit_enable"),
|
|
),
|
|
tu.InlineKeyboardRow(
|
|
tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.cancel")).WithCallbackData("add_client_cancel"),
|
|
),
|
|
}
|
|
}
|
|
|
|
// addClient renders the draft as the chat's screen: the wizard keeps ONE
|
|
// message, and a value picker can edit it without losing the card.
|
|
func (t *Tgbot) addClient(chatId int64, draft *clientDraft, msg string, messageID ...int) {
|
|
if len(messageID) > 0 {
|
|
t.adoptScreen(chatId, messageID[0])
|
|
}
|
|
body := msg
|
|
if body == "" {
|
|
body = t.BuildClientDraftMessage(draft)
|
|
}
|
|
t.renderScreen(chatId, t.newScreen("wizard", body, t.getCommonClientButtons(draft)...))
|
|
}
|