satusehat-bridging/internal/integration/allergancytoleran_integration.go

package integration

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"os"
	"satusehat-rssa/internal/constant"
	"satusehat-rssa/internal/model"
	"satusehat-rssa/pkg/httputil"
)

type AllergancyToleranInterface interface {
	// Define methods for AllergancyToleranInterface
	CreateAllergancyToleran(req model.AllergancyToleranRequest) (*model.AllergancyToleranResponse, error)
	UpdateAllergancyToleran(req model.AllergancyToleranRequest) (map[string]interface{}, error)
	GetAllergytoleranByPatient(id string) (map[string]interface{}, error)
	HandleCheckAllergancyToleran(id string) ([]string, bool, error)
}

type AllergancyToleranRepository struct {
	// Define fields for AllergancyToleranRepository
	akses *model.Akses
}

// GetAllergytoleranByPatient implements AllergancyToleranInterface.
func (a *AllergancyToleranRepository) GetAllergytoleranByPatient(id string) (map[string]interface{}, error) {
	var data map[string]interface{}

	url := a.akses.BaseUrl + "/AllergyIntolerance?patient=" + id
	method := "GET"

	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}
	oauth := model.OauthRequest{
		ClientId:     a.akses.ClientId,
		ClientSecret: a.akses.ClientSecret,
	}
	token, err := NewOauthRequestRepo(a.akses).GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}
	request.Header.Add("Authorization", "Bearer "+token.AccessToken)
	request.Header.Set("Content-Type", constant.ContentTypeFHIRJSON)
	request.Header.Set("Accept", constant.ContentTypeFHIRJSON)

	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}

	return data, nil
}

// HandleCheckAllergancyToleran implements AllergancyToleranInterface.
func (a *AllergancyToleranRepository) HandleCheckAllergancyToleran(id string) ([]string, bool, error) {
	allergy, err := a.GetAllergytoleranByPatient(id)
	if err != nil {
		return nil, false, err
	}

	var ids []string
	if entries, ok := allergy["entry"].([]interface{}); ok && len(entries) != 0 {
		if entries, ok := (allergy)["entry"].([]interface{}); ok && len(entries) > 0 {
			if entryMap, ok := entries[0].(map[string]interface{}); ok {
				if resource, ok := entryMap["resource"].(map[string]interface{}); ok {
					if id, ok := resource["id"].(string); ok {
						//fmt.Println("resource.id:", id)
						ids = append(ids, id)
						return ids, true, nil
					}
				}
			}
		}
		return nil, true, nil
	}

	return nil, false, nil
}

// CreateAllergancyToleran implements AllergancyToleranInterface.
func (a *AllergancyToleranRepository) CreateAllergancyToleran(req model.AllergancyToleranRequest) (*model.AllergancyToleranResponse, error) {
	var data *model.AllergancyToleranResponse

	req.ResourceType = constant.AllergyIntoleranceResourceType
	req.Identifier = append(req.Identifier, &model.IdentifierObject{
		Use:    "official",
		System: "http://sys-ids.kemkes.go.id/allergy/" + os.Getenv("ORGANIZATION_ID"), // Set this if needed, or remove if not present in IdentifierObject
		Value:  os.Getenv("ORGANIZATION_ID"),
	})

	patient, err := a.setupPatient(&req)
	if err != nil {
		return nil, err
	}

	err = a.setupEncounter(&req, patient)
	if err != nil {
		return nil, err
	}

	// err = a.setupPractitioner(&req)
	// if err != nil {
	// 	return nil, err
	// }

	url := a.akses.BaseUrl + "/AllergyIntolerance"
	method := "POST"

	payload, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	client := &http.Client{}
	request, err := http.NewRequest(method, url, bytes.NewBuffer(payload))
	if err != nil {
		return nil, err
	}

	oauth := model.OauthRequest{
		ClientId:     a.akses.ClientId,
		ClientSecret: a.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(a.akses)
	token, err := OauthInterface.GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}
	request.Header.Add("Authorization", "Bearer "+token.AccessToken)
	request.Header.Set("Content-Type", constant.ContentTypeFHIRJSON)
	request.Header.Set("Accept", constant.ContentTypeFHIRJSON)

	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}

	return data, nil
}

func (a *AllergancyToleranRepository) UpdateAllergancyToleran(req model.AllergancyToleranRequest) (map[string]interface{}, error) {
	req.ResourceType = constant.AllergyIntoleranceResourceType
	req.Identifier = append(req.Identifier, &model.IdentifierObject{
		Use:    "official",
		System: "http://sys-ids.kemkes.go.id/allergy/" + os.Getenv("ORGANIZATION_ID"), // Set this if needed, or remove if not present in IdentifierObject
		Value:  os.Getenv("ORGANIZATION_ID"),
	})

	patient, err := a.setupPatient(&req)
	if err != nil {
		return nil, err
	}

	err = a.setupEncounter(&req, patient)
	if err != nil {
		return nil, err
	}

	// err = a.setupPractitioner(&req)
	// if err != nil {
	// 	return nil, err
	// }

	oauth := model.OauthRequest{
		ClientId:     a.akses.ClientId,
		ClientSecret: a.akses.ClientSecret,
	}
	token, err := NewOauthRequestRepo(a.akses).GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}

	url := a.akses.BaseUrl + fmt.Sprintf("/AllergyIntolerance/%s", req.Id)
	return httputil.DoRequest(httputil.RequestOption{
		Method:      "PUT",
		URL:         url,
		Body:        req,
		BearerToken: token.AccessToken,
		Headers:     httputil.DefaultFHIRHeaders(),
	})
}

// setupPatient handles patient reference logic.
func (a *AllergancyToleranRepository) setupPatient(req *model.AllergancyToleranRequest) (string, error) {
	if req.Patient.Reference == "" {
		return "", nil
	}
	patientInterface := NewPatientRepo(a.akses)
	patient, err := patientInterface.HandleCheckPatient(req.Patient.Reference)
	if err != nil {
		return "", err
	}
	if patient != "" {
		req.Patient.Reference = "Patient/" + patient
	}
	return patient, nil
}

// setupEncounter handles encounter reference logic.
func (a *AllergancyToleranRepository) setupEncounter(req *model.AllergancyToleranRequest, patient string) error {
	if patient == "" {
		return nil
	}
	encounterInterface := NewEncounterRepo(a.akses)
	encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
	if err != nil {
		return err
	}
	if encounterExist {
		req.Encounter.Reference = "Encounter/" + encounterId
	}
	return nil
}

// setupPractitioner handles practitioner reference logic.
func (a *AllergancyToleranRepository) setupPractitioner(req *model.AllergancyToleranRequest) error {
	if req.Recorder.Reference == "" {
		return nil
	}
	practicionerInterface := NewPracticionerRepo(a.akses)
	ref, display, err := practicionerInterface.HandleCheckPartitioner(req.Recorder.Reference)
	if err != nil {
		return err
	}
	if ref != "" {
		req.Recorder.Reference = "Practitioner/" + ref
		req.Recorder.Display = display
	}
	return nil
}

func NewAllergancyToleranRepo(akses *model.Akses) AllergancyToleranInterface {
	return &AllergancyToleranRepository{
		akses: akses,
	}
}