Deploy files from GitHub repository

config/database_connection_config.go

@@ -71,6 +71,9 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.Answer{},
 		&models.UserAnswer{},
 		&models.PersonalityAndPreferenceCV{},
+		&models.FamilyMemberCV{},
+		&models.PhysicalAndHealthCV{},
+		&models.WorshipAndReligiousUnderstandingCV{},
 	)
 
 	if err != nil {

controller/cv/cv_controller.go

@@ -7,11 +7,27 @@ import (
 	"api.qobiltu.id/services"
 	"github.com/gin-gonic/gin"
 	"net/http"
+	"strconv"
 )
 
 type CVController interface {
+	SaveAccountDetails(ctx *gin.Context)
+	GetAccountDetails(ctx *gin.Context)
+
 	SavePersonalityAndPreference(ctx *gin.Context)
 	GetPersonalityAndPreference(ctx *gin.Context)
+
+	CreateFamilyMember(ctx *gin.Context)
+	UpdateFamilyMember(ctx *gin.Context)
+	ListFamilyMember(ctx *gin.Context)
+	GetFamilyMember(ctx *gin.Context)
+	DeleteFamilyMember(ctx *gin.Context)
+
+	SavePhysicalAndHealth(ctx *gin.Context)
+	GetPhysicalAndHealth(ctx *gin.Context)
+
+	SaveWorshipAndReligiousUnderstanding(ctx *gin.Context)
+	GetWorshipAndReligiousUnderstanding(ctx *gin.Context)
 }
 
 type cvController struct {
@@ -24,6 +40,41 @@ func NewCVController(cvService services.CVService) CVController {
 	}
 }
 
+// --- Account Details ---
+func (c *cvController) SaveAccountDetails(ctx *gin.Context) {
+	var req models.AccountDetailsRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SaveAccountDetails(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Account details saved", res, nil)
+}
+
+func (c *cvController) GetAccountDetails(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetAccountDetails(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get account details success", res, nil)
+}
+
+// --- Personality & Preference ---
+
 func (c *cvController) SavePersonalityAndPreference(ctx *gin.Context) {
 	var req models.PersonalityAndPreferenceCVRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
@@ -55,3 +106,162 @@ func (c *cvController) GetPersonalityAndPreference(ctx *gin.Context) {
 
 	response.HandleSuccess(ctx, http.StatusOK, "Get Personality and Preference success", res, nil)
 }
+
+// --- Family Member ---
+
+func (c *cvController) CreateFamilyMember(ctx *gin.Context) {
+	var req models.FamilyMemberRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.CreateFamilyMember(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member saved", res, nil)
+}
+
+func (c *cvController) UpdateFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	var req models.FamilyMemberRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.UpdateFamilyMember(ctx, id, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member updated", res, nil)
+}
+
+func (c *cvController) ListFamilyMember(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	list, err := c.cvService.ListFamilyMember(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "List family members", list, nil)
+}
+
+func (c *cvController) GetFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.GetFamilyMember(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get family member success", res, nil)
+}
+
+func (c *cvController) DeleteFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	err = c.cvService.DeleteFamilyMember(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member deleted", nil, nil)
+}
+
+// --- Physical and Health ---
+
+func (c *cvController) SavePhysicalAndHealth(ctx *gin.Context) {
+	var req models.PhysicalAndHealthRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SavePhysicalAndHealth(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Physical and health saved", res, nil)
+}
+
+func (c *cvController) GetPhysicalAndHealth(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetPhysicalAndHealth(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get physical and health success", res, nil)
+}
+
+// --- Worship and Religious Understanding ---
+
+func (c *cvController) SaveWorshipAndReligiousUnderstanding(ctx *gin.Context) {
+	var req models.WorshipAndReligiousUnderstandingRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SaveWorshipAndReligiousUnderstanding(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Worship and religious understanding saved", res, nil)
+}
+
+func (c *cvController) GetWorshipAndReligiousUnderstanding(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetWorshipAndReligiousUnderstanding(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get worship and religious understanding success", res, nil)
+}

controller/user/user_profile_controller.go

@@ -1,21 +1,21 @@
-package user
-
-import (
-	"api.qobiltu.id/controller"
-	"api.qobiltu.id/models"
-	"api.qobiltu.id/services"
-	"github.com/gin-gonic/gin"
-)
-
-func Profile(c *gin.Context) {
-	userProfile := services.UserProfileService{}
-	userProfileController := controller.Controller[any, models.AccountDetails, models.UserProfileResponse]{
-		Service: &userProfile.Service,
-	}
-	userProfileController.HeaderParse(c, func() {
-		userProfileController.Service.Constructor.AccountID = uint(userProfileController.AccountData.UserID)
-		userProfile.Retrieve()
-		userProfileController.Response(c)
-	},
-	)
-}
+package user
+
+import (
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func Profile(c *gin.Context) {
+	userProfile := services.UserProfileService{}
+	userProfileController := controller.Controller[any, models.AccountDetails, models.UserProfileResponse]{
+		Service: &userProfile.Service,
+	}
+	userProfileController.HeaderParse(c, func() {
+		userProfileController.Service.Constructor.AccountID = uint(userProfileController.AccountData.UserID)
+		userProfile.Retrieve()
+		userProfileController.Response(c)
+	},
+	)
+}

controller/user/user_update_profile_controller.go

@@ -1,25 +1,25 @@
-package user
-
-import (
-	"api.qobiltu.id/controller"
-	"api.qobiltu.id/models"
-	"api.qobiltu.id/services"
-	"github.com/gin-gonic/gin"
-)
-
-func UpdateProfile(c *gin.Context) {
-	userProfile := services.UserProfileService{}
-	userUpdateProfileController := controller.Controller[models.AccountDetails, models.AccountDetails, models.UserProfileResponse]{
-		Service: &userProfile.Service,
-	}
-
-	userUpdateProfileController.RequestJSON(c, func() {
-		userUpdateProfileController.Service.Constructor = userUpdateProfileController.Request
-		userUpdateProfileController.HeaderParse(c, func() {
-			userUpdateProfileController.Service.Constructor.AccountID = uint(userUpdateProfileController.AccountData.UserID)
-
-		})
-		userProfile.Update()
-	},
-	)
-}
+package user
+
+import (
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func UpdateProfile(c *gin.Context) {
+	userProfile := services.UserProfileService{}
+	userUpdateProfileController := controller.Controller[models.AccountDetails, models.AccountDetails, models.UserProfileResponse]{
+		Service: &userProfile.Service,
+	}
+
+	userUpdateProfileController.RequestJSON(c, func() {
+		userUpdateProfileController.Service.Constructor = userUpdateProfileController.Request
+		userUpdateProfileController.HeaderParse(c, func() {
+			userUpdateProfileController.Service.Constructor.AccountID = userUpdateProfileController.AccountData.UserID
+
+		})
+		userProfile.Update()
+	},
+	)
+}

models/database_orm_model.go

@@ -18,19 +18,21 @@ type Account struct {
 }
 
 type AccountDetails struct {
-	ID            uint64     `gorm:"primaryKey" json:"id"`
-	AccountID     uint       `json:"account_id"`
-	InitialName   string     `json:"initial_name"`
-	FullName      *string    `json:"full_name"`
-	DateOfBirth   *time.Time `json:"date_of_birth"`
-	PlaceOfBirth  *string    `json:"place_of_birth"`
-	Domicile      *string    `json:"domicile"`
-	LastJob       *string    `json:"last_job"`
-	Gender        *string    `json:"gender"`
-	LastEducation *string    `json:"last_education"`
-	MaritalStatus *string    `json:"marital_status"`
-	Avatar        *string    `json:"avatar"`
-	PhoneNumber   *string    `json:"phone_number"`
+	ID            uint64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+	AccountID     uint       `gorm:"column:account_id;not null;unique" json:"account_id"`
+	InitialName   string     `gorm:"column:initial_name;not null" json:"initial_name"`
+	FullName      *string    `gorm:"column:full_name" json:"full_name"`
+	DateOfBirth   *time.Time `gorm:"column:date_of_birth" json:"date_of_birth"`
+	PlaceOfBirth  *string    `gorm:"column:place_of_birth" json:"place_of_birth"`
+	Domicile      *string    `gorm:"column:domicile" json:"domicile"`
+	LastJob       *string    `gorm:"column:last_job" json:"last_job"`
+	Gender        *string    `gorm:"column:gender" json:"gender"`
+	LastEducation *string    `gorm:"column:last_education" json:"last_education"`
+	MaritalStatus *string    `gorm:"column:marital_status" json:"marital_status"`
+	Avatar        *string    `gorm:"column:avatar" json:"avatar"`
+	PhoneNumber   *string    `gorm:"column:phone_number" json:"phone_number"`
+	CreatedAt     time.Time  `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+	UpdatedAt     time.Time  `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 }
 
 type EmailVerification struct {
@@ -184,49 +186,107 @@ type QuizResult struct {
 	AverageScore   float64 `gorm:"column:average_score" json:"average_score"`
 }
 
-type PersonalityAndPreferenceCV struct {
-	ID                    int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
-	AccountID             int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
-	Account               *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
-	PositiveTraits        *string   `gorm:"column:positive_traits" json:"positive_traits"`                   // sifat positif
-	NegativeTraits        *string   `gorm:"column:negative_traits" json:"negative_traits"`                   // sifat negatif
-	Hobbies               *string   `gorm:"column:hobbies" json:"hobbies"`                                   // hobi
-	LifeGoals             *string   `gorm:"column:life_goals" json:"life_goals"`                             // target hidup
-	DailyActivities       *string   `gorm:"column:daily_activities" json:"daily_activities"`                 // kegiatan sehari-hari
-	LeisureActivities     *string   `gorm:"column:leisure_activities" json:"leisure_activities"`             // kegiatan waktu luang
-	Likes                 *string   `gorm:"column:likes" json:"likes"`                                       // hal yang disukai
-	Dislikes              *string   `gorm:"column:dislikes" json:"dislikes"`                                 // hal yang tidak disukai
-	StressHandling        *string   `gorm:"column:stress_handling" json:"stress_handling"`                   // cara mengatasi stres
-	AngerTriggers         *string   `gorm:"column:anger_triggers" json:"anger_triggers"`                     // pemicu amarah
-	FavoriteFoodAndDrinks *string   `gorm:"column:favorite_food_and_drinks" json:"favorite_food_and_drinks"` // makanan dan minuman favorit
-	CanCook               *bool     `gorm:"column:can_cook" json:"can_cook"`                                 // bisa memasak
-	TypesOfDishesCooked   *string   `gorm:"column:types_of_dishes_cooked" json:"types_of_dishes_cooked"`     // jenis masakan yang bisa dimasak
-	MonthlyExpenses       *string   `gorm:"column:monthly_expenses" json:"monthly_expenses"`                 // pengeluaran per bulan
-	CreatedAt             time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
-	UpdatedAt             time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
-}
+type (
+	PersonalityAndPreferenceCV struct {
+		ID                    int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID             int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account               *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		PositiveTraits        *string   `gorm:"column:positive_traits" json:"positive_traits"`                   // sifat positif
+		NegativeTraits        *string   `gorm:"column:negative_traits" json:"negative_traits"`                   // sifat negatif
+		Hobbies               *string   `gorm:"column:hobbies" json:"hobbies"`                                   // hobi
+		LifeGoals             *string   `gorm:"column:life_goals" json:"life_goals"`                             // target hidup
+		DailyActivities       *string   `gorm:"column:daily_activities" json:"daily_activities"`                 // kegiatan sehari-hari
+		LeisureActivities     *string   `gorm:"column:leisure_activities" json:"leisure_activities"`             // kegiatan waktu luang
+		Likes                 *string   `gorm:"column:likes" json:"likes"`                                       // hal yang disukai
+		Dislikes              *string   `gorm:"column:dislikes" json:"dislikes"`                                 // hal yang tidak disukai
+		StressHandling        *string   `gorm:"column:stress_handling" json:"stress_handling"`                   // cara mengatasi stres
+		AngerTriggers         *string   `gorm:"column:anger_triggers" json:"anger_triggers"`                     // pemicu amarah
+		FavoriteFoodAndDrinks *string   `gorm:"column:favorite_food_and_drinks" json:"favorite_food_and_drinks"` // makanan dan minuman favorit
+		CanCook               *bool     `gorm:"column:can_cook" json:"can_cook"`                                 // bisa memasak
+		TypesOfDishesCooked   *string   `gorm:"column:types_of_dishes_cooked" json:"types_of_dishes_cooked"`     // jenis masakan yang bisa dimasak
+		MonthlyExpenses       *string   `gorm:"column:monthly_expenses" json:"monthly_expenses"`                 // pengeluaran per bulan
+		CreatedAt             time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt             time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	FamilyMemberCV struct {
+		ID            int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID     int64     `gorm:"column:account_id;not null" json:"account_id"`
+		Account       *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		Role          *string   `gorm:"column:role" json:"role"`                     // Peran dalam keluarga
+		Status        *string   `gorm:"column:status" json:"status"`                 // Status (Hidup, Wafat)
+		Religion      *string   `gorm:"column:religion" json:"religion"`             // Agama
+		Job           *string   `gorm:"column:job" json:"job"`                       // Pekerjaan
+		LastEducation *string   `gorm:"column:last_education" json:"last_education"` // Pendidikan terakhir
+		Age           *int      `gorm:"column:age" json:"age"`                       // Usia
+		CreatedAt     time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt     time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	PhysicalAndHealthCV struct {
+		ID               int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID        int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account          *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		HeightInCm       *int      `gorm:"column:height_cm" json:"height_cm"`                  // Tinggi badan dalam satuan sentimeter
+		WeightInKg       *int      `gorm:"column:weight_kg" json:"weight_kg"`                  // Berat badan dalam satuan kilogram
+		BodyShape        *string   `gorm:"column:body_shape" json:"body_shape"`                // Bentuk tubuh
+		SkinColor        *string   `gorm:"column:skin_color" json:"skin_color"`                // Warna kulit
+		HairType         *string   `gorm:"column:hair_type" json:"hair_type"`                  // Tipe rambut
+		MedicalHistory   *string   `gorm:"column:medical_history" json:"medical_history"`      // Riwayat penyakit
+		PhysicalDisorder *string   `gorm:"column:physical_disorder" json:"physical_disorder"`  // Cacat fisik
+		PhysicalTraits   *string   `gorm:"column:physical_traits" json:"physical_traits"`      // Ciri khas fisik
+		CreatedAt        time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"` // Waktu data dibuat
+		UpdatedAt        time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"` // Waktu data terakhir diperbarui
+	}
+
+	WorshipAndReligiousUnderstandingCV struct {
+		ID                         int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID                  int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account                    *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		ObligatoryPrayer           *string   `gorm:"column:obligatory_prayer" json:"obligatory_prayer"`                           // sholat_wajib_5_waktu
+		CongregationalPrayer       *string   `gorm:"column:congregational_prayer" json:"congregational_prayer"`                   // sholat_berjamaah_di_masjid
+		TahajjudPrayer             *string   `gorm:"column:tahajjud_prayer" json:"tahajjud_prayer"`                               // sholat_tahajud
+		DhuhaPrayer                *string   `gorm:"column:dhuha_prayer" json:"dhuha_prayer"`                                     // sholat_dhuha
+		QuranMemorization          *string   `gorm:"column:quran_memorization" json:"quran_memorization"`                         // hafalan_alquran
+		QuranReadingAbility        *string   `gorm:"column:quran_reading_ability" json:"quran_reading_ability"`                   // kemampuan_baca_alquran
+		DaudFasting                *string   `gorm:"column:daud_fasting" json:"daud_fasting"`                                     // puasa_daud
+		AyyamulBidhFasting         *string   `gorm:"column:ayyamul_bidh_fasting" json:"ayyamul_bidh_fasting"`                     // puasa_ayyamul_bidh
+		HajjOrUmrah                *string   `gorm:"column:hajj_or_umrah" json:"hajj_or_umrah"`                                   // ibadah_haji_umroh
+		ListeningToMusic           *string   `gorm:"column:listening_to_music" json:"listening_to_music"`                         // mendengarkan_musik
+		OpinionOnIkhtilat          *string   `gorm:"column:opinion_on_ikhtilat" json:"opinion_on_ikhtilat"`                       // pendapat_ikhtilat
+		OpinionOnTouchingNonMahram *string   `gorm:"column:opinion_on_touching_non_mahram" json:"opinion_on_touching_non_mahram"` // pendapat_menyentuh_non_mahram
+		OpinionOnVeil              *string   `gorm:"column:opinion_on_veil" json:"opinion_on_veil"`                               // pendapat_tentang_cadar
+		WeeklyReligiousStudies     *string   `gorm:"column:weekly_religious_studies" json:"weekly_religious_studies"`             // kajian_yang_diikuti_dalam_sepekan
+		FollowedUstadz             *string   `gorm:"column:followed_ustadz" json:"followed_ustadz"`                               // ustadz_yang_diikuti
+		CreatedAt                  time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt                  time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+)
 
 // Gorm table name settings
-func (Account) TableName() string                 { return "account" }
-func (AccountDetails) TableName() string          { return "account_details" }
-func (EmailVerification) TableName() string       { return "email_verifications" }
-func (ExternalAuth) TableName() string            { return "extern_auth" }
-func (FCM) TableName() string                     { return "fcm" }
-func (ForgotPassword) TableName() string          { return "forgot_password" }
-func (Academy) TableName() string                 { return "academy" }
-func (AcademyMaterial) TableName() string         { return "academy_materials" }
-func (AcademyContent) TableName() string          { return "academy_contents" }
-func (AcademyMaterialProgress) TableName() string { return "academy_materials_progress" }
-func (AcademyContentProgress) TableName() string  { return "academy_contents_progress" }
-func (RegionProvince) TableName() string          { return "region_provinces" }
-func (RegionCity) TableName() string              { return "region_cities" }
-func (Answer) TableName() string                  { return "answers" }
-func (Question) TableName() string                { return "questions" }
-func (Quiz) TableName() string                    { return "quizzes" }
-func (QuizAttempt) TableName() string             { return "quiz_attempts" }
-func (UserAnswer) TableName() string              { return "user_answers" }
-func (OptionCategory) TableName() string          { return "option_categories" }
-func (OptionValues) TableName() string            { return "option_values" }
-func (PersonalityAndPreferenceCV) TableName() string {
-	return "personality_and_preference_cv"
+func (Account) TableName() string                    { return "account" }
+func (AccountDetails) TableName() string             { return "account_details" }
+func (EmailVerification) TableName() string          { return "email_verifications" }
+func (ExternalAuth) TableName() string               { return "extern_auth" }
+func (FCM) TableName() string                        { return "fcm" }
+func (ForgotPassword) TableName() string             { return "forgot_password" }
+func (Academy) TableName() string                    { return "academy" }
+func (AcademyMaterial) TableName() string            { return "academy_materials" }
+func (AcademyContent) TableName() string             { return "academy_contents" }
+func (AcademyMaterialProgress) TableName() string    { return "academy_materials_progress" }
+func (AcademyContentProgress) TableName() string     { return "academy_contents_progress" }
+func (RegionProvince) TableName() string             { return "region_provinces" }
+func (RegionCity) TableName() string                 { return "region_cities" }
+func (Answer) TableName() string                     { return "answers" }
+func (Question) TableName() string                   { return "questions" }
+func (Quiz) TableName() string                       { return "quizzes" }
+func (QuizAttempt) TableName() string                { return "quiz_attempts" }
+func (UserAnswer) TableName() string                 { return "user_answers" }
+func (OptionCategory) TableName() string             { return "option_categories" }
+func (OptionValues) TableName() string               { return "option_values" }
+func (PersonalityAndPreferenceCV) TableName() string { return "personality_and_preference_cv" }
+func (FamilyMemberCV) TableName() string             { return "family_member_cv" }
+func (PhysicalAndHealthCV) TableName() string        { return "physical_and_health_cv" }
+func (WorshipAndReligiousUnderstandingCV) TableName() string {
+	return "worship_and_religious_understanding_cv"
 }

models/request_model.go

@@ -54,7 +54,7 @@ type AnswerQuizRequest struct {
 
 type (
 	PersonalityAndPreferenceCVRequest struct {
-		AccountID             int64   `json:"account_id"`
+		AccountID             int64   `json:"-"`
 		PositiveTraits        *string `json:"positive_traits"`          // sifat positif
 		NegativeTraits        *string `json:"negative_traits"`          // sifat negatif
 		Hobbies               *string `json:"hobbies"`                  // hobi
@@ -71,24 +71,56 @@ type (
 		MonthlyExpenses       *string `json:"monthly_expenses"`         // pengeluaran per bulan
 	}
 
-	PersonalityAndPreferenceCVResponse struct {
-		ID                    int64     `json:"id"`
-		AccountID             int64     `json:"account_id"`
-		PositiveTraits        *string   `json:"positive_traits"`          // sifat positif
-		NegativeTraits        *string   `json:"negative_traits"`          // sifat negatif
-		Hobbies               *string   `json:"hobbies"`                  // hobi
-		LifeGoals             *string   `json:"life_goals"`               // target hidup
-		DailyActivities       *string   `json:"daily_activities"`         // kegiatan sehari-hari
-		LeisureActivities     *string   `json:"leisure_activities"`       // kegiatan waktu luang
-		Likes                 *string   `json:"likes"`                    // hal yang disukai
-		Dislikes              *string   `json:"dislikes"`                 // hal yang tidak disukai
-		StressHandling        *string   `json:"stress_handling"`          // cara mengatasi stres
-		AngerTriggers         *string   `json:"anger_triggers"`           // pemicu amarah
-		FavoriteFoodAndDrinks *string   `json:"favorite_food_and_drinks"` // makanan dan minuman favorit
-		CanCook               *bool     `json:"can_cook"`                 // bisa memasak
-		TypesOfDishesCooked   *string   `json:"types_of_dishes_cooked"`   // jenis masakan yang bisa dimasak
-		MonthlyExpenses       *string   `json:"monthly_expenses"`         // pengeluaran per bulan
-		CreatedAt             time.Time `json:"created_at"`
-		UpdatedAt             time.Time `json:"updated_at"`
+	FamilyMemberRequest struct {
+		AccountID     int64   `json:"-"`
+		Role          *string `json:"role"`           // Peran dalam keluarga
+		Status        *string `json:"status"`         // Status (Hidup, Wafat)
+		Religion      *string `json:"religion"`       // Agama
+		Job           *string `json:"job"`            // Pekerjaan
+		LastEducation *string `json:"last_education"` // Pendidikan terakhir
+		Age           *int    `json:"age"`            // Usia
+	}
+
+	PhysicalAndHealthRequest struct {
+		AccountID        int64   `json:"-"`
+		HeightInCm       *int    `json:"height_cm"`         // Tinggi badan dalam satuan sentimeter
+		WeightInKg       *int    `json:"weight_kg"`         // Berat badan dalam satuan kilogram
+		BodyShape        *string `json:"body_shape"`        // Bentuk tubuh
+		SkinColor        *string `json:"skin_color"`        // Warna kulit
+		HairType         *string `json:"hair_type"`         // Tipe rambut
+		MedicalHistory   *string `json:"medical_history"`   // Riwayat penyakit
+		PhysicalDisorder *string `json:"physical_disorder"` // Cacat fisik
+		PhysicalTraits   *string `json:"physical_traits"`   // Ciri khas fisik
+	}
+
+	AccountDetailsRequest struct {
+		AccountID     int64      `json:"-"`
+		FullName      *string    `json:"full_name"`
+		Gender        *string    `json:"gender"`
+		DateOfBirth   *time.Time `json:"date_of_birth"`
+		PlaceOfBirth  *string    `json:"place_of_birth"`
+		Domicile      *string    `json:"domicile"`
+		MaritalStatus *string    `json:"marital_status"`
+		LastEducation *string    `json:"last_education"`
+		LastJob       *string    `json:"last_job"`
+	}
+
+	WorshipAndReligiousUnderstandingRequest struct {
+		AccountID                  int64   `json:"-"`
+		ObligatoryPrayer           *string `json:"obligatory_prayer"`              // sholat_wajib_5_waktu
+		CongregationalPrayer       *string `json:"congregational_prayer"`          // sholat_berjamaah_di_masjid
+		TahajjudPrayer             *string `json:"tahajjud_prayer"`                // sholat_tahajud
+		DhuhaPrayer                *string `json:"dhuha_prayer"`                   // sholat_dhuha
+		QuranMemorization          *string `json:"quran_memorization"`             // hafalan_alquran
+		QuranReadingAbility        *string `json:"quran_reading_ability"`          // kemampuan_baca_alquran
+		DaudFasting                *string `json:"daud_fasting"`                   // puasa_daud
+		AyyamulBidhFasting         *string `json:"ayyamul_bidh_fasting"`           // puasa_ayyamul_bidh
+		HajjOrUmrah                *string `json:"hajj_or_umrah"`                  // ibadah_haji_umroh
+		ListeningToMusic           *string `json:"listening_to_music"`             // mendengarkan_musik
+		OpinionOnIkhtilat          *string `json:"opinion_on_ikhtilat"`            // pendapat_ikhtilat
+		OpinionOnTouchingNonMahram *string `json:"opinion_on_touching_non_mahram"` // pendapat_menyentuh_non_mahram
+		OpinionOnVeil              *string `json:"opinion_on_veil"`                // pendapat_tentang_cadar
+		WeeklyReligiousStudies     *string `json:"weekly_religious_studies"`       // kajian_yang_diikuti_dalam_sepekan
+		FollowedUstadz             *string `json:"followed_ustadz"`                // ustadz_yang_diikuti
 	}
 )

repositories/account_repository.go

@@ -1,87 +1,87 @@
-package repositories
-
-import (
-	"api.qobiltu.id/models"
-)
-
-func GetAccountbyEmail(email string) Repository[models.Account, models.Account] {
-	repo := Construct[models.Account, models.Account](
-		models.Account{Email: email},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.Account, models.Account],
-		Find[models.Account, models.Account],
-	)
-	return *repo
-}
-
-func GetAllAccount() Repository[models.Account, []models.Account] {
-	repo := Construct[models.Account, []models.Account](
-		models.Account{},
-	)
-	repo.Transactions(
-		Find[models.Account, []models.Account],
-	)
-	return *repo
-}
-func GetAccountById(accountId uint) Repository[models.Account, models.Account] {
-	repo := Construct[models.Account, models.Account](
-		models.Account{Id: accountId},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.Account, models.Account],
-		Find[models.Account, models.Account],
-	)
-	return *repo
-}
-
-func UpdateAccount(account models.Account) Repository[models.Account, models.Account] {
-	repo := Construct[models.Account, models.Account](
-		account,
-	)
-	repo.Transaction.Save(&repo.Constructor)
-	repo.Result = repo.Constructor
-	return *repo
-}
-
-func GetDetailAccountById(accountId uint) Repository[models.AccountDetails, models.AccountDetails] {
-	repo := Construct[models.AccountDetails, models.AccountDetails](
-		models.AccountDetails{AccountID: accountId},
-	)
-
-	// fmt.Println("Account ID:", repo.Constructor.AccountID)
-	repo.Transactions(
-		WhereGivenConstructor[models.AccountDetails, models.AccountDetails],
-		Find[models.AccountDetails, models.AccountDetails],
-	)
-	return *repo
-}
-
-func CreateAccount(account models.Account) Repository[models.Account, models.Account] {
-	repo := Construct[models.Account, models.Account](
-		account,
-	)
-	Create(repo)
-	return *repo
-}
-
-func CreateAccountDetails(accountDetails models.AccountDetails) Repository[models.AccountDetails, models.AccountDetails] {
-	repo := Construct[models.AccountDetails, models.AccountDetails](
-		accountDetails,
-	)
-	Create(repo)
-	return *repo
-}
-
-func UpdateAccountDetails(accountDetails models.AccountDetails) Repository[models.AccountDetails, models.AccountDetails] {
-	repo := Construct[models.AccountDetails, models.AccountDetails](
-		models.AccountDetails{AccountID: accountDetails.AccountID},
-	)
-	repo.Transaction.Where("account_id = ?", accountDetails.AccountID).First(&repo.Constructor)
-	accountDetails.ID = repo.Constructor.ID
-	// fmt.Println(repo.Constructor)
-	// fmt.Println(accountDetails)
-	repo.Transaction.Updates(accountDetails)
-	repo.Result = accountDetails
-	return *repo
-}
+package repositories
+
+import (
+	"api.qobiltu.id/models"
+)
+
+func GetAccountbyEmail(email string) Repository[models.Account, models.Account] {
+	repo := Construct[models.Account, models.Account](
+		models.Account{Email: email},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Account, models.Account],
+		Find[models.Account, models.Account],
+	)
+	return *repo
+}
+
+func GetAllAccount() Repository[models.Account, []models.Account] {
+	repo := Construct[models.Account, []models.Account](
+		models.Account{},
+	)
+	repo.Transactions(
+		Find[models.Account, []models.Account],
+	)
+	return *repo
+}
+func GetAccountById(accountId uint) Repository[models.Account, models.Account] {
+	repo := Construct[models.Account, models.Account](
+		models.Account{Id: accountId},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Account, models.Account],
+		Find[models.Account, models.Account],
+	)
+	return *repo
+}
+
+func UpdateAccount(account models.Account) Repository[models.Account, models.Account] {
+	repo := Construct[models.Account, models.Account](
+		account,
+	)
+	repo.Transaction.Save(&repo.Constructor)
+	repo.Result = repo.Constructor
+	return *repo
+}
+
+func GetDetailAccountById(accountId uint) Repository[models.AccountDetails, models.AccountDetails] {
+	repo := Construct[models.AccountDetails, models.AccountDetails](
+		models.AccountDetails{AccountID: accountId},
+	)
+
+	// fmt.Println("Account ID:", repo.Constructor.AccountID)
+	repo.Transactions(
+		WhereGivenConstructor[models.AccountDetails, models.AccountDetails],
+		Find[models.AccountDetails, models.AccountDetails],
+	)
+	return *repo
+}
+
+func CreateAccount(account models.Account) Repository[models.Account, models.Account] {
+	repo := Construct[models.Account, models.Account](
+		account,
+	)
+	Create(repo)
+	return *repo
+}
+
+func CreateAccountDetails(accountDetails models.AccountDetails) Repository[models.AccountDetails, models.AccountDetails] {
+	repo := Construct[models.AccountDetails, models.AccountDetails](
+		accountDetails,
+	)
+	Create(repo)
+	return *repo
+}
+
+func UpdateAccountDetails(accountDetails models.AccountDetails) Repository[models.AccountDetails, models.AccountDetails] {
+	repo := Construct[models.AccountDetails, models.AccountDetails](
+		models.AccountDetails{AccountID: accountDetails.AccountID},
+	)
+	repo.Transaction.Where("account_id = ?", accountDetails.AccountID).First(&repo.Constructor)
+	accountDetails.ID = repo.Constructor.ID
+	// fmt.Println(repo.Constructor)
+	// fmt.Println(accountDetails)
+	repo.Transaction.Updates(accountDetails)
+	repo.Result = accountDetails
+	return *repo
+}

repositories/cv_repository.go

@@ -1,37 +1,126 @@
 package repositories
 
 import (
-	"api.qobiltu.id/models"
-	"context"
-	"gorm.io/gorm"
+    "api.qobiltu.id/models"
+    "context"
+    "gorm.io/gorm"
 )
 
 type CVRepository interface {
-	SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCV) (*models.PersonalityAndPreferenceCV, error)
-	GetPersonalityAndPreferenceByAccountID(ctx context.Context, accountID int64) (*models.PersonalityAndPreferenceCV, error)
+    SaveAccountDetails(ctx context.Context, req *models.AccountDetails) (*models.AccountDetails, error)
+    GetAccountDetailsByAccountID(ctx context.Context, accountID int64) (*models.AccountDetails, error)
+
+    SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCV) (*models.PersonalityAndPreferenceCV, error)
+    GetPersonalityAndPreferenceByAccountID(ctx context.Context, accountID int64) (*models.PersonalityAndPreferenceCV, error)
+
+    SaveFamilyMember(ctx context.Context, req *models.FamilyMemberCV) (*models.FamilyMemberCV, error)
+    ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error)
+    GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error)
+    DeleteFamilyMember(ctx context.Context, id int64) error
+
+    SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthCV) (*models.PhysicalAndHealthCV, error)
+    GetPhysicalAndHealthByAccountID(ctx context.Context, accountID int64) (*models.PhysicalAndHealthCV, error)
+
+    SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingCV) (*models.WorshipAndReligiousUnderstandingCV, error)
+    GetWorshipAndReligiousUnderstandingByAccountID(ctx context.Context, accountID int64) (*models.WorshipAndReligiousUnderstandingCV, error)
 }
 
 type cvRepository struct {
-	db *gorm.DB
+    db *gorm.DB
 }
 
 func NewCVRepository(db *gorm.DB) CVRepository {
-	return &cvRepository{
-		db: db,
-	}
+    return &cvRepository{
+        db: db,
+    }
+}
+
+func (r *cvRepository) SaveAccountDetails(ctx context.Context, req *models.AccountDetails) (*models.AccountDetails, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetAccountDetailsByAccountID(ctx context.Context, accountID int64) (*models.AccountDetails, error) {
+    var accountDetails models.AccountDetails
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&accountDetails).Error; err != nil {
+        return nil, err
+    }
+    return &accountDetails, nil
 }
 
 func (r *cvRepository) SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCV) (*models.PersonalityAndPreferenceCV, error) {
-	if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
-		return req, err
-	}
-	return req, nil
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
 }
 
 func (r *cvRepository) GetPersonalityAndPreferenceByAccountID(ctx context.Context, accountID int64) (*models.PersonalityAndPreferenceCV, error) {
-	var personalityAndPreference models.PersonalityAndPreferenceCV
-	if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&personalityAndPreference).Error; err != nil {
-		return nil, err
-	}
-	return &personalityAndPreference, nil
+    var personalityAndPreference models.PersonalityAndPreferenceCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&personalityAndPreference).Error; err != nil {
+        return nil, err
+    }
+    return &personalityAndPreference, nil
+}
+
+func (r *cvRepository) SaveFamilyMember(ctx context.Context, req *models.FamilyMemberCV) (*models.FamilyMemberCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error) {
+    var familyMember models.FamilyMemberCV
+    if err := r.db.WithContext(ctx).Where("id = ?", id).First(&familyMember).Error; err != nil {
+        return nil, err
+    }
+    return &familyMember, nil
+}
+
+func (r *cvRepository) DeleteFamilyMember(ctx context.Context, id int64) error {
+    if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&models.FamilyMemberCV{}).Error; err != nil {
+        return err
+    }
+    return nil
+}
+
+func (r *cvRepository) ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error) {
+    familyMembers := make([]models.FamilyMemberCV, 0)
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).Find(&familyMembers).Error; err != nil {
+        return nil, err
+    }
+    return familyMembers, nil
+}
+
+func (r *cvRepository) SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthCV) (*models.PhysicalAndHealthCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetPhysicalAndHealthByAccountID(ctx context.Context, accountID int64) (*models.PhysicalAndHealthCV, error) {
+    var physicalAndHealth models.PhysicalAndHealthCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&physicalAndHealth).Error; err != nil {
+        return nil, err
+    }
+    return &physicalAndHealth, nil
+}
+
+func (r *cvRepository) SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingCV) (*models.WorshipAndReligiousUnderstandingCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetWorshipAndReligiousUnderstandingByAccountID(ctx context.Context, accountID int64) (*models.WorshipAndReligiousUnderstandingCV, error) {
+    var worshipAndReligiousUnderstanding models.WorshipAndReligiousUnderstandingCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&worshipAndReligiousUnderstanding).Error; err != nil {
+        return nil, err
+    }
+    return &worshipAndReligiousUnderstanding, nil
 }

router/cv_route.go

@@ -3,9 +3,24 @@ package router
 import "api.qobiltu.id/middleware"
 
 func (s *Server) CVRoute() {
-    routerGroup := s.router.Group("/api/v1/cv").Use(middleware.AuthUser)
-    {
-        routerGroup.POST("/personality-and-preference", s.cvController.SavePersonalityAndPreference)
-        routerGroup.GET("/personality-and-preference", s.cvController.GetPersonalityAndPreference)
-    }
+	routerGroup := s.router.Group("/api/v1/cv").Use(middleware.AuthUser)
+	{
+		routerGroup.POST("/account-details", s.cvController.SaveAccountDetails)
+		routerGroup.GET("/account-details", s.cvController.GetAccountDetails)
+
+		routerGroup.POST("/personality-and-preferences", s.cvController.SavePersonalityAndPreference)
+		routerGroup.GET("/personality-and-preferences", s.cvController.GetPersonalityAndPreference)
+
+		routerGroup.POST("/family-members", s.cvController.CreateFamilyMember)
+		routerGroup.GET("/family-members", s.cvController.ListFamilyMember)
+		routerGroup.GET("/family-members/:id", s.cvController.GetFamilyMember)
+		routerGroup.PUT("/family-members/:id", s.cvController.UpdateFamilyMember)
+		routerGroup.DELETE("/family-members/:id", s.cvController.DeleteFamilyMember)
+
+		routerGroup.POST("/physical-and-healths", s.cvController.SavePhysicalAndHealth)
+		routerGroup.GET("/physical-and-healths", s.cvController.GetPhysicalAndHealth)
+
+		routerGroup.POST("/worship-and-religious-understandings", s.cvController.SaveWorshipAndReligiousUnderstanding)
+		routerGroup.GET("/worship-and-religious-understandings", s.cvController.GetWorshipAndReligiousUnderstanding)
+	}
 }

services/cv_service.go

@@ -1,108 +1,277 @@
 package services
 
 import (
-    "api.qobiltu.id/models"
-    "api.qobiltu.id/repositories"
-    "api.qobiltu.id/response"
-    "context"
-    "errors"
-    "gorm.io/gorm"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+	"api.qobiltu.id/response"
+	"context"
+	"errors"
+	"gorm.io/gorm"
 )
 
 type CVService interface {
-    SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCVResponse, error)
-    GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCVResponse, error)
+	SaveAccountDetails(ctx context.Context, req *models.AccountDetailsRequest) (*models.AccountDetails, error)
+	GetAccountDetails(ctx context.Context, id int64) (*models.AccountDetails, error)
+
+	SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCV, error)
+	GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCV, error)
+
+	CreateFamilyMember(ctx context.Context, req *models.FamilyMemberRequest) (*models.FamilyMemberCV, error)
+	UpdateFamilyMember(ctx context.Context, id int64, req *models.FamilyMemberRequest) (*models.FamilyMemberCV, error)
+	ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error)
+	GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error)
+	DeleteFamilyMember(ctx context.Context, id int64) error
+
+	SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthRequest) (*models.PhysicalAndHealthCV, error)
+	GetPhysicalAndHealth(ctx context.Context, id int64) (*models.PhysicalAndHealthCV, error)
+
+	SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingRequest) (*models.WorshipAndReligiousUnderstandingCV, error)
+	GetWorshipAndReligiousUnderstanding(ctx context.Context, id int64) (*models.WorshipAndReligiousUnderstandingCV, error)
 }
 
 type cvService struct {
-    cvRepository repositories.CVRepository
+	cvRepository repositories.CVRepository
 }
 
 func NewCVService(cvRepository repositories.CVRepository) CVService {
-    return &cvService{
-        cvRepository: cvRepository,
-    }
-}
-
-func (s *cvService) SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCVResponse, error) {
-    // Ambil data lama jika ada
-    personalityAndPreference, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, req.AccountID)
-    if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-        return nil, response.HandleGormError(err, "Internal Server Error")
-    }
-
-    // Apply perubahan
-    if personalityAndPreference == nil {
-        personalityAndPreference = &models.PersonalityAndPreferenceCV{}
-    }
-
-    personalityAndPreference.AccountID = req.AccountID
-    personalityAndPreference.PositiveTraits = req.PositiveTraits
-    personalityAndPreference.NegativeTraits = req.NegativeTraits
-    personalityAndPreference.Hobbies = req.Hobbies
-    personalityAndPreference.LifeGoals = req.LifeGoals
-    personalityAndPreference.DailyActivities = req.DailyActivities
-    personalityAndPreference.LeisureActivities = req.LeisureActivities
-    personalityAndPreference.Likes = req.Likes
-    personalityAndPreference.Dislikes = req.Dislikes
-    personalityAndPreference.StressHandling = req.StressHandling
-    personalityAndPreference.AngerTriggers = req.AngerTriggers
-    personalityAndPreference.FavoriteFoodAndDrinks = req.FavoriteFoodAndDrinks
-    personalityAndPreference.CanCook = req.CanCook
-    personalityAndPreference.TypesOfDishesCooked = req.TypesOfDishesCooked
-    personalityAndPreference.MonthlyExpenses = req.MonthlyExpenses
-
-    res, err := s.cvRepository.SavePersonalityAndPreference(ctx, personalityAndPreference)
-    if err != nil {
-        return nil, response.HandleGormError(err, "Internal Server Error")
-    }
-
-    return &models.PersonalityAndPreferenceCVResponse{
-        ID:                    res.ID,
-        AccountID:             res.AccountID,
-        PositiveTraits:        res.PositiveTraits,
-        NegativeTraits:        res.NegativeTraits,
-        Hobbies:               res.Hobbies,
-        LifeGoals:             res.LifeGoals,
-        DailyActivities:       res.DailyActivities,
-        LeisureActivities:     res.LeisureActivities,
-        Likes:                 res.Likes,
-        Dislikes:              res.Dislikes,
-        StressHandling:        res.StressHandling,
-        AngerTriggers:         res.AngerTriggers,
-        FavoriteFoodAndDrinks: res.FavoriteFoodAndDrinks,
-        CanCook:               res.CanCook,
-        TypesOfDishesCooked:   res.TypesOfDishesCooked,
-        MonthlyExpenses:       res.MonthlyExpenses,
-        CreatedAt:             res.CreatedAt,
-        UpdatedAt:             res.UpdatedAt,
-    }, nil
-}
-
-func (s *cvService) GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCVResponse, error) {
-    res, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, id)
-    if err != nil {
-        return nil, response.HandleGormError(err, "Internal Server Error")
-    }
-    
-    return &models.PersonalityAndPreferenceCVResponse{
-        ID:                    res.ID,
-        AccountID:             res.AccountID,
-        PositiveTraits:        res.PositiveTraits,
-        NegativeTraits:        res.NegativeTraits,
-        Hobbies:               res.Hobbies,
-        LifeGoals:             res.LifeGoals,
-        DailyActivities:       res.DailyActivities,
-        LeisureActivities:     res.LeisureActivities,
-        Likes:                 res.Likes,
-        Dislikes:              res.Dislikes,
-        StressHandling:        res.StressHandling,
-        AngerTriggers:         res.AngerTriggers,
-        FavoriteFoodAndDrinks: res.FavoriteFoodAndDrinks,
-        CanCook:               res.CanCook,
-        TypesOfDishesCooked:   res.TypesOfDishesCooked,
-        MonthlyExpenses:       res.MonthlyExpenses,
-        CreatedAt:             res.CreatedAt,
-        UpdatedAt:             res.UpdatedAt,
-    }, nil
+	return &cvService{
+		cvRepository: cvRepository,
+	}
+}
+
+func (s *cvService) SaveAccountDetails(ctx context.Context, req *models.AccountDetailsRequest) (*models.AccountDetails, error) {
+	// Ambil data lama jika ada
+	accountDetails, err := s.cvRepository.GetAccountDetailsByAccountID(ctx, req.AccountID)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	// Apply perubahan
+	if accountDetails == nil {
+		accountDetails = &models.AccountDetails{}
+	}
+
+	accountDetails.AccountID = uint(req.AccountID)
+	accountDetails.FullName = req.FullName
+	accountDetails.Gender = req.Gender
+	accountDetails.DateOfBirth = req.DateOfBirth
+	accountDetails.PlaceOfBirth = req.PlaceOfBirth
+	accountDetails.Domicile = req.Domicile
+	accountDetails.MaritalStatus = req.MaritalStatus
+	accountDetails.LastEducation = req.LastEducation
+	accountDetails.LastJob = req.LastJob
+
+	// Simpan data
+	res, err := s.cvRepository.SaveAccountDetails(ctx, accountDetails)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) GetAccountDetails(ctx context.Context, id int64) (*models.AccountDetails, error) {
+	res, err := s.cvRepository.GetAccountDetailsByAccountID(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data diri tidak ditemukan")
+	}
+	return res, nil
+}
+
+func (s *cvService) SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCV, error) {
+	// Ambil data lama jika ada
+	personalityAndPreference, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, req.AccountID)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	// Apply perubahan
+	if personalityAndPreference == nil {
+		personalityAndPreference = &models.PersonalityAndPreferenceCV{}
+	}
+
+	personalityAndPreference.AccountID = req.AccountID
+	personalityAndPreference.PositiveTraits = req.PositiveTraits
+	personalityAndPreference.NegativeTraits = req.NegativeTraits
+	personalityAndPreference.Hobbies = req.Hobbies
+	personalityAndPreference.LifeGoals = req.LifeGoals
+	personalityAndPreference.DailyActivities = req.DailyActivities
+	personalityAndPreference.LeisureActivities = req.LeisureActivities
+	personalityAndPreference.Likes = req.Likes
+	personalityAndPreference.Dislikes = req.Dislikes
+	personalityAndPreference.StressHandling = req.StressHandling
+	personalityAndPreference.AngerTriggers = req.AngerTriggers
+	personalityAndPreference.FavoriteFoodAndDrinks = req.FavoriteFoodAndDrinks
+	personalityAndPreference.CanCook = req.CanCook
+	personalityAndPreference.TypesOfDishesCooked = req.TypesOfDishesCooked
+	personalityAndPreference.MonthlyExpenses = req.MonthlyExpenses
+
+	res, err := s.cvRepository.SavePersonalityAndPreference(ctx, personalityAndPreference)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCV, error) {
+	res, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) CreateFamilyMember(ctx context.Context, req *models.FamilyMemberRequest) (*models.FamilyMemberCV, error) {
+	// Mapping request ke model
+	familyMember := &models.FamilyMemberCV{
+		AccountID:     req.AccountID,
+		Role:          req.Role,
+		Status:        req.Status,
+		Religion:      req.Religion,
+		Job:           req.Job,
+		LastEducation: req.LastEducation,
+		Age:           req.Age,
+	}
+
+	// Simpan ke repository
+	res, err := s.cvRepository.SaveFamilyMember(ctx, familyMember)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal menyimpan anggota keluarga")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error) {
+	list, err := s.cvRepository.ListFamilyMember(ctx, accountID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal mengambil daftar anggota keluarga")
+	}
+	return list, nil
+}
+
+func (s *cvService) GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error) {
+	res, err := s.cvRepository.GetFamilyMember(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data anggota keluarga tidak ditemukan")
+	}
+	return res, nil
+}
+
+func (s *cvService) DeleteFamilyMember(ctx context.Context, id int64) error {
+	err := s.cvRepository.DeleteFamilyMember(ctx, id)
+	if err != nil {
+		return response.HandleGormError(err, "Gagal menghapus anggota keluarga")
+	}
+	return nil
+}
+
+func (s *cvService) UpdateFamilyMember(ctx context.Context, id int64, req *models.FamilyMemberRequest) (*models.FamilyMemberCV, error) {
+	existing, err := s.cvRepository.GetFamilyMember(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data anggota keluarga tidak ditemukan")
+	}
+
+	existing.Role = req.Role
+	existing.Status = req.Status
+	existing.Religion = req.Religion
+	existing.Job = req.Job
+	existing.LastEducation = req.LastEducation
+	existing.Age = req.Age
+
+	updated, err := s.cvRepository.SaveFamilyMember(ctx, existing)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal memperbarui anggota keluarga")
+	}
+
+	return updated, nil
+}
+
+func (s *cvService) SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthRequest) (*models.PhysicalAndHealthCV, error) {
+	// Cek apakah data sudah ada berdasarkan account_id
+	existing, err := s.cvRepository.GetPhysicalAndHealthByAccountID(ctx, req.AccountID)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, response.HandleGormError(err, "Terjadi kesalahan saat mengambil data fisik dan kesehatan")
+	}
+
+	// Jika belum ada, buat objek baru
+	if existing == nil {
+		existing = &models.PhysicalAndHealthCV{}
+	}
+
+	// Mapping field dari request
+	existing.AccountID = req.AccountID
+	existing.HeightInCm = req.HeightInCm
+	existing.WeightInKg = req.WeightInKg
+	existing.BodyShape = req.BodyShape
+	existing.SkinColor = req.SkinColor
+	existing.HairType = req.HairType
+	existing.MedicalHistory = req.MedicalHistory
+	existing.PhysicalDisorder = req.PhysicalDisorder
+	existing.PhysicalTraits = req.PhysicalTraits
+
+	// Simpan data
+	res, err := s.cvRepository.SavePhysicalAndHealth(ctx, existing)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal menyimpan data fisik dan kesehatan")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) GetPhysicalAndHealth(ctx context.Context, id int64) (*models.PhysicalAndHealthCV, error) {
+	res, err := s.cvRepository.GetPhysicalAndHealthByAccountID(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data fisik dan kesehatan tidak ditemukan")
+	}
+	return res, nil
+}
+
+func (s *cvService) SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingRequest) (*models.WorshipAndReligiousUnderstandingCV, error) {
+	// Cek apakah data sudah ada berdasarkan account_id
+	worshipAndReligiousUnderstanding, err := s.cvRepository.GetWorshipAndReligiousUnderstandingByAccountID(ctx, req.AccountID)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, response.HandleGormError(err, "Terjadi kesalahan saat mengambil data agama dan pemahaman agama")
+	}
+
+	// Jika belum ada, buat objek baru
+	if worshipAndReligiousUnderstanding == nil {
+		worshipAndReligiousUnderstanding = &models.WorshipAndReligiousUnderstandingCV{}
+	}
+
+	// Mapping field dari request
+	worshipAndReligiousUnderstanding.AccountID = req.AccountID
+	worshipAndReligiousUnderstanding.ObligatoryPrayer = req.ObligatoryPrayer
+	worshipAndReligiousUnderstanding.CongregationalPrayer = req.CongregationalPrayer
+	worshipAndReligiousUnderstanding.TahajjudPrayer = req.TahajjudPrayer
+	worshipAndReligiousUnderstanding.DhuhaPrayer = req.DhuhaPrayer
+	worshipAndReligiousUnderstanding.QuranMemorization = req.QuranMemorization
+	worshipAndReligiousUnderstanding.QuranReadingAbility = req.QuranReadingAbility
+	worshipAndReligiousUnderstanding.DaudFasting = req.DaudFasting
+	worshipAndReligiousUnderstanding.AyyamulBidhFasting = req.AyyamulBidhFasting
+	worshipAndReligiousUnderstanding.HajjOrUmrah = req.HajjOrUmrah
+	worshipAndReligiousUnderstanding.ListeningToMusic = req.ListeningToMusic
+	worshipAndReligiousUnderstanding.OpinionOnIkhtilat = req.OpinionOnIkhtilat
+	worshipAndReligiousUnderstanding.OpinionOnTouchingNonMahram = req.OpinionOnTouchingNonMahram
+	worshipAndReligiousUnderstanding.OpinionOnVeil = req.OpinionOnVeil
+	worshipAndReligiousUnderstanding.WeeklyReligiousStudies = req.WeeklyReligiousStudies
+	worshipAndReligiousUnderstanding.FollowedUstadz = req.FollowedUstadz
+
+	// Simpan data
+	res, err := s.cvRepository.SaveWorshipAndReligiousUnderstanding(ctx, worshipAndReligiousUnderstanding)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) GetWorshipAndReligiousUnderstanding(ctx context.Context, id int64) (*models.WorshipAndReligiousUnderstandingCV, error) {
+	res, err := s.cvRepository.GetWorshipAndReligiousUnderstandingByAccountID(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data agama dan pemahaman agama tidak ditemukan")
+	}
+	return res, nil
 }

services/external_authentication_service.go

@@ -1,81 +1,81 @@
-package services
-
-import (
-	"context"
-	"errors"
-
-	"api.qobiltu.id/models"
-	"api.qobiltu.id/repositories"
-	uuid "github.com/satori/go.uuid"
-	"google.golang.org/api/idtoken"
-)
-
-type GoogleAuthService struct {
-	Service[models.ExternalAuth, models.AuthenticatedUser]
-}
-
-func (s *GoogleAuthService) Authenticate(isAgree bool) {
-	GoogleAuth := repositories.GetExternalAccountByOauthId(s.Constructor.OauthID)
-	payload, errGoogleAuth := idtoken.Validate(context.Background(), s.Constructor.OauthID, "")
-	s.Error = errGoogleAuth
-	if errGoogleAuth != nil {
-		s.Exception.Unauthorized = true
-		s.Exception.Message = "Oauth Provider Failed Login (Google Authentication)"
-		return
-	}
-	email := payload.Claims["email"]
-	checkRegisteredEmail := repositories.GetAccountbyEmail(email.(string))
-	if !checkRegisteredEmail.NoRecord {
-		token, _ := GenerateToken(&checkRegisteredEmail.Result)
-		checkRegisteredEmail.Result.Password = "SECRET"
-		s.Result = models.AuthenticatedUser{
-			Account: checkRegisteredEmail.Result,
-			Token:   token,
-		}
-		return
-	}
-	if GoogleAuth.NoRecord {
-		if !isAgree {
-			s.Exception.BadRequest = true
-			s.Exception.Message = "Please agree to the terms and conditions to create an account"
-			return
-		}
-		s.Constructor.UUID = uuid.NewV4()
-		s.Constructor.OauthProvider = "Google"
-
-		createAccount := repositories.CreateAccount(models.Account{
-			UUID:            uuid.NewV4(),
-			Email:           email.(string),
-			IsEmailVerified: true,
-		})
-
-		s.Constructor.AccountID = createAccount.Result.Id
-		createGoogleAuth := repositories.CreateExternalAuth(s.Constructor)
-
-		GoogleAuth.Result.AccountID = createGoogleAuth.Result.AccountID
-		userProfile := UserProfileService{}
-		userProfile.Constructor.AccountID = GoogleAuth.Result.AccountID
-		userProfile.Create()
-		if userProfile.Error != nil {
-			s.Error = userProfile.Error
-			return
-		}
-		s.Error = createGoogleAuth.RowsError
-		s.Error = errors.Join(s.Error, createAccount.RowsError)
-	}
-
-	accountData := repositories.GetAccountById(GoogleAuth.Result.AccountID)
-	token, err_tok := GenerateToken(&accountData.Result)
-
-	if err_tok != nil {
-		s.Error = errors.Join(s.Error, err_tok)
-	}
-
-	accountData.Result.Password = "SECRET"
-	s.Result = models.AuthenticatedUser{
-		Account: accountData.Result,
-		Token:   token,
-	}
-	s.Error = accountData.RowsError
-
-}
+package services
+
+import (
+	"context"
+	"errors"
+
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+	uuid "github.com/satori/go.uuid"
+	"google.golang.org/api/idtoken"
+)
+
+type GoogleAuthService struct {
+	Service[models.ExternalAuth, models.AuthenticatedUser]
+}
+
+func (s *GoogleAuthService) Authenticate(isAgree bool) {
+	GoogleAuth := repositories.GetExternalAccountByOauthId(s.Constructor.OauthID)
+	payload, errGoogleAuth := idtoken.Validate(context.Background(), s.Constructor.OauthID, "")
+	s.Error = errGoogleAuth
+	if errGoogleAuth != nil {
+		s.Exception.Unauthorized = true
+		s.Exception.Message = "Oauth Provider Failed Login (Google Authentication)"
+		return
+	}
+	email := payload.Claims["email"]
+	checkRegisteredEmail := repositories.GetAccountbyEmail(email.(string))
+	if !checkRegisteredEmail.NoRecord {
+		token, _ := GenerateToken(&checkRegisteredEmail.Result)
+		checkRegisteredEmail.Result.Password = "SECRET"
+		s.Result = models.AuthenticatedUser{
+			Account: checkRegisteredEmail.Result,
+			Token:   token,
+		}
+		return
+	}
+	if GoogleAuth.NoRecord {
+		if !isAgree {
+			s.Exception.BadRequest = true
+			s.Exception.Message = "Please agree to the terms and conditions to create an account"
+			return
+		}
+		s.Constructor.UUID = uuid.NewV4()
+		s.Constructor.OauthProvider = "Google"
+
+		createAccount := repositories.CreateAccount(models.Account{
+			UUID:            uuid.NewV4(),
+			Email:           email.(string),
+			IsEmailVerified: true,
+		})
+
+		s.Constructor.AccountID = createAccount.Result.Id
+		createGoogleAuth := repositories.CreateExternalAuth(s.Constructor)
+
+		GoogleAuth.Result.AccountID = createGoogleAuth.Result.AccountID
+		userProfile := UserProfileService{}
+		userProfile.Constructor.AccountID = GoogleAuth.Result.AccountID
+		userProfile.Create()
+		if userProfile.Error != nil {
+			s.Error = userProfile.Error
+			return
+		}
+		s.Error = createGoogleAuth.RowsError
+		s.Error = errors.Join(s.Error, createAccount.RowsError)
+	}
+
+	accountData := repositories.GetAccountById(GoogleAuth.Result.AccountID)
+	token, err_tok := GenerateToken(&accountData.Result)
+
+	if err_tok != nil {
+		s.Error = errors.Join(s.Error, err_tok)
+	}
+
+	accountData.Result.Password = "SECRET"
+	s.Result = models.AuthenticatedUser{
+		Account: accountData.Result,
+		Token:   token,
+	}
+	s.Error = accountData.RowsError
+
+}

services/user_profile_service.go

@@ -53,12 +53,12 @@ func (s *UserProfileService) Create() {
 		return
 	}
 	s.Result = models.UserProfileResponse{
-		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
+		Account: repositories.GetAccountById(uint(s.Constructor.AccountID)).Result,
 		Details: userProfile.Result,
 	}
 }
 func (s *UserProfileService) Retrieve() {
-	userProfile := repositories.GetDetailAccountById(s.Constructor.AccountID)
+	userProfile := repositories.GetDetailAccountById(uint(s.Constructor.AccountID))
 	s.Error = userProfile.RowsError
 	if userProfile.NoRecord {
 		s.Exception.DataNotFound = true
@@ -66,7 +66,7 @@ func (s *UserProfileService) Retrieve() {
 		return
 	}
 	s.Result = models.UserProfileResponse{
-		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
+		Account: repositories.GetAccountById(uint(s.Constructor.AccountID)).Result,
 		Details: userProfile.Result,
 	}
 	s.Result.Account.Password = "SECRET"
@@ -96,7 +96,7 @@ func (s *UserProfileService) Update() {
 		s.Exception.Message = "There is no account with given credentials!"
 		return
 	}
-	account := repositories.GetAccountById(s.Constructor.AccountID)
+	account := repositories.GetAccountById(uint(s.Constructor.AccountID))
 	account.Result.IsDetailCompleted = (userProfile.Result.InitialName != "" &&
 		userProfile.Result.FullName != nil &&
 		userProfile.Result.DateOfBirth != nil &&

space/config/database_connection_config.go

@@ -70,6 +70,10 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.Question{},
 		&models.Answer{},
 		&models.UserAnswer{},
+		&models.PersonalityAndPreferenceCV{},
+		&models.FamilyMemberCV{},
+		&models.PhysicalAndHealthCV{},
+		&models.WorshipAndReligiousUnderstandingCV{},
 	)
 
 	if err != nil {

space/controller/cv/cv_controller.go

@@ -0,0 +1,267 @@
+package cv_controller
+
+import (
+	"api.qobiltu.id/middleware"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/response"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+)
+
+type CVController interface {
+	SaveAccountDetails(ctx *gin.Context)
+	GetAccountDetails(ctx *gin.Context)
+
+	SavePersonalityAndPreference(ctx *gin.Context)
+	GetPersonalityAndPreference(ctx *gin.Context)
+
+	CreateFamilyMember(ctx *gin.Context)
+	UpdateFamilyMember(ctx *gin.Context)
+	ListFamilyMember(ctx *gin.Context)
+	GetFamilyMember(ctx *gin.Context)
+	DeleteFamilyMember(ctx *gin.Context)
+
+	SavePhysicalAndHealth(ctx *gin.Context)
+	GetPhysicalAndHealth(ctx *gin.Context)
+
+	SaveWorshipAndReligiousUnderstanding(ctx *gin.Context)
+	GetWorshipAndReligiousUnderstanding(ctx *gin.Context)
+}
+
+type cvController struct {
+	cvService services.CVService
+}
+
+func NewCVController(cvService services.CVService) CVController {
+	return &cvController{
+		cvService: cvService,
+	}
+}
+
+// --- Account Details ---
+func (c *cvController) SaveAccountDetails(ctx *gin.Context) {
+	var req models.AccountDetailsRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SaveAccountDetails(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Account details saved", res, nil)
+}
+
+func (c *cvController) GetAccountDetails(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetAccountDetails(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get account details success", res, nil)
+}
+
+// --- Personality & Preference ---
+
+func (c *cvController) SavePersonalityAndPreference(ctx *gin.Context) {
+	var req models.PersonalityAndPreferenceCVRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SavePersonalityAndPreference(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Personality and Preference saved", res, nil)
+}
+
+func (c *cvController) GetPersonalityAndPreference(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetPersonalityAndPreference(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get Personality and Preference success", res, nil)
+}
+
+// --- Family Member ---
+
+func (c *cvController) CreateFamilyMember(ctx *gin.Context) {
+	var req models.FamilyMemberRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.CreateFamilyMember(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member saved", res, nil)
+}
+
+func (c *cvController) UpdateFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	var req models.FamilyMemberRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.UpdateFamilyMember(ctx, id, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member updated", res, nil)
+}
+
+func (c *cvController) ListFamilyMember(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	list, err := c.cvService.ListFamilyMember(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "List family members", list, nil)
+}
+
+func (c *cvController) GetFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.GetFamilyMember(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get family member success", res, nil)
+}
+
+func (c *cvController) DeleteFamilyMember(ctx *gin.Context) {
+	idStr := ctx.Param("id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	err = c.cvService.DeleteFamilyMember(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Family member deleted", nil, nil)
+}
+
+// --- Physical and Health ---
+
+func (c *cvController) SavePhysicalAndHealth(ctx *gin.Context) {
+	var req models.PhysicalAndHealthRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SavePhysicalAndHealth(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Physical and health saved", res, nil)
+}
+
+func (c *cvController) GetPhysicalAndHealth(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetPhysicalAndHealth(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get physical and health success", res, nil)
+}
+
+// --- Worship and Religious Understanding ---
+
+func (c *cvController) SaveWorshipAndReligiousUnderstanding(ctx *gin.Context) {
+	var req models.WorshipAndReligiousUnderstandingRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.cvService.SaveWorshipAndReligiousUnderstanding(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Worship and religious understanding saved", res, nil)
+}
+
+func (c *cvController) GetWorshipAndReligiousUnderstanding(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.GetWorshipAndReligiousUnderstanding(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get worship and religious understanding success", res, nil)
+}

space/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"api.qobiltu.id/config"
+	cv_controller "api.qobiltu.id/controller/cv"
 	"api.qobiltu.id/controller/health_check"
 	"api.qobiltu.id/mail"
 	"api.qobiltu.id/repositories"
@@ -46,13 +47,20 @@ func main() {
 	healthCheckService := services.NewHealthCheckService(healthCheckRepository)
 	healthCheckController := health_check_controller.NewHealthCheckController(healthCheckService)
 
+	cvRepository := repositories.NewCVRepository(config.DB)
+	cvService := services.NewCVService(cvRepository)
+	cvController := cv_controller.NewCVController(cvService)
+
 	// start task processor
 	err = taskProcessor.Start()
 	utils.FatalIfErr("failed to start task processor", err)
 	slog.Info("Task processor started")
 
 	// create server
-	s, err := router.NewServer(healthCheckController)
+	s, err := router.NewServer(
+		healthCheckController,
+		cvController,
+	)
 	utils.FatalIfErr("failed to create server", err)
 
 	// run server

space/middleware/authentication_middleware.go

@@ -33,5 +33,12 @@ func AuthUser(c *gin.Context) {
 		c.Abort()
 		return
 	}
+}
 
+func GetAccountData(c *gin.Context) models.AccountData {
+	cParam, _ := c.Get("accountData")
+	if cParam != nil {
+		return cParam.(models.AccountData)
+	}
+	return models.AccountData{}
 }

space/models/database_orm_model.go

@@ -18,19 +18,21 @@ type Account struct {
 }
 
 type AccountDetails struct {
-	ID            uint64     `gorm:"primaryKey" json:"id"`
-	AccountID     uint       `json:"account_id"`
-	InitialName   string     `json:"initial_name"`
-	FullName      *string    `json:"full_name"`
-	DateOfBirth   *time.Time `json:"date_of_birth"`
-	PlaceOfBirth  *string    `json:"place_of_birth"`
-	Domicile      *string    `json:"domicile"`
-	LastJob       *string    `json:"last_job"`
-	Gender        *string    `json:"gender"`
-	LastEducation *string    `json:"last_education"`
-	MaritalStatus *string    `json:"marital_status"`
-	Avatar        *string    `json:"avatar"`
-	PhoneNumber   *string    `json:"phone_number"`
+	ID            uint64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+	AccountID     uint       `gorm:"column:account_id;not null;unique" json:"account_id"`
+	InitialName   string     `gorm:"column:initial_name;not null" json:"initial_name"`
+	FullName      *string    `gorm:"column:full_name" json:"full_name"`
+	DateOfBirth   *time.Time `gorm:"column:date_of_birth" json:"date_of_birth"`
+	PlaceOfBirth  *string    `gorm:"column:place_of_birth" json:"place_of_birth"`
+	Domicile      *string    `gorm:"column:domicile" json:"domicile"`
+	LastJob       *string    `gorm:"column:last_job" json:"last_job"`
+	Gender        *string    `gorm:"column:gender" json:"gender"`
+	LastEducation *string    `gorm:"column:last_education" json:"last_education"`
+	MaritalStatus *string    `gorm:"column:marital_status" json:"marital_status"`
+	Avatar        *string    `gorm:"column:avatar" json:"avatar"`
+	PhoneNumber   *string    `gorm:"column:phone_number" json:"phone_number"`
+	CreatedAt     time.Time  `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+	UpdatedAt     time.Time  `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 }
 
 type EmailVerification struct {
@@ -184,24 +186,107 @@ type QuizResult struct {
 	AverageScore   float64 `gorm:"column:average_score" json:"average_score"`
 }
 
+type (
+	PersonalityAndPreferenceCV struct {
+		ID                    int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID             int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account               *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		PositiveTraits        *string   `gorm:"column:positive_traits" json:"positive_traits"`                   // sifat positif
+		NegativeTraits        *string   `gorm:"column:negative_traits" json:"negative_traits"`                   // sifat negatif
+		Hobbies               *string   `gorm:"column:hobbies" json:"hobbies"`                                   // hobi
+		LifeGoals             *string   `gorm:"column:life_goals" json:"life_goals"`                             // target hidup
+		DailyActivities       *string   `gorm:"column:daily_activities" json:"daily_activities"`                 // kegiatan sehari-hari
+		LeisureActivities     *string   `gorm:"column:leisure_activities" json:"leisure_activities"`             // kegiatan waktu luang
+		Likes                 *string   `gorm:"column:likes" json:"likes"`                                       // hal yang disukai
+		Dislikes              *string   `gorm:"column:dislikes" json:"dislikes"`                                 // hal yang tidak disukai
+		StressHandling        *string   `gorm:"column:stress_handling" json:"stress_handling"`                   // cara mengatasi stres
+		AngerTriggers         *string   `gorm:"column:anger_triggers" json:"anger_triggers"`                     // pemicu amarah
+		FavoriteFoodAndDrinks *string   `gorm:"column:favorite_food_and_drinks" json:"favorite_food_and_drinks"` // makanan dan minuman favorit
+		CanCook               *bool     `gorm:"column:can_cook" json:"can_cook"`                                 // bisa memasak
+		TypesOfDishesCooked   *string   `gorm:"column:types_of_dishes_cooked" json:"types_of_dishes_cooked"`     // jenis masakan yang bisa dimasak
+		MonthlyExpenses       *string   `gorm:"column:monthly_expenses" json:"monthly_expenses"`                 // pengeluaran per bulan
+		CreatedAt             time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt             time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	FamilyMemberCV struct {
+		ID            int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID     int64     `gorm:"column:account_id;not null" json:"account_id"`
+		Account       *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		Role          *string   `gorm:"column:role" json:"role"`                     // Peran dalam keluarga
+		Status        *string   `gorm:"column:status" json:"status"`                 // Status (Hidup, Wafat)
+		Religion      *string   `gorm:"column:religion" json:"religion"`             // Agama
+		Job           *string   `gorm:"column:job" json:"job"`                       // Pekerjaan
+		LastEducation *string   `gorm:"column:last_education" json:"last_education"` // Pendidikan terakhir
+		Age           *int      `gorm:"column:age" json:"age"`                       // Usia
+		CreatedAt     time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt     time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	PhysicalAndHealthCV struct {
+		ID               int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID        int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account          *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		HeightInCm       *int      `gorm:"column:height_cm" json:"height_cm"`                  // Tinggi badan dalam satuan sentimeter
+		WeightInKg       *int      `gorm:"column:weight_kg" json:"weight_kg"`                  // Berat badan dalam satuan kilogram
+		BodyShape        *string   `gorm:"column:body_shape" json:"body_shape"`                // Bentuk tubuh
+		SkinColor        *string   `gorm:"column:skin_color" json:"skin_color"`                // Warna kulit
+		HairType         *string   `gorm:"column:hair_type" json:"hair_type"`                  // Tipe rambut
+		MedicalHistory   *string   `gorm:"column:medical_history" json:"medical_history"`      // Riwayat penyakit
+		PhysicalDisorder *string   `gorm:"column:physical_disorder" json:"physical_disorder"`  // Cacat fisik
+		PhysicalTraits   *string   `gorm:"column:physical_traits" json:"physical_traits"`      // Ciri khas fisik
+		CreatedAt        time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"` // Waktu data dibuat
+		UpdatedAt        time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"` // Waktu data terakhir diperbarui
+	}
+
+	WorshipAndReligiousUnderstandingCV struct {
+		ID                         int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AccountID                  int64     `gorm:"column:account_id;not null;unique" json:"account_id"`
+		Account                    *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		ObligatoryPrayer           *string   `gorm:"column:obligatory_prayer" json:"obligatory_prayer"`                           // sholat_wajib_5_waktu
+		CongregationalPrayer       *string   `gorm:"column:congregational_prayer" json:"congregational_prayer"`                   // sholat_berjamaah_di_masjid
+		TahajjudPrayer             *string   `gorm:"column:tahajjud_prayer" json:"tahajjud_prayer"`                               // sholat_tahajud
+		DhuhaPrayer                *string   `gorm:"column:dhuha_prayer" json:"dhuha_prayer"`                                     // sholat_dhuha
+		QuranMemorization          *string   `gorm:"column:quran_memorization" json:"quran_memorization"`                         // hafalan_alquran
+		QuranReadingAbility        *string   `gorm:"column:quran_reading_ability" json:"quran_reading_ability"`                   // kemampuan_baca_alquran
+		DaudFasting                *string   `gorm:"column:daud_fasting" json:"daud_fasting"`                                     // puasa_daud
+		AyyamulBidhFasting         *string   `gorm:"column:ayyamul_bidh_fasting" json:"ayyamul_bidh_fasting"`                     // puasa_ayyamul_bidh
+		HajjOrUmrah                *string   `gorm:"column:hajj_or_umrah" json:"hajj_or_umrah"`                                   // ibadah_haji_umroh
+		ListeningToMusic           *string   `gorm:"column:listening_to_music" json:"listening_to_music"`                         // mendengarkan_musik
+		OpinionOnIkhtilat          *string   `gorm:"column:opinion_on_ikhtilat" json:"opinion_on_ikhtilat"`                       // pendapat_ikhtilat
+		OpinionOnTouchingNonMahram *string   `gorm:"column:opinion_on_touching_non_mahram" json:"opinion_on_touching_non_mahram"` // pendapat_menyentuh_non_mahram
+		OpinionOnVeil              *string   `gorm:"column:opinion_on_veil" json:"opinion_on_veil"`                               // pendapat_tentang_cadar
+		WeeklyReligiousStudies     *string   `gorm:"column:weekly_religious_studies" json:"weekly_religious_studies"`             // kajian_yang_diikuti_dalam_sepekan
+		FollowedUstadz             *string   `gorm:"column:followed_ustadz" json:"followed_ustadz"`                               // ustadz_yang_diikuti
+		CreatedAt                  time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt                  time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+)
+
 // Gorm table name settings
-func (Account) TableName() string                 { return "account" }
-func (AccountDetails) TableName() string          { return "account_details" }
-func (EmailVerification) TableName() string       { return "email_verifications" }
-func (ExternalAuth) TableName() string            { return "extern_auth" }
-func (FCM) TableName() string                     { return "fcm" }
-func (ForgotPassword) TableName() string          { return "forgot_password" }
-func (Academy) TableName() string                 { return "academy" }
-func (AcademyMaterial) TableName() string         { return "academy_materials" }
-func (AcademyContent) TableName() string          { return "academy_contents" }
-func (AcademyMaterialProgress) TableName() string { return "academy_materials_progress" }
-func (AcademyContentProgress) TableName() string  { return "academy_contents_progress" }
-func (RegionProvince) TableName() string          { return "region_provinces" }
-func (RegionCity) TableName() string              { return "region_cities" }
-func (Answer) TableName() string                  { return "answers" }
-func (Question) TableName() string                { return "questions" }
-func (Quiz) TableName() string                    { return "quizzes" }
-func (QuizAttempt) TableName() string             { return "quiz_attempts" }
-func (UserAnswer) TableName() string              { return "user_answers" }
-func (OptionCategory) TableName() string          { return "option_categories" }
-func (OptionValues) TableName() string            { return "option_values" }
+func (Account) TableName() string                    { return "account" }
+func (AccountDetails) TableName() string             { return "account_details" }
+func (EmailVerification) TableName() string          { return "email_verifications" }
+func (ExternalAuth) TableName() string               { return "extern_auth" }
+func (FCM) TableName() string                        { return "fcm" }
+func (ForgotPassword) TableName() string             { return "forgot_password" }
+func (Academy) TableName() string                    { return "academy" }
+func (AcademyMaterial) TableName() string            { return "academy_materials" }
+func (AcademyContent) TableName() string             { return "academy_contents" }
+func (AcademyMaterialProgress) TableName() string    { return "academy_materials_progress" }
+func (AcademyContentProgress) TableName() string     { return "academy_contents_progress" }
+func (RegionProvince) TableName() string             { return "region_provinces" }
+func (RegionCity) TableName() string                 { return "region_cities" }
+func (Answer) TableName() string                     { return "answers" }
+func (Question) TableName() string                   { return "questions" }
+func (Quiz) TableName() string                       { return "quizzes" }
+func (QuizAttempt) TableName() string                { return "quiz_attempts" }
+func (UserAnswer) TableName() string                 { return "user_answers" }
+func (OptionCategory) TableName() string             { return "option_categories" }
+func (OptionValues) TableName() string               { return "option_values" }
+func (PersonalityAndPreferenceCV) TableName() string { return "personality_and_preference_cv" }
+func (FamilyMemberCV) TableName() string             { return "family_member_cv" }
+func (PhysicalAndHealthCV) TableName() string        { return "physical_and_health_cv" }
+func (WorshipAndReligiousUnderstandingCV) TableName() string {
+	return "worship_and_religious_understanding_cv"
+}

space/models/request_model.go

@@ -1,51 +1,126 @@
-package models
-
-type LoginRequest struct {
-	Email    string `json:"email" binding:"required"`
-	Password string `json:"password" binding:"required"`
-}
-
-type RegisterRequest struct {
-	Name     string `json:"name"`
-	Email    string `json:"email" binding:"required,email"`
-	Phone    int    `json:"phone"`
-	Password string `json:"password" binding:"required"`
-}
-
-type ChangePasswordRequest struct {
-	OldPassword string `json:"old_password" binding:"required" `
-	NewPassword string `json:"new_password" binding:"required" `
-}
-
-type CreateVerifyEmailRequest struct {
-	Token uint `json:"token" binding:"required"`
-}
-
-type OptionsRequest struct {
-	OptionName  string   `json:"option_name" binding:"required"`
-	OptionValue []string `json:"option_values" binding:"required"`
-}
-
-type ExternalAuthRequest struct {
-	OauthID         string `json:"oauth_id" binding:"required"`
-	OauthProvider   string `json:"oauth_provider" binding:"required"`
-	IsAgreeTerms    bool   `json:"is_agree_terms"`
-	IsSexualDisease bool   `json:"is_sexual_disease"`
-}
-
-type ForgotPasswordRequest struct {
-	Email string `json:"email" binding:"required,email"`
-}
-type ValidateForgotPasswordRequest struct {
-	Token       uint   `json:"token" binding:"required"`
-	NewPassword string `json:"new_password"`
-}
-
-type QuestionQuizRequest struct {
-	QuestionNo int `json:"question_no" binding:"required"`
-}
-
-type AnswerQuizRequest struct {
-	QuestionNo int `json:"question_no" binding:"required"`
-	Answer     int `json:"answer" binding:"required"`
-}
+package models
+
+import "time"
+
+type LoginRequest struct {
+	Email    string `json:"email" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+type RegisterRequest struct {
+	Name     string `json:"name"`
+	Email    string `json:"email" binding:"required,email"`
+	Phone    int    `json:"phone"`
+	Password string `json:"password" binding:"required"`
+}
+
+type ChangePasswordRequest struct {
+	OldPassword string `json:"old_password" binding:"required" `
+	NewPassword string `json:"new_password" binding:"required" `
+}
+
+type CreateVerifyEmailRequest struct {
+	Token uint `json:"token" binding:"required"`
+}
+
+type OptionsRequest struct {
+	OptionName  string   `json:"option_name" binding:"required"`
+	OptionValue []string `json:"option_values" binding:"required"`
+}
+
+type ExternalAuthRequest struct {
+	OauthID         string `json:"oauth_id" binding:"required"`
+	OauthProvider   string `json:"oauth_provider" binding:"required"`
+	IsAgreeTerms    bool   `json:"is_agree_terms"`
+	IsSexualDisease bool   `json:"is_sexual_disease"`
+}
+
+type ForgotPasswordRequest struct {
+	Email string `json:"email" binding:"required,email"`
+}
+type ValidateForgotPasswordRequest struct {
+	Token       uint   `json:"token" binding:"required"`
+	NewPassword string `json:"new_password"`
+}
+
+type QuestionQuizRequest struct {
+	QuestionNo int `json:"question_no" binding:"required"`
+}
+
+type AnswerQuizRequest struct {
+	QuestionNo int `json:"question_no" binding:"required"`
+	Answer     int `json:"answer" binding:"required"`
+}
+
+type (
+	PersonalityAndPreferenceCVRequest struct {
+		AccountID             int64   `json:"-"`
+		PositiveTraits        *string `json:"positive_traits"`          // sifat positif
+		NegativeTraits        *string `json:"negative_traits"`          // sifat negatif
+		Hobbies               *string `json:"hobbies"`                  // hobi
+		LifeGoals             *string `json:"life_goals"`               // target hidup
+		DailyActivities       *string `json:"daily_activities"`         // kegiatan sehari-hari
+		LeisureActivities     *string `json:"leisure_activities"`       // kegiatan waktu luang
+		Likes                 *string `json:"likes"`                    // hal yang disukai
+		Dislikes              *string `json:"dislikes"`                 // hal yang tidak disukai
+		StressHandling        *string `json:"stress_handling"`          // cara mengatasi stres
+		AngerTriggers         *string `json:"anger_triggers"`           // pemicu amarah
+		FavoriteFoodAndDrinks *string `json:"favorite_food_and_drinks"` // makanan dan minuman favorit
+		CanCook               *bool   `json:"can_cook"`                 // bisa memasak
+		TypesOfDishesCooked   *string `json:"types_of_dishes_cooked"`   // jenis masakan yang bisa dimasak
+		MonthlyExpenses       *string `json:"monthly_expenses"`         // pengeluaran per bulan
+	}
+
+	FamilyMemberRequest struct {
+		AccountID     int64   `json:"-"`
+		Role          *string `json:"role"`           // Peran dalam keluarga
+		Status        *string `json:"status"`         // Status (Hidup, Wafat)
+		Religion      *string `json:"religion"`       // Agama
+		Job           *string `json:"job"`            // Pekerjaan
+		LastEducation *string `json:"last_education"` // Pendidikan terakhir
+		Age           *int    `json:"age"`            // Usia
+	}
+
+	PhysicalAndHealthRequest struct {
+		AccountID        int64   `json:"-"`
+		HeightInCm       *int    `json:"height_cm"`         // Tinggi badan dalam satuan sentimeter
+		WeightInKg       *int    `json:"weight_kg"`         // Berat badan dalam satuan kilogram
+		BodyShape        *string `json:"body_shape"`        // Bentuk tubuh
+		SkinColor        *string `json:"skin_color"`        // Warna kulit
+		HairType         *string `json:"hair_type"`         // Tipe rambut
+		MedicalHistory   *string `json:"medical_history"`   // Riwayat penyakit
+		PhysicalDisorder *string `json:"physical_disorder"` // Cacat fisik
+		PhysicalTraits   *string `json:"physical_traits"`   // Ciri khas fisik
+	}
+
+	AccountDetailsRequest struct {
+		AccountID     int64      `json:"-"`
+		FullName      *string    `json:"full_name"`
+		Gender        *string    `json:"gender"`
+		DateOfBirth   *time.Time `json:"date_of_birth"`
+		PlaceOfBirth  *string    `json:"place_of_birth"`
+		Domicile      *string    `json:"domicile"`
+		MaritalStatus *string    `json:"marital_status"`
+		LastEducation *string    `json:"last_education"`
+		LastJob       *string    `json:"last_job"`
+	}
+
+	WorshipAndReligiousUnderstandingRequest struct {
+		AccountID                  int64   `json:"-"`
+		ObligatoryPrayer           *string `json:"obligatory_prayer"`              // sholat_wajib_5_waktu
+		CongregationalPrayer       *string `json:"congregational_prayer"`          // sholat_berjamaah_di_masjid
+		TahajjudPrayer             *string `json:"tahajjud_prayer"`                // sholat_tahajud
+		DhuhaPrayer                *string `json:"dhuha_prayer"`                   // sholat_dhuha
+		QuranMemorization          *string `json:"quran_memorization"`             // hafalan_alquran
+		QuranReadingAbility        *string `json:"quran_reading_ability"`          // kemampuan_baca_alquran
+		DaudFasting                *string `json:"daud_fasting"`                   // puasa_daud
+		AyyamulBidhFasting         *string `json:"ayyamul_bidh_fasting"`           // puasa_ayyamul_bidh
+		HajjOrUmrah                *string `json:"hajj_or_umrah"`                  // ibadah_haji_umroh
+		ListeningToMusic           *string `json:"listening_to_music"`             // mendengarkan_musik
+		OpinionOnIkhtilat          *string `json:"opinion_on_ikhtilat"`            // pendapat_ikhtilat
+		OpinionOnTouchingNonMahram *string `json:"opinion_on_touching_non_mahram"` // pendapat_menyentuh_non_mahram
+		OpinionOnVeil              *string `json:"opinion_on_veil"`                // pendapat_tentang_cadar
+		WeeklyReligiousStudies     *string `json:"weekly_religious_studies"`       // kajian_yang_diikuti_dalam_sepekan
+		FollowedUstadz             *string `json:"followed_ustadz"`                // ustadz_yang_diikuti
+	}
+)

space/repositories/cv_repository.go

@@ -0,0 +1,126 @@
+package repositories
+
+import (
+    "api.qobiltu.id/models"
+    "context"
+    "gorm.io/gorm"
+)
+
+type CVRepository interface {
+    SaveAccountDetails(ctx context.Context, req *models.AccountDetails) (*models.AccountDetails, error)
+    GetAccountDetailsByAccountID(ctx context.Context, accountID int64) (*models.AccountDetails, error)
+
+    SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCV) (*models.PersonalityAndPreferenceCV, error)
+    GetPersonalityAndPreferenceByAccountID(ctx context.Context, accountID int64) (*models.PersonalityAndPreferenceCV, error)
+
+    SaveFamilyMember(ctx context.Context, req *models.FamilyMemberCV) (*models.FamilyMemberCV, error)
+    ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error)
+    GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error)
+    DeleteFamilyMember(ctx context.Context, id int64) error
+
+    SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthCV) (*models.PhysicalAndHealthCV, error)
+    GetPhysicalAndHealthByAccountID(ctx context.Context, accountID int64) (*models.PhysicalAndHealthCV, error)
+
+    SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingCV) (*models.WorshipAndReligiousUnderstandingCV, error)
+    GetWorshipAndReligiousUnderstandingByAccountID(ctx context.Context, accountID int64) (*models.WorshipAndReligiousUnderstandingCV, error)
+}
+
+type cvRepository struct {
+    db *gorm.DB
+}
+
+func NewCVRepository(db *gorm.DB) CVRepository {
+    return &cvRepository{
+        db: db,
+    }
+}
+
+func (r *cvRepository) SaveAccountDetails(ctx context.Context, req *models.AccountDetails) (*models.AccountDetails, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetAccountDetailsByAccountID(ctx context.Context, accountID int64) (*models.AccountDetails, error) {
+    var accountDetails models.AccountDetails
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&accountDetails).Error; err != nil {
+        return nil, err
+    }
+    return &accountDetails, nil
+}
+
+func (r *cvRepository) SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCV) (*models.PersonalityAndPreferenceCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetPersonalityAndPreferenceByAccountID(ctx context.Context, accountID int64) (*models.PersonalityAndPreferenceCV, error) {
+    var personalityAndPreference models.PersonalityAndPreferenceCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&personalityAndPreference).Error; err != nil {
+        return nil, err
+    }
+    return &personalityAndPreference, nil
+}
+
+func (r *cvRepository) SaveFamilyMember(ctx context.Context, req *models.FamilyMemberCV) (*models.FamilyMemberCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetFamilyMember(ctx context.Context, id int64) (*models.FamilyMemberCV, error) {
+    var familyMember models.FamilyMemberCV
+    if err := r.db.WithContext(ctx).Where("id = ?", id).First(&familyMember).Error; err != nil {
+        return nil, err
+    }
+    return &familyMember, nil
+}
+
+func (r *cvRepository) DeleteFamilyMember(ctx context.Context, id int64) error {
+    if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&models.FamilyMemberCV{}).Error; err != nil {
+        return err
+    }
+    return nil
+}
+
+func (r *cvRepository) ListFamilyMember(ctx context.Context, accountID int64) ([]models.FamilyMemberCV, error) {
+    familyMembers := make([]models.FamilyMemberCV, 0)
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).Find(&familyMembers).Error; err != nil {
+        return nil, err
+    }
+    return familyMembers, nil
+}
+
+func (r *cvRepository) SavePhysicalAndHealth(ctx context.Context, req *models.PhysicalAndHealthCV) (*models.PhysicalAndHealthCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetPhysicalAndHealthByAccountID(ctx context.Context, accountID int64) (*models.PhysicalAndHealthCV, error) {
+    var physicalAndHealth models.PhysicalAndHealthCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&physicalAndHealth).Error; err != nil {
+        return nil, err
+    }
+    return &physicalAndHealth, nil
+}
+
+func (r *cvRepository) SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingCV) (*models.WorshipAndReligiousUnderstandingCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+func (r *cvRepository) GetWorshipAndReligiousUnderstandingByAccountID(ctx context.Context, accountID int64) (*models.WorshipAndReligiousUnderstandingCV, error) {
+    var worshipAndReligiousUnderstanding models.WorshipAndReligiousUnderstandingCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).First(&worshipAndReligiousUnderstanding).Error; err != nil {
+        return nil, err
+    }
+    return &worshipAndReligiousUnderstanding, nil
+}

space/router/cv_route.go

@@ -0,0 +1,26 @@
+package router
+
+import "api.qobiltu.id/middleware"
+
+func (s *Server) CVRoute() {
+	routerGroup := s.router.Group("/api/v1/cv").Use(middleware.AuthUser)
+	{
+		routerGroup.POST("/account-details", s.cvController.SaveAccountDetails)
+		routerGroup.GET("/account-details", s.cvController.GetAccountDetails)
+
+		routerGroup.POST("/personality-and-preferences", s.cvController.SavePersonalityAndPreference)
+		routerGroup.GET("/personality-and-preferences", s.cvController.GetPersonalityAndPreference)
+
+		routerGroup.POST("/family-members", s.cvController.CreateFamilyMember)
+		routerGroup.GET("/family-members", s.cvController.ListFamilyMember)
+		routerGroup.GET("/family-members/:id", s.cvController.GetFamilyMember)
+		routerGroup.PUT("/family-members/:id", s.cvController.UpdateFamilyMember)
+		routerGroup.DELETE("/family-members/:id", s.cvController.DeleteFamilyMember)
+
+		routerGroup.POST("/physical-and-healths", s.cvController.SavePhysicalAndHealth)
+		routerGroup.GET("/physical-and-healths", s.cvController.GetPhysicalAndHealth)
+
+		routerGroup.POST("/worship-and-religious-understandings", s.cvController.SaveWorshipAndReligiousUnderstanding)
+		routerGroup.GET("/worship-and-religious-understandings", s.cvController.GetWorshipAndReligiousUnderstanding)
+	}
+}

space/router/router.go

@@ -1,20 +1,21 @@
 package router
 
 import (
-    "api.qobiltu.id/controller"
+	"api.qobiltu.id/controller"
 )
 
 func (s *Server) setupRoutes() {
 
-    s.router.GET("/", controller.HomeController)
+	s.router.GET("/", controller.HomeController)
 
-    AuthRoute(s.router)
-    UserRoute(s.router)
-    EmailRoute(s.router)
-    OptionsRoute(s.router)
-    AcademyRoute(s.router)
-    QuizRoute(s.router)
+	AuthRoute(s.router)
+	UserRoute(s.router)
+	EmailRoute(s.router)
+	OptionsRoute(s.router)
+	AcademyRoute(s.router)
+	QuizRoute(s.router)
 
-    // another way to register routes
-    s.HealthCheckRoute()
+	// another way to register routes
+	s.HealthCheckRoute()
+	s.CVRoute()
 }

space/router/server.go

@@ -1,6 +1,7 @@
 package router
 
 import (
+	cv_controller "api.qobiltu.id/controller/cv"
 	"api.qobiltu.id/controller/health_check"
 	"github.com/gin-gonic/gin"
 )
@@ -8,10 +9,12 @@ import (
 type Server struct {
 	router                *gin.Engine
 	healthCheckController health_check_controller.HealthCheckController
+	cvController          cv_controller.CVController
 }
 
 func NewServer(
 	healthCheckController health_check_controller.HealthCheckController,
+	cvController cv_controller.CVController,
 ) (*Server, error) {
 
 	router := gin.Default()
@@ -19,6 +22,7 @@ func NewServer(
 
 	server := &Server{
 		healthCheckController: healthCheckController,
+		cvController:          cvController,
 		router:                router,
 	}
 

space/services/cv_service.go

@@ -0,0 +1,108 @@
+package services
+
+import (
+    "api.qobiltu.id/models"
+    "api.qobiltu.id/repositories"
+    "api.qobiltu.id/response"
+    "context"
+    "errors"
+    "gorm.io/gorm"
+)
+
+type CVService interface {
+    SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCVResponse, error)
+    GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCVResponse, error)
+}
+
+type cvService struct {
+    cvRepository repositories.CVRepository
+}
+
+func NewCVService(cvRepository repositories.CVRepository) CVService {
+    return &cvService{
+        cvRepository: cvRepository,
+    }
+}
+
+func (s *cvService) SavePersonalityAndPreference(ctx context.Context, req *models.PersonalityAndPreferenceCVRequest) (*models.PersonalityAndPreferenceCVResponse, error) {
+    // Ambil data lama jika ada
+    personalityAndPreference, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, req.AccountID)
+    if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+        return nil, response.HandleGormError(err, "Internal Server Error")
+    }
+
+    // Apply perubahan
+    if personalityAndPreference == nil {
+        personalityAndPreference = &models.PersonalityAndPreferenceCV{}
+    }
+
+    personalityAndPreference.AccountID = req.AccountID
+    personalityAndPreference.PositiveTraits = req.PositiveTraits
+    personalityAndPreference.NegativeTraits = req.NegativeTraits
+    personalityAndPreference.Hobbies = req.Hobbies
+    personalityAndPreference.LifeGoals = req.LifeGoals
+    personalityAndPreference.DailyActivities = req.DailyActivities
+    personalityAndPreference.LeisureActivities = req.LeisureActivities
+    personalityAndPreference.Likes = req.Likes
+    personalityAndPreference.Dislikes = req.Dislikes
+    personalityAndPreference.StressHandling = req.StressHandling
+    personalityAndPreference.AngerTriggers = req.AngerTriggers
+    personalityAndPreference.FavoriteFoodAndDrinks = req.FavoriteFoodAndDrinks
+    personalityAndPreference.CanCook = req.CanCook
+    personalityAndPreference.TypesOfDishesCooked = req.TypesOfDishesCooked
+    personalityAndPreference.MonthlyExpenses = req.MonthlyExpenses
+
+    res, err := s.cvRepository.SavePersonalityAndPreference(ctx, personalityAndPreference)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Internal Server Error")
+    }
+
+    return &models.PersonalityAndPreferenceCVResponse{
+        ID:                    res.ID,
+        AccountID:             res.AccountID,
+        PositiveTraits:        res.PositiveTraits,
+        NegativeTraits:        res.NegativeTraits,
+        Hobbies:               res.Hobbies,
+        LifeGoals:             res.LifeGoals,
+        DailyActivities:       res.DailyActivities,
+        LeisureActivities:     res.LeisureActivities,
+        Likes:                 res.Likes,
+        Dislikes:              res.Dislikes,
+        StressHandling:        res.StressHandling,
+        AngerTriggers:         res.AngerTriggers,
+        FavoriteFoodAndDrinks: res.FavoriteFoodAndDrinks,
+        CanCook:               res.CanCook,
+        TypesOfDishesCooked:   res.TypesOfDishesCooked,
+        MonthlyExpenses:       res.MonthlyExpenses,
+        CreatedAt:             res.CreatedAt,
+        UpdatedAt:             res.UpdatedAt,
+    }, nil
+}
+
+func (s *cvService) GetPersonalityAndPreference(ctx context.Context, id int64) (*models.PersonalityAndPreferenceCVResponse, error) {
+    res, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Internal Server Error")
+    }
+    
+    return &models.PersonalityAndPreferenceCVResponse{
+        ID:                    res.ID,
+        AccountID:             res.AccountID,
+        PositiveTraits:        res.PositiveTraits,
+        NegativeTraits:        res.NegativeTraits,
+        Hobbies:               res.Hobbies,
+        LifeGoals:             res.LifeGoals,
+        DailyActivities:       res.DailyActivities,
+        LeisureActivities:     res.LeisureActivities,
+        Likes:                 res.Likes,
+        Dislikes:              res.Dislikes,
+        StressHandling:        res.StressHandling,
+        AngerTriggers:         res.AngerTriggers,
+        FavoriteFoodAndDrinks: res.FavoriteFoodAndDrinks,
+        CanCook:               res.CanCook,
+        TypesOfDishesCooked:   res.TypesOfDishesCooked,
+        MonthlyExpenses:       res.MonthlyExpenses,
+        CreatedAt:             res.CreatedAt,
+        UpdatedAt:             res.UpdatedAt,
+    }, nil
+}

space/space/services/health_check_service.go

@@ -5,7 +5,6 @@ import (
 	"api.qobiltu.id/repositories"
 	"api.qobiltu.id/response"
 	"context"
-	"gorm.io/gorm"
 )
 
 type HealthCheckService interface {
@@ -25,7 +24,7 @@ func NewHealthCheckService(healthCheckRepository repositories.HealthCheckReposit
 func (s *healthCheckService) Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error) {
 	res, err := s.healthCheckRepository.Check(ctx, req)
 	if err != nil {
-		return nil, response.HandleGormError(gorm.ErrDuplicatedKey, "Internal Server Error")
+		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
 	return res, nil

space/space/space/.gitignore

@@ -6,3 +6,4 @@ README.md
 .error
 logs/
 .idea
+my-notes

space/space/space/controller/health_check/health_check_controller.go

@@ -3,29 +3,33 @@ package health_check_controller
 import (
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/response"
-	"api.qobiltu.id/services/health_check_service"
+	"api.qobiltu.id/services"
 	"github.com/gin-gonic/gin"
 	"net/http"
 )
 
-type HealthCheckController struct {
-	healthCheckService *health_check_service.HealthCheckService
+type HealthCheckController interface {
+	Check(ctx *gin.Context)
 }
 
-func NewHealthCheckController(healthCheckService *health_check_service.HealthCheckService) *HealthCheckController {
-	return &HealthCheckController{
+type healthCheckController struct {
+	healthCheckService services.HealthCheckService
+}
+
+func NewHealthCheckController(healthCheckService services.HealthCheckService) HealthCheckController {
+	return &healthCheckController{
 		healthCheckService: healthCheckService,
 	}
 }
 
-func (h *HealthCheckController) Check(ctx *gin.Context) {
+func (c *healthCheckController) Check(ctx *gin.Context) {
 	req := models.HealthCheckRequest{}
 
-	res, err := h.healthCheckService.Check(ctx, &req)
+	res, err := c.healthCheckService.Check(ctx, &req)
 	if err != nil {
 		response.HandleError(ctx, err)
 		return
 	}
 
-	response.HandleSuccess(ctx, "Service is running", http.StatusOK, res, nil)
+	response.HandleSuccess(ctx, http.StatusOK, "Service OK", res, nil)
 }

space/space/space/main.go

@@ -6,7 +6,7 @@ import (
 	"api.qobiltu.id/mail"
 	"api.qobiltu.id/repositories"
 	"api.qobiltu.id/router"
-	"api.qobiltu.id/services/health_check_service"
+	"api.qobiltu.id/services"
 	"api.qobiltu.id/utils"
 	"api.qobiltu.id/worker"
 	"github.com/hibiken/asynq"
@@ -43,7 +43,7 @@ func main() {
 
 	// setup repo, service, and controller
 	healthCheckRepository := repositories.NewHealthCheckRepository(config.DB)
-	healthCheckService := health_check_service.NewHealthCheckService(healthCheckRepository)
+	healthCheckService := services.NewHealthCheckService(healthCheckRepository)
 	healthCheckController := health_check_controller.NewHealthCheckController(healthCheckService)
 
 	// start task processor

space/space/space/models/database_orm_model.go

@@ -1,207 +1,207 @@
-package models
-
-import (
-	"time"
-
-	uuid "github.com/satori/go.uuid"
-)
-
-type Account struct {
-	Id                uint       `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID  `gorm:"type:uuid" json:"uuid" `
-	Email             string     `gorm:"uniqueIndex" json:"email"`
-	Password          string     `json:"password"`
-	IsEmailVerified   bool       `json:"is_email_verified"`
-	IsDetailCompleted bool       `json:"is_detail_completed"`
-	CreatedAt         time.Time  `json:"created_at"`
-	DeletedAt         *time.Time `json:"deleted_at" gorm:"default:null"`
-}
-
-type AccountDetails struct {
-	ID            uint       `gorm:"primaryKey" json:"id"`
-	AccountID     uint       `json:"account_id"`
-	InitialName   string     `json:"initial_name"`
-	FullName      *string    `json:"full_name"`
-	DateOfBirth   *time.Time `json:"date_of_birth"`
-	PlaceOfBirth  *string    `json:"place_of_birth"`
-	Domicile      *string    `json:"domicile"`
-	LastJob       *string    `json:"last_job"`
-	Gender        *bool      `json:"gender"`
-	LastEducation *string    `json:"last_education"`
-	MaritalStatus *string    `json:"marital_status"`
-	Avatar        *string    `json:"avatar"`
-	PhoneNumber   *string    `json:"phone_number"`
-}
-
-type EmailVerification struct {
-	ID        uint      `gorm:"primaryKey" json:"id"`
-	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid" `
-	Token     uint      `json:"token"`
-	AccountID uint      `json:"account_id"`
-	IsExpired bool      `json:"is_expired"`
-	CreatedAt time.Time `json:"created_at"`
-	ExpiredAt time.Time `json:"expired_at"`
-}
-
-type ExternalAuth struct {
-	ID            uint      `gorm:"primaryKey" json:"id"`
-	UUID          uuid.UUID `gorm:"type:uuid" json:"uuid" `
-	OauthID       string    `json:"oauth_id"`
-	AccountID     uint      `json:"account_id"`
-	OauthProvider string    `json:"oauth_provider"`
-}
-
-type FCM struct {
-	ID        uint   `gorm:"primaryKey" json:"id"`
-	AccountID uint   `json:"account_id"`
-	FCMToken  string `json:"fcm_token"`
-}
-
-type ForgotPassword struct {
-	ID        uint      `gorm:"primaryKey" json:"id"`
-	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid" `
-	Token     uint      `json:"token"`
-	AccountID uint      `json:"account_id"`
-	IsExpired bool      `json:"is_expired"`
-	CreatedAt time.Time `json:"created_at"`
-	ExpiredAt time.Time `json:"expired_at"`
-}
-
-type Academy struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	Title             string    `json:"title"`
-	Slug              string    `json:"slug" gorm:"uniqueIndex" `
-	TotalMaterial     int       `json:"total_material"`
-	CompletedMaterial int       `json:"completed_material"`
-	IsCompletedRead   bool      `json:"is_read"`
-	IsPassedExam      bool      `json:"is_exam"`
-	Description       string    `json:"description"`
-}
-
-type AcademyMaterial struct {
-	ID          uint      `gorm:"primaryKey" json:"id"`
-	UUID        uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AcademyID   uint      `json:"academy_id"`
-	Title       string    `json:"title"`
-	Slug        string    `json:"slug" gorm:"uniqueIndex"`
-	IsCompleted bool      `json:"is_completed"`
-	Description string    `json:"description"`
-}
-
-type AcademyContent struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `json:"uuid"`
-	Title             string    `json:"title"`
-	Order             uint      `json:"order"`
-	AcademyMaterialID uint      `json:"academy_material_id"`
-	Description       string    `json:"description"`
-}
-type OptionCategory struct {
-	ID         uint   `gorm:"primaryKey" json:"id"`
-	OptionName string `json:"option_name"`
-	OptionSlug string `json:"option_slug" gorm:"uniqueIndex"`
-}
-
-type OptionValues struct {
-	ID               uint   `gorm:"primaryKey" json:"id"`
-	OptionCategoryID uint   `json:"option_category_id"`
-	OptionValue      string `json:"option_value"`
-}
-type AcademyMaterialProgress struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AccountID         uint      `json:"account_id"`
-	AcademyMaterialID uint      `json:"academy_material_id"`
-	Progress          uint      `json:"progress"`
-}
-
-type AcademyContentProgress struct {
-	ID        uint      `gorm:"primaryKey" json:"id"`
-	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AccountID uint      `json:"account_id"`
-	AcademyID uint      `json:"academy_id"`
-}
-
-type RegionProvince struct {
-	ID   uint   `json:"id"`
-	Name string `json:"name"`
-	Code string `json:"code"`
-}
-
-type RegionCity struct {
-	ID         uint   `json:"id"`
-	Type       string `json:"type"`
-	Name       string `json:"name"`
-	Code       string `json:"code"`
-	FullCode   string `json:"full_code"`
-	ProvinceID uint   `json:"province_id"`
-}
-type Answer struct {
-	ID         uint   `gorm:"primaryKey" json:"id"`
-	QuestionID uint   `json:"question_id"`
-	Content    string `json:"content"`
-	IsCorrect  bool   `json:"-"`
-}
-type Question struct {
-	ID            uint   `gorm:"primaryKey"  json:"id"`
-	QuizID        uint   `json:"quiz_id"`
-	Content       string `json:"content"`
-	Order         int    `json:"order"`
-	CorrectAnswer uint   `json:"-"`
-}
-type Quiz struct {
-	ID           uint      `gorm:"primaryKey" json:"id"`
-	AcademyID    uint      `json:"academy_id"`
-	Title        string    `json:"title"`
-	Description  string    `json:"description"`
-	AttemptLimit int       `json:"attempt_limit"`
-	TimeLimit    int       `json:"time_limit"`
-	MinScore     int       `json:"min_score"`
-	CreatedAt    time.Time `json:"created_at"`
-}
-
-type QuizAttempt struct {
-	ID         uint       `gorm:"primaryKey" json:"id"`
-	AccountID  uint       `json:"user_id"`
-	QuizID     uint       `json:"quiz_id"`
-	StartedAt  time.Time  `json:"started_at"`
-	DueAt      time.Time  `json:"due_at"`
-	FinishedAt *time.Time `json:"finished_at"`
-	Score      float64    `json:"score"`
-}
-type UserAnswer struct {
-	ID             uint `gorm:"primaryKey" json:"id"`
-	QuizAttemptID  uint `json:"quiz_attempt_id"`
-	QuestionID     uint `json:"question_id"`
-	SelectedAnswer uint `json:"selected_answer"`
-	IsCorrect      bool `json:"is_correct"`
-}
-type QuizResult struct {
-	QuizAttemptID  uint    `gorm:"column:quiz_attempt_id" json:"quiz_attempt_id"`
-	TotalQuestions int     `gorm:"column:total_questions" json:"total_questions"`
-	CorrectAnswers int     `gorm:"column:correct_answers" json:"correct_answers"`
-	AverageScore   float64 `gorm:"column:average_score" json:"average_score"`
-}
-
-// Gorm table name settings
-func (Account) TableName() string                 { return "account" }
-func (AccountDetails) TableName() string          { return "account_details" }
-func (EmailVerification) TableName() string       { return "email_verifications" }
-func (ExternalAuth) TableName() string            { return "extern_auth" }
-func (FCM) TableName() string                     { return "fcm" }
-func (ForgotPassword) TableName() string          { return "forgot_password" }
-func (Academy) TableName() string                 { return "academy" }
-func (AcademyMaterial) TableName() string         { return "academy_materials" }
-func (AcademyContent) TableName() string          { return "academy_contents" }
-func (AcademyMaterialProgress) TableName() string { return "academy_materials_progress" }
-func (AcademyContentProgress) TableName() string  { return "academy_contents_progress" }
-func (RegionProvince) TableName() string          { return "region_provinces" }
-func (RegionCity) TableName() string              { return "region_cities" }
-func (Answer) TableName() string                  { return "answers" }
-func (Question) TableName() string                { return "questions" }
-func (Quiz) TableName() string                    { return "quizzes" }
-func (QuizAttempt) TableName() string             { return "quiz_attempts" }
-func (UserAnswer) TableName() string              { return "user_answers" }
-func (OptionCategory) TableName() string          { return "option_categories" }
-func (OptionValues) TableName() string            { return "option_values" }
+package models
+
+import (
+	"time"
+
+	uuid "github.com/satori/go.uuid"
+)
+
+type Account struct {
+	Id                uint       `gorm:"primaryKey" json:"id"`
+	UUID              uuid.UUID  `gorm:"type:uuid" json:"uuid" `
+	Email             string     `gorm:"uniqueIndex" json:"email"`
+	Password          string     `json:"password"`
+	IsEmailVerified   bool       `json:"is_email_verified"`
+	IsDetailCompleted bool       `json:"is_detail_completed"`
+	CreatedAt         time.Time  `json:"created_at"`
+	DeletedAt         *time.Time `json:"deleted_at" gorm:"default:null"`
+}
+
+type AccountDetails struct {
+	ID            uint64     `gorm:"primaryKey" json:"id"`
+	AccountID     uint       `json:"account_id"`
+	InitialName   string     `json:"initial_name"`
+	FullName      *string    `json:"full_name"`
+	DateOfBirth   *time.Time `json:"date_of_birth"`
+	PlaceOfBirth  *string    `json:"place_of_birth"`
+	Domicile      *string    `json:"domicile"`
+	LastJob       *string    `json:"last_job"`
+	Gender        *string    `json:"gender"`
+	LastEducation *string    `json:"last_education"`
+	MaritalStatus *string    `json:"marital_status"`
+	Avatar        *string    `json:"avatar"`
+	PhoneNumber   *string    `json:"phone_number"`
+}
+
+type EmailVerification struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid" `
+	Token     uint      `json:"token"`
+	AccountID uint      `json:"account_id"`
+	IsExpired bool      `json:"is_expired"`
+	CreatedAt time.Time `json:"created_at"`
+	ExpiredAt time.Time `json:"expired_at"`
+}
+
+type ExternalAuth struct {
+	ID            uint      `gorm:"primaryKey" json:"id"`
+	UUID          uuid.UUID `gorm:"type:uuid" json:"uuid" `
+	OauthID       string    `json:"oauth_id"`
+	AccountID     uint      `json:"account_id"`
+	OauthProvider string    `json:"oauth_provider"`
+}
+
+type FCM struct {
+	ID        uint   `gorm:"primaryKey" json:"id"`
+	AccountID uint   `json:"account_id"`
+	FCMToken  string `json:"fcm_token"`
+}
+
+type ForgotPassword struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid" `
+	Token     uint      `json:"token"`
+	AccountID uint      `json:"account_id"`
+	IsExpired bool      `json:"is_expired"`
+	CreatedAt time.Time `json:"created_at"`
+	ExpiredAt time.Time `json:"expired_at"`
+}
+
+type Academy struct {
+	ID                uint      `gorm:"primaryKey" json:"id"`
+	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
+	Title             string    `json:"title"`
+	Slug              string    `json:"slug" gorm:"uniqueIndex" `
+	TotalMaterial     int       `json:"total_material"`
+	CompletedMaterial int       `json:"completed_material"`
+	IsCompletedRead   bool      `json:"is_read"`
+	IsPassedExam      bool      `json:"is_exam"`
+	Description       string    `json:"description"`
+}
+
+type AcademyMaterial struct {
+	ID          uint      `gorm:"primaryKey" json:"id"`
+	UUID        uuid.UUID `gorm:"type:uuid" json:"uuid"`
+	AcademyID   uint      `json:"academy_id"`
+	Title       string    `json:"title"`
+	Slug        string    `json:"slug" gorm:"uniqueIndex"`
+	IsCompleted bool      `json:"is_completed"`
+	Description string    `json:"description"`
+}
+
+type AcademyContent struct {
+	ID                uint      `gorm:"primaryKey" json:"id"`
+	UUID              uuid.UUID `json:"uuid"`
+	Title             string    `json:"title"`
+	Order             uint      `json:"order"`
+	AcademyMaterialID uint      `json:"academy_material_id"`
+	Description       string    `json:"description"`
+}
+type OptionCategory struct {
+	ID         uint   `gorm:"primaryKey" json:"id"`
+	OptionName string `json:"option_name"`
+	OptionSlug string `json:"option_slug" gorm:"uniqueIndex"`
+}
+
+type OptionValues struct {
+	ID               uint   `gorm:"primaryKey" json:"id"`
+	OptionCategoryID uint   `json:"option_category_id"`
+	OptionValue      string `json:"option_value"`
+}
+type AcademyMaterialProgress struct {
+	ID                uint      `gorm:"primaryKey" json:"id"`
+	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
+	AccountID         uint      `json:"account_id"`
+	AcademyMaterialID uint      `json:"academy_material_id"`
+	Progress          uint      `json:"progress"`
+}
+
+type AcademyContentProgress struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid"`
+	AccountID uint      `json:"account_id"`
+	AcademyID uint      `json:"academy_id"`
+}
+
+type RegionProvince struct {
+	ID   uint   `json:"id"`
+	Name string `json:"name"`
+	Code string `json:"code"`
+}
+
+type RegionCity struct {
+	ID         uint   `json:"id"`
+	Type       string `json:"type"`
+	Name       string `json:"name"`
+	Code       string `json:"code"`
+	FullCode   string `json:"full_code"`
+	ProvinceID uint   `json:"province_id"`
+}
+type Answer struct {
+	ID         uint   `gorm:"primaryKey" json:"id"`
+	QuestionID uint   `json:"question_id"`
+	Content    string `json:"content"`
+	IsCorrect  bool   `json:"-"`
+}
+type Question struct {
+	ID            uint   `gorm:"primaryKey"  json:"id"`
+	QuizID        uint   `json:"quiz_id"`
+	Content       string `json:"content"`
+	Order         int    `json:"order"`
+	CorrectAnswer uint   `json:"-"`
+}
+type Quiz struct {
+	ID           uint      `gorm:"primaryKey" json:"id"`
+	AcademyID    uint      `json:"academy_id"`
+	Title        string    `json:"title"`
+	Description  string    `json:"description"`
+	AttemptLimit int       `json:"attempt_limit"`
+	TimeLimit    int       `json:"time_limit"`
+	MinScore     int       `json:"min_score"`
+	CreatedAt    time.Time `json:"created_at"`
+}
+
+type QuizAttempt struct {
+	ID         uint       `gorm:"primaryKey" json:"id"`
+	AccountID  uint       `json:"user_id"`
+	QuizID     uint       `json:"quiz_id"`
+	StartedAt  time.Time  `json:"started_at"`
+	DueAt      time.Time  `json:"due_at"`
+	FinishedAt *time.Time `json:"finished_at"`
+	Score      float64    `json:"score"`
+}
+type UserAnswer struct {
+	ID             uint `gorm:"primaryKey" json:"id"`
+	QuizAttemptID  uint `json:"quiz_attempt_id"`
+	QuestionID     uint `json:"question_id"`
+	SelectedAnswer uint `json:"selected_answer"`
+	IsCorrect      bool `json:"is_correct"`
+}
+type QuizResult struct {
+	QuizAttemptID  uint    `gorm:"column:quiz_attempt_id" json:"quiz_attempt_id"`
+	TotalQuestions int     `gorm:"column:total_questions" json:"total_questions"`
+	CorrectAnswers int     `gorm:"column:correct_answers" json:"correct_answers"`
+	AverageScore   float64 `gorm:"column:average_score" json:"average_score"`
+}
+
+// Gorm table name settings
+func (Account) TableName() string                 { return "account" }
+func (AccountDetails) TableName() string          { return "account_details" }
+func (EmailVerification) TableName() string       { return "email_verifications" }
+func (ExternalAuth) TableName() string            { return "extern_auth" }
+func (FCM) TableName() string                     { return "fcm" }
+func (ForgotPassword) TableName() string          { return "forgot_password" }
+func (Academy) TableName() string                 { return "academy" }
+func (AcademyMaterial) TableName() string         { return "academy_materials" }
+func (AcademyContent) TableName() string          { return "academy_contents" }
+func (AcademyMaterialProgress) TableName() string { return "academy_materials_progress" }
+func (AcademyContentProgress) TableName() string  { return "academy_contents_progress" }
+func (RegionProvince) TableName() string          { return "region_provinces" }
+func (RegionCity) TableName() string              { return "region_cities" }
+func (Answer) TableName() string                  { return "answers" }
+func (Question) TableName() string                { return "questions" }
+func (Quiz) TableName() string                    { return "quizzes" }
+func (QuizAttempt) TableName() string             { return "quiz_attempts" }
+func (UserAnswer) TableName() string              { return "user_answers" }
+func (OptionCategory) TableName() string          { return "option_categories" }
+func (OptionValues) TableName() string            { return "option_values" }

space/space/space/models/exception_model.go

@@ -1,17 +1,23 @@
 package models
 
 type Exception struct {
-	Unauthorized          bool   `json:"unauthorized,omitempty"`
-	BadRequest            bool   `json:"bad_request,omitempty"`
-	DataNotFound          bool   `json:"data_not_found,omitempty"`
-	InternalServerError   bool   `json:"internal_server_error,omitempty"`
-	DataDuplicate         bool   `json:"data_duplicate,omitempty"`
-	QueryError            bool   `json:"query_error,omitempty"`
-	InvalidPasswordLength bool   `json:"invalid_password_length,omitempty"`
-	IsPassTheLimit        bool   `json:"is_pass_the_limit,omitempty"`
-	IsTimeOut             bool   `json:"is_time_out,omitempty"`
-	AttemptNotFound       bool   `json:"attempt_not_found,omitempty"`
-	Forbidden             bool   `json:"forbidden,omitempty"`
-	ValidationError       bool   `json:"validation_error,omitempty"`
-	Message               string `json:"message,omitempty"`
+    Unauthorized          bool `json:"unauthorized,omitempty"`
+    BadRequest            bool `json:"bad_request,omitempty"`
+    DataNotFound          bool `json:"data_not_found,omitempty"`
+    InternalServerError   bool `json:"internal_server_error,omitempty"`
+    DataDuplicate         bool `json:"data_duplicate,omitempty"`
+    QueryError            bool `json:"query_error,omitempty"`
+    InvalidPasswordLength bool `json:"invalid_password_length,omitempty"`
+    IsPassTheLimit        bool `json:"is_pass_the_limit,omitempty"`
+    IsTimeOut             bool `json:"is_time_out,omitempty"`
+    AttemptNotFound       bool `json:"attempt_not_found,omitempty"`
+    Forbidden             bool `json:"forbidden,omitempty"`
+    ValidationError       bool `json:"validation_error,omitempty"`
+
+    Message string `json:"message,omitempty"`
+    Err     error  `json:"-"`
+}
+
+func (a Exception) Error() string {
+    return a.Err.Error()
 }

space/space/space/models/health_check_model.go

@@ -1,8 +1,6 @@
 package models
 
-type HealthCheckRequest struct {
-	ExampleCallback func() (string, string)
-}
+type HealthCheckRequest struct{}
 
 type HealthCheckResponse struct {
 	DatabaseStatus string `json:"database_status"`

space/space/space/repositories/health_check_repository.go

@@ -7,29 +7,25 @@ import (
 	"gorm.io/gorm"
 )
 
-type HealthCheckRepository struct {
+type HealthCheckRepository interface {
+	Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error)
+}
+
+type healthCheckRepository struct {
 	db *gorm.DB
 }
 
-func NewHealthCheckRepository(db *gorm.DB) *HealthCheckRepository {
-	return &HealthCheckRepository{
+func NewHealthCheckRepository(db *gorm.DB) HealthCheckRepository {
+	return &healthCheckRepository{
 		db: db,
 	}
 }
 
-func (r *HealthCheckRepository) Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error) {
-	res := &models.HealthCheckResponse{}
-
+func (r *healthCheckRepository) Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error) {
 	err := config.RunTx(ctx, r.db, func(tx *gorm.DB) error {
 		if err := tx.Exec("SELECT 1").Error; err != nil {
 			return err
 		}
-
-		// call logic from service if needed
-		// instead of writing the logic in the repository
-		// and make sure the param consist of the ctx and request
-		res.DatabaseStatus, res.RedisStatus = req.ExampleCallback()
-
 		return nil
 	})
 
@@ -37,5 +33,8 @@ func (r *HealthCheckRepository) Check(ctx context.Context, req *models.HealthChe
 		return nil, err
 	}
 
-	return res, nil
+	return &models.HealthCheckResponse{
+		DatabaseStatus: "OK",
+		RedisStatus:    "OK",
+	}, nil
 }

space/space/space/response/api_response_v2.go

@@ -0,0 +1,79 @@
+package response
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/utils"
+	"errors"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+func HandleError(c *gin.Context, err error) {
+	var exception models.Exception
+
+	if errors.As(err, &exception) {
+		utils.LogError(exception.Err)
+
+		switch {
+		case exception.DataDuplicate:
+			responseError(c, http.StatusConflict, exception)
+		case exception.Unauthorized:
+			responseError(c, http.StatusUnauthorized, exception)
+		case exception.DataNotFound:
+			responseError(c, http.StatusNotFound, exception)
+		case exception.Forbidden:
+			responseError(c, http.StatusForbidden, exception)
+		case exception.BadRequest:
+			responseError(c, http.StatusBadRequest, exception)
+		case exception.InternalServerError:
+			responseError(c, http.StatusInternalServerError, exception)
+		case exception.QueryError:
+			responseError(c, http.StatusInternalServerError, exception)
+		case exception.InvalidPasswordLength:
+			responseError(c, http.StatusBadRequest, exception)
+		case exception.IsPassTheLimit:
+			responseError(c, http.StatusTooManyRequests, exception)
+		case exception.IsTimeOut:
+			responseError(c, http.StatusRequestTimeout, exception)
+		case exception.AttemptNotFound:
+			responseError(c, http.StatusNotFound, exception)
+		case exception.ValidationError:
+			responseError(c, http.StatusUnprocessableEntity, exception)
+		default:
+			responseError(c, http.StatusInternalServerError, exception)
+		}
+	} else {
+		utils.LogError(err)
+		responseError(c, http.StatusInternalServerError, models.Exception{
+			InternalServerError: true,
+			Message:             "Internal Server Error",
+		})
+	}
+}
+
+func HandleSuccess(c *gin.Context, status int, msg string, data any, metaData any) {
+	res := models.SuccessResponse{
+		Status:   "success",
+		Message:  msg,
+		Data:     data,
+		MetaData: metaData,
+	}
+
+	c.JSON(status, res)
+	return
+}
+
+func responseError(c *gin.Context, status int, exception models.Exception) {
+	message := exception.Message
+	exception.Message = ""
+
+	res := models.ErrorResponse{
+		Status:  "error",
+		Message: message,
+		Errors:  exception,
+	}
+
+	c.AbortWithStatusJSON(status, res)
+	return
+}

space/space/space/response/gorm.go

@@ -0,0 +1,62 @@
+package response
+
+import (
+	"api.qobiltu.id/models"
+	"errors"
+	"strings"
+
+	"gorm.io/gorm"
+)
+
+func HandleGormError(err error, fallbackMessage string) error {
+	if err == nil {
+		return nil
+	}
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return models.Exception{
+			Message:      "Data not found",
+			DataNotFound: true,
+			Err:          err,
+		}
+	}
+
+	lowerErr := strings.ToLower(err.Error())
+	if strings.Contains(lowerErr, "duplicated key") || strings.Contains(lowerErr, "unique constraint") || strings.Contains(lowerErr, "duplicate entry") {
+		return models.Exception{
+			Message:       "Data already exists",
+			DataDuplicate: true,
+			Err:           err,
+		}
+	}
+
+	if strings.Contains(lowerErr, "password") && strings.Contains(lowerErr, "length") {
+		return models.Exception{
+			Message:               "Invalid password length",
+			InvalidPasswordLength: true,
+			Err:                   err,
+		}
+	}
+
+	if strings.Contains(lowerErr, "permission denied") || strings.Contains(lowerErr, "forbidden") {
+		return models.Exception{
+			Message:   "Access forbidden",
+			Forbidden: true,
+			Err:       err,
+		}
+	}
+
+	if errors.As(err, &gorm.ErrInvalidData) {
+		return models.Exception{
+			Message:    "Invalid data format",
+			BadRequest: true,
+			Err:        err,
+		}
+	}
+
+	return models.Exception{
+		Message:             fallbackMessage,
+		InternalServerError: true,
+		Err:                 err,
+	}
+}

space/space/space/router/server.go

@@ -7,11 +7,11 @@ import (
 
 type Server struct {
 	router                *gin.Engine
-	healthCheckController *health_check_controller.HealthCheckController
+	healthCheckController health_check_controller.HealthCheckController
 }
 
 func NewServer(
-	healthCheckController *health_check_controller.HealthCheckController,
+	healthCheckController health_check_controller.HealthCheckController,
 ) (*Server, error) {
 
 	router := gin.Default()

space/space/space/services/health_check_service.go

@@ -0,0 +1,32 @@
+package services
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+	"api.qobiltu.id/response"
+	"context"
+	"gorm.io/gorm"
+)
+
+type HealthCheckService interface {
+	Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error)
+}
+
+type healthCheckService struct {
+	healthCheckRepository repositories.HealthCheckRepository
+}
+
+func NewHealthCheckService(healthCheckRepository repositories.HealthCheckRepository) HealthCheckService {
+	return &healthCheckService{
+		healthCheckRepository: healthCheckRepository,
+	}
+}
+
+func (s *healthCheckService) Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error) {
+	res, err := s.healthCheckRepository.Check(ctx, req)
+	if err != nil {
+		return nil, response.HandleGormError(gorm.ErrDuplicatedKey, "Internal Server Error")
+	}
+
+	return res, nil
+}

space/space/space/services/user_profile_service.go

@@ -1,115 +1,115 @@
-package services
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-
-	"api.qobiltu.id/models"
-	"api.qobiltu.id/repositories"
-)
-
-type UserProfileService struct {
-	Service[models.AccountDetails, models.UserProfileResponse]
-}
-
-// SanitizePhoneNumber membersihkan dan menormalkan nomor telepon ke format +62
-func SanitizePhoneNumber(input string) string {
-	// Hilangkan semua spasi dan strip
-	input = strings.ReplaceAll(input, " ", "")
-	input = strings.ReplaceAll(input, "-", "")
-	input = strings.ReplaceAll(input, "(", "")
-	input = strings.ReplaceAll(input, ")", "")
-
-	// Hilangkan semua karakter non-digit kecuali +
-	re := regexp.MustCompile(`[^0-9\+]`)
-	input = re.ReplaceAllString(input, "")
-
-	// Handle nomor diawali 0 (contoh: 0812...) menjadi +62812...
-	if strings.HasPrefix(input, "0") {
-		input = "+62" + input[1:]
-	}
-
-	// Handle jika diawali dengan 62 tanpa + (contoh: 62812...)
-	if strings.HasPrefix(input, "62") && !strings.HasPrefix(input, "+62") {
-		input = "+" + input
-	}
-
-	// Handle jika tidak ada awalan +62 sama sekali (contoh: 8123456789)
-	if !strings.HasPrefix(input, "+62") {
-		if strings.HasPrefix(input, "8") {
-			input = "+62" + input
-		}
-	}
-
-	return input
-}
-func (s *UserProfileService) Create() {
-	userProfile := repositories.CreateAccountDetails(s.Constructor)
-	s.Error = userProfile.RowsError
-	if userProfile.NoRecord {
-		s.Exception.DataNotFound = true
-		s.Exception.Message = "There is no account with given credentials!"
-		return
-	}
-	s.Result = models.UserProfileResponse{
-		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
-		Details: userProfile.Result,
-	}
-}
-func (s *UserProfileService) Retrieve() {
-	userProfile := repositories.GetDetailAccountById(s.Constructor.AccountID)
-	s.Error = userProfile.RowsError
-	if userProfile.NoRecord {
-		s.Exception.DataNotFound = true
-		s.Exception.Message = "There is no account with given credentials!"
-		return
-	}
-	s.Result = models.UserProfileResponse{
-		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
-		Details: userProfile.Result,
-	}
-	s.Result.Account.Password = "SECRET"
-}
-
-func (s *UserProfileService) Update() {
-	if s.Constructor.PhoneNumber != nil {
-		phoneNumber := *s.Constructor.PhoneNumber
-		*s.Constructor.PhoneNumber = SanitizePhoneNumber(phoneNumber)
-	}
-	usersCount := repositories.GetAllAccount().RowsCount
-	var initialName string
-	if s.Constructor.Gender != nil {
-		if *s.Constructor.Gender {
-			initialName = "IKH_"
-		} else {
-			initialName = "AKH_"
-		}
-	}
-
-	initialName += strconv.Itoa(usersCount)
-	s.Constructor.InitialName = initialName
-	userProfile := repositories.UpdateAccountDetails(s.Constructor)
-	s.Error = userProfile.RowsError
-	if userProfile.NoRecord {
-		s.Exception.DataNotFound = true
-		s.Exception.Message = "There is no account with given credentials!"
-		return
-	}
-	account := repositories.GetAccountById(s.Constructor.AccountID)
-	account.Result.IsDetailCompleted = (userProfile.Result.InitialName != "" &&
-		userProfile.Result.FullName != nil &&
-		userProfile.Result.DateOfBirth != nil &&
-		userProfile.Result.PlaceOfBirth != nil &&
-		userProfile.Result.Domicile != nil &&
-		userProfile.Result.LastJob != nil &&
-		userProfile.Result.Gender != nil &&
-		userProfile.Result.LastEducation != nil &&
-		userProfile.Result.MaritalStatus != nil)
-	repositories.UpdateAccount(account.Result)
-	s.Result = models.UserProfileResponse{
-		Account: account.Result,
-		Details: userProfile.Result,
-	}
-	s.Result.Account.Password = "SECRET"
-}
+package services
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+)
+
+type UserProfileService struct {
+	Service[models.AccountDetails, models.UserProfileResponse]
+}
+
+// SanitizePhoneNumber membersihkan dan menormalkan nomor telepon ke format +62
+func SanitizePhoneNumber(input string) string {
+	// Hilangkan semua spasi dan strip
+	input = strings.ReplaceAll(input, " ", "")
+	input = strings.ReplaceAll(input, "-", "")
+	input = strings.ReplaceAll(input, "(", "")
+	input = strings.ReplaceAll(input, ")", "")
+
+	// Hilangkan semua karakter non-digit kecuali +
+	re := regexp.MustCompile(`[^0-9\+]`)
+	input = re.ReplaceAllString(input, "")
+
+	// Handle nomor diawali 0 (contoh: 0812...) menjadi +62812...
+	if strings.HasPrefix(input, "0") {
+		input = "+62" + input[1:]
+	}
+
+	// Handle jika diawali dengan 62 tanpa + (contoh: 62812...)
+	if strings.HasPrefix(input, "62") && !strings.HasPrefix(input, "+62") {
+		input = "+" + input
+	}
+
+	// Handle jika tidak ada awalan +62 sama sekali (contoh: 8123456789)
+	if !strings.HasPrefix(input, "+62") {
+		if strings.HasPrefix(input, "8") {
+			input = "+62" + input
+		}
+	}
+
+	return input
+}
+func (s *UserProfileService) Create() {
+	userProfile := repositories.CreateAccountDetails(s.Constructor)
+	s.Error = userProfile.RowsError
+	if userProfile.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no account with given credentials!"
+		return
+	}
+	s.Result = models.UserProfileResponse{
+		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
+		Details: userProfile.Result,
+	}
+}
+func (s *UserProfileService) Retrieve() {
+	userProfile := repositories.GetDetailAccountById(s.Constructor.AccountID)
+	s.Error = userProfile.RowsError
+	if userProfile.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no account with given credentials!"
+		return
+	}
+	s.Result = models.UserProfileResponse{
+		Account: repositories.GetAccountById(s.Constructor.AccountID).Result,
+		Details: userProfile.Result,
+	}
+	s.Result.Account.Password = "SECRET"
+}
+
+func (s *UserProfileService) Update() {
+	if s.Constructor.PhoneNumber != nil {
+		phoneNumber := *s.Constructor.PhoneNumber
+		*s.Constructor.PhoneNumber = SanitizePhoneNumber(phoneNumber)
+	}
+	usersCount := repositories.GetAllAccount().RowsCount
+	var initialName string
+	if s.Constructor.Gender != nil {
+		if strings.ToLower(*s.Constructor.Gender) == "laki-laki" {
+			initialName = "IKH_"
+		} else {
+			initialName = "AKH_"
+		}
+	}
+
+	initialName += strconv.Itoa(usersCount)
+	s.Constructor.InitialName = initialName
+	userProfile := repositories.UpdateAccountDetails(s.Constructor)
+	s.Error = userProfile.RowsError
+	if userProfile.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no account with given credentials!"
+		return
+	}
+	account := repositories.GetAccountById(s.Constructor.AccountID)
+	account.Result.IsDetailCompleted = (userProfile.Result.InitialName != "" &&
+		userProfile.Result.FullName != nil &&
+		userProfile.Result.DateOfBirth != nil &&
+		userProfile.Result.PlaceOfBirth != nil &&
+		userProfile.Result.Domicile != nil &&
+		userProfile.Result.LastJob != nil &&
+		userProfile.Result.Gender != nil &&
+		userProfile.Result.LastEducation != nil &&
+		userProfile.Result.MaritalStatus != nil)
+	repositories.UpdateAccount(account.Result)
+	s.Result = models.UserProfileResponse{
+		Account: account.Result,
+		Details: userProfile.Result,
+	}
+	s.Result.Account.Password = "SECRET"
+}

space/space/space/space/Dockerfile

@@ -25,6 +25,12 @@ FROM alpine:latest
 # Set working directory
 WORKDIR /app
 
+# Install tzdata
+RUN apk update && apk add --no-cache tzdata
+
+# Set the timezone environment variable
+ENV TZ="Asia/Jakarta"
+
 # Copy hasil build dari builder ke image runtime
 COPY --from=builder /app/main .
 

space/space/space/space/space/.github/workflows/main.yml

@@ -25,4 +25,5 @@ jobs:
             git pull origin main
             docker-compose down -v
             docker-compose up --build -d
+            docker image prune -f
           EOF

space/space/space/space/space/apperror/apperror.go

@@ -0,0 +1,168 @@
+package apperror
+
+import (
+	"api.qobiltu.id/validation"
+	"fmt"
+)
+
+// AppError is a custom error type for the application.
+type AppError struct {
+	Code    string         // Optional: Error code for programmatic handling
+	Message string         // Human-readable error message
+	Err     error          // Underlying error, if any
+	Details map[string]any // Optional: Additional details about the error
+}
+
+func (e AppError) Error() string {
+	if e.Code != "" {
+		return fmt.Sprintf("[%s] %s", e.Code, e.Message)
+	}
+	return e.Message
+}
+
+// NewAppError creates a new AppError.
+func NewAppError(code, message string, err error, details map[string]any) error {
+	return &AppError{
+		Code:    code,
+		Message: message,
+		Err:     err,
+		Details: details,
+	}
+}
+
+// ValidationError represents errors related to data validation.
+type ValidationError struct {
+	Errors []validation.ErrorMessage // Structure to hold field and message of validation errors
+}
+
+func (e ValidationError) Error() string {
+	return fmt.Sprintf("validation failed: %+v", e.Errors)
+}
+
+// NewValidationError creates a new ValidationError.
+func NewValidationError(message string, errors []validation.ErrorMessage) error {
+	return &AppError{
+		Code:    "VALIDATION_ERROR",
+		Message: message,
+		Err:     ValidationError{Errors: errors},
+	}
+}
+
+// InternalError represents unexpected errors within the application.
+type InternalError struct {
+	Message string
+	Err     error
+}
+
+func (e InternalError) Error() string {
+	return fmt.Sprintf("internal server error: %v", e.Err)
+}
+
+// NewInternalError creates a new InternalError wrapped in AppError.
+func NewInternalError(message string, err error) error {
+	return &AppError{
+		Code:    "INTERNAL_ERROR",
+		Message: message,
+		Err:     InternalError{Message: message, Err: err},
+	}
+}
+
+// ConflictError represents errors due to a conflict with the current state.
+type ConflictError struct {
+	Message string
+	Err     error
+}
+
+func (e ConflictError) Error() string {
+	return fmt.Sprintf("conflict: %s", e.Err)
+}
+
+// NewConflictError creates a new ConflictError wrapped in AppError.
+func NewConflictError(message string, err error) error {
+	return &AppError{
+		Code:    "CONFLICT_ERROR",
+		Message: message,
+		Err:     ConflictError{Message: message, Err: err},
+	}
+}
+
+// NotFoundError represents errors when a resource is not found.
+type NotFoundError struct {
+	Message  string
+	Resource string
+	ID       any
+}
+
+func (e NotFoundError) Error() string {
+	return fmt.Sprintf("%s with ID '%v' not found", e.Resource, e.ID)
+}
+
+// NewNotFoundError creates a new NotFoundError wrapped in AppError.
+func NewNotFoundError(resource string, id any) error {
+	message := fmt.Sprintf("%s not found", resource)
+	return &AppError{
+		Code:    "NOT_FOUND_ERROR",
+		Message: fmt.Sprintf("%s not found", resource),
+		Err:     NotFoundError{Message: message, Resource: resource, ID: id},
+		Details: map[string]any{
+			"resource": resource,
+			"id":       id,
+		},
+	}
+}
+
+// UnauthorizedError represents errors when access is denied due to lack of credentials.
+type UnauthorizedError struct {
+	Message string
+	Err     error
+}
+
+func (e UnauthorizedError) Error() string {
+	return fmt.Sprintf("unauthorized: %s", e.Err)
+}
+
+// NewUnauthorizedError creates a new UnauthorizedError wrapped in AppError.
+func NewUnauthorizedError(message string, err error) error {
+	return &AppError{
+		Code:    "UNAUTHORIZED_ERROR",
+		Message: message,
+		Err:     UnauthorizedError{Message: message, Err: err},
+	}
+}
+
+// ForbiddenError represents errors when access is denied even with valid credentials.
+type ForbiddenError struct {
+	Message string
+	Err     error
+}
+
+func (e ForbiddenError) Error() string {
+	return fmt.Sprintf("forbidden: %s", e.Err)
+}
+
+// NewForbiddenError creates a new ForbiddenError wrapped in AppError.
+func NewForbiddenError(message string, err error) error {
+	return &AppError{
+		Code:    "FORBIDDEN_ERROR",
+		Message: message,
+		Err:     ForbiddenError{Message: message, Err: err},
+	}
+}
+
+// BadRequestError represents errors due to an invalid request.
+type BadRequestError struct {
+	Message string
+	Err     error
+}
+
+func (e BadRequestError) Error() string {
+	return fmt.Sprintf("bad request: %s", e.Err)
+}
+
+func NewBadRequestError(message string, err error) error {
+	return &AppError{
+		Code:    "BAD_REQUEST_ERROR",
+		Message: message,
+		Err:     BadRequestError{Message: message, Err: err},
+	}
+}

space/space/space/space/space/config/database_connection_config.go

@@ -1,79 +1,80 @@
-package config
-
-import (
-	"fmt"
-	"log"
-	"os"
-
-	"gorm.io/driver/postgres"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-
-	"api.qobiltu.id/models"
-	"github.com/joho/godotenv"
-)
-
-var DB *gorm.DB
-var err error
-var Salt string
-
-func init() {
-	godotenv.Load()
-	if err != nil {
-		fmt.Println("Gagal membaca file .env")
-		return
-	}
-	os.Setenv("TZ", "Asia/Jakarta")
-	dbHost := os.Getenv("DB_HOST")
-	dbPort := os.Getenv("DB_PORT")
-	dbUser := os.Getenv("DB_USER")
-	dbPassword := os.Getenv("DB_PASSWORD")
-	dbName := os.Getenv("DB_NAME")
-	Salt := os.Getenv("SALT")
-	dsn := "host=" + dbHost + " user=" + dbUser + " password=" + dbPassword + " dbname=" + dbName + " port=" + dbPort + " sslmode=disable TimeZone=Asia/Jakarta"
-	DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true})
-	if err != nil {
-		panic(err)
-	}
-	if Salt == "" {
-		Salt = "D3f4u|t"
-	}
-
-	// Call AutoMigrateAll to perform auto-migration
-	AutoMigrateAll(DB)
-}
-
-func AutoMigrateAll(db *gorm.DB) {
-	// Enable logger to see SQL logs
-	db.Logger.LogMode(logger.Info)
-
-	// Auto-migrate all models
-	err := db.AutoMigrate(
-		&models.Account{},
-		&models.AccountDetails{},
-		&models.EmailVerification{},
-		&models.ExternalAuth{},
-		&models.FCM{},
-		&models.ForgotPassword{},
-		&models.Academy{},
-		&models.AcademyMaterial{},
-		&models.AcademyContent{},
-		&models.AcademyMaterialProgress{},
-		&models.AcademyContentProgress{},
-		&models.RegionCity{},
-		&models.RegionProvince{},
-		&models.OptionCategory{},
-		&models.OptionValues{},
-		&models.Quiz{},
-		&models.QuizAttempt{},
-		&models.Question{},
-		&models.Answer{},
-		&models.UserAnswer{},
-	)
-
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Println("Migration completed successfully.")
-}
+package config
+
+import (
+	"fmt"
+	"log"
+	"log/slog"
+	"os"
+
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	"api.qobiltu.id/models"
+	"github.com/joho/godotenv"
+)
+
+var DB *gorm.DB
+var err error
+var Salt string
+
+func init() {
+	godotenv.Load()
+	if err != nil {
+		fmt.Println("Gagal membaca file .env")
+		return
+	}
+	os.Setenv("TZ", "Asia/Jakarta")
+	dbHost := os.Getenv("DB_HOST")
+	dbPort := os.Getenv("DB_PORT")
+	dbUser := os.Getenv("DB_USER")
+	dbPassword := os.Getenv("DB_PASSWORD")
+	dbName := os.Getenv("DB_NAME")
+	Salt := os.Getenv("SALT")
+	dsn := "host=" + dbHost + " user=" + dbUser + " password=" + dbPassword + " dbname=" + dbName + " port=" + dbPort + " sslmode=disable TimeZone=Asia/Jakarta"
+	DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true})
+	if err != nil {
+		panic(err)
+	}
+	if Salt == "" {
+		Salt = "D3f4u|t"
+	}
+
+	// Call AutoMigrateAll to perform auto-migration
+	AutoMigrateAll(DB)
+}
+
+func AutoMigrateAll(db *gorm.DB) {
+	// Enable logger to see SQL logs
+	db.Logger.LogMode(logger.Info)
+
+	// Auto-migrate all models
+	err := db.AutoMigrate(
+		&models.Account{},
+		&models.AccountDetails{},
+		&models.EmailVerification{},
+		&models.ExternalAuth{},
+		&models.FCM{},
+		&models.ForgotPassword{},
+		&models.Academy{},
+		&models.AcademyMaterial{},
+		&models.AcademyContent{},
+		&models.AcademyMaterialProgress{},
+		&models.AcademyContentProgress{},
+		&models.RegionCity{},
+		&models.RegionProvince{},
+		&models.OptionCategory{},
+		&models.OptionValues{},
+		&models.Quiz{},
+		&models.QuizAttempt{},
+		&models.Question{},
+		&models.Answer{},
+		&models.UserAnswer{},
+	)
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	slog.Info("Auto-migration completed successfully")
+}

space/space/space/space/space/config/tx.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"gorm.io/gorm"
+)
+
+func RunTx(ctx context.Context, db *gorm.DB, fn func(tx *gorm.DB) error) error {
+	tx := db.WithContext(ctx).Begin()
+	if tx.Error != nil {
+		return fmt.Errorf("failed to begin transaction: %w", tx.Error)
+	}
+
+	defer func() {
+		if p := recover(); p != nil {
+			_ = tx.Rollback()
+			panic(p) // Re-throw panic setelah rollback
+		}
+	}()
+
+	if err := fn(tx); err != nil {
+		if rbErr := tx.Rollback().Error; rbErr != nil {
+			return fmt.Errorf("transaction error: %v, rollback error: %w", err, rbErr)
+		}
+		return err
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		return fmt.Errorf("failed to commit transaction: %w", err)
+	}
+
+	return nil
+}

space/space/space/space/space/controller/health_check/health_check_controller.go

@@ -0,0 +1,31 @@
+package health_check_controller
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/response"
+	"api.qobiltu.id/services/health_check_service"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type HealthCheckController struct {
+	healthCheckService *health_check_service.HealthCheckService
+}
+
+func NewHealthCheckController(healthCheckService *health_check_service.HealthCheckService) *HealthCheckController {
+	return &HealthCheckController{
+		healthCheckService: healthCheckService,
+	}
+}
+
+func (h *HealthCheckController) Check(ctx *gin.Context) {
+	req := models.HealthCheckRequest{}
+
+	res, err := h.healthCheckService.Check(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, "Service is running", http.StatusOK, res, nil)
+}

space/space/space/space/space/models/exception_model.go

@@ -1,15 +1,17 @@
-package models
-
-type Exception struct {
-	Unauthorized          bool   `json:"unauthorized,omitempty"`
-	BadRequest            bool   `json:"bad_request,omitempty"`
-	DataNotFound          bool   `json:"data_not_found,omitempty"`
-	InternalServerError   bool   `json:"internal_server_error,omitempty"`
-	DataDuplicate         bool   `json:"data_duplicate,omitempty"`
-	QueryError            bool   `json:"query_error,omitempty"`
-	InvalidPasswordLength bool   `json:"invalid_password_length,omitempty"`
-	IsPassTheLimit        bool   `json:"is_pass_the_limit,omitempty"`
-	IsTimeOut             bool   `json:"is_time_out,omitempty"`
-	AttemptNotFound       bool   `json:"attempt_not_found,omitempty"`
-	Message               string `json:"message,omitempty"`
-}
+package models
+
+type Exception struct {
+	Unauthorized          bool   `json:"unauthorized,omitempty"`
+	BadRequest            bool   `json:"bad_request,omitempty"`
+	DataNotFound          bool   `json:"data_not_found,omitempty"`
+	InternalServerError   bool   `json:"internal_server_error,omitempty"`
+	DataDuplicate         bool   `json:"data_duplicate,omitempty"`
+	QueryError            bool   `json:"query_error,omitempty"`
+	InvalidPasswordLength bool   `json:"invalid_password_length,omitempty"`
+	IsPassTheLimit        bool   `json:"is_pass_the_limit,omitempty"`
+	IsTimeOut             bool   `json:"is_time_out,omitempty"`
+	AttemptNotFound       bool   `json:"attempt_not_found,omitempty"`
+	Forbidden             bool   `json:"forbidden,omitempty"`
+	ValidationError       bool   `json:"validation_error,omitempty"`
+	Message               string `json:"message,omitempty"`
+}

space/space/space/space/space/models/health_check_model.go

@@ -0,0 +1,10 @@
+package models
+
+type HealthCheckRequest struct {
+	ExampleCallback func() (string, string)
+}
+
+type HealthCheckResponse struct {
+	DatabaseStatus string `json:"database_status"`
+	RedisStatus    string `json:"redis_status"`
+}

space/space/space/space/space/repositories/health_check_repository.go

@@ -0,0 +1,41 @@
+package repositories
+
+import (
+	"api.qobiltu.id/config"
+	"api.qobiltu.id/models"
+	"context"
+	"gorm.io/gorm"
+)
+
+type HealthCheckRepository struct {
+	db *gorm.DB
+}
+
+func NewHealthCheckRepository(db *gorm.DB) *HealthCheckRepository {
+	return &HealthCheckRepository{
+		db: db,
+	}
+}
+
+func (r *HealthCheckRepository) Check(ctx context.Context, req *models.HealthCheckRequest) (*models.HealthCheckResponse, error) {
+	res := &models.HealthCheckResponse{}
+
+	err := config.RunTx(ctx, r.db, func(tx *gorm.DB) error {
+		if err := tx.Exec("SELECT 1").Error; err != nil {
+			return err
+		}
+
+		// call logic from service if needed
+		// instead of writing the logic in the repository
+		// and make sure the param consist of the ctx and request
+		res.DatabaseStatus, res.RedisStatus = req.ExampleCallback()
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}

space/space/space/space/space/response/paging.go

@@ -0,0 +1,58 @@
+package response
+
+import (
+	"errors"
+	"fmt"
+)
+
+type PagingInfo struct {
+	HasPreviousPage        bool   `json:"has_previous_page"`
+	HasNextPage            bool   `json:"has_next_page"`
+	CurrentPage            int    `json:"current_page"`
+	PerPage                int    `json:"per_page"`
+	TotalData              int    `json:"total_data"`
+	LastPage               int    `json:"last_page"`
+	From                   int    `json:"from"`
+	To                     int    `json:"to"`
+	TotalDataInCurrentPage int    `json:"total_data_in_current_page"`
+	Label                  string `json:"label"`
+}
+
+var ErrPageInfo = errors.New("per_page harus lebih besar dari 0 dan offset tidak boleh negatif")
+
+func NewPagingInfo(currentPage, perPage, offset, totalData int) (*PagingInfo, error) {
+	if perPage <= 0 || offset < 0 {
+		return nil, ErrPageInfo
+	}
+
+	lastPage := totalData / perPage
+	if totalData%perPage != 0 {
+		lastPage++
+	}
+
+	to := min(offset+perPage, totalData)
+	from := int(0)
+	if to > offset {
+		from = offset + 1
+	}
+
+	if currentPage > lastPage {
+		currentPage = lastPage
+	}
+
+	totalDataInCurrentPage := to - offset
+	label := fmt.Sprintf("Menampilkan %d sampai %d dari %d data", from, to, totalData)
+
+	return &PagingInfo{
+		HasPreviousPage:        currentPage > 1,
+		HasNextPage:            currentPage < lastPage,
+		CurrentPage:            currentPage,
+		PerPage:                perPage,
+		TotalData:              totalData,
+		LastPage:               lastPage,
+		From:                   from,
+		To:                     to,
+		TotalDataInCurrentPage: totalDataInCurrentPage,
+		Label:                  label,
+	}, nil
+}

space/space/space/space/space/response/response.go

@@ -0,0 +1,152 @@
+package response
+
+import (
+	errors "api.qobiltu.id/apperror"
+	"api.qobiltu.id/models"
+	goErrors "errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"net/http"
+)
+
+type ErrorResponse struct {
+	Details          string            `json:"details"`
+	ValidationErrors []ValidationError `json:"validation_errors,omitempty"`
+	models.Exception
+}
+
+type API struct {
+	Status   string         `json:"status"`
+	Message  string         `json:"message,omitempty"`
+	Data     any            `json:"data,omitempty"`
+	MetaData any            `json:"meta_data"`
+	Error    *ErrorResponse `json:"errors,omitempty"`
+}
+
+type List struct {
+	List any `json:"list"`
+}
+
+type ValidationError struct {
+	Field   string `json:"field"`
+	Message string `json:"message"`
+}
+
+func HandleError(c *gin.Context, err error) {
+
+	apiResponse := API{
+		Status:  "error",
+		Message: "An error occurred, " + err.Error(),
+		Error: &ErrorResponse{
+			Exception: models.Exception{Message: ""},
+		},
+		MetaData: struct{}{},
+	}
+
+	var appErr *errors.AppError
+
+	if goErrors.As(err, &appErr) {
+		apiResponse.Error.Details = fmt.Sprintf("%v", appErr.Err)
+
+		switch specificErr := appErr.Err.(type) {
+		case errors.ValidationError:
+			validationError := make([]ValidationError, len(specificErr.Errors))
+			apiResponse.Message = "Validation Error"
+			apiResponse.Error.ValidationErrors = validationError
+			for i, ve := range specificErr.Errors {
+				apiResponse.Error.ValidationErrors[i] = ValidationError{
+					Field:   ve.Field,
+					Message: ve.Message,
+				}
+			}
+			c.JSON(http.StatusBadRequest, apiResponse)
+			return
+		case errors.ConflictError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.DataDuplicate = true
+			c.JSON(http.StatusConflict, apiResponse)
+			return
+		case errors.InternalError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.InternalServerError = true
+			c.JSON(http.StatusInternalServerError, apiResponse)
+			return
+		case errors.NotFoundError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.DataNotFound = true
+			c.JSON(http.StatusNotFound, apiResponse)
+			return
+		case errors.UnauthorizedError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.Unauthorized = true
+			c.JSON(http.StatusUnauthorized, apiResponse)
+			return
+		case errors.ForbiddenError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.Forbidden = true
+			c.JSON(http.StatusForbidden, apiResponse)
+			return
+		case errors.BadRequestError:
+			apiResponse.Message = specificErr.Message
+			apiResponse.Error.Details = specificErr.Error()
+			apiResponse.Error.Exception.BadRequest = true
+			c.JSON(http.StatusBadRequest, apiResponse)
+			return
+		default:
+			apiResponse.Error.Details = "An unexpected error occurred."
+			apiResponse.Error.Exception.InternalServerError = true
+			c.JSON(http.StatusInternalServerError, apiResponse)
+			return
+		}
+	} else if validationErrors, ok := err.(validator.ValidationErrors); ok {
+		apiResponse.Error.Details = "Validation failed for the request."
+		apiResponse.Error.Exception.ValidationError = true
+		apiResponse.Error.ValidationErrors = make([]ValidationError, len(validationErrors))
+		for i, fe := range validationErrors {
+			apiResponse.Error.ValidationErrors[i] = ValidationError{
+				Field:   fe.Field(),
+				Message: fe.Translate(nil), // adjust if you use translator
+			}
+		}
+		c.JSON(http.StatusBadRequest, apiResponse)
+		return
+	}
+
+	c.JSON(http.StatusInternalServerError, apiResponse)
+	apiResponse.Error.Details = err.Error()
+}
+
+func HandleSuccess(c *gin.Context, message string, statusCode int, data any, metaData any) {
+	apiResponse := API{
+		Status:   "success",
+		Message:  message,
+		Data:     data,
+		MetaData: metaData,
+	}
+
+	if metaData == nil {
+		apiResponse.MetaData = struct{}{}
+	}
+
+	c.JSON(statusCode, apiResponse)
+}
+
+func HandleSuccessWithPaging(c *gin.Context, message string, content any, pagingInfo *PagingInfo) {
+
+	apiResponse := API{
+		Message: message,
+		Status:  "success",
+		Data: List{
+			List: content,
+		},
+		MetaData: pagingInfo,
+	}
+
+	c.JSON(http.StatusOK, apiResponse)
+}

space/space/space/space/space/router/health_check_route.go

@@ -0,0 +1,5 @@
+package router
+
+func (s *Server) HealthCheckRoute() {
+	s.router.GET("/api/v1/health-check", s.healthCheckController.Check)
+}

space/space/space/space/space/router/router.go

@@ -1,27 +1,20 @@
 package router
 
 import (
-	"log"
-
-	"api.qobiltu.id/config"
-	"api.qobiltu.id/controller"
-	"github.com/gin-gonic/gin"
+    "api.qobiltu.id/controller"
 )
 
-func StartService() {
-	router := gin.Default()
-	router.Use(gin.Recovery())
+func (s *Server) setupRoutes() {
+
+    s.router.GET("/", controller.HomeController)
 
-	router.GET("/", controller.HomeController)
-	AuthRoute(router)
-	UserRoute(router)
-	EmailRoute(router)
-	OptionsRoute(router)
-	AcademyRoute(router)
-	QuizRoute(router)
+    AuthRoute(s.router)
+    UserRoute(s.router)
+    EmailRoute(s.router)
+    OptionsRoute(s.router)
+    AcademyRoute(s.router)
+    QuizRoute(s.router)
 
-	err := router.Run(config.TCP_ADDRESS)
-	if err != nil {
-		log.Fatalf("Failed to run server: %v", err)
-	}
+    // another way to register routes
+    s.HealthCheckRoute()
 }

space/space/space/space/space/router/server.go

@@ -0,0 +1,32 @@
+package router
+
+import (
+	"api.qobiltu.id/controller/health_check"
+	"github.com/gin-gonic/gin"
+)
+
+type Server struct {
+	router                *gin.Engine
+	healthCheckController *health_check_controller.HealthCheckController
+}
+
+func NewServer(
+	healthCheckController *health_check_controller.HealthCheckController,
+) (*Server, error) {
+
+	router := gin.Default()
+	router.Use(gin.Recovery())
+
+	server := &Server{
+		healthCheckController: healthCheckController,
+		router:                router,
+	}
+
+	server.setupRoutes()
+
+	return server, nil
+}
+
+func (s *Server) Start(address string) error {
+	return s.router.Run(address)
+}