337 lines
8.7 KiB
Go
337 lines
8.7 KiB
Go
package integration
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"satusehat-rssa/internal/constant"
|
|
"satusehat-rssa/internal/model"
|
|
"satusehat-rssa/pkg/httputil"
|
|
)
|
|
|
|
type SpecimenInterface interface {
|
|
CreateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error)
|
|
GetSpecimenByPatient(id string) (map[string]interface{}, error)
|
|
GetSpecimenByPatientCategory(id string, category string) (map[string]interface{}, error)
|
|
HandleCheckSpecimen(id string) ([]string, bool, error)
|
|
HandleCheckSpecimenCategory(id string, category string) ([]string, bool, error)
|
|
UpdateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error)
|
|
}
|
|
|
|
type SpecimenRepository struct {
|
|
akses *model.Akses
|
|
}
|
|
|
|
// GetSpecimenByPatientCategory implements SpecimenInterface.
|
|
func (s *SpecimenRepository) GetSpecimenByPatientCategory(id string, category string) (map[string]interface{}, error) {
|
|
var data map[string]interface{}
|
|
|
|
url := s.akses.BaseUrl + "/Specimen?subject=" + id + "&category=" + category
|
|
method := "GET"
|
|
|
|
client := &http.Client{}
|
|
request, err := http.NewRequest(method, url, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
oauth := model.OauthRequest{
|
|
ClientId: s.akses.ClientId,
|
|
ClientSecret: s.akses.ClientSecret,
|
|
}
|
|
OauthInterface := NewOauthRequestRepo(s.akses)
|
|
token, err := OauthInterface.GenerateToken(oauth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if token != nil {
|
|
request.Header.Set("Authorization", "Bearer "+token.AccessToken)
|
|
}
|
|
request.Header.Set("Content-Type", 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
|
|
}
|
|
|
|
// HandleCheckSpecimenCategory implements SpecimenInterface.
|
|
func (s *SpecimenRepository) HandleCheckSpecimenCategory(id string, category string) ([]string, bool, error) {
|
|
specimen, err := s.GetSpecimenByPatientCategory(id, category)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
var ids []string
|
|
if entries, ok := specimen["entry"].([]interface{}); ok && len(entries) != 0 {
|
|
if entries, ok := (specimen)["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
|
|
}
|
|
|
|
// CreateSpecimen implements SpecimenInterface.
|
|
func (s *SpecimenRepository) CreateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error) {
|
|
var data map[string]interface{}
|
|
|
|
req.ResourceType = constant.SpecimenResourceType
|
|
// Setup Patient
|
|
var patient string
|
|
if req.Subject.Reference != "" {
|
|
patientInterface := NewPatientRepo(s.akses)
|
|
var err error
|
|
patient, err = patientInterface.HandleCheckPatient(req.Subject.Reference)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if patient == "" { // Belum ada di satu sehat
|
|
return nil, errors.New("patient not found")
|
|
} else {
|
|
req.Subject.Reference = "Patient/" + patient
|
|
}
|
|
}
|
|
|
|
// Setup Service Request
|
|
err := s.setupServiceRequest(&req, patient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
url := s.akses.BaseUrl + "/Specimen"
|
|
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
|
|
}
|
|
|
|
request.Header.Set("Content-Type", "application/json")
|
|
|
|
oauth := model.OauthRequest{
|
|
ClientId: s.akses.ClientId,
|
|
ClientSecret: s.akses.ClientSecret,
|
|
}
|
|
OauthInterface := NewOauthRequestRepo(s.akses)
|
|
token, err := OauthInterface.GenerateToken(oauth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if token != nil {
|
|
request.Header.Set("Authorization", "Bearer "+token.AccessToken)
|
|
}
|
|
|
|
response, err := client.Do(request)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer response.Body.Close()
|
|
err = json.NewDecoder(response.Body).Decode(&data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !isOperationOutcomeError(data) {
|
|
// Setup Encounter
|
|
if patient != "" {
|
|
encounterInterface := NewEncounterRepo(s.akses)
|
|
encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if encounterExist {
|
|
data["encounter"] = map[string]interface{}{
|
|
"reference": "Encounter/" + encounterId,
|
|
}
|
|
} else {
|
|
return nil, errors.New("encounter not found")
|
|
}
|
|
}
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// GetSpecimenByPatient implements SpecimenInterface.
|
|
func (s *SpecimenRepository) GetSpecimenByPatient(id string) (map[string]interface{}, error) {
|
|
var data map[string]interface{}
|
|
url := s.akses.BaseUrl + "/Specimen?subject=" + id
|
|
method := "GET"
|
|
client := &http.Client{}
|
|
request, err := http.NewRequest(method, url, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
oauth := model.OauthRequest{
|
|
ClientId: s.akses.ClientId,
|
|
ClientSecret: s.akses.ClientSecret,
|
|
}
|
|
OauthInterface := NewOauthRequestRepo(s.akses)
|
|
token, err := OauthInterface.GenerateToken(oauth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if token != nil {
|
|
request.Header.Set("Authorization", "Bearer "+token.AccessToken)
|
|
}
|
|
|
|
response, err := client.Do(request)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer response.Body.Close()
|
|
err = json.NewDecoder(response.Body).Decode(&data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// isOperationOutcomeError returns true when the response is an OperationOutcome
|
|
// with at least one issue that includes diagnostics or details.text.
|
|
func isOperationOutcomeError(resp map[string]interface{}) bool {
|
|
if resp == nil {
|
|
return false
|
|
}
|
|
if rt, ok := resp["resourceType"].(string); !ok || rt != "OperationOutcome" {
|
|
return false
|
|
}
|
|
issues, ok := resp["issue"].([]interface{})
|
|
if !ok || len(issues) == 0 {
|
|
return false
|
|
}
|
|
for _, it := range issues {
|
|
if m, ok := it.(map[string]interface{}); ok {
|
|
if diag, ok := m["diagnostics"].(string); ok && diag != "" {
|
|
return true
|
|
}
|
|
if details, ok := m["details"].(map[string]interface{}); ok {
|
|
if txt, ok := details["text"].(string); ok && txt != "" {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (s *SpecimenRepository) setupServiceRequest(req *model.SpecimenRequest, patient string) error {
|
|
if patient == "" {
|
|
return nil
|
|
}
|
|
serviceReq := NewServiceRequestRepository(s.akses)
|
|
ids, _, err := serviceReq.HandleCheckServiceRequest(patient)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(ids) > 0 {
|
|
req.Request = []model.Reference{
|
|
{
|
|
Reference: "ServiceRequest/" + ids[0],
|
|
},
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HandleCheckSpecimen implements SpecimenInterface.
|
|
func (s *SpecimenRepository) HandleCheckSpecimen(id string) ([]string, bool, error) {
|
|
specimen, err := s.GetSpecimenByPatient(id)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
|
|
// You can process 'specimen' here if needed
|
|
var ids []string
|
|
if entries, ok := specimen["entry"].([]interface{}); ok && len(entries) != 0 {
|
|
if entries, ok := (specimen)["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
|
|
}
|
|
|
|
func (s *SpecimenRepository) UpdateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error) {
|
|
req.ResourceType = constant.SpecimenResourceType
|
|
// Setup Patient
|
|
var patient string
|
|
if req.Subject.Reference != "" {
|
|
patientInterface := NewPatientRepo(s.akses)
|
|
var err error
|
|
patient, err = patientInterface.HandleCheckPatient(req.Subject.Reference)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if patient == "" { // Belum ada di satu sehat
|
|
return nil, errors.New("patient not found")
|
|
} else {
|
|
req.Subject.Reference = "Patient/" + patient
|
|
}
|
|
}
|
|
|
|
// Setup Service Request
|
|
err := s.setupServiceRequest(&req, patient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
oauth := model.OauthRequest{
|
|
ClientId: s.akses.ClientId,
|
|
ClientSecret: s.akses.ClientSecret,
|
|
}
|
|
token, err := NewOauthRequestRepo(s.akses).GenerateToken(oauth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if token == nil {
|
|
return nil, errors.New(constant.ErrGenerateToken)
|
|
}
|
|
|
|
url := s.akses.BaseUrl + fmt.Sprintf("/Specimen/%s", req.Id)
|
|
return httputil.DoRequest(httputil.RequestOption{
|
|
Method: "PUT",
|
|
URL: url,
|
|
Body: req,
|
|
BearerToken: token.AccessToken,
|
|
})
|
|
}
|
|
|
|
func NewSpecimenRepository(akses *model.Akses) SpecimenInterface {
|
|
return &SpecimenRepository{akses: akses}
|
|
}
|