You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

322 lines
9.5 KiB
Go

4 weeks ago
package icshttp
import (
"batchmodule/icsconf"
"batchmodule/icserror"
"batchmodule/icslog"
"bytes"
"crypto/tls"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"strconv"
"strings"
"time"
"github.com/gorilla/websocket"
)
var (
conf icsconf.AppInfo
l *log.Logger
)
func init() {
conf = icsconf.Getconfig()
l = icslog.InitializeLogger()
}
type TAInfoJSON struct {
Cmd string `json:"cmd"`
ConnId string `json:"connId"`
Tel string `json:"tel"`
Ext string `json:"ext"`
EmpId string `json:"empId"`
DateTime string `json:"dateTime"`
CallStartTime string `json:"callStartTime"`
Index string `json:"index"`
Stt string `json:"stt"`
Dir string `json:"dir"`
IoGbn string `json:"ioGbn"`
}
type FailedList struct {
No int `json:"no"`
ConnId string `json:"connid"`
Ext string `json:"ext"`
StartTime string `json:"starttime"`
}
type FailedDataListReqBody struct {
StartTime string `json:"starttime"`
Ext string `json:"ext"`
ConnId string `json:"connid"`
}
type FailedDataListResBody struct {
TotalCnt string `json:"totalCnt"`
ReturnCode string `json:"returnCode"`
ReturnMsg string `json:"returnMsg"`
List []FailedList `json:"list"`
}
type FailedDataVoiceResBody struct {
VoiceFile string `json:"voiceFile"`
ReturnCode string `json:"returnCode"`
ReturnMsg string `json:"returnMsg"`
}
type IcsHttpClient struct {
Method string
URL string
Request *http.Request
http.Client
}
type TAResp struct {
Success bool `json:"success"`
ReturnCode string `json:"returnCode"`
Message string `json:"message"`
}
type NockChiReqBody struct {
Uid string `json:"uid"`
Ext string `json:"ext"`
SpeakerTag string `json:"speackertag"`
Transcripts string `json:"transcripts"`
}
func NewIcsHttpClient(method, url string, body io.Reader) *IcsHttpClient {
c := &IcsHttpClient{Method: method, URL: url}
r, err := http.NewRequest(method, url, body)
if err != nil {
l.Println("HTTP Client error while http.NewRequest(). error: ", err)
return nil
}
c.Request = r
c.SetTimeout(time.Millisecond * 1000 * 5)
return c
}
func (c *IcsHttpClient) SetTimeout(timeout time.Duration) {
c.Timeout = timeout
}
func HttpRequest(url, method, requestBody string) (*http.Response, error) {
// TLS 설정
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // 인증서 검증 비활성화
}
client := &http.Client{Transport: tr}
// client := &http.Client{}
payload := strings.NewReader(requestBody)
req, _ := http.NewRequest(method, url, payload)
req.Header.Set("Content-Type", "application/json")
// 요청
res, err := client.Do(req)
if err != nil {
return nil, fmt.Errorf("요청 오류: %w", err)
}
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("error: received non-200 response status: %s", res.Status)
}
return res, nil
}
func PostReqForFailedDataList() (response *FailedDataListResBody, cerr *icserror.IcsError) {
url := conf.Urls.FailedDataListUrl
currentDate := time.Now().Format("20060102")
currentDateUint64, _ := strconv.ParseUint(currentDate, 10, 64)
starttime := currentDateUint64 - 1
starttimeStr := strconv.FormatUint(starttime, 10)
body := FailedDataListReqBody{
StartTime: starttimeStr,
Ext: "",
ConnId: "",
}
jsonBody, err := json.Marshal(body)
if err != nil {
return nil, icserror.ICSERRMarshal
}
reqBody := bytes.NewBuffer(jsonBody)
l.Printf("client.go>PostReqForFailedDataList()> url: %s, reqBody: %+v", url, reqBody.String())
client := NewIcsHttpClient("POST", url, reqBody)
if client == nil {
return nil, icserror.ICSERRHTTPClientCreate
}
client.Request.Header.Add("Content-Type", "application/json;charset=utf-8")
client.Request.Header.Add("Accept", "application/json")
l.Printf("Error at client.go>PostReqForFailedDataList()> client.Request: %+v", client)
resp, err := client.Do(client.Request)
if err != nil {
l.Printf("Err at client.go>PostReqForFailedDataList()> client.Do failed. resp: %+v", resp)
l.Printf("The err: %+v", err)
return nil, icserror.ICSERRHTTPClientExcecution
}
l.Printf("client.go>PostReqForFailedDataList()> resp: %+v", resp)
resBody, err := io.ReadAll(resp.Body)
if err != nil {
l.Printf("client.go>PostReqForFailedDataList()> ReadAll err: %+v", err)
return nil, icserror.ICSERRRead
}
defer resp.Body.Close()
if err := json.Unmarshal(resBody, &response); err != nil {
l.Printf("Error at client.go>PostReqForFailedDataList()> Unmarshal err: %+v", err)
return nil, icserror.ICSERRUnmarshal
}
if strings.Contains(response.ReturnCode, "9999") {
l.Printf("Error at client.go>PostReqForFailedDataList()> response returnCode is 9999 with the message: %s", response.ReturnMsg)
return nil, icserror.ICSERRHTTPClientResponseFail
}
return response, nil
}
func PostReqForEachVoiceFile(reqDataForVoiceFile FailedDataListReqBody) (response *FailedDataVoiceResBody, cerr *icserror.IcsError) {
url := conf.Urls.FailedDataListUrl
jsonBody, err := json.Marshal(reqDataForVoiceFile)
if err != nil {
return nil, icserror.ICSERRMarshal
}
reqBody := bytes.NewBuffer(jsonBody)
l.Printf("client.go>PostReqForEachVoiceFile()> url: %s, reqBody: %+v", url, reqBody.String())
client := NewIcsHttpClient("POST", url, reqBody)
if client == nil {
return nil, icserror.ICSERRHTTPClientCreate
}
client.Request.Header.Add("Content-Type", "application/json;charset=utf-8")
client.Request.Header.Add("Accept", "application/json")
l.Printf("Error at client.go>PostReqForEachVoiceFile()> client.Request: %+v", client)
resp, err := client.Do(client.Request)
if err != nil {
l.Printf("Error at client.go>PostReqForEachVoiceFile()> client.Do failed. resp: %+v", resp)
l.Printf("The err: %+v", err)
return nil, icserror.ICSERRHTTPClientExcecution
}
l.Printf("client.go>PostReqForEachVoiceFile()> resp: %+v", resp)
resBody, err := io.ReadAll(resp.Body)
if err != nil {
l.Printf("client.go>PostReqForEachVoiceFile()> ReadAll err: %+v", err)
return nil, icserror.ICSERRRead
}
defer resp.Body.Close()
if err := json.Unmarshal(resBody, &response); err != nil {
l.Printf("Error at client.go>PostReqForEachVoiceFile()> Unmarshal err: %+v", err)
return nil, icserror.ICSERRUnmarshal
}
if strings.Contains(response.ReturnCode, "9999") {
l.Printf("Error at client.go>PostReqForEachVoiceFile()> response returnCode is 9999 with the message: %s", response.ReturnMsg)
return nil, icserror.ICSERRHTTPClientResponseFail
}
l.Printf("client.go>PostReqForEachVoiceFile()> response: %+v", response)
return response, nil
}
func SendSTTResToNockChiServer(parsedRes FailedDataListReqBody, sttRes string, dir string) *icserror.IcsError {
url := conf.Urls.NockChiServer.SrcIP
headers := http.Header{
"Origin": {"https://192.168.0.69"},
}
conn, _, err := websocket.DefaultDialer.Dial(url, headers)
if err != nil {
l.Println("[ERR] client.go>SendSTTResToNockChiServer()> connecting websocket failed. err: %v", err)
return icserror.ICSERRWEBSOCKETConnectFailError
}
defer conn.Close()
reqData := NockChiReqBody{
Uid: parsedRes.ConnId,
Ext: parsedRes.Ext,
SpeakerTag: dir,
Transcripts: sttRes,
}
jsonData, _ := json.Marshal(reqData)
reqBody := fmt.Sprintf(`{"data":"%s"}`, jsonData)
err = conn.WriteMessage(websocket.TextMessage, []byte(reqBody))
if err != nil {
l.Println("[ERR] client.go>SendSTTResToNockChiServer()> conn.WriteMessage() failed. err: ", err)
return icserror.ICSERRWEBSOCKETWriteError
}
l.Println("[LOG] client.go>SendSTTResToNockChiServer()> the stt result(connId: %s) was successfully sent via websocket. reqBody: %s", parsedRes.ConnId, reqBody)
return nil
}
func PostProcessTA(url, cmd string, connId string, tel string, ext string, empId string, dateTime string, callStartTime string, index string, stt string, dir string, ioGbn string) (tAResp *TAResp, cerr *icserror.IcsError) {
tAInfoJSON := TAInfoJSON{
Cmd: cmd,
ConnId: connId,
Tel: tel,
Ext: ext,
EmpId: empId,
DateTime: dateTime,
CallStartTime: callStartTime,
Index: index,
Stt: stt,
Dir: dir,
IoGbn: ioGbn,
}
b, err := json.Marshal(tAInfoJSON)
if err != nil {
return nil, icserror.ICSERRMarshal
}
body := bytes.NewBuffer(b)
client := NewIcsHttpClient("POST", url, body)
if client == nil {
l.Printf("[ERR] client.go>PostProcessTA()> NewIcsHttpClient() failed. err: %v", err)
l.Printf("[ERR] client.go>PostProcessTA()> NewIcsHttpClient() failed. url: %s, body: %s", url, body)
return nil, icserror.ICSERRHTTPClientCreate
}
client.Request.Header.Add("Content-Type", "application/json;charset=utf-8")
client.Request.Header.Add("Accept", "application/json")
l.Printf("[LOG] client.go>PostProcessTA()> Post Request Body: %+v", client.Request.Body)
resp, err := client.Do(client.Request)
if err != nil {
l.Printf("[ERR] client.go>PostProcessTA()> client.Do failed. err: %v", err)
l.Printf("[ERR] client.go>PostProcessTA()> client.Do failed. resp: %v", resp)
return nil, icserror.ICSERRHTTPClientPostRequest
}
l.Printf("[LOG] client.go>PostProcessTA()> client.Do() resp: %v", resp)
resBody, err := io.ReadAll(resp.Body)
if err != nil {
l.Printf("[ERR] client.go>PostProcessTA()> ReadAll failed. err: %v", err)
return nil, icserror.ICSERRRead
}
defer resp.Body.Close()
if err := json.Unmarshal(resBody, &tAResp); err != nil {
l.Printf("[ERR] client.go>PostProcessTA()> Unmarshal failed. err: %v", err)
return nil, icserror.ICSERRUnmarshal
}
return tAResp, nil
}