api-bpjs-surkon/handlers/bpjs/surat_kontrol/response.go

package suratkontrol

import (
	"bridging-rssa/docs"
	suratkontrol "bridging-rssa/models/bpjs/surat_kontrol"
	"bridging-rssa/models/config"
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"strings"
	"time"
)

func PostData(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("POST", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		return nil, err
	}
	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	log.Println("Res:", string(res))

	var resSuratKontrolRaw suratkontrol.ResponseRaw
	err = json.Unmarshal([]byte(string(res)), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	log.Println("ResponseRaw : ", resSuratKontrolRaw)

	responses := &suratkontrol.Response{}
	if resSuratKontrolRaw.MetaData.Code != "200" {
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol suratkontrol.ResponseSuratKontrol

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: resSuratKontrol,
	}

	return responses, nil
}

func ResponseUpdateSuratKontrol(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("PUT", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{
		Timeout: 10 * time.Second,
	}
	responses := &suratkontrol.Response{}
	response, err := client.Do(req)
	if err != nil {
		if strings.Contains(strings.ToLower(err.Error()), "deadline exceeded") {
			errMsg := errors.New("context deadline exceeded")
			log.Printf("error : %v", errMsg)
			responses.MetaData.Message = errMsg.Error()
			log.Println("responses: ", responses)
			return responses, err
		}
		log.Printf("Error making external API request: %v", err)
		return responses, err
	}
	log.Println("RESPONSE: ", response)

	if response.StatusCode == http.StatusGatewayTimeout { // 504
		errMsg := errors.New("504 Gateway Time-out")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "504"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, err
	}

	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	var resSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(res), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	if resSuratKontrolRaw.MetaData.Code != "200" {
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol *suratkontrol.ResponseSuratKontrol

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: *resSuratKontrol,
	}

	return responses, nil
}

func ResponseDeleteSuratKontrol(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("DELETE", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		return nil, err
	}
	log.Println("RESPONSE: ", response)

	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	var resSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(res), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	responses := &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
	}

	log.Println("res: ", responses)

	return responses, nil
}

func ResponseGetNomorSuratKontrol(url string, header *config.Header, headers map[string]string) (*suratkontrol.ResponseGetSuratKontrol, error) {
	log.Println("URL", url)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Printf("Error creating request: %v", err)
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
	}
	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		log.Println(err)
	}
	log.Println("res: ", string(res))

	var resNoSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(string(res)), &resNoSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	dataResp, err := docs.StringDecrypt(key, resNoSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		return nil, err
	}

	log.Println("dataresp: ", dataResp)

	var responseNoSuratKontrol suratkontrol.ResponseNomorSuratKontrol
	err = json.Unmarshal([]byte(dataResp), &responseNoSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses := &suratkontrol.ResponseGetSuratKontrol{
		MetaData: resNoSuratKontrolRaw.MetaData,
		Response: responseNoSuratKontrol,
	}
	log.Println("res: ", responses)

	return responses, nil
}

func ResponseGetSuratKontrolBySEP(url string, header *config.Header, headers map[string]string) (*suratkontrol.ResponseGetSuratKontrolBySEP, error) {
	log.Println("URL", url)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Printf("Error creating request: %v", err)
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
	}
	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		log.Println(err)
	}

	var resSurKonSEP suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(string(res)), &resSurKonSEP)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	dataResp, err := docs.StringDecrypt(key, resSurKonSEP.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		return nil, err
	}

	var responseNoSuratKontrol suratkontrol.ResponseSuratKontrolBySEP
	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &responseNoSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	log.Println("res: ", resSurKonSEP)

	responses := &suratkontrol.ResponseGetSuratKontrolBySEP{
		MetaData: resSurKonSEP.MetaData,
		Response: responseNoSuratKontrol,
	}

	return responses, nil
}