simrsx-be/internal/use-case/simgos-sync-use-case/installation/case.go

package installation

import (
	"errors"
	esimgos "simrs-vx/internal/domain/simgos-entities/installation"
	esync "simrs-vx/internal/domain/sync-entities/log"

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

	pl "simrs-vx/pkg/logger"

	"gorm.io/gorm"

	e "simrs-vx/internal/domain/main-entities/installation"
)

const source = "installation"

func Create(input e.CreateDto) (*d.Data, error) {
	var (
		txSync   = dg.I.Begin()
		txSimgos = dg.IS["simrs"].Begin()
	)

	event := pl.Event{
		Feature: "Create",
		Source:  source,
	}

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

	// STEP 1: Insert to simgos
	sgData, err := CreateSimgosData(input, &event, txSimgos)
	if err != nil {
		return nil, err
	}

	// STEP 2: Insert to Link
	if err = CreateLinkData(*input.Id, sgData.No_Instalasi, &event, txSync); err != nil {
		txSimgos.Rollback()
		return nil, err
	}

	// STEP 3: Commit two trx
	if err = txSimgos.Commit().Error; err != nil {
		txSimgos.Rollback()
		txSync.Rollback()
		return nil, err
	}

	if err = txSync.Commit().Error; err != nil {
		// STEP 4: Rollback Partial
		go func() {
			_ = DeleteSimgosData(sgData, &event)
		}()
		return nil, err
	}

	pl.SetLogInfo(&event, nil, "complete")

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

func CreateSimxLog(input esync.SimxLogDto) (*d.Data, error) {
	event := pl.Event{
		Feature: "Create",
		Source:  source,
	}

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

	err := dg.I.Transaction(func(tx *gorm.DB) error {
		// InsertSimxLog
		if err := CreateLogData(input, &event, tx); err != nil {
			return err
		}

		pl.SetLogInfo(&event, nil, "complete")

		return nil
	})

	if err != nil {
		return nil, err
	}

	pl.SetLogInfo(&event, nil, "complete")

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

func Update(input e.UpdateDto) (*d.Data, error) {
	var (
		txSync   = dg.I.Begin()
		txSimgos = dg.IS["simrs"].Begin()
		sgData   *esimgos.MInstalasi
		err      error
	)

	event := pl.Event{
		Feature: "Update",
		Source:  source,
	}

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

	// STEP 1: Get Installation Link
	syncLink, errGetLink := ReadDetailLinkData(*input.Id, &event)
	if errGetLink != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, err
		}
	}

	if errGetLink != nil && errors.Is(errGetLink, gorm.ErrRecordNotFound) {
		// STEP 2.1: Insert to simgos
		sgData, err = CreateSimgosData(input.CreateDto, &event, txSimgos)
		if err != nil {
			return nil, err
		}

		// STEP 2.2: Insert to Link
		simxId := uint(*input.Id)
		if err = CreateLinkData(simxId, sgData.No_Instalasi, &event, txSync); err != nil {
			txSimgos.Rollback()
			return nil, err
		}
	} else {
		// Step 3.1: Update Simgos
		err = UpdateSimgosData(input, syncLink, &event, txSimgos)
		if err != nil {
			return nil, err
		}
	}

	// STEP 4: Commit two trx
	if err = txSimgos.Commit().Error; err != nil {
		txSimgos.Rollback()
		txSync.Rollback()
		return nil, err
	}

	if errGetLink != nil {
		if err = txSync.Commit().Error; err != nil {
			// STEP 5.1: Rollback Partial
			go func() {
				_ = DeleteSimgosData(sgData, &event)
			}()
			return nil, err
		}
	}

	pl.SetLogInfo(&event, nil, "complete")

	return &d.Data{
		Meta: d.IS{
			"source":    source,
			"structure": "single-data",
			"status":    "updated",
		},
	}, nil
}

func Delete(input e.DeleteDto) (*d.Data, error) {
	var (
		txSync   = dg.I.Begin()
		txSimgos = dg.IS["simrs"].Begin()
		sgData   *esimgos.MInstalasi
		err      error
	)

	event := pl.Event{
		Feature: "Delete",
		Source:  source,
	}

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

	// STEP 1: Get Installation Link
	syncLink, errGetLink := ReadDetailLinkData(*input.Id, &event)
	if errGetLink != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, err
		}
	}

	if errGetLink == nil {
		// STEP 2: Get Simgos
		sgData, err = ReadDetailSimgosData(uint16(syncLink.Simgos_Id), &event)
		if err != nil {
			return nil, err
		}

		// STEP 3: Delete M_Instalation Simgos
		err = DeleteSimgosData(sgData, &event, txSimgos)
		if err != nil {
			return nil, err
		}

		// STEP 4: Delete Installation Link
		err = DeleteLinkData(syncLink, &event, txSync)
		if err != nil {
			txSimgos.Rollback()
			return nil, err
		}

		// STEP 4: Commit two trx
		if err = txSimgos.Commit().Error; err != nil {
			txSimgos.Rollback()
			txSync.Rollback()
			return nil, err
		}

		if err = txSync.Commit().Error; err != nil {
			// STEP 5: Rollback Partial
			go func() {
				inputRollback := e.UpdateDto{
					CreateDto: e.CreateDto{
						Name: sgData.Nama_Instalasi,
					},
				}
				_ = UpdateSimgosData(inputRollback, syncLink, &event)
			}()
			return nil, err
		}
	}

	pl.SetLogInfo(&event, nil, "complete")

	return &d.Data{
		Meta: d.IS{
			"source":    source,
			"structure": "single-data",
			"status":    "deleted",
		},
	}, nil

}