MiFaZhan
386 lines
11 KiB
Go
386 lines
11 KiB
Go
package warningconfig
|
||
|
||
import (
|
||
"context"
|
||
"crypto/rand"
|
||
"encoding/json"
|
||
"fmt"
|
||
"math/big"
|
||
"mime"
|
||
"net"
|
||
"net/mail"
|
||
"net/smtp"
|
||
"strings"
|
||
|
||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
|
||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility"
|
||
|
||
"github.com/gogf/gf/v2/errors/gerror"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/util/gconv"
|
||
)
|
||
|
||
const (
|
||
warnMethodSMS = "0"
|
||
warnMethodEmail = "1"
|
||
warnMethodPhone = "2"
|
||
warnMethodPlatform = "3"
|
||
warnEmailCodeTTLSeconds = 300
|
||
warnEmailCodeRedisKeyScope = "iotlcm:warning:email-code"
|
||
)
|
||
|
||
func SendEmailCode(ctx context.Context, in *model.TSimWarningConfigEmailCodeParam) error {
|
||
if in == nil {
|
||
return gerror.New("邮箱验证码参数不能为空")
|
||
}
|
||
email, err := normalizeSingleWarnEmail(in.Email)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if strings.TrimSpace(in.CaptchaID) == "" || strings.TrimSpace(in.CaptchaValue) == "" {
|
||
return gerror.New("图片验证码不能为空")
|
||
}
|
||
if err = service.SysCaptcha().VerifyCaptcha(ctx, in.CaptchaID, in.CaptchaValue); err != nil {
|
||
return err
|
||
}
|
||
userID := contexts.GetUserId(ctx)
|
||
tenantID := contexts.GetTenantId(ctx)
|
||
if userID <= 0 || strings.TrimSpace(tenantID) == "" {
|
||
return gerror.New("登录信息已过期")
|
||
}
|
||
code, err := generateWarnEmailCode()
|
||
if err != nil {
|
||
return gerror.Wrap(err, "生成邮箱验证码失败")
|
||
}
|
||
if err = setWarnEmailCode(ctx, tenantID, userID, email, code); err != nil {
|
||
return gerror.Wrap(err, "保存邮箱验证码失败，请稍后重试")
|
||
}
|
||
return sendWarnEmailCode(ctx, email, code)
|
||
}
|
||
|
||
func ValidateEmailCode(ctx context.Context, options Options) error {
|
||
return validateEmailCode(ctx, options, false)
|
||
}
|
||
|
||
func ConsumeEmailCode(ctx context.Context, options Options) error {
|
||
return validateEmailCode(ctx, options, true)
|
||
}
|
||
|
||
func validateEmailCode(ctx context.Context, options Options, consume bool) error {
|
||
if !hasEmailMethod(options.WarnMethods) {
|
||
return nil
|
||
}
|
||
email, err := normalizeSingleWarnEmail(options.WarnEmails)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
code := strings.TrimSpace(options.WarnEmailCode)
|
||
if code == "" {
|
||
return gerror.New("请选择邮箱提醒时必须填写邮箱验证码")
|
||
}
|
||
userID := contexts.GetUserId(ctx)
|
||
tenantID := contexts.GetTenantId(ctx)
|
||
if userID <= 0 || strings.TrimSpace(tenantID) == "" {
|
||
return gerror.New("登录信息已过期")
|
||
}
|
||
cacheCode, err := getWarnEmailCode(ctx, tenantID, userID, email)
|
||
if err != nil {
|
||
return gerror.Wrap(err, "获取邮箱验证码失败，请稍后重试")
|
||
}
|
||
if cacheCode == "" {
|
||
return gerror.New("邮箱验证码已失效")
|
||
}
|
||
if cacheCode != code {
|
||
return gerror.New("邮箱验证码错误")
|
||
}
|
||
if consume {
|
||
return deleteWarnEmailCode(ctx, tenantID, userID, email)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateNotificationOptions(options *Options) error {
|
||
if options == nil {
|
||
return gerror.New("预警配置参数不能为空")
|
||
}
|
||
if hasSMSMethod(options.WarnMethods) {
|
||
phones, err := normalizeWarnPhones(options.WarnPhones)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
options.WarnPhones = phones
|
||
}
|
||
if hasEmailMethod(options.WarnMethods) {
|
||
emails, err := normalizeWarnEmails(options.WarnEmails)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
options.WarnEmails = emails
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func hasSMSMethod(methods string) bool {
|
||
for _, method := range splitWarnList(methods) {
|
||
if method == warnMethodSMS {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func hasEmailMethod(methods string) bool {
|
||
for _, method := range splitWarnList(methods) {
|
||
if method == warnMethodEmail {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func normalizeSingleWarnEmail(value string) (string, error) {
|
||
emails := splitWarnList(value)
|
||
if len(emails) == 0 {
|
||
return "", gerror.New("请选择邮箱提醒时必须填写邮箱地址")
|
||
}
|
||
if len(emails) > 1 {
|
||
return "", gerror.New("邮箱提醒验证码第一版仅支持一个邮箱地址")
|
||
}
|
||
address, err := mail.ParseAddress(emails[0])
|
||
if err != nil || address == nil || strings.TrimSpace(address.Address) == "" {
|
||
return "", gerror.New("邮箱格式不正确")
|
||
}
|
||
return strings.ToLower(strings.TrimSpace(address.Address)), nil
|
||
}
|
||
|
||
func normalizeWarnEmails(value string) (string, error) {
|
||
emails := splitWarnList(value)
|
||
if len(emails) == 0 {
|
||
return "", gerror.New("请选择邮箱提醒时必须填写邮箱地址")
|
||
}
|
||
result := make([]string, 0, len(emails))
|
||
for _, email := range emails {
|
||
address, err := mail.ParseAddress(email)
|
||
if err != nil || address == nil || strings.TrimSpace(address.Address) == "" {
|
||
return "", gerror.Newf("邮箱格式不正确：%s", email)
|
||
}
|
||
result = append(result, strings.ToLower(strings.TrimSpace(address.Address)))
|
||
}
|
||
return strings.Join(result, ","), nil
|
||
}
|
||
|
||
func normalizeWarnPhones(value string) (string, error) {
|
||
phones := splitWarnList(value)
|
||
if len(phones) == 0 {
|
||
return "", gerror.New("请选择短信提醒时必须填写短信号码")
|
||
}
|
||
for _, phone := range phones {
|
||
if !isValidWarnPhone(phone) {
|
||
return "", gerror.Newf("手机号格式不正确：%s", phone)
|
||
}
|
||
}
|
||
return strings.Join(phones, ","), nil
|
||
}
|
||
|
||
func isValidWarnPhone(phone string) bool {
|
||
if len(phone) != 11 || phone[0] != '1' {
|
||
return false
|
||
}
|
||
for _, r := range phone {
|
||
if r < '0' || r > '9' {
|
||
return false
|
||
}
|
||
}
|
||
return phone[1] >= '3' && phone[1] <= '9'
|
||
}
|
||
|
||
func splitWarnList(value string) []string {
|
||
parts := strings.FieldsFunc(value, func(r rune) bool {
|
||
switch r {
|
||
case ',', ';', '，', '；', '|', '\n', '\r', '\t', ' ':
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
})
|
||
seen := make(map[string]struct{}, len(parts))
|
||
result := make([]string, 0, len(parts))
|
||
for _, part := range parts {
|
||
part = strings.TrimSpace(part)
|
||
if part == "" {
|
||
continue
|
||
}
|
||
key := strings.ToLower(part)
|
||
if _, exists := seen[key]; exists {
|
||
continue
|
||
}
|
||
seen[key] = struct{}{}
|
||
result = append(result, part)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func warnEmailCodeKey(tenantID string, userID int64, email string) string {
|
||
return fmt.Sprintf("%s:%s:%d:%s", warnEmailCodeRedisKeyScope, strings.TrimSpace(tenantID), userID, strings.ToLower(strings.TrimSpace(email)))
|
||
}
|
||
|
||
func setWarnEmailCode(ctx context.Context, tenantID string, userID int64, email string, code string) error {
|
||
_, err := g.Redis().Do(ctx, "SETEX", warnEmailCodeKey(tenantID, userID, email), warnEmailCodeTTLSeconds, code)
|
||
return err
|
||
}
|
||
|
||
func getWarnEmailCode(ctx context.Context, tenantID string, userID int64, email string) (string, error) {
|
||
value, err := g.Redis().Get(ctx, warnEmailCodeKey(tenantID, userID, email))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if value.IsNil() {
|
||
return "", nil
|
||
}
|
||
return value.String(), nil
|
||
}
|
||
|
||
func deleteWarnEmailCode(ctx context.Context, tenantID string, userID int64, email string) error {
|
||
_, err := g.Redis().Del(ctx, warnEmailCodeKey(tenantID, userID, email))
|
||
return err
|
||
}
|
||
|
||
func generateWarnEmailCode() (string, error) {
|
||
n, err := rand.Int(rand.Reader, big.NewInt(1000000))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return fmt.Sprintf("%06d", n.Int64()), nil
|
||
}
|
||
|
||
func sendWarnEmailCode(ctx context.Context, email string, code string) error {
|
||
cfg, ok := loadWarnEmailCodeConfig(ctx)
|
||
if !ok || strings.TrimSpace(cfg.Host) == "" {
|
||
if strings.TrimSpace(cfg.Url) != "" {
|
||
return callWarnEmailCodeHTTP(ctx, cfg.UserCodeHttpSenderConfig, email, code)
|
||
}
|
||
g.Log().Infof(ctx, "warning email config code, email:%s, code:%s", email, code)
|
||
return nil
|
||
}
|
||
if cfg.Port <= 0 {
|
||
cfg.Port = 25
|
||
}
|
||
if strings.TrimSpace(cfg.From) == "" {
|
||
cfg.From = cfg.Username
|
||
}
|
||
if strings.TrimSpace(cfg.From) == "" {
|
||
return gerror.New("预警邮箱验证码发件人为空")
|
||
}
|
||
addr := net.JoinHostPort(cfg.Host, gconv.String(cfg.Port))
|
||
auth := smtp.PlainAuth("", cfg.Username, cfg.Password, cfg.Host)
|
||
msg := buildWarnEmailCodeMessage(cfg, email, code)
|
||
|
||
err := utility.SendSMTP(ctx, utility.SMTPOptions{
|
||
Address: addr,
|
||
Host: cfg.Host,
|
||
Auth: auth,
|
||
From: cfg.From,
|
||
To: []string{email},
|
||
Data: msg,
|
||
SSL: cfg.SSL,
|
||
Timeout: utility.ExternalRequestTimeout(cfg.Timeout),
|
||
})
|
||
if err != nil {
|
||
g.Log().Errorf(ctx, "send warning email config code failed, email:%s, err:%+v", email, err)
|
||
return gerror.New("发送邮箱验证码失败，请稍后重试")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func loadWarnEmailCodeConfig(ctx context.Context) (model.UserCodeEmailSenderConfig, bool) {
|
||
var cfg model.UserCodeEmailSenderConfig
|
||
for _, key := range []string{"warning.email", "register.email"} {
|
||
v, err := g.Cfg().Get(ctx, key)
|
||
if err != nil || v.IsNil() {
|
||
continue
|
||
}
|
||
_ = v.Scan(&cfg)
|
||
if strings.TrimSpace(cfg.Url) != "" || strings.TrimSpace(cfg.Host) != "" {
|
||
return cfg, true
|
||
}
|
||
}
|
||
return cfg, false
|
||
}
|
||
|
||
func buildWarnEmailCodeMessage(cfg model.UserCodeEmailSenderConfig, email string, code string) []byte {
|
||
subject := strings.TrimSpace(cfg.Subject)
|
||
if subject == "" || subject == "注册验证码" {
|
||
subject = "预警邮箱验证码"
|
||
}
|
||
body := renderWarnEmailCodeTemplate(cfg.BodyTemplate, email, code)
|
||
if body == "" || strings.Contains(body, "注册验证码") {
|
||
body = fmt.Sprintf("您的预警邮箱验证码是：%s，5分钟内有效。", code)
|
||
}
|
||
from := strings.TrimSpace(cfg.From)
|
||
if strings.TrimSpace(cfg.FromName) != "" {
|
||
from = mime.QEncoding.Encode("UTF-8", cfg.FromName) + " <" + from + ">"
|
||
}
|
||
message := strings.Builder{}
|
||
message.WriteString("From: " + from + "\r\n")
|
||
message.WriteString("To: " + email + "\r\n")
|
||
message.WriteString("Subject: " + mime.QEncoding.Encode("UTF-8", subject) + "\r\n")
|
||
message.WriteString("MIME-Version: 1.0\r\n")
|
||
message.WriteString("Content-Type: text/html; charset=UTF-8\r\n")
|
||
message.WriteString("\r\n")
|
||
message.WriteString(body)
|
||
return []byte(message.String())
|
||
}
|
||
|
||
func renderWarnEmailCodeTemplate(template string, contact string, code string) string {
|
||
if strings.TrimSpace(template) == "" {
|
||
return ""
|
||
}
|
||
replacer := strings.NewReplacer(
|
||
"{contact}", contact,
|
||
"{{contact}}", contact,
|
||
"{email}", contact,
|
||
"{{email}}", contact,
|
||
"{code}", code,
|
||
"{{code}}", code,
|
||
)
|
||
return replacer.Replace(template)
|
||
}
|
||
|
||
func callWarnEmailCodeHTTP(ctx context.Context, cfg model.UserCodeHttpSenderConfig, email string, code string) error {
|
||
method := strings.ToUpper(strings.TrimSpace(cfg.Method))
|
||
if method == "" {
|
||
method = "POST"
|
||
}
|
||
successStatus := cfg.SuccessStatus
|
||
if successStatus <= 0 {
|
||
successStatus = 200
|
||
}
|
||
body := renderWarnEmailCodeTemplate(cfg.BodyTemplate, email, code)
|
||
if body == "" {
|
||
bodyBytes, _ := json.Marshal(g.Map{
|
||
"contact": email,
|
||
"email": email,
|
||
"code": code,
|
||
})
|
||
body = string(bodyBytes)
|
||
}
|
||
headers := cfg.Headers
|
||
if headers == nil {
|
||
headers = map[string]string{}
|
||
}
|
||
if _, ok := headers["Content-Type"]; !ok {
|
||
headers["Content-Type"] = "application/json"
|
||
}
|
||
resp, err := g.Client().Timeout(utility.ExternalRequestTimeout(cfg.Timeout)).SetHeaderMap(headers).DoRequest(ctx, method, cfg.Url, body)
|
||
if err != nil {
|
||
return gerror.Wrap(err, "发送邮箱验证码失败，请稍后重试")
|
||
}
|
||
defer resp.Close()
|
||
if resp.StatusCode != successStatus {
|
||
return gerror.Newf("发送邮箱验证码失败，服务响应状态码：%d", resp.StatusCode)
|
||
}
|
||
return nil
|
||
}
|