669 lines
17 KiB
Go
669 lines
17 KiB
Go
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"mail_go/internal/db"
|
|
"mail_go/internal/storage"
|
|
"mail_go/internal/store"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
// MailHandler handles mail-related routes (inbox, compose, sent, view, etc.).
|
|
type MailHandler struct {
|
|
stores *store.Stores
|
|
storage *storage.AttachmentStorage
|
|
}
|
|
|
|
// NewMailHandler creates a new MailHandler with the given stores and attachment storage.
|
|
func NewMailHandler(stores *store.Stores, attStorage *storage.AttachmentStorage) *MailHandler {
|
|
return &MailHandler{stores: stores, storage: attStorage}
|
|
}
|
|
|
|
// Inbox renders the inbox page showing all messages in the user's INBOX folder.
|
|
func (h *MailHandler) Inbox(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
page := getPageParam(c, "page", 1)
|
|
|
|
messages, total, err := h.stores.Mails.ListByUserAndFolder(userID, "INBOX", page, 20)
|
|
if err != nil {
|
|
c.String(http.StatusInternalServerError, "加载收件箱失败: %v", err)
|
|
return
|
|
}
|
|
|
|
unreadCount, _ := h.stores.Mails.CountUnread(userID, "INBOX")
|
|
|
|
currentUser, _ := c.Get("currentUser")
|
|
|
|
totalPages := int(total) / 20
|
|
if int(total)%20 > 0 {
|
|
totalPages++
|
|
}
|
|
if totalPages < 1 {
|
|
totalPages = 0
|
|
}
|
|
|
|
c.HTML(200, "inbox", gin.H{
|
|
"currentUser": currentUser,
|
|
"messages": messages,
|
|
"total": total,
|
|
"unreadCount": unreadCount,
|
|
"page": page,
|
|
"pageSize": 20,
|
|
"totalPages": totalPages,
|
|
"folder": "INBOX",
|
|
"activeFolder": "inbox",
|
|
})
|
|
}
|
|
|
|
// View renders the email detail page for a specific message.
|
|
func (h *MailHandler) View(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "无效的邮件ID")
|
|
return
|
|
}
|
|
|
|
msg, err := h.stores.Mails.GetByID(uint(id))
|
|
if err != nil {
|
|
c.String(http.StatusNotFound, "邮件不存在")
|
|
return
|
|
}
|
|
|
|
// Verify the message belongs to the current user
|
|
if msg.UserID != userID {
|
|
c.String(http.StatusForbidden, "禁止访问")
|
|
return
|
|
}
|
|
|
|
// Load attachments
|
|
attachments, _ := h.stores.Attachments.ListByMessage(uint(id))
|
|
|
|
// Auto mark as read
|
|
if !msg.IsRead {
|
|
_ = h.stores.Mails.MarkRead(uint(id))
|
|
msg.IsRead = true
|
|
}
|
|
|
|
currentUser, _ := c.Get("currentUser")
|
|
|
|
c.HTML(200, "view", gin.H{
|
|
"currentUser": currentUser,
|
|
"message": msg,
|
|
"attachments": attachments,
|
|
"activeFolder": resolveActiveFolder(msg.Folder),
|
|
})
|
|
}
|
|
|
|
// Compose renders the email composition page.
|
|
func (h *MailHandler) Compose(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
currentUser, _ := c.Get("currentUser")
|
|
|
|
// Get user quota info for display
|
|
user, _ := h.stores.Users.GetByID(userID)
|
|
var usedBytes int64
|
|
var quotaBytes int64
|
|
if user != nil {
|
|
usedBytes = user.UsedBytes
|
|
quotaBytes = user.QuotaBytes
|
|
}
|
|
|
|
c.HTML(200, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": "",
|
|
"to": c.Query("to"),
|
|
"subject": c.Query("subject"),
|
|
"bodyContent": "",
|
|
"usedBytes": usedBytes,
|
|
"quotaBytes": quotaBytes,
|
|
})
|
|
}
|
|
|
|
// DoSend processes the email composition form, sends the email via SMTP,
|
|
// and stores the message record.
|
|
func (h *MailHandler) DoSend(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
currentUserVal, _ := c.Get("currentUser")
|
|
currentUser := currentUserVal.(*db.User)
|
|
|
|
to := c.PostForm("to")
|
|
subject := c.PostForm("subject")
|
|
body := c.PostForm("body")
|
|
htmlBody := c.PostForm("html_body")
|
|
cc := c.PostForm("cc")
|
|
|
|
if to == "" {
|
|
c.HTML(http.StatusBadRequest, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": "请输入收件人",
|
|
"to": to,
|
|
"subject": subject,
|
|
"cc": cc,
|
|
"bodyContent": htmlBody,
|
|
"usedBytes": currentUser.UsedBytes,
|
|
"quotaBytes": currentUser.QuotaBytes,
|
|
})
|
|
return
|
|
}
|
|
|
|
// Handle attachments and check quota
|
|
form, multipartErr := c.MultipartForm()
|
|
if multipartErr == nil {
|
|
files := form.File["attachments"]
|
|
if len(files) > 0 {
|
|
// Check attachment quota before saving
|
|
user, _ := h.stores.Users.GetByID(userID)
|
|
if user != nil {
|
|
var totalNewSize int64
|
|
for _, file := range files {
|
|
totalNewSize += file.Size
|
|
}
|
|
if user.UsedBytes+totalNewSize > user.QuotaBytes {
|
|
c.HTML(http.StatusBadRequest, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": fmt.Sprintf("附件超出配额限制。已用 %s / 总配额 %s", formatBytes(user.UsedBytes), formatBytes(user.QuotaBytes)),
|
|
"to": to,
|
|
"subject": subject,
|
|
"cc": cc,
|
|
"bodyContent": htmlBody,
|
|
"usedBytes": user.UsedBytes,
|
|
"quotaBytes": user.QuotaBytes,
|
|
})
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build the email content
|
|
fromAddr := fmt.Sprintf("%s@%s", currentUser.Username, currentUser.Domain.Name)
|
|
now := time.Now()
|
|
messageID := fmt.Sprintf("<%s@mail_go>", uuid.New().String())
|
|
|
|
// Construct the raw email message
|
|
var sb strings.Builder
|
|
sb.WriteString(fmt.Sprintf("From: %s\r\n", fromAddr))
|
|
sb.WriteString(fmt.Sprintf("To: %s\r\n", to))
|
|
if cc != "" {
|
|
sb.WriteString(fmt.Sprintf("Cc: %s\r\n", cc))
|
|
}
|
|
sb.WriteString(fmt.Sprintf("Subject: %s\r\n", subject))
|
|
sb.WriteString(fmt.Sprintf("Message-ID: %s\r\n", messageID))
|
|
sb.WriteString(fmt.Sprintf("Date: %s\r\n", now.Format(time.RFC1123Z)))
|
|
sb.WriteString("MIME-Version: 1.0\r\n")
|
|
|
|
// Build message body with multipart/alternative if HTML is present
|
|
if htmlBody != "" {
|
|
boundary := fmt.Sprintf("----=_Part_%s", uuid.New().String())
|
|
sb.WriteString(fmt.Sprintf("Content-Type: multipart/alternative; boundary=\"%s\"\r\n", boundary))
|
|
sb.WriteString("\r\n")
|
|
sb.WriteString(fmt.Sprintf("--%s\r\n", boundary))
|
|
sb.WriteString("Content-Type: text/plain; charset=utf-8\r\n\r\n")
|
|
sb.WriteString(body)
|
|
sb.WriteString(fmt.Sprintf("\r\n--%s\r\n", boundary))
|
|
sb.WriteString("Content-Type: text/html; charset=utf-8\r\n\r\n")
|
|
sb.WriteString(htmlBody)
|
|
sb.WriteString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
|
|
} else {
|
|
sb.WriteString("Content-Type: text/plain; charset=utf-8\r\n")
|
|
sb.WriteString("\r\n")
|
|
sb.WriteString(body)
|
|
}
|
|
|
|
allRecipients := append(parseAddressInput(to), parseAddressInput(cc)...)
|
|
localUsers := make([]*db.User, 0, len(allRecipients))
|
|
var unsupported []string
|
|
for _, rcpt := range allRecipients {
|
|
user, err := h.stores.Users.GetByEmail(rcpt)
|
|
if err != nil {
|
|
unsupported = append(unsupported, rcpt)
|
|
continue
|
|
}
|
|
localUsers = append(localUsers, user)
|
|
}
|
|
if len(unsupported) > 0 {
|
|
c.HTML(http.StatusBadRequest, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": fmt.Sprintf("暂不支持外部投递: %s", strings.Join(unsupported, ", ")),
|
|
"to": to,
|
|
"subject": subject,
|
|
"cc": cc,
|
|
"bodyContent": htmlBody,
|
|
"usedBytes": currentUser.UsedBytes,
|
|
"quotaBytes": currentUser.QuotaBytes,
|
|
})
|
|
return
|
|
}
|
|
|
|
for _, rcptUser := range localUsers {
|
|
inboxMsg := &db.Message{
|
|
UserID: rcptUser.ID,
|
|
MessageID: messageID,
|
|
Folder: "INBOX",
|
|
FromAddr: fromAddr,
|
|
ToAddr: to,
|
|
CcAddr: cc,
|
|
Subject: subject,
|
|
TextBody: body,
|
|
HtmlBody: htmlBody,
|
|
RawData: sb.String(),
|
|
Date: now,
|
|
IsRead: false,
|
|
}
|
|
if createErr := h.stores.Mails.Create(inboxMsg); createErr != nil {
|
|
c.HTML(http.StatusInternalServerError, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": fmt.Sprintf("投递邮件失败: %v", createErr),
|
|
"to": to,
|
|
"subject": subject,
|
|
"cc": cc,
|
|
"bodyContent": htmlBody,
|
|
"usedBytes": currentUser.UsedBytes,
|
|
"quotaBytes": currentUser.QuotaBytes,
|
|
})
|
|
return
|
|
}
|
|
}
|
|
|
|
// Save to Sent folder
|
|
msg := &db.Message{
|
|
UserID: userID,
|
|
MessageID: messageID,
|
|
Folder: "Sent",
|
|
FromAddr: fromAddr,
|
|
ToAddr: to,
|
|
CcAddr: cc,
|
|
Subject: subject,
|
|
TextBody: body,
|
|
HtmlBody: htmlBody,
|
|
RawData: sb.String(),
|
|
Date: now,
|
|
IsRead: true,
|
|
}
|
|
|
|
if createErr := h.stores.Mails.Create(msg); createErr != nil {
|
|
c.HTML(http.StatusInternalServerError, "compose", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "compose",
|
|
"error": fmt.Sprintf("保存邮件失败: %v", createErr),
|
|
"to": to,
|
|
"subject": subject,
|
|
"cc": cc,
|
|
"bodyContent": htmlBody,
|
|
"usedBytes": currentUser.UsedBytes,
|
|
"quotaBytes": currentUser.QuotaBytes,
|
|
})
|
|
return
|
|
}
|
|
|
|
// Handle attachments
|
|
if multipartErr == nil {
|
|
files := form.File["attachments"]
|
|
for _, file := range files {
|
|
// Read file content
|
|
f, err := file.Open()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
buf, err := io.ReadAll(f)
|
|
f.Close()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
// Save to disk
|
|
relPath, err := h.storage.Save(file.Filename, buf)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
// Determine content type from extension
|
|
contentType := "application/octet-stream"
|
|
ext := strings.ToLower(filepath.Ext(file.Filename))
|
|
if ct, ok := mimeTypes[ext]; ok {
|
|
contentType = ct
|
|
}
|
|
|
|
att := &db.Attachment{
|
|
MessageID: msg.ID,
|
|
FileName: file.Filename,
|
|
FilePath: relPath,
|
|
ContentType: contentType,
|
|
FileSize: file.Size,
|
|
}
|
|
_ = h.stores.Attachments.Create(att)
|
|
// Update user used bytes
|
|
_ = h.stores.Users.UpdateUsedBytes(userID, att.FileSize)
|
|
}
|
|
}
|
|
|
|
c.Redirect(http.StatusFound, "/sent")
|
|
}
|
|
|
|
func parseAddressInput(input string) []string {
|
|
parts := strings.FieldsFunc(input, func(r rune) bool {
|
|
return r == ',' || r == ';' || r == '\n' || r == '\r' || r == '\t' || r == ' '
|
|
})
|
|
addresses := make([]string, 0, len(parts))
|
|
for _, part := range parts {
|
|
addr := strings.TrimSpace(part)
|
|
if addr != "" {
|
|
addresses = append(addresses, addr)
|
|
}
|
|
}
|
|
return addresses
|
|
}
|
|
|
|
// mimeTypes maps common file extensions to MIME types.
|
|
var mimeTypes = map[string]string{
|
|
".txt": "text/plain",
|
|
".html": "text/html",
|
|
".htm": "text/html",
|
|
".pdf": "application/pdf",
|
|
".doc": "application/msword",
|
|
".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
|
".xls": "application/vnd.ms-excel",
|
|
".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
|
".png": "image/png",
|
|
".jpg": "image/jpeg",
|
|
".jpeg": "image/jpeg",
|
|
".gif": "image/gif",
|
|
".zip": "application/zip",
|
|
".rar": "application/x-rar-compressed",
|
|
".csv": "text/csv",
|
|
}
|
|
|
|
// Sent renders the sent mail folder page.
|
|
func (h *MailHandler) Sent(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
page := getPageParam(c, "page", 1)
|
|
|
|
messages, total, err := h.stores.Mails.ListByUserAndFolder(userID, "Sent", page, 20)
|
|
if err != nil {
|
|
c.String(http.StatusInternalServerError, "加载发件箱失败: %v", err)
|
|
return
|
|
}
|
|
|
|
currentUser, _ := c.Get("currentUser")
|
|
|
|
totalPages := int(total) / 20
|
|
if int(total)%20 > 0 {
|
|
totalPages++
|
|
}
|
|
if totalPages < 1 {
|
|
totalPages = 0
|
|
}
|
|
|
|
c.HTML(200, "sent", gin.H{
|
|
"currentUser": currentUser,
|
|
"messages": messages,
|
|
"total": total,
|
|
"page": page,
|
|
"pageSize": 20,
|
|
"totalPages": totalPages,
|
|
"folder": "Sent",
|
|
"activeFolder": "sent",
|
|
})
|
|
}
|
|
|
|
// Delete removes a message by ID after verifying ownership.
|
|
func (h *MailHandler) Delete(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "无效的邮件ID")
|
|
return
|
|
}
|
|
|
|
msg, err := h.stores.Mails.GetByID(uint(id))
|
|
if err != nil || msg.UserID != userID {
|
|
c.String(http.StatusForbidden, "禁止访问")
|
|
return
|
|
}
|
|
|
|
// Delete attachments on disk and in DB, and decrease UsedBytes
|
|
attachments, _ := h.stores.Attachments.ListByMessage(uint(id))
|
|
for _, att := range attachments {
|
|
_ = h.storage.Delete(att.FilePath)
|
|
_ = h.stores.Users.UpdateUsedBytes(userID, -att.FileSize)
|
|
}
|
|
_ = h.stores.Attachments.DeleteByMessage(uint(id))
|
|
_ = h.stores.Mails.Delete(uint(id))
|
|
|
|
// Redirect back based on the folder
|
|
referer := c.GetHeader("Referer")
|
|
if referer == "" {
|
|
referer = "/inbox"
|
|
}
|
|
c.Redirect(http.StatusFound, referer)
|
|
}
|
|
|
|
// MarkRead marks a message as read.
|
|
func (h *MailHandler) MarkRead(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "无效的邮件ID")
|
|
return
|
|
}
|
|
|
|
msg, err := h.stores.Mails.GetByID(uint(id))
|
|
if err != nil || msg.UserID != userID {
|
|
c.String(http.StatusForbidden, "禁止访问")
|
|
return
|
|
}
|
|
|
|
_ = h.stores.Mails.MarkRead(uint(id))
|
|
|
|
referer := c.GetHeader("Referer")
|
|
if referer == "" {
|
|
referer = "/inbox"
|
|
}
|
|
c.Redirect(http.StatusFound, referer)
|
|
}
|
|
|
|
// DownloadAttachment serves an attachment file for download.
|
|
func (h *MailHandler) DownloadAttachment(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "无效的附件ID")
|
|
return
|
|
}
|
|
|
|
att, err := h.stores.Attachments.GetByID(uint(id))
|
|
if err != nil {
|
|
c.String(http.StatusNotFound, "附件不存在")
|
|
return
|
|
}
|
|
|
|
// Verify the message belongs to the current user
|
|
msg, err := h.stores.Mails.GetByID(att.MessageID)
|
|
if err != nil || msg.UserID != userID {
|
|
c.String(http.StatusForbidden, "禁止访问")
|
|
return
|
|
}
|
|
|
|
data, err := h.storage.Read(att.FilePath)
|
|
if err != nil {
|
|
c.String(http.StatusInternalServerError, "读取附件失败")
|
|
return
|
|
}
|
|
|
|
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", att.FileName))
|
|
c.Data(http.StatusOK, att.ContentType, data)
|
|
}
|
|
|
|
// getPageParam extracts and validates a page query parameter.
|
|
// Returns defaultVal if the parameter is missing or invalid.
|
|
func getPageParam(c *gin.Context, key string, defaultVal int) int {
|
|
pageStr := c.Query(key)
|
|
if pageStr == "" {
|
|
return defaultVal
|
|
}
|
|
page, err := strconv.Atoi(pageStr)
|
|
if err != nil || page < 1 {
|
|
return defaultVal
|
|
}
|
|
return page
|
|
}
|
|
|
|
// Drafts renders the drafts folder page.
|
|
func (h *MailHandler) Drafts(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
page := getPageParam(c, "page", 1)
|
|
|
|
messages, total, err := h.stores.Mails.ListByUserAndFolder(userID, "Drafts", page, 20)
|
|
if err != nil {
|
|
c.String(http.StatusInternalServerError, "加载草稿箱失败: %v", err)
|
|
return
|
|
}
|
|
|
|
currentUser, _ := c.Get("currentUser")
|
|
|
|
totalPages := int(total) / 20
|
|
if int(total)%20 > 0 {
|
|
totalPages++
|
|
}
|
|
if totalPages < 1 {
|
|
totalPages = 0
|
|
}
|
|
|
|
c.HTML(200, "drafts", gin.H{
|
|
"currentUser": currentUser,
|
|
"messages": messages,
|
|
"total": total,
|
|
"page": page,
|
|
"pageSize": 20,
|
|
"totalPages": totalPages,
|
|
"folder": "Drafts",
|
|
"activeFolder": "drafts",
|
|
})
|
|
}
|
|
|
|
// Settings renders the user settings page.
|
|
func (h *MailHandler) Settings(c *gin.Context) {
|
|
currentUser, _ := c.Get("currentUser")
|
|
c.HTML(200, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "",
|
|
"success": "",
|
|
})
|
|
}
|
|
|
|
// UpdateSettings handles the password change form.
|
|
func (h *MailHandler) UpdateSettings(c *gin.Context) {
|
|
userID := c.GetUint("userID")
|
|
currentUserVal, _ := c.Get("currentUser")
|
|
currentUser := currentUserVal.(*db.User)
|
|
|
|
oldPassword := c.PostForm("old_password")
|
|
newPassword := c.PostForm("new_password")
|
|
confirmPassword := c.PostForm("confirm_password")
|
|
|
|
// Verify old password
|
|
if err := bcrypt.CompareHashAndPassword([]byte(currentUser.PasswordHash), []byte(oldPassword)); err != nil {
|
|
c.HTML(http.StatusBadRequest, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "当前密码不正确",
|
|
"success": "",
|
|
})
|
|
return
|
|
}
|
|
|
|
if newPassword == "" {
|
|
c.HTML(http.StatusBadRequest, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "新密码不能为空",
|
|
"success": "",
|
|
})
|
|
return
|
|
}
|
|
|
|
if newPassword != confirmPassword {
|
|
c.HTML(http.StatusBadRequest, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "两次输入的密码不一致",
|
|
"success": "",
|
|
})
|
|
return
|
|
}
|
|
|
|
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
c.HTML(http.StatusInternalServerError, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "密码加密失败",
|
|
"success": "",
|
|
})
|
|
return
|
|
}
|
|
|
|
if err := h.stores.Users.UpdatePassword(userID, string(hashedPassword)); err != nil {
|
|
c.HTML(http.StatusInternalServerError, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "密码更新失败",
|
|
"success": "",
|
|
})
|
|
return
|
|
}
|
|
|
|
c.HTML(http.StatusOK, "settings", gin.H{
|
|
"currentUser": currentUser,
|
|
"activeFolder": "settings",
|
|
"error": "",
|
|
"success": "密码修改成功",
|
|
})
|
|
}
|
|
|
|
// resolveActiveFolder maps a folder name to a sidebar active state key.
|
|
func resolveActiveFolder(folder string) string {
|
|
switch folder {
|
|
case "INBOX":
|
|
return "inbox"
|
|
case "Sent":
|
|
return "sent"
|
|
case "Drafts":
|
|
return "drafts"
|
|
default:
|
|
return folder
|
|
}
|
|
}
|
|
|
|
// formatBytes converts a file size in bytes to a human-readable string.
|
|
// This is a handler-level utility that reuses the web package function.
|
|
func formatBytes(b int64) string {
|
|
const unit = 1024
|
|
if b < unit {
|
|
return fmt.Sprintf("%d B", b)
|
|
}
|
|
div, exp := int64(unit), 0
|
|
for n := b / unit; n >= unit; n /= unit {
|
|
div *= unit
|
|
exp++
|
|
}
|
|
return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "KMGTPE"[exp])
|
|
}
|