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

package suratkontrol

import (
	cfg "bridging-rssa/config"
	"bridging-rssa/database/satu_data/jadwal"
	log_api "bridging-rssa/database/satu_data/log_api"
	lokasiruang "bridging-rssa/database/satu_data/lokasi_ruang"
	suratkontrol "bridging-rssa/database/satu_data/surat_kontrol"
	"bridging-rssa/docs/utils"
	sk "bridging-rssa/models/bpjs/surat_kontrol"
	"bridging-rssa/models/config"
	logapi "bridging-rssa/models/log_api"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

func InsertSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("INSERT_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	var req sk.RequestInsertRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: errLibur.Error(),
			},
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: jadwalLibur.NamaLiburPelayanan,
			},
		})
		return
	}

	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	log.Println("Request: ", string(reqJson))

	conf := config.ConfigBpjs{}

	header := cfg.SetHeader(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	var headerStringBuilder strings.Builder
	for key, value := range headers {
		headerStringBuilder.WriteString(fmt.Sprintf("%s: %s; ", key, value))
	}
	headerString := strings.TrimSuffix(headerStringBuilder.String(), "; ")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	var idRuangan int
	if kunjunganPasien.Ruangan != 0 {
		idRuangan = kunjunganPasien.Ruangan
	} else {
		idRuangan, err = lokasiruang.GetDaftarLokasiRuang(req.Ruangan)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
	}

	uuid := uuid.New().String()
	if req.TipeSurKon != "1" {
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}

		noUrut := "001"
		if dataSurkon != "" {
			noUrut, err = utils.GetNoUrut(dataSurkon)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "203",
						Message: err.Error(),
					},
				})
				return
			}
		}

		noSurKon := "SI/" + req.TipeRawat + "/" + kunjunganPasien.NomorRM + "/" + noUrut
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       noSurKon,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     idRuangan,
			DPJPSurKon:        req.IDDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			UserCreatedSurKon: req.User,
			TipeSurKon:        req.TipeSurKon,
		}
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}

		err = suratkontrol.UpdateKunjunganPasien(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "200",
				Message: "Berhasil Insert Surat Kontrol",
			},
		})
		return
	}

	reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.ReqInsertRencanaKontrol{
			NoSEP:             req.NoSEP,
			KodeDokter:        req.KodeHFIS,
			PoliKontrol:       req.KodePoli,
			TglRencanaKontrol: req.TglRencanaKontrol,
			User:              req.User,
		},
	}
	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := PostData(url, header, headers, reqSuratKontrol)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: res.MetaData,
		})
		return
	}

	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}
	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
	reqInsert := &sk.DataSuratKontrol{
		ID:                uuid,
		DateCreated:       timeNow,
		TglCetakSurKon:    timeNow,
		TglRencanaKontrol: res.Response.TglRencanaKontrol,
		NomorSurKon:       res.Response.NoSuratKontrol,
		KunjunganPasien:   kunjunganPasien.ID,
		RuanganSurKon:     idRuangan,
		DPJPSurKon:        req.IDDokter,
		StatusSurKon:      1, // First Insert status always set to 1
		UserCreatedSurKon: req.User,
		TipeSurKon:        "1",
	}

	err = suratkontrol.InsertDataSuratKontrol(reqInsert)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	if req.KodeDiagnosa == "" || req.NamaDiagnosa == "" {
		diagnosa := strings.Split(res.Response.NamaDiagnosa, " - ")
		req.KodeDiagnosa = diagnosa[0]
		req.NamaDiagnosa = diagnosa[1]
	}

	err = suratkontrol.UpdateKunjunganPasien(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "POST",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	response := &sk.ResponseInsertSuratKontrol{
		MetaData: res.MetaData,
		Response: sk.ResponseData{
			NoSuratKontrol:    res.Response.NoSuratKontrol,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NamaDokter:        res.Response.NamaDokter,
			NoKartu:           res.Response.NoKartu,
			Nama:              res.Response.Nama,
			Kelamin:           res.Response.Kelamin,
			TglLahir:          res.Response.TglLahir,
			NamaDiagnosa:      res.Response.NamaDiagnosa,
			SubSpesialis:      req.Subspesialis,
		},
	}

	log.Println("Response: ", response)
	c.JSON(http.StatusOK, response)
}

func UpdateSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("UPDATE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	var req sk.RequestUpdateRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: jadwalLibur.NamaLiburPelayanan,
		})
		return
	}

	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("Request: ", string(reqJson))

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	uuid := uuid.New().String()
	if req.TipeSurKon != "1" {
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}

		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       dataSurkon, //TODO How to get Nomor SurKon
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     kunjunganPasien.Ruangan,
			DPJPSurKon:        req.IDDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			TipeSurKon:        req.TipeSurKon,
			UserUpdatedSurKon: req.User,
		}
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDSurKon,
			StatusSurKon:      2,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		c.JSON(http.StatusOK, &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Update Surat Kontrol",
		})
		return
	}

	log.Println("Request: ", reqJson)

	conf := config.ConfigBpjs{}

	header := cfg.SetHeader(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	var headerStringBuilder strings.Builder
	for key, value := range headers {
		headerStringBuilder.WriteString(fmt.Sprintf("%s: %s; ", key, value))
	}
	headerString := strings.TrimSuffix(headerStringBuilder.String(), "; ")

	reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.ReqUpdateRencanaKontrol{
			NoSuratKontrol:    req.NoSuratKontrol,
			NoSEP:             req.NoSEP,
			KodeDokter:        req.KodeHFIS,
			PoliKontrol:       req.KodePoli,
			TglRencanaKontrol: req.TglRencanaKontrol,
			User:              req.User,
		},
	}

	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := ResponseUpdateSuratKontrol(url, header, headers, reqSuratKontrol)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		if res.MetaData.Code == "504" {
			log.Println(err)
			c.JSON(http.StatusGatewayTimeout, res.MetaData)
			return
		}
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "PUT",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		log.Println(err)
		c.JSON(http.StatusInternalServerError, res.MetaData)
		return
	}
	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")

	reqUpdate := &sk.DataSuratKontrol{
		DateUpdated:       timeNow,
		ID:                req.IDSurKon,
		StatusSurKon:      2,
		UserUpdatedSurKon: req.User,
	}

	err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	reqInsert := &sk.DataSuratKontrol{
		ID:                uuid,
		DateCreated:       timeNow,
		TglCetakSurKon:    timeNow,
		TglRencanaKontrol: res.Response.TglRencanaKontrol,
		NomorSurKon:       res.Response.NoSuratKontrol,
		KunjunganPasien:   kunjunganPasien.ID,
		RuanganSurKon:     kunjunganPasien.Ruangan,
		DPJPSurKon:        req.IDDokter,
		StatusSurKon:      1, // Insert status always set to 1
		TipeSurKon:        "1",
		UserUpdatedSurKon: req.User,
	}

	if reqInsert.DPJPSurKon == "" {
		reqInsert.DPJPSurKon = kunjunganPasien.DPJP
	}

	err = suratkontrol.InsertDataSuratKontrol(reqInsert)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "PUT",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, res)
}

func DeleteSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("DELETE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	var req sk.ReqDeleteRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("REQUEST: ", req)

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	if req.TipeSurKon != "1" {
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDDataSurKon,
			StatusSurKon:      0,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		res := &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Hapus Data",
		}
		c.JSON(http.StatusOK, res)
		return
	}

	conf := config.ConfigBpjs{}

	header := cfg.SetHeader(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	var headerStringBuilder strings.Builder
	for key, value := range headers {
		headerStringBuilder.WriteString(fmt.Sprintf("%s: %s; ", key, value))
	}

	headerString := strings.TrimSuffix(headerStringBuilder.String(), "; ")
	request := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.TSuratKontrol{
			RequestDelete: sk.RequestDeleteRencanaKontrol{
				NoSuratKontrol: req.NomorSurKon,
				User:           req.User,
			},
		},
	}

	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := ResponseDeleteSuratKontrol(url, header, headers, request)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		uuid := uuid.New().String()
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "DELETE",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, err)
		return
	}
	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}
	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
	uuid := uuid.New().String()
	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "DELETE",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	reqUpdate := &sk.DataSuratKontrol{
		DateUpdated:       timeNow,
		ID:                req.IDDataSurKon,
		StatusSurKon:      0,
		UserUpdatedSurKon: req.User,
	}

	err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	c.JSON(http.StatusOK, res)
}

func GetNomorSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("GET_NOMOR_SURAT_KONTROL")
	noSurat := c.Param("noSuratKontrol")
	url := baseUrl + endpoint + param + noSurat

	conf := config.ConfigBpjs{}

	header := cfg.SetHeader(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	res, err := ResponseGetNomorSuratKontrol(url, header, headers)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, res)
}

func GetSuratKontrolBySEP(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("GET_SURAT_KONTROL_SEP")
	noSEP := c.Param("noSEP")
	url := baseUrl + endpoint + param + noSEP

	conf := config.ConfigBpjs{}

	header := cfg.SetHeader(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	res, err := ResponseGetSuratKontrolBySEP(url, header, headers)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, err)
		return
	}

	c.JSON(http.StatusOK, res)
}

func GetDataSurKon(c *gin.Context) {
	offset := c.Param("offset")
	limit := c.Param("limit")
	data, err := suratkontrol.GetDataSuratKontrol(offset, limit)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	var resSurKon []*sk.ResponseGetDataSuratKontrol
	for _, v := range data {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkapDokter + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		dateCetakSurkon, _ := time.Parse(time.RFC3339, v.TglCetakSurKon)
		dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
		dateRencanaSurkon, _ := time.Parse(time.RFC3339, v.TglRencanaKontrol)
		dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
		resSurKon = append(resSurKon, &sk.ResponseGetDataSuratKontrol{
			IDDataSurKon:      v.IDDataSurKon,
			IDXDaftar:         v.IDXDaftar,
			TglCetakSurKon:    dateCetakSurkonString,
			TglRencanaKontrol: dateRencanaSurkonString,
			NomorSurKon:       v.NomorSurKon,
			PoliAsal:          v.PoliAsal,
			PoliTujuan:        v.PoliTujuan,
			NomorSEP:          v.NomorSEP,
			NamaPasien:        v.NamaPasien,
			NamaDokter:        namaLengkap,
			NomorKartu:        "",
			Subspesialis:      v.Subspesialis,
			KodePoli:          v.KodePoli,
			KodeDokter:        v.KodeDokter,
			IDDokter:          v.IDDokter,
			KodeDPJP:          v.KodeDPJP,
			NoRM:              v.NoRM,
			KodeDiagnosa:      v.KodeDiagnosa,
			NamaDiagnosa:      v.NamaDiagnosa,
			TipeSurKon:        v.TipeSurKon,
		})
	}
	c.JSON(http.StatusOK, resSurKon)
}

func GetDataSurKonByID(c *gin.Context) {
	id := c.Param("idxdaftar")
	data, err := suratkontrol.GetDataSuratKontrolByID(id)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	gelarDepan := utils.ReplaceGelar(data.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(data.GelarBelakang)
	namaLengkap := gelarDepan + " " + data.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, data.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, data.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      data.IDDataSurKon,
		IDXDaftar:         data.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       data.NomorSurKon,
		PoliAsal:          data.PoliAsal,
		PoliTujuan:        data.PoliTujuan,
		NomorSEP:          data.NomorSEP,
		NamaPasien:        data.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        "",
		Subspesialis:      data.Subspesialis,
		KodePoli:          data.KodePoli,
		KodeDokter:        data.KodeDokter,
		IDPoli:            data.IDPoli,
		IDDokter:          data.IDDokter,
		KodeDPJP:          data.KodeDPJP,
		NoRM:              data.NoRM,
		KodeDiagnosa:      data.KodeDiagnosa,
		NamaDiagnosa:      data.NamaDiagnosa,
		TipeSurKon:        data.TipeSurKon,
		User:              data.User,
	}
	c.JSON(http.StatusOK, resSurKon)
}

func PrintSurKon(c *gin.Context) {
	id := c.Param("idxdaftar")
	data, err := suratkontrol.GetDataSuratKontrolByID(id)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	gelarDepan := utils.ReplaceGelar(data.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(data.GelarBelakang)
	namaLengkap := gelarDepan + " " + data.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, data.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, data.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      data.IDDataSurKon,
		IDXDaftar:         data.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       data.NomorSurKon,
		PoliAsal:          data.PoliAsal,
		PoliTujuan:        data.PoliTujuan,
		NomorSEP:          data.NomorSEP,
		NamaPasien:        data.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        "",
		Subspesialis:      data.Subspesialis,
	}
	log.Println("Data surkon", resSurKon)
	c.JSON(http.StatusOK, resSurKon)
}

func CariPasienTPP(c *gin.Context) {
	var req sk.RequestCariPasien

	err := c.ShouldBindJSON(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("request :", req)

	query := ``
	var args []interface{}
	var argsCount []interface{}
	var data []*sk.GetDataSuratKontrol
	var count int
	if req.NoRM != "" {
		query += `and dkp2."NOMR" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.NoRM, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.NoRM, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
	} else if req.NoSEP != "" {
		query += `and dkp2."Nomor_sep" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.NoSEP, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.NoSEP, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
	} else if req.PoliKlinik != "" {
		query += `and ds."id" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.PoliKlinik, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.PoliKlinik, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
	} else {
		argsCount = append(argsCount, req.TipeSurKon, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
	}
	var listData []*sk.ResponseGetDataSuratKontrol
	for _, v := range data {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkapDokter + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		dateCetakSurkon, _ := time.Parse(time.RFC3339, v.TglCetakSurKon)
		dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
		dateRencanaSurkon, _ := time.Parse(time.RFC3339, v.TglRencanaKontrol)
		dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
		listData = append(listData, &sk.ResponseGetDataSuratKontrol{
			IDDataSurKon:      v.IDDataSurKon,
			IDXDaftar:         v.IDXDaftar,
			TglCetakSurKon:    dateCetakSurkonString,
			TglRencanaKontrol: dateRencanaSurkonString,
			NomorSurKon:       v.NomorSurKon,
			PoliAsal:          v.PoliAsal,
			PoliTujuan:        v.PoliTujuan,
			NomorSEP:          v.NomorSEP,
			NamaPasien:        v.NamaPasien,
			NamaDokter:        namaLengkap,
			NomorKartu:        "",
			Subspesialis:      v.Subspesialis,
			KodePoli:          v.KodePoli,
			KodeDokter:        v.KodeDokter,
			IDDokter:          v.IDDokter,
			KodeDPJP:          v.KodeDPJP,
			NoRM:              v.NoRM,
			KodeDiagnosa:      v.KodeDiagnosa,
			NamaDiagnosa:      v.NamaDiagnosa,
			TipeSurKon:        v.TipeSurKon,
		})
	}

	resSurKon := &sk.ResponseCariDataSuratKontrol{
		JumlahData:           count,
		ListDataSuratKontrol: listData,
	}
	c.JSON(http.StatusOK, resSurKon)
}