Merge branch 'feat/consultation-82' into fe-prescription-56

app/schemas/base.schema.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod'
-import type { Base } from '~/models/_model'
+import type { CodeName } from '~/models/_base'
 
 const BaseSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
 })
 
-type BaseFormData = z.infer<typeof BaseSchema> & Base
+type BaseFormData = z.infer<typeof BaseSchema> & CodeName
 
 export { BaseSchema }
 export type { BaseFormData }

app/schemas/consultation.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import type { Consultation } from '~/models/consultation'
+
+const ConsultationSchema = z.object({
+  unit_id: z.number({ required_error: 'Unit harus diisi' }),
+  problem: z.string({ required_error: 'Uraian harus diisi' }).min(20, 'Kode minimum 20 karakter'),
+})
+
+type ConsultationFormData = z.infer<typeof ConsultationSchema> & (Consultation)
+
+export { ConsultationSchema }
+export type { ConsultationFormData }

app/schemas/division.schema.ts

@@ -1,10 +1,14 @@
 import { z } from 'zod'
-import type { Division, DivisionPosition } from '~/models/division'
+import type { Division } from '~/models/division'
+import type { DivisionPosition } from '~/models/division-position'
 
 const DivisionSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  parent_id: z.string({ required_error: 'Divisi Induk harus diisi' }).optional().nullable(),
+  parent_id: z.union([
+    z.string({ required_error: 'Divisi Induk harus diisi' }),
+    z.number({ required_error: 'Divisi Induk harus diisi' })
+  ]).optional().nullable(),
   division_id: z.string({ required_error: 'Divisi Induk harus diisi' }).optional().nullable(),
 })
 

app/schemas/infra.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import type { Infra } from '~/models/infra'
+
+const InfraSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+  infraGroup_code: z.string().min(1, 'Infra Group harus diisi'),
+  parent_id: z
+    .union([z.string({ required_error: 'Induk harus diisi' }), z.number({ required_error: 'Induk harus diisi' })])
+    .optional()
+    .nullable(),
+  specialist_id: z.union([z.string(), z.number()]).nullable().optional(),
+  subspecialist_id: z.union([z.string(), z.number()]).nullable().optional(),
+  unit_id: z.union([z.string(), z.number()]).nullable().optional(),
+})
+
+type InfraFormData = z.infer<typeof InfraSchema> & Infra
+
+export { InfraSchema }
+export type { InfraFormData }

app/schemas/patient.schema.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod'
+
+const CommunicationBarrierSchema = z
+  .enum(['YA', 'TIDAK'], {
+    required_error: 'Mohon lengkapi Status Hambatan Berkomunikasi',
+  })
+  .transform((val) => val === 'YA')
+
+const PatientSchema = z
+  .object({
+    // Data Diri Pasien
+    identityNumber: z
+      .string({
+        required_error: 'Mohon lengkapi NIK',
+      })
+      .min(16, 'NIK harus berupa angka 16 digit')
+      .regex(/^\d+$/, 'NIK harus berupa angka 16 digit'),
+    // identityCardFile: z.instanceof(File, { message: 'File KTP harus dipilih' }),
+    // familyCardFile: z.instanceof(File, { message: 'File KK harus dipilih' }),
+
+    // Informasi Dasar
+    alias: z.string({
+      required_error: 'Mohon pilih sapaan',
+    }),
+    fullName: z.string({
+      required_error: 'Mohon lengkapi Nama',
+    }),
+    birthPlace: z
+      .string({
+        required_error: 'Mohon lengkapi Tempat Lahir',
+      })
+      .min(1, 'Mohon lengkapi Tempat Lahir'),
+    birthDate: z
+      .string({
+        required_error: 'Mohon lengkapi Tanggal Lahir',
+      })
+      .refine(
+        (date) => {
+          // Jika kosong, return false untuk required validation
+          if (!date || date.trim() === '') return false
+
+          // Jika ada isi, validasi format tanggal
+          try {
+            const dateObj = new Date(date)
+            // Cek apakah tanggal valid dan tahun >= 1900
+            return !isNaN(dateObj.getTime()) && dateObj.getFullYear() >= 1900
+          } catch {
+            return false
+          }
+        },
+        {
+          message: 'Mohon lengkapi Tanggal Lahir dengan format yang valid',
+        },
+      )
+      .transform((dateStr) => new Date(dateStr).toISOString()),
+
+    // Jenis Kelamin & Status
+    gender: z.string({
+      required_error: 'Pilih Jenis Kelamin',
+    }),
+    maritalStatus: z.enum(['TIDAK_DIKETAHUI', 'BELUM_KAWIN', 'KAWIN', 'CERAI_HIDUP', 'CERAI_MATI'], {
+      required_error: 'Pilih Status Perkawinan',
+    }),
+
+    // Informasi Lokasi & Sosial
+    job: z
+      .string({
+        required_error: 'Mohon lengkapi Pekerjaan',
+      })
+      .min(1),
+    nationality: z.string({
+      required_error: 'Pilih Kebangsaan',
+    }),
+    language: z.string({
+      required_error: 'Mohon pilih Preferensi Bahasa',
+    }),
+    education: z
+      .string({
+        required_error: 'Mohon lengkapi Pendidikan',
+      })
+      .min(1),
+    religion: z
+      .string({
+        required_error: 'Pilih Kepercayaan',
+      })
+      .min(1),
+    ethnicity: z.string().optional(),
+
+    // Disabilitas
+    disability: z.enum(['YA', 'TIDAK'], {
+      required_error: 'Mohon lengkapi Status Disabilitas',
+    }),
+    disabilityType: z.string().optional(),
+
+    // Informasi Kontak
+    passportNumber: z.string().optional(),
+    communicationBarrier: CommunicationBarrierSchema,
+
+    note: z.string().optional(),
+    drivingLicenseNumber: z.string().optional(),
+  })
+  .refine((data) => (data.disability === 'TIDAK' ? !data.disabilityType : true), {
+    message: "DisabilityType hanya boleh diisi jika disability = 'YA'",
+    path: ['disabilityType'],
+  })
+  .refine((data) => (data.disability === 'YA' ? !!data.disabilityType?.trim() : true), {
+    message: 'Mohon pilih Jenis Disabilitas',
+    path: ['disabilityType'],
+  })
+
+type PatientFormData = z.infer<typeof PatientSchema>
+
+export { PatientSchema }
+export type { PatientFormData }

app/schemas/person-address-relative.schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod'
+import { PersonAddressSchema } from './person-address.schema'
+
+// Schema untuk alamat opsional ketika isSameAddress = '1'
+const OptionalAddressSchema = PersonAddressSchema.partial()
+
+// Schema untuk alamat required ketika isSameAddress = '0'
+const RequiredAddressSchema = PersonAddressSchema
+
+const PersonAddressRelativeSchema = z.discriminatedUnion('isSameAddress', [
+  z
+    .object({
+      isSameAddress: z.literal('1').default('1'),
+    })
+    .merge(OptionalAddressSchema),
+
+  z
+    .object({
+      isSameAddress: z.literal('0'),
+    })
+    .merge(RequiredAddressSchema),
+])
+
+type PersonAddressRelativeFormData = z.infer<typeof PersonAddressRelativeSchema>
+
+export { PersonAddressRelativeSchema }
+export type { PersonAddressRelativeFormData }

app/schemas/person-address.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+const PersonAddressSchema = z.object({
+  address: z.string({
+    required_error: 'Mohon lengkapi alamat',
+  }),
+  province_code: z.string({
+    required_error: 'Mohon pilih provinsi',
+  }),
+  regency_code: z.string({
+    required_error: 'Mohon pilih kabupaten/kota',
+  }),
+  district_code: z.string({
+    required_error: 'Mohon pilih kecamatan',
+  }),
+  village_code: z.string({
+    required_error: 'Mohon pilih kelurahan',
+  }),
+  // diganti postalCode, zipCode hanya beberapa negara, kurang universal
+  postalCode: z.string({
+    required_error: 'Mohon lengkapi kode pos',
+  }),
+  // .min(5, 'Kode pos harus berupa angka 5 digit')
+  // .regex(/^\d+$/, 'Kode pos harus berupa angka 5 digit'),
+  rt: z.string().optional(),
+  rw: z.string().optional(),
+})
+
+type PersonAddressFormData = z.infer<typeof PersonAddressSchema>
+
+export { PersonAddressSchema }
+export type { PersonAddressFormData }

app/schemas/person-contact.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod'
+
+const PersonContactBaseSchema = z.object({
+  contactType: z.string().min(1, 'Mohon pilih tipe kontak'),
+  contactNumber: z.string().min(8, 'Nomor minimal 8 digit'),
+})
+
+const PersonContactListSchema = z.object({
+  contacts: z.array(PersonContactBaseSchema).min(1, 'Minimal 1 kontak'),
+})
+
+type PersonContactFormData = z.infer<typeof PersonContactListSchema>
+
+export { PersonContactListSchema, PersonContactBaseSchema }
+export type { PersonContactFormData }

app/schemas/person-family.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+
+const PersonFamilySchema = z.object({
+  relation: z.enum(['mother', 'father', 'guardian', 'emergency_contact']),
+  name: z
+    .string({
+      required_error: 'Mohon lengkapi nama',
+    })
+    .min(1, 'Mohon lengkapi nama'),
+  education: z
+    .string({
+      required_error: 'Mohon pilih pendidikan',
+    })
+    .min(1, 'Mohon pilih pendidikan'),
+  occupation: z.string().optional(),
+})
+
+const PersonFamiliesSchema = z.discriminatedUnion('shareFamilyData', [
+  z.object({
+    shareFamilyData: z.literal('0'),
+    families: z.array(PersonFamilySchema).optional().default([]),
+  }),
+  z.object({
+    shareFamilyData: z.literal('1'),
+    families: z.array(PersonFamilySchema).min(1, 'Minimal 1 kontak keluarga'),
+  }),
+])
+
+type PersonFamilyFormData = z.infer<typeof PersonFamilySchema>
+type PersonFamiliesFormData = z.infer<typeof PersonFamiliesSchema>
+
+export { PersonFamilySchema, PersonFamiliesSchema }
+export type { PersonFamilyFormData, PersonFamiliesFormData }

app/schemas/person-relative.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+const ResponsibleContactPersonSchema = z.object({
+  relation: z.string({ required_error: 'Pilih jenis Penanggung Jawab' }).min(1, 'Pilih jenis Penanggung Jawab'),
+  name: z.string({ required_error: 'Mohon lengkapi Nama' }).min(3, 'Mohon lengkapi Nama'),
+  address: z.string({ required_error: 'Mohon lengkapi Alamat' }).min(3, 'Mohon lengkapi Alamat'),
+  phone: z
+    .string({ required_error: 'Mohon lengkapi Nomor HP' })
+    .min(8, 'Nomor HP minimal 10 digit')
+    .max(15, 'Nomor HP maksimal 15 digit'),
+})
+
+const ResponsiblePersonSchema = z.object({
+  contacts: z.array(ResponsibleContactPersonSchema).min(1, 'Minimal harus ada 1 penanggung jawab'),
+})
+
+type PersonRelativeFormData = z.infer<typeof ResponsiblePersonSchema>
+
+export { ResponsiblePersonSchema }
+export type { PersonRelativeFormData }

app/schemas/specialist.schema.ts

@@ -4,7 +4,10 @@ import type { Specialist } from '~/models/specialist'
 const SpecialistSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  unit_id: z.number().positive('Unit harus diisi'),
+  unit_id: z
+    .union([z.string({ required_error: 'Unit harus diisi' }), z.number({ required_error: 'Unit harus diisi' })])
+    .optional()
+    .nullable(),
 })
 
 type SpecialistFormData = z.infer<typeof SpecialistSchema> & Specialist

app/schemas/subspecialist.schema.ts

@@ -4,7 +4,13 @@ import type { Subspecialist } from '~/models/subspecialist'
 const SubspecialistSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  specialist_id: z.number().positive('Spesialis harus diisi'),
+  specialist_id: z
+    .union([
+      z.string({ required_error: 'Spesialis harus diisi' }),
+      z.number({ required_error: 'Spesialis harus diisi' }),
+    ])
+    .optional()
+    .nullable(),
 })
 
 type SubspecialistFormData = z.infer<typeof SubspecialistSchema> & Subspecialist

app/schemas/unit.schema.ts

@@ -4,7 +4,13 @@ import type { Unit } from '~/models/unit'
 const UnitSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  installation_id: z.number().min(1, 'Instalasi harus diisi').nullable(),
+  installation_id: z
+    .union([
+      z.string({ required_error: 'Instalasi harus diisi' }),
+      z.number({ required_error: 'Instalasi harus diisi' }),
+    ])
+    .optional()
+    .nullable(),
 })
 
 type UnitFormData = z.infer<typeof UnitSchema> & Unit

app/schemas/uom.schema.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, type BaseFormData } from './base.schema'
+import { BaseSchema, type BaseFormData } from './my-ui.schema'
 
 export { BaseSchema as UomSchema }
 export type { BaseFormData as UomFormData }