nms_cxy/features/fm/smsforward.go

package fm

import (
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"

	"nms_cxy/lib/dborm"
	"nms_cxy/lib/log"
	"nms_cxy/omc/config"

	"github.com/linxGnu/gosmpp"
	"github.com/linxGnu/gosmpp/data"
	"github.com/linxGnu/gosmpp/pdu"
)

func AlarmSMSForward(alarmData *Alarm) error {
	switch config.GetYamlConfig().Alarm.SMProxy {
	case "sms":
		users, err := AlarmForwardBySMS(alarmData)
		writeLog(alarmData, users, "SMS", err)
		return err
	case "smsc":
		users, err := AlarmForwardBySMPP(alarmData)
		writeLog(alarmData, users, "SMS", err)
		return err
	default:
		users, err := AlarmForwardBySMPP(alarmData)
		writeLog(alarmData, users, "SMS", err)
		return err
	}
}

func AlarmForwardBySMS(alarmData *Alarm) (string, error) {
	log.Info("AlarmForwardBySMS processing... ")

	SMSFforwardconfig := config.GetYamlConfig().Alarm.SMS
	// 阿里云短信API的请求地址
	apiURL := SMSFforwardconfig.ApiURL

	// 阿里云短信API的AccessKey ID和AccessKey Secret
	//accessKeyID := SMSFforwardconfig.AccessKeyID
	accessKeySecret := SMSFforwardconfig.AccessKeySecret

	toUsers, err := dborm.XormGetAlarmForward("SMS")
	if err != nil {
		log.Error("Failed to XormGetAlarmForward:", err)
		return "", err
	} else if toUsers == nil {
		err := errors.New("not found forward phone number")
		log.Error(err)
		return "", err
	}
	userList := strings.Join(*toUsers, ",")

	// 短信相关参数
	params := url.Values{}
	params.Set("PhoneNumbers", userList)
	params.Set("SignName", SMSFforwardconfig.SignName)
	params.Set("TemplateCode", SMSFforwardconfig.TemplateCode)
	params.Set("TemplateParam", `{"message":"alarm"}`)

	// 构建请求URL
	reqURL := apiURL + "?Action=SendSms&" + params.Encode()

	// 创建HTTP请求
	req, err := http.NewRequest("GET", reqURL, nil)
	if err != nil {
		log.Error("Failed to create request:", err)
		return userList, err
	}

	// 添加请求头部
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Authorization", "APPCODE "+accessKeySecret)

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Error("Failed to send request:%v", err)
		return userList, err
	}
	defer resp.Body.Close()

	// 解析响应
	switch resp.StatusCode {
	case http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusCreated:
		return userList, nil
	default:
		err := fmt.Errorf("Failed to send SMS: %s(Code=%d)", resp.Status, resp.StatusCode)
		log.Error(err)
		return userList, err
	}
}

func AlarmForwardBySMPP(alarmData *Alarm) (string, error) {
	log.Info("AlarmForwardBySMPP processing... ")

	toUsers, err := dborm.XormGetAlarmForward("SMS")
	if err != nil {
		log.Error("Failed to XormGetAlarmForward:", err)
		return "", err
	} else if toUsers == nil {
		err := errors.New("not found forward phone number")
		log.Error(err)
		return "", err
	}
	userList := strings.Join(*toUsers, ",")

	auth := gosmpp.Auth{
		SMSC:       config.GetYamlConfig().Alarm.SMSC.Addr,
		SystemID:   config.GetYamlConfig().Alarm.SMSC.SystemID,
		Password:   config.GetYamlConfig().Alarm.SMSC.Password,
		SystemType: config.GetYamlConfig().Alarm.SMSC.SystemType,
	}

	// conn, err := gosmpp.NonTLSDialer(auth.SMSC)
	// connection := gosmpp.NewConnection(conn)

	trans, err := gosmpp.NewSession(
		gosmpp.TXConnector(gosmpp.NonTLSDialer, auth),
		gosmpp.Settings{
			ReadTimeout: 2 * time.Second,

			OnPDU: func(p pdu.PDU, _ bool) {
				log.Debug("%+v", p)
			},

			OnSubmitError: func(_ pdu.PDU, err error) {
				log.Error(err)
			},

			OnRebindingError: func(err error) {
				log.Error(err)
			},

			OnClosed: func(state gosmpp.State) {
				log.Error(state)
			},
		}, -1)
	if err != nil {
		log.Error("Failed to create SMPP new session:", err)
		return userList, err
	}
	defer func() {
		_ = trans.Close()
	}()

	// sending SMS(s)
	// var results []string
	// for _, toUser := range *toUsers {
	message := "Alarm Notification: " + alarmData.AlarmTitle + " from " + alarmData.NeType + " " + alarmData.NeId + " at " + alarmData.EventTime
	if err = trans.Transceiver().Submit(newSubmitSM(userList, message)); err != nil {
		// result := fmt.Sprintf("Failed to submit %s hort message:%s", toUser, err.Error())
		// results = append(results, result)
		log.Error("Failed to submit hort message:", err)
		return userList, err
	}
	// }
	return userList, nil
}

func writeLog(alarmData *Alarm, toUser, forwardBy string, err error) error {
	var result string
	if err == nil {
		result = "SMS sent successfully"
	} else {
		result = err.Error()
	}
	forwardLog := &dborm.AlarmForwardLog{
		NeType:     alarmData.NeType,
		NeID:       alarmData.NeId,
		AlarmID:    alarmData.AlarmId,
		AlarmTitle: alarmData.AlarmTitle,
		AlarmSeq:   alarmData.AlarmSeq,
		EventTime:  alarmData.EventTime,
		Interface:  forwardBy,
		ToUser:     toUser,
		OperResult: result,
	}

	affected, err := dborm.XormInsertAlarmForwardLog(forwardLog)
	if err != nil && affected <= 0 {
		log.Error("Failed to insert data:", err)
		return err
	}
	return nil
}

func handlePDU() func(pdu.PDU) (pdu.PDU, bool) {
	return func(p pdu.PDU) (pdu.PDU, bool) {
		switch pd := p.(type) {
		case *pdu.Unbind:
			log.Trace("Unbind Received")
			return pd.GetResponse(), true

		case *pdu.UnbindResp:
			log.Trace("UnbindResp Received")

		case *pdu.SubmitSMResp:
			log.Trace("SubmitSMResp Received")

		case *pdu.GenericNack:
			log.Trace("GenericNack Received")

		case *pdu.EnquireLinkResp:
			fmt.Println("EnquireLinkResp Received")

		case *pdu.EnquireLink:
			log.Trace("EnquireLink Received")
			return pd.GetResponse(), false

		case *pdu.DataSM:
			log.Trace("DataSM receiver")
			return pd.GetResponse(), false

		case *pdu.DeliverSM:
			log.Trace("DeliverSM receiver")
			return pd.GetResponse(), false
		}
		return nil, false
	}
}

func newSubmitSM(phoneNumber string, message string) *pdu.SubmitSM {
	// build up submitSM
	srcAddr := pdu.NewAddress()
	srcAddr.SetTon(5)
	srcAddr.SetNpi(0)
	_ = srcAddr.SetAddress("alarm notification:")

	destAddr := pdu.NewAddress()
	destAddr.SetTon(1)
	destAddr.SetNpi(1)
	_ = destAddr.SetAddress(phoneNumber)

	submitSM := pdu.NewSubmitSM().(*pdu.SubmitSM)
	submitSM.SourceAddr = srcAddr
	submitSM.DestAddr = destAddr
	_ = submitSM.Message.SetMessageWithEncoding(message, data.UCS2)
	submitSM.ProtocolID = 0
	submitSM.RegisteredDelivery = 1
	submitSM.ReplaceIfPresentFlag = 0
	submitSM.EsmClass = 0

	return submitSM
}