simrsx-be/internal/use-case/main-use-case/generate-file/case.go

package generatefile

import (
	"encoding/json"
	"errors"

	evs "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
	evscl "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-control-letter"
	egc "simrs-vx/internal/domain/main-entities/general-consent"

	uvs "simrs-vx/internal/use-case/bpjs-use-case/vclaim-sep"
	uvscl "simrs-vx/internal/use-case/bpjs-use-case/vclaim-sep-control-letter"
	ugc "simrs-vx/internal/use-case/main-use-case/general-consent"

	pc "simrs-vx/pkg/conv-helper"
	pl "simrs-vx/pkg/logger"
	pu "simrs-vx/pkg/use-case-helper"

	dg "github.com/karincake/apem/db-gorm-pg"
	d "github.com/karincake/dodol"
	"gorm.io/gorm"

	erc "simrs-vx/internal/domain/references/common"
	ere "simrs-vx/internal/domain/references/encounter"
)

const source = "generate-file"

func Generate(input GenerateDto) (*d.Data, error) {
	event := pl.Event{
		Feature: "Generate",
		Source:  source,
	}

	var response ResponseDto

	// Start log
	pl.SetLogInfo(&event, input, "started", "create")

	err := dg.I.Transaction(func(tx *gorm.DB) error {
		switch input.Type_Code {
		// general-consent
		case ere.DTCGC:
			// get value from general consent by ref_id
			gc, err := ugc.ReadDetailData(egc.ReadDetailDto{Id: uint(*pc.StringToUint64(*input.Ref_Id))}, &event)
			if err != nil {
				return err
			}

			if gc.FileUrl != nil {
				if err := removeFile(string(input.EntityType_Code), *gc.FileUrl); err != nil {
					return err
				}
			}

			// map template data
			templateData := GeneralConsentPDF{}
			if gc.Value != nil {
				err := json.Unmarshal([]byte(*gc.Value), &templateData)
				if err != nil {
					event.ErrInfo = pl.ErrorInfo{
						Code:   "data-unmarshal-fail",
						Detail: err.Error(),
						Raw:    err,
					}
					return err
				}
			} else {
				return errors.New("no value in this general consent")
			}

			input.FormatType = erc.DFTCPDF
			input.TemplateName = TDNGC
			input.Encounter_Id = gc.Encounter_Id
			templateData.Date = pu.FormatIndonesianDate(gc.CreatedAt)

			// generate file
			urlPub, err := generateFile(input, templateData)
			if err != nil {
				return err
			}

			gc.FileUrl = &urlPub
			if err := dg.I.Save(&gc).Error; err != nil {
				return err
			}

			response = ResponseDto{
				FileUrl: urlPub,
			}

		// control-letter
		case ere.DTCVSCL:
			// get value from control letter by ref_id
			cl, err := uvscl.ReadDetailData(evscl.ReadDetailDto{Number: input.Ref_Id}, &event)
			if err != nil {
				if !pu.IsDataNotFoundError(err) {
					return err
				}
			}

			if cl != nil && cl.FileUrl != nil {
				if err := removeFile(string(input.EntityType_Code), *cl.FileUrl); err != nil {
					return err
				}
			}

			// map template data
			clData := VclaimControlLetter{}
			if input.Data != nil {
				err := json.Unmarshal([]byte(*input.Data), &clData)
				if err != nil {
					event.ErrInfo = pl.ErrorInfo{
						Code:   "data-unmarshal-fail",
						Detail: err.Error(),
						Raw:    err,
					}
					return err
				}
			} else {
				return errors.New("there is no data to be used")
			}

			if cl == nil {
				createCL := evscl.CreateDto{
					VclaimSep_Number: &clData.VclaimSep.Number,
					Number:           &clData.Number,
					Value:            input.Data,
				}
				if cl, err = uvscl.CreateData(createCL, &event, tx); err != nil {
					return err
				}

			}
			// get encounter id by vclaim sep number
			vs, err := uvs.ReadDetailData(evs.ReadDetailDto{Number: &clData.VclaimSep.Number}, &event)
			if err != nil {
				return err
			}

			input.FormatType = erc.DFTCPDF
			input.TemplateName = TDNCL
			input.Encounter_Id = vs.Encounter_Id
			input.UseA5Lanscape = true

			templateData := clData.generateTemplateData()
			// generate file
			urlPub, err := generateFile(input, templateData)
			if err != nil {
				return err
			}

			cl.FileUrl = &urlPub
			if err := tx.Save(&cl).Error; err != nil {
				return err
			}

			response = ResponseDto{
				FileUrl: urlPub,
			}

		default:
			return errors.New("invalid type code")
		}

		return nil
	})

	if err != nil {
		return nil, err
	}

	return &d.Data{
		Meta: d.II{
			"source":    source,
			"structure": "single-data",
			"status":    "created",
		},
		Data: response,
	}, nil
}