tbfajri/cpone_midleware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add package creation and clone validation

Browse Source
This commit is contained in:
Tubagus Fajri
2026-09-16 13:55:56 +07:00
parent 94c3dd1a70
commit 19fe8c5d94
12 changed files with 1034 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
internal/http/handler.go
View File

@@ -38,6 +38,7 @@ type LabResultRepository interface {
type PaketRepository interface {
ListPaket(ctx context.Context, params repository.PaketListParams) (repository.PaketPage, error)
GetPaket(ctx context.Context, id string) (*repository.PaketDetail, error)
CreatePaket(ctx context.Context, params repository.CreatePaketParams) (repository.CreatePaketResult, error)
}
type TarifKerjasamaRepository interface {

378
internal/http/paket_create.go Normal file
View File

@@ -0,0 +1,378 @@
package http
import (
"encoding/json"
"fmt"
"log"
"math"
"net/http"
"strconv"
"strings"
"time"
"primaya-api/cpone-middleware/internal/repository"
)
type PaketCreateResponse struct {
Success bool `json:"success"`
Status string `json:"status"`
Message string `json:"message"`
Data *PaketCreateResponseData `json:"data"`
}
type PaketCreateResponseData struct {
PaketID string `json:"paket_id"`
Nama string `json:"nama"`
TotalHarga string `json:"total_harga"`
TotalDiskon string `json:"total_diskon"`
JumlahLayanan int `json:"jumlah_layanan"`
}
func (h Handler) CreatePaket(w http.ResponseWriter, r *http.Request) {
payload, err := decodeJSONObject(r)
if err != nil {
writePaketCreateError(w, http.StatusUnprocessableEntity, "Payload harus berupa object JSON")
return
}
params, message := validateCreatePaket(payload)
if message != "" {
writePaketCreateError(w, http.StatusUnprocessableEntity, message)
return
}
result, err := h.paketRepository(r.Context()).CreatePaket(r.Context(), params)
if err != nil {
log.Printf("create paket failed: %v", err)
if validationMessage, ok := asValidationError(err); ok {
writePaketCreateError(w, http.StatusUnprocessableEntity, validationMessage)
return
}
WriteJSON(w, http.StatusInternalServerError, Response{Success: false, Message: "internal server error", Data: nil})
return
}
WriteJSON(w, http.StatusCreated, PaketCreateResponse{
Success: true,
Status: "created",
Message: "Paket berhasil dibuat",
Data: &PaketCreateResponseData{
PaketID: result.PaketID, Nama: result.Nama,
TotalHarga: result.TotalHarga, TotalDiskon: result.TotalDiskon,
JumlahLayanan: result.JumlahLayanan,
},
})
}
func validateCreatePaket(payload map[string]any) (repository.CreatePaketParams, string) {
name, message := requiredString(payload, "nama", 255, "Nama paket wajib diisi")
if message != "" {
return repository.CreatePaketParams{}, message
}
typeID, message := requiredString(payload, "jenis_paket", 50, "Jenis paket wajib diisi")
if message != "" {
return repository.CreatePaketParams{}, message
}
rawatInap, message := optionalPaketBoolean(payload, "rawat_inap")
if message != "" {
return repository.CreatePaketParams{}, message
}
rawatJalan, message := optionalPaketBoolean(payload, "rawat_jalan")
if message != "" {
return repository.CreatePaketParams{}, message
}
if !rawatInap && !rawatJalan {
return repository.CreatePaketParams{}, "Rawat inap atau rawat jalan minimal salah satu harus aktif"
}
multiVisit, message := optionalPaketBoolean(payload, "multi_visit")
if message != "" {
return repository.CreatePaketParams{}, message
}
startDate, message := optionalPaketDate(payload, "tanggal_mulai")
if message != "" {
return repository.CreatePaketParams{}, message
}
endDate, message := optionalPaketDate(payload, "tanggal_selesai")
if message != "" {
return repository.CreatePaketParams{}, message
}
if startDate != "" && endDate != "" && endDate < startDate {
return repository.CreatePaketParams{}, "Tanggal selesai harus setelah atau sama dengan tanggal mulai"
}
classID, _, message := optionalString(payload, "kelas_id", 50)
if message != "" {
return repository.CreatePaketParams{}, message
}
if strings.TrimSpace(classID) == "" {
classID = "Default"
}
headerID, _, message := optionalString(payload, "header_paket_id", 50)
if message != "" {
return repository.CreatePaketParams{}, message
}
notes, _, message := optionalString(payload, "keterangan", 500)
if message != "" {
return repository.CreatePaketParams{}, message
}
channel, present, message := optionalString(payload, "channel", 50)
if message != "" {
return repository.CreatePaketParams{}, message
}
if !present || strings.TrimSpace(channel) == "" {
channel = "CPONE"
}
days := int64(1)
if value, present := nullableValue(payload, "jumlah_hari"); present {
days, message = parsePaketInteger(value, "jumlah_hari", "Jumlah hari paket harus berupa angka")
if message != "" {
return repository.CreatePaketParams{}, message
}
if days < 1 {
return repository.CreatePaketParams{}, "Jumlah hari paket minimal 1"
}
}
rawServices, exists := payload["layanan"]
if !exists || isLaravelEmpty(rawServices) {
return repository.CreatePaketParams{}, "Layanan wajib diisi"
}
services, ok := rawServices.([]any)
if !ok || len(services) == 0 {
return repository.CreatePaketParams{}, "Layanan harus berupa array dan minimal memiliki satu data"
}
result := make([]repository.CreatePaketLayananParams, 0, len(services))
seen := make(map[string]struct{}, len(services))
for index, rawService := range services {
item, ok := rawService.(map[string]any)
if !ok {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "layanan harus berupa object")
}
serviceID, message := requiredNestedString(item, "layanan_id", index, 50, "Layanan wajib diisi")
if message != "" {
return repository.CreatePaketParams{}, message
}
departmentID, message := requiredNestedString(item, "departemen_id", index, 50, "Departemen wajib diisi")
if message != "" {
return repository.CreatePaketParams{}, message
}
serviceID = strings.TrimSpace(serviceID)
departmentID = strings.TrimSpace(departmentID)
if _, exists := seen[serviceID]; exists {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "layanan_id tidak boleh duplikat dalam satu paket")
}
seen[serviceID] = struct{}{}
quantity, message := optionalPaketNestedInteger(item, "jumlah", index, 1)
if message != "" {
return repository.CreatePaketParams{}, message
}
if quantity < 1 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "jumlah minimal 1")
}
serviceDays, message := optionalPaketNestedInteger(item, "jumlah_hari", index, 1)
if message != "" {
return repository.CreatePaketParams{}, message
}
if serviceDays < 1 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "jumlah_hari minimal 1")
}
harga, message := requiredPaketMoney(item, "harga", index, "Harga wajib diisi")
if message != "" {
return repository.CreatePaketParams{}, message
}
discountType, _, message := optionalNestedString(item, "tipe_diskon", index, 30)
if message != "" {
return repository.CreatePaketParams{}, message
}
if strings.TrimSpace(discountType) == "" {
discountType = "Percentage"
}
discountType, message = normalizePaketType(discountType, "tipe_diskon", index)
if message != "" {
return repository.CreatePaketParams{}, message
}
discount, message := optionalPaketMoney(item, "diskon", index, 0)
if message != "" {
return repository.CreatePaketParams{}, message
}
if discountType == "Percentage" && discount > 10000 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "diskon percentage tidak boleh lebih dari 100")
}
if discountType == "Absolute" && discount > harga {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "diskon absolute tidak boleh lebih besar dari harga")
}
shareType, _, message := optionalNestedString(item, "tipe_share", index, 30)
if message != "" {
return repository.CreatePaketParams{}, message
}
if strings.TrimSpace(shareType) == "" {
shareType = "Percentage"
}
shareType, message = normalizePaketType(shareType, "tipe_share", index)
if message != "" {
return repository.CreatePaketParams{}, message
}
shares := make([]int64, 4)
shareKeys := []string{"share_rs", "share_dokter", "share_external", "share_lain"}
for shareIndex, key := range shareKeys {
shares[shareIndex], message = optionalPaketMoney(item, key, index, 0)
if message != "" {
return repository.CreatePaketParams{}, message
}
}
if shareType == "Percentage" {
shareTotal := shares[0] + shares[1] + shares[2] + shares[3]
for _, share := range shares {
if share < 0 || share > 10000 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "share percentage harus antara 0 dan 100")
}
}
if shareTotal != 10000 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "total share percentage harus 100")
}
} else if math.Abs(float64(shares[0]+shares[1]+shares[2]+shares[3]-harga)) > 1 {
return repository.CreatePaketParams{}, nestedCreatePaketMessage(index, "total share absolute harus sama dengan harga")
}
result = append(result, repository.CreatePaketLayananParams{
LayananID: serviceID, DepartemenID: departmentID, Jumlah: quantity, JumlahHari: serviceDays,
HargaCents: harga, TipeDiskon: discountType, DiskonCents: discount, TipeShare: shareType,
ShareRSCents: shares[0], ShareDokterCents: shares[1], ShareExternalCents: shares[2], ShareLainCents: shares[3],
})
}
return repository.CreatePaketParams{
Nama: strings.TrimSpace(name), JenisPaket: strings.ToUpper(strings.TrimSpace(typeID)),
RawatInap: rawatInap, RawatJalan: rawatJalan, MultiVisit: multiVisit,
TanggalMulai: startDate, TanggalSelesai: endDate, KelasID: strings.TrimSpace(classID),
HeaderPaketID: strings.TrimSpace(headerID), Keterangan: strings.TrimSpace(notes), JumlahHari: days,
Channel: strings.ToUpper(strings.TrimSpace(channel)), Layanan: result,
}, ""
}
func optionalPaketBoolean(payload map[string]any, key string) (bool, string) {
value, present := nullableValue(payload, key)
if !present {
return false, ""
}
parsed, ok := parseLaravelBoolean(value)
if !ok {
return false, fmt.Sprintf("The %s field must be true or false.", strings.ReplaceAll(key, "_", " "))
}
return parsed, ""
}
func optionalPaketDate(payload map[string]any, key string) (string, string) {
value, present := nullableValue(payload, key)
if !present {
return "", ""
}
date, ok := value.(string)
if !ok || !validDateFormat(date, time.Local) {
return "", fmt.Sprintf("The %s does not match the format Y-m-d.", strings.ReplaceAll(key, "_", " "))
}
return date, ""
}
func parsePaketInteger(value any, key, message string) (int64, string) {
parsed, ok := parseInteger(value)
if !ok {
return 0, message
}
return parsed, ""
}
func optionalPaketNestedInteger(item map[string]any, key string, index int, fallback int64) (int64, string) {
value, present := nullableValue(item, key)
if !present {
return fallback, ""
}
parsed, ok := parseInteger(value)
if !ok {
return 0, nestedCreatePaketMessage(index, key+" harus berupa angka")
}
return parsed, ""
}
func requiredPaketMoney(item map[string]any, key string, index int, requiredMessage string) (int64, string) {
value, present := nullableValue(item, key)
if !present {
return 0, nestedCreatePaketMessage(index, requiredMessage)
}
return parsePaketMoney(value, nestedCreatePaketMessage(index, key+" harus berupa nominal desimal"))
}
func optionalPaketMoney(item map[string]any, key string, index int, fallback int64) (int64, string) {
value, present := nullableValue(item, key)
if !present {
return fallback, ""
}
return parsePaketMoney(value, nestedCreatePaketMessage(index, key+" harus berupa nominal desimal"))
}
func parsePaketMoney(value any, message string) (int64, string) {
var text string
switch typed := value.(type) {
case json.Number:
text = typed.String()
case string:
text = strings.TrimSpace(typed)
default:
return 0, message
}
if text == "" || strings.HasPrefix(text, "-") || strings.HasPrefix(text, "+") {
return 0, message
}
parts := strings.Split(text, ".")
if len(parts) > 2 || parts[0] == "" || len(parts[0]) > 16 || (len(parts) == 2 && len(parts[1]) > 2) {
return 0, message
}
if _, err := strconv.ParseUint(parts[0], 10, 64); err != nil {
return 0, message
}
frac := ""
if len(parts) == 2 {
frac = parts[1]
}
for len(frac) < 2 {
frac += "0"
}
fracValue := int64(0)
if frac != "" {
parsed, err := strconv.ParseInt(frac, 10, 64)
if err != nil {
return 0, message
}
fracValue = parsed
}
whole, err := strconv.ParseInt(parts[0], 10, 64)
if err != nil || whole > (math.MaxInt64-fracValue)/100 {
return 0, message
}
return whole*100 + fracValue, ""
}
func normalizePaketType(value, key string, index int) (string, string) {
value = strings.TrimSpace(value)
switch strings.ToLower(value) {
case "percentage":
return "Percentage", ""
case "absolute":
return "Absolute", ""
default:
return "", nestedCreatePaketMessage(index, key+" harus Percentage atau Absolute")
}
}
func nestedCreatePaketMessage(index int, message string) string {
return fmt.Sprintf("The layanan.%d %s.", index, message)
}
func writePaketCreateError(w http.ResponseWriter, statusCode int, message string) {
WriteJSON(w, statusCode, PaketCreateResponse{Success: false, Status: "validation_error", Message: message, Data: nil})
}

128
internal/http/paket_create_test.go Normal file
View File

@@ -0,0 +1,128 @@
package http
import (
"net/http"
"net/http/httptest"
"strings"
"testing"
"primaya-api/cpone-middleware/internal/repository"
)
const validCreatePaketJSON = `{
"nama":"PAKET MCU CPONE TES 2",
"jenis_paket":"MCU",
"rawat_inap":false,
"rawat_jalan":true,
"multi_visit":false,
"tanggal_mulai":"2026-09-01",
"tanggal_selesai":"2026-09-30",
"kelas_id":"Default",
"layanan":[{
"layanan_id":"1200",
"departemen_id":"MED-PNJ-LAB",
"jumlah":1,
"jumlah_hari":1,
"harga":"130000.00",
"tipe_diskon":"Percentage",
"diskon":"0.00",
"tipe_share":"Absolute",
"share_rs":"65000.00",
"share_dokter":"0.00",
"share_external":"65000.00",
"share_lain":"0.00"
}]
}`
func TestCreatePaketResponseAndDecimalParsing(t *testing.T) {
repo := &fakePaketRepository{create: repository.CreatePaketResult{
PaketID: "DISP-260900022", Nama: "PAKET MCU CPONE TES 2",
TotalHarga: "130000.00", TotalDiskon: "0.00", JumlahLayanan: 1,
}}
handler := Handler{paketRepo: repo}
request := httptest.NewRequest(http.MethodPost, "/api/cpone/paket", strings.NewReader(validCreatePaketJSON))
recorder := httptest.NewRecorder()
handler.CreatePaket(recorder, request)
if recorder.Code != http.StatusCreated {
t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
}
if len(repo.createParams.Layanan) != 1 || repo.createParams.Layanan[0].HargaCents != 13000000 || repo.createParams.Layanan[0].ShareExternalCents != 6500000 {
t.Fatalf("unexpected parsed params: %+v", repo.createParams)
}
const expected = `{"success":true,"status":"created","message":"Paket berhasil dibuat","data":{"paket_id":"DISP-260900022","nama":"PAKET MCU CPONE TES 2","total_harga":"130000.00","total_diskon":"0.00","jumlah_layanan":1}}` + "\n"
if recorder.Body.String() != expected {
t.Fatalf("body mismatch\n got: %s\nwant: %s", recorder.Body.String(), expected)
}
}
func TestCreatePaketValidation(t *testing.T) {
tests := []struct {
name string
mutate func(map[string]any)
message string
valid bool
}{
{
name: "requires care type",
mutate: func(payload map[string]any) {
payload["rawat_jalan"] = false
},
message: "Rawat inap atau rawat jalan minimal salah satu harus aktif",
},
{
name: "rejects percentage discount above 100",
mutate: func(payload map[string]any) {
service := payload["layanan"].([]any)[0].(map[string]any)
service["diskon"] = "100.01"
},
message: "The layanan.0 diskon percentage tidak boleh lebih dari 100.",
},
{
name: "rejects absolute share mismatch",
mutate: func(payload map[string]any) {
service := payload["layanan"].([]any)[0].(map[string]any)
service["share_external"] = "64000.00"
},
message: "The layanan.0 total share absolute harus sama dengan harga.",
},
{
name: "allows one cent absolute share rounding difference",
mutate: func(payload map[string]any) {
service := payload["layanan"].([]any)[0].(map[string]any)
service["share_external"] = "64999.99"
},
message: "",
valid: true,
},
{
name: "rejects duplicate service",
mutate: func(payload map[string]any) {
services := payload["layanan"].([]any)
services = append(services, services[0])
payload["layanan"] = services
},
message: "The layanan.1 layanan_id tidak boleh duplikat dalam satu paket.",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var payload map[string]any
request := httptest.NewRequest(http.MethodPost, "/api/cpone/paket", strings.NewReader(validCreatePaketJSON))
payload, _ = decodeJSONObject(request)
test.mutate(payload)
params, message := validateCreatePaket(payload)
if test.valid {
if params.Nama == "" || message != "" {
t.Fatalf("params=%+v message=%q want valid payload", params, message)
}
return
}
if params.Nama != "" || message != test.message {
t.Fatalf("params=%+v message=%q want=%q", params, message, test.message)
}
})
}
}

17
internal/http/paket_test.go
View File

@@ -12,11 +12,13 @@ import (
)
type fakePaketRepository struct {
page repository.PaketPage
detail *repository.PaketDetail
err error
listParams repository.PaketListParams
detailID string
page repository.PaketPage
detail *repository.PaketDetail
create repository.CreatePaketResult
err error
listParams repository.PaketListParams
detailID string
createParams repository.CreatePaketParams
}
func (f *fakePaketRepository) ListPaket(_ context.Context, params repository.PaketListParams) (repository.PaketPage, error) {
@@ -29,6 +31,11 @@ func (f *fakePaketRepository) GetPaket(_ context.Context, id string) (*repositor
return f.detail, f.err
}
func (f *fakePaketRepository) CreatePaket(_ context.Context, params repository.CreatePaketParams) (repository.CreatePaketResult, error) {
f.createParams = params
return f.create, f.err
}
func TestListPaketResponseParity(t *testing.T) {
kodeCorp := "ANP"
jenisPaket := "Medical Check Up"