fix: adjustment directory structure

This commit is contained in:
zhangsz
2025-03-25 09:46:16 +08:00
parent e9b29a109d
commit 63ec6e5b14
167 changed files with 374 additions and 21127 deletions

35
proxy/Nmysql/alert_sms.go Normal file
View File

@@ -0,0 +1,35 @@
package Nmysql
import (
// "fmt"
l4g "proxy/logger"
)
func SetAlertSmsState2Sent(alertId int) error {
stmt, _ := MySqlDb.Prepare("update tb_sms_info set sms_state=2 where sms_alert_id=?;")
defer stmt.Close()
_, err := stmt.Exec(alertId)
if err != nil {
l4g.MysqlLog.Errorf("SetAlertSmsState2Sent err: %v", err)
return err
}
l4g.MysqlLog.Debugf("SetAlertSmsState2Sent succ!")
return nil
}
func InsertExpiredNotifySms(accountId uint32, planId uint32, expiredDate int64) error {
stmt, _ := MySqlDb.Prepare("INSERT into tb_sync_msg SET msg_type=1, acct_id=?, ofr_inst_id=?, exp_date=FROM_UNIXTIME(?), state=1;")
defer stmt.Close()
_, err := stmt.Exec(accountId, planId, expiredDate)
if err != nil {
l4g.MysqlLog.Errorf("InsertExpiredNotifySms acctId[%d], planId[%d], expiredDate[%d] err: %v", accountId, planId, expiredDate, err)
return err
}
l4g.MysqlLog.Debugf("InsertExpiredNotifySms acctId[%d], planId[%d], expiredDate[%d] succ!", accountId, planId, expiredDate)
return nil
}

View File

@@ -0,0 +1,72 @@
package Nmysql
import (
"fmt"
l4g "proxy/logger"
)
func QueryOfrIdByPrdInstId(prdInstId int) (int, error) {
sqlStr := fmt.Sprintf("select OFR_ID from tb_prd_sub_prd_inst_551 where MAIN_PRD_INST_ID=%d limit 1;", prdInstId)
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_prd_sub_prd_inst_551, prdInstId[%d] fail: %v", prdInstId, err)
return 0, err
}
defer rows.Close()
var ofrId int
for rows.Next(){
if err = rows.Scan(&ofrId); err != nil {
l4g.MysqlLog.Errorf("query row of TB_RESOURCE_EXAM fail: %v", err)
return 0, err
}
return ofrId, nil
}
return 0, nil
}
func QueryOfrLevelByOfrId(ofrId int) (int, error) {
sqlStr := fmt.Sprintf("select OFR_LEVEL from tb_prd_ofr where OFR_ID=%d limit 1;", ofrId)
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_prd_ofr, ofrId[%d] fail: %v", ofrId, err)
return 0, err
}
defer rows.Close()
var ofrLevel int
for rows.Next(){
if err = rows.Scan(&ofrLevel); err != nil {
l4g.MysqlLog.Errorf("query row of tb_prd_ofr fail: %v", err)
return 0, err
}
return ofrLevel, nil
}
return 0, nil
}
func QueryRentByOfrId(ofrId int) (int, error) {
sqlStr := fmt.Sprintf("SELECT f.FEE_VALUE rentValue FROM tb_prd_prd_once_fee f WHERE f.PRD_ID = %d AND f.TYPE = 2 AND f.FEE_TYPE = 5;", ofrId)
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_prd_prd_once_fee, ofrId[%d] fail: %v", ofrId, err)
return 0, err
}
defer rows.Close()
var onceFee int
for rows.Next(){
if err = rows.Scan(&onceFee); err != nil {
l4g.MysqlLog.Errorf("query row of tb_prd_prd_once_fee fail: %v", err)
return 0, err
}
return onceFee, nil
}
return 0, nil
}

4
proxy/Nmysql/map.go Normal file
View File

@@ -0,0 +1,4 @@
package Nmysql
type void struct{}
var member void

1311
proxy/Nmysql/mysql_db.go Normal file

File diff suppressed because it is too large Load Diff

175
proxy/Nmysql/provision.go Normal file
View File

@@ -0,0 +1,175 @@
package Nmysql
import (
"fmt"
l4g "proxy/logger"
)
func QuerySyncMobileInfo() ([]SyncMobileInfo, error) {
sqlStr := fmt.Sprintf("select PRE_ID, OPER_TYPE, IMSI, SERVICE_NBR, KI, IFNULL(OPC,'') as OPC, CUST_ID, ACCT_ID, PRD_INST_ID, MOBILE_TYPE, VMS_FLAG, IFNULL(BIRTH_DATE,'') as BIRTH_DATE, BALANCE, BALANCE_EXP_DATE, OFR_ID, EXP_DATE, IFNULL(CUG_ID,0) as CUG_ID from tb_sync_mobile where STATE=1 limit 10;")
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_mobile fail: %v", err)
return nil, err
}
defer rows.Close()
var rsp []SyncMobileInfo= nil
for rows.Next(){
var si SyncMobileInfo
if err = rows.Scan(&si.PreId, &si.OperType, &si.Imsi, &si.ServiceNbr, &si.Ki, &si.Opc, &si.CustId, &si.AcctId, &si.PrdInstId,
&si.MobileType, &si.VmsFlag, &si.BirthDate, &si.Balance, &si.BalanceExpDate, &si.OfrId, &si.ExpDate, &si.CugId); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_mobile fail: %v", err)
return nil, err
}
if si.BirthDate == "" {
si.BirthDate = "2000-01-01"
}
rsp = append(rsp, si)
}
return rsp, nil
}
type SyncMobileInfo struct {
PreId int// auto incr
OperType int// 1: create subs, 2: replace IMSI
Imsi string
ServiceNbr string
Ki string
Opc string
CustId int
AcctId int
PrdInstId int
MobileType int//0: postpaid, 1: prepaid
VmsFlag int//0: not VMS service, 1: VMS service
BirthDate string
Balance int
BalanceExpDate string
OfrId int
ExpDate string
CugId int// 1: staff, 2: customer
}
func QueryOldImsiInfo(serviceNbr string) (*OldImsiInfo, error) {
sqlStr := fmt.Sprintf("select PRE_ID, IMSI, PRD_INST_ID from tb_sync_mobile WHERE SERVICE_NBR='%s' and STATE>1 ORDER BY PRE_ID DESC limit 1;", serviceNbr)
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_mobile fail: %v", err)
return nil, err
}
defer rows.Close()
var rsp OldImsiInfo
for rows.Next(){
if err = rows.Scan(&rsp.PreId, &rsp.Imsi, &rsp.PrdInstId); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_mobile fail: %v", err)
return nil, err
}
return &rsp, nil
}
return nil, nil
}
type OldImsiInfo struct {
PreId int
Imsi string
PrdInstId int
}
func AddSmcliCmd2Mysql(cmdType int, nt int, serviceNbr string, cmdStr string) error {
sqlStr := fmt.Sprintf("INSERT INTO tb_sync_cn_cmd SET cmd_type=%d, node_type=%d, node_name='%s', srv_num='%s', command='%s', state=1, result=0, timestamp=NOW();",
cmdType, nt, NodeName[nt], serviceNbr, cmdStr)
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec()
if err != nil {
l4g.MysqlLog.Errorf("AddSmcliCmd2Mysql, cmdType[%d], nt[%d], prdInstId[%s], cmd[%s] error: %v", cmdType, nt, serviceNbr, cmdStr, err)
return err
}
l4g.MysqlLog.Debugf("AddSmcliCmd2Mysql, cmdType[%d], nt[%d], prdInstId[%s], cmd[%s] succ!", cmdType, nt, serviceNbr, cmdStr)
return nil
}
func AddSmcliCmdSucc2Mysql(cmdType int, nt int, serviceNbr string, cmdStr string) error {
cause := "000:Command Successful"
sqlStr := fmt.Sprintf("INSERT INTO tb_sync_cn_cmd SET cmd_type=%d, node_type=%d, node_name='%s', srv_num='%s', command='%s', state=2, result=1, cause='%s', timestamp=NOW();",
cmdType, nt, NodeName[nt], serviceNbr, cmdStr, cause)
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec()
if err != nil {
l4g.MysqlLog.Errorf("AddSmcliCmd2Mysql, cmdType[%d], nt[%d], prdInstId[%s], cmd[%s] error: %v", cmdType, nt, serviceNbr, cmdStr, err)
return err
}
l4g.MysqlLog.Debugf("AddSmcliCmd2Mysql, cmdType[%d], nt[%d], prdInstId[%s], cmd[%s] succ!", cmdType, nt, serviceNbr, cmdStr)
return nil
}
func UpdateSyncMobileState(preId int, state int) error {
sqlStr := fmt.Sprintf("UPDATE tb_sync_mobile set STATE=%d where PRE_ID=%d;", state, preId)
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec()
if err != nil {
l4g.MysqlLog.Errorf("UpdateSyncMobileState, preId[%d], state[%d] error: %v", preId, state, err)
return err
}
l4g.MysqlLog.Debugf("UpdateSyncMobileState, preId[%d], state[%d] succ!", preId, state)
return nil
}
func QuerySyncCnCmd() ([]CnCmdInfo, error) {
sqlStr := fmt.Sprintf("select id, node_type, command from tb_sync_cn_cmd where state=1 limit 40;")
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_cn_cmd fail: %v", err)
return nil, err
}
defer rows.Close()
var rsp []CnCmdInfo= nil
for rows.Next(){
var si CnCmdInfo
if err = rows.Scan(&si.Id, &si.NodeType, &si.Command); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_cn_cmd fail: %v", err)
return nil, err
}
rsp = append(rsp, si)
}
return rsp, nil
}
type CnCmdInfo struct {
Id int// auto incr
NodeType int
Command string
}
func UpdateCnCmdResult(id int, state int, result int, desc string) error {
sqlStr := fmt.Sprintf("update tb_sync_cn_cmd set state=%d,result=%d,cause='%s',timestamp=NOW() where id=%d;",
state, result, desc, id)
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec()
if err != nil {
l4g.MysqlLog.Errorf("UpdateCnCmdResult, id[%d], state[%d], result[%d], cause[%s] error: %v", id, state, result, desc, err)
return err
}
l4g.MysqlLog.Debugf("UpdateCnCmdResult, id[%d], state[%d], result[%d], cause[%s] succ!", id, state, result, desc)
return nil
}

29
proxy/Nmysql/smcli_cmd.go Normal file
View File

@@ -0,0 +1,29 @@
package Nmysql
const (
CT_CREATE_NA int= 0
CT_CREATE_SUB int= 1
CT_REPLACE_SUB int= 2
CT_SUSPEND_ACCOUNT int= 3
CT_DISABLE_ACCOUNT int= 4
CT_RESUME_ACCOUNT int= 5
CT_DISCONNECT_ACCOUNT int= 6
CT_UPDATE_SUB int= 7
CT_MAX int= 8
)
const (
NT_NA int= 0
NT_OCS int= 1
NT_HSS int= 2
NT_AUC int= 3
NT_VMS int= 4
NT_PSTN int= 5
NT_MSAN int= 6
NT_ADSL int= 7
NT_PCRF int= 8
NT_MAX int= 9
)
var NodeName = []string{"NULL","OCS","HSS","AUC","VMS","PSTN","MSAN","ADSL","PCRF"}

View File

@@ -0,0 +1,68 @@
package Nmysql
import (
l4g "proxy/logger"
)
func UpdateDataPlanInfo(bundleId uint32, thisTimeAdded uint64, opFlag bool) error {
var sqlStr string
if !opFlag {
sqlStr = "UPDATE ratable_history SET `VALUE`= `VALUE`+? WHERE ID=?;"
} else {
sqlStr = "UPDATE ratable_history SET `VALUE`= `VALUE`-? WHERE ID=?;"
}
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec(thisTimeAdded, bundleId)
if err != nil {
l4g.MysqlLog.Errorf("UpdateDataPlanInfo for bundle[%d], added[%d], op[%t] error: %v", bundleId, thisTimeAdded, opFlag, err)
return err
}
l4g.MysqlLog.Debugf("UpdateDataPlanInfo for bundle[%d], added[%d], op[%t] succ!", bundleId, thisTimeAdded, opFlag)
return nil
}
func UpdateVoiceAndSmsPlanInfo(serviceType byte, bundleId uint32, usedValue uint64, totalValue uint64, updateExpiryDate bool) error {
var sqlStr string
var value uint64
if updateExpiryDate {
sqlStr = "UPDATE ratable_history SET `VALUE`=? WHERE ID=?;"
value = totalValue
} else {
sqlStr = "UPDATE ratable_history SET `VALUE`=? WHERE ID=?;"
value = usedValue
}
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec(value, bundleId)
if err != nil {
l4g.MysqlLog.Errorf("UpdateVoiceAndSmsPlanInfo for bundle[%d], value[%d] error: %v", bundleId, value, err)
return err
}
l4g.MysqlLog.Debugf("UpdateVoiceAndSmsPlanInfo for bundle[%d], value[%d] succ!", bundleId, value)
return nil
}
func AddNotificationSms(accountId uint32, planId uint32, serviceType byte, updateExpiryDate bool, rateUsed int) error {
var sqlStr string= "INSERT into tb_sync_msg SET msg_type=2, rate_type=?, acct_id=?, rate_value=?, state=1, ofr_inst_id=?;"
rate := rateUsed
//if updateExpiryDate {
// rate = 100
//}
stmt, _ := MySqlDb.Prepare(sqlStr)
defer stmt.Close()
_, err := stmt.Exec(serviceType, accountId, rate, planId)
if err != nil {
l4g.MysqlLog.Errorf("AddNotificationSms for plan[%d], acct[%d], type[%d], rate[%d/100] error: %v", planId, accountId, serviceType, rate, err)
return err
}
l4g.MysqlLog.Debugf("AddNotificationSms for plan[%d], acct[%d], type[%d], rate[%d/100] succ!", planId, accountId, serviceType, rate)
return nil
}

303
proxy/Nmysql/user_status.go Normal file
View File

@@ -0,0 +1,303 @@
package Nmysql
import "C"
import (
"fmt"
. "proxy/config"
l4g "proxy/logger"
"strconv"
)
func UpdateUserStatus2Mdb(accountId uint32, status byte) error {
statusInCrm := 1001
switch status {
case 1:
statusInCrm = 1001
case 2:
statusInCrm = 1205
case 4:
statusInCrm = 1101
case 6:
statusInCrm = 1202
}
if false {
stmt, _ := MySqlDb.Prepare("update tb_prd_prd_inst_551 set PRD_INST_STAS_ID=?, MOD_DATE=NOW() where ACCT_ID=?;")
defer stmt.Close()
_, _ = stmt.Exec(statusInCrm, accountId)
}
if status == 4 {
stmt, _ := MySqlDb.Prepare("INSERT INTO tb_mobile_disc_cmd set ACCT_ID=?, ACCT_STATUS=0, UPDATE_DATE=NOW();")
defer stmt.Close()
_, err := stmt.Exec(accountId)
if err != nil {
l4g.MysqlLog.Errorf("UpdateUserStatus2Mdb acctId[%d] err: %v", accountId, err)
//return err
}
l4g.MysqlLog.Debugf("UpdateUserStatus2Mdb acctId[%d] succ!", accountId)
_ = InsertPrepaidUserDeleteCliCmd(accountId)
}
return nil
}
func InsertPrepaidUserDeleteCliCmd(accountId uint32) error {
//sqlStr := "select PRE_ID, OPER_TYPE, IMSI, SERVICE_NBR, KI, OPC, CUST_ID, STATE, PRD_INST_ID, MOBILE_TYPE, VMS_FLAG, BIRTH_DATE, BALANCE, "
//sqlStr += "BALANCE_EXP_DATE, OFR_ID, EXP_DATE, CUG_ID from tb_sync_mobile where ACCT_ID=? ORDER BY PRE_ID DESC limit 1;"
sqlStr := "select IMSI, SERVICE_NBR, PRD_INST_ID "
sqlStr += "from tb_sync_mobile where ACCT_ID=" + strconv.Itoa(int(accountId)) + " ORDER BY PRE_ID DESC limit 1;"
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_mobile, accountId[%d] fail: %v", accountId, err)
return err
}
//defer rows.Close()
var imsi, msisdn string
var prdInstId int
for rows.Next(){
if err = rows.Scan(&imsi, &msisdn, &prdInstId); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_mobile fail: %v", err)
_ = rows.Close()
return err
}
break
}
_ = rows.Close()
if imsi != "" {
cmd := "delete subscriber -imsi " + imsi
stmt, _ := MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err := stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_HSS, NodeName[NT_HSS], prdInstId, cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
cmd = "delete aucSubscriber -imsi " + imsi
stmt, _ = MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err = stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_AUC, NodeName[NT_AUC], prdInstId, cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
cmd = "delete vmsSubscriber -msisdn " + msisdn
stmt, _ = MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err = stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_VMS, NodeName[NT_VMS], prdInstId, cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
}
return nil
}
func CrmDeleteSubsProfile(serviceNbr string, acctType string, acctId string) {
if acctType == "1" {
//sqlStr := "select PRE_ID, OPER_TYPE, IMSI, SERVICE_NBR, KI, OPC, CUST_ID, STATE, PRD_INST_ID, MOBILE_TYPE, VMS_FLAG, BIRTH_DATE, BALANCE, "
//sqlStr += "BALANCE_EXP_DATE, OFR_ID, EXP_DATE, CUG_ID from tb_sync_mobile where ACCT_ID=? ORDER BY PRE_ID DESC limit 1;"
sqlStr := "select IMSI, SERVICE_NBR, PRD_INST_ID, MOBILE_TYPE, VMS_FLAG "
sqlStr += "from tb_sync_mobile where ACCT_ID=" + acctId + " ORDER BY PRE_ID DESC limit 1;"
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_mobile, accountId[%d] fail: %v", acctId, err)
return
}
//defer rows.Close()
var imsi, msisdn string
var prdInstId, mobileType, vmsFlag int
for rows.Next(){
if err = rows.Scan(&imsi, &msisdn, &prdInstId, &mobileType, &vmsFlag); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_mobile fail: %v", err)
_ = rows.Close()
return
}
break
}
_ = rows.Close()
if imsi != "" {
cmd := "delete subscriber -imsi " + imsi
stmt, _ := MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err := stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_HSS, NodeName[NT_HSS], strconv.Itoa(prdInstId), cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
cmd = "delete aucSubscriber -imsi " + imsi
stmt, _ = MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err = stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_AUC, NodeName[NT_AUC], strconv.Itoa(prdInstId), cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
if mobileType == 1{
cmd = "delete ppsSubscriber -msisdn " + msisdn
stmt, _ = MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=2, result=1, cause='0000:Command successful', timestamp=NOW();")
//defer stmt.Close()
_, err = stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_OCS, NodeName[NT_OCS], strconv.Itoa(prdInstId), cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
}
if vmsFlag == 1{
cmd = "delete vmsSubscriber -msisdn " + msisdn
stmt, _ = MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=0, timestamp=NOW();")
//defer stmt.Close()
_, err = stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_VMS, NodeName[NT_VMS], strconv.Itoa(prdInstId), cmd)
if err != nil {
l4g.MysqlLog.Errorf("add cmd[%s], msisdn[%s], prdInstId[%d] err: %v", cmd, msisdn, prdInstId, err)
//return err
} else {
l4g.MysqlLog.Debugf("add cmd[%s], msisdn[%s], prdInstId[%d]", cmd, msisdn, prdInstId)
}
stmt.Close()
}
}
} else if acctType == "2" {
ssEntryIdInCrm := Config.Provision.SsEntryIdInCrm
orderId := queryOrderIdByServiceNbr(serviceNbr)
if orderId == 0 {
return
}
examNumStr := queryResourceExamNumByOrderId(orderId)
if examNumStr == "" {
return
}
kronePairId, _ := strconv.Atoi(examNumStr)
if kronePairId <= 0 {
return
}
examNumStr = querySsEntryByResIdAndOrderId(ssEntryIdInCrm, orderId)
if examNumStr == "" {
return
}
ssEntry, _ := strconv.Atoi(examNumStr)
cmdDelPstn := fmt.Sprintf("delete pstn user isdn=%s, krone_pair_id=%d, ssentry=%d, state=Deleted, account_id=%s;",
serviceNbr,kronePairId, ssEntry,acctId)
insertCmdDelPstn(cmdDelPstn, serviceNbr)
}
return
}
func insertCmdDelPstn(cmd string, serviceNbr string) {
stmt, _ := MySqlDb.Prepare("INSERT INTO tb_sync_cn_cmd SET cmd_type=?, node_type=?, node_name=?, srv_num=?, command=?, state=1, result=1, timestamp=NOW();")
//defer stmt.Close()
_, err := stmt.Exec(CT_DISCONNECT_ACCOUNT, NT_PSTN, NodeName[NT_PSTN], serviceNbr, cmd)
if err != nil {
l4g.MysqlLog.Errorf("insertCmdDelPstn cmd[%s], msisdn[%s] err: %v", cmd, serviceNbr, err)
//return err
} else {
l4g.MysqlLog.Debugf("insertCmdDelPstn cmd[%s], msisdn[%s]", cmd, serviceNbr)
}
stmt.Close()
}
func queryOrderIdByServiceNbr(serviceNbr string) int {
sqlStr := "select ORDER_ID from tb_sync_pstn where SERVICE_NBR=" + serviceNbr + " ORDER by ORDER_ID desc limit 1;"
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query tb_sync_pstn, serviceNbr[%s] fail: %v", serviceNbr, err)
return 0
}
defer rows.Close()
var orderId int
for rows.Next(){
if err = rows.Scan(&orderId); err != nil {
l4g.MysqlLog.Errorf("query row of tb_sync_pstn fail: %v", err)
//_ = rows.Close()
return 0
}
return orderId
}
//_ = rows.Close()
return 0
}
func queryResourceExamNumByOrderId(orderId int) string {
sqlStr := "SELECT C.RESOURCE_EXAM_NUM FROM TB_PRD_RES_INST_551 A, TB_PRD_RES_INST_DETAIL_551 B, TB_RESOURCE_EXAM C "
sqlStr += "WHERE A.RES_INST_ID=B.RES_INST_ID AND B.RESOURCE_EXAM_ID=C.RESOURCE_EXAM_ID AND C.RESOURCE_ID=1046 AND A.ORDER_ID=" + strconv.Itoa(orderId)+";"
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query TB_RESOURCE_EXAM, orderId[%d] fail: %v", orderId, err)
return ""
}
defer rows.Close()
var resExamNum string
for rows.Next(){
if err = rows.Scan(&resExamNum); err != nil {
l4g.MysqlLog.Errorf("query row of TB_RESOURCE_EXAM fail: %v", err)
//_ = rows.Close()
return ""
}
return resExamNum
}
//_ = rows.Close()
return ""
}
func querySsEntryByResIdAndOrderId(resId, orderId int) string {
sqlStr := fmt.Sprintf("%s%sC.RESOURCE_ID=%d AND A.ORDER_ID=%d;",
"SELECT C.RESOURCE_EXAM_NUM FROM TB_PRD_RES_INST_551 A, TB_PRD_RES_INST_DETAIL_551 B, TB_RESOURCE_EXAM C ",
"WHERE A.RES_INST_ID=B.RES_INST_ID AND B.RESOURCE_EXAM_ID=C.RESOURCE_EXAM_ID AND ", resId, orderId)
rows, err := MySqlDb.Query(sqlStr)
if err != nil {
l4g.MysqlLog.Errorf("Query TB_RESOURCE_EXAM, orderId[%d] fail: %v", orderId, err)
return ""
}
defer rows.Close()
var resExamNum string
for rows.Next(){
if err = rows.Scan(&resExamNum); err != nil {
l4g.MysqlLog.Errorf("query row of TB_RESOURCE_EXAM fail: %v", err)
return ""
}
return resExamNum
}
return ""
}